home *** CD-ROM | disk | FTP | other *** search
/ Simtel MSDOS 1992 December / simtel1292_SIMTEL_1292_Walnut_Creek.iso / msdos / ddjmag / ddj8911.arc / KAR.LST < prev    next >
File List  |  1989-10-04  |  6KB  |  226 lines
  1. _DATE-FLOW MULTITASKING_
  2. by Rabindra Kar
  3.  
  4.  
  5. [LISTING ONE] 
  6.  
  7. /*  quad_eq.c -
  8.  *  Calculate roots of quadratic equation:  ax  + bx + c = 0
  9.  */
  10.  
  11. #include "stdio.h"
  12. #include "rmx.h"
  13. #include "math.h"
  14.  
  15. #define NUM_VALS 100
  16.  
  17. unsigned status;
  18. struct coeffs {double a, b, c;} y[NUM_VALS+1];
  19. double det;
  20. double num;
  21. double res;
  22.  
  23. /* Calculate determinant */
  24. determinant(i)
  25. unsigned i;
  26. {
  27.     det = y[i].b * y[i].b - 4 * y[i].a * y[i].c;
  28. }
  29.  
  30. /* Calculate numerator */
  31. numerator(i)
  32. unsigned i;
  33. {
  34.     num = pow(det,0.5) - y[i].b;
  35. }
  36.  
  37. /* Calculate, print result */
  38. result(i)
  39. unsigned i;
  40. {
  41.     res = num / (2 * y[i].a);
  42.     printf("Coeffs = %.1f,%.1f,%.1f  Root = %7.2f\n",
  43.                             y[i].a,y[i].b,y[i].c,res);
  44. }
  45.  
  46. main()
  47. { 
  48.   unsigned i;
  49.   /* Create input data. Done for convenience. Could have read the data
  50.    * from any input device.
  51.    */
  52.   for (i = 1; i < NUM_VALS; i++)
  53.     {y[i].a = (double)i; y[i].c = (double)i; y[i].b = 3*(double)i;}
  54.  
  55.   /* Compute the roots */
  56.   
  57.   for (i = 1; i < NUM_VALS; i++)
  58.   { 
  59.     determinant(i);
  60.     numerator(i);
  61.     result(i);
  62.   }
  63.   printf("\n");
  64. }
  65.  
  66.  
  67. [LISTING TWO] 
  68.  
  69. /****************************************************************************\
  70.  *  dflow.c -
  71.  *    Compute the roots of a quadratic equation using multitasking
  72.  *    and data flow concepts.
  73.  *  Operating System: iRMX II. Compiler: iC-286 V3.2
  74. \****************************************************************************/
  75.  
  76. #include "stdio.h"
  77. #include "rmx.h"
  78. #include "math.h"
  79.  
  80. #define NUM_VALS 100
  81.  
  82. unsigned status, task_t;
  83. FILE *fp;
  84.  
  85. /* "union" used to decompose a pointer into segment:offset */
  86. typedef struct {unsigned offset; unsigned sel;} ptr_s;
  87. union { unsigned *pointer; ptr_s ptr; } ptr_u;
  88.  
  89. /* Input data area */
  90. struct coeffs {double a, b, c;} y[NUM_VALS+1];
  91.  
  92. /* "DET" mailbox -
  93.  *      Output from main task; input to num_task
  94.  */
  95. double det = 0.0;
  96. unsigned index1 = 0;
  97.  
  98. /* "NUM" mailbox -
  99.  *      Output from num_task; input to res_task
  100.  */
  101. double num = 0.0;
  102. unsigned index2 = 0;
  103.  
  104. /************************ Computational tasks *************************/
  105.  
  106. det_task()
  107. {    /* Calculate determinant */
  108.   unsigned i;
  109.   for (i = 1; y[i].a != 0.0; i++)
  110.   {
  111.     while (det != 0.0) rq$sleep(0,&status);
  112.     index1++;
  113.     det = y[i].b * y[i].b - 4 * y[i].a * y[i].c;
  114.   }
  115. }
  116.  
  117. num_task()
  118. {    /* Calculate numerator */
  119.   while (y[index1].a != 0.0)
  120.   {
  121.     while ((det == 0.0) || (num != 0.0)) rq$sleep(0,&status);
  122.     index2++;
  123.     num = pow(det, 0.5) - y[index1].b;
  124.     det = 0.0;
  125.   }
  126.   rq$delete$task(0,&status);    /* Delete self */
  127. }
  128.  
  129. res_task()
  130. {    /* Calculate result, print on console */
  131.   double res;
  132.   while (y[index2].a != 0.0)
  133.   {
  134.     while (num == 0.0) rq$sleep(0,&status);
  135.     res = num / (2 * y[index2].a);
  136.     num = 0.0;
  137.     printf("Coeffs = %.1f,%.1f,%.1f  Root = %7.2f\n",
  138.                             y[index2].a, y[index2].b, y[index2].c, res);
  139.   }
  140.   printf("\n");
  141.   rq$delete$task(0,&status);    /* Delete self */
  142. }
  143.  
  144. /****************************** Main Program ******************************/
  145.  
  146. main()
  147. { 
  148.   unsigned i;
  149.   unsigned short pri;
  150.  
  151.   /* Create input data. Done for convenience. Could have read the data
  152.    * from any input device.
  153.    */
  154.   for (i = 1; i < NUM_VALS; i++)
  155.     {y[i].a = (double)i; y[i].c = (double)i; y[i].b = 3*(double)i;}
  156.  
  157.   y[NUM_VALS].a = 0.0;   /* 0.0 indicates end of input data */
  158.   
  159.   /* Place a pointer to any variable in union "ptr_u", so the data segment
  160.      of this program becomes known.
  161.    */
  162.   ptr_u.pointer = &status;
  163.   
  164.   /* Find the priority level that iRMX accords the main task */
  165.   pri = rq$get$priority (NULL, &status);
  166.  
  167.   /*
  168.    * Spawn the operation tasks. All have the same priority as main.
  169.    */
  170.   task_t = rq$create$task (pri, (long)det_task, ptr_u.ptr.sel,
  171.                      0L, 1024, 1, &status);
  172.   if (status != 0) printf("det_task create error = %u\n",status);
  173.  
  174.   task_t = rq$create$task (pri, (long)num_task, ptr_u.ptr.sel,
  175.                      0L, 1024, 1, &status);
  176.   if (status != 0) printf("num_task create error = %u\n",status);
  177.  
  178.   task_t = rq$create$task (pri, (long)res_task, ptr_u.ptr.sel,
  179.                      0L, 1024, 1, &status);
  180.   if (status != 0) printf("res_task create error = %u\n",status);
  181.  
  182.   /*
  183.    * Lower main task's priority so main() will be idled by OS while other
  184.    * tasks do computations. Will return here when input data is exhausted.
  185.    */
  186.   rq$set$priority (NULL, (pri+1), &status); 
  187.  
  188.   /*********************************************************************/
  189.  
  190.   rq$sleep(10, &status);     /* Let other tasks complete */
  191.   printf("\n  Done! \n");
  192.  
  193. }
  194.  
  195. [LISTING THREE]
  196.  
  197.  
  198. /* 
  199.  * This code is similar to "res_task()" in dflow.c, except
  200.  * that the computed result is output to a file instead of the (default)
  201.  * console screen.
  202.  *     This code could be added to dflow.c along with two statements in
  203.  * main() to: 1. create a "res_task2()" task, and 2. open a file for
  204.  * output with fp as its file pointer. By so doing, the I/O delay involved
  205.  * in waiting for console output could be overlapped with file output delays,
  206.  * thus speeding up the program. Of course, the results would then be
  207.  * distributed between the console and the output file.
  208.  */
  209.  
  210. res_task2()
  211. {    /* Calculate result, print to file */
  212.   double res;
  213.   
  214.   while (y[index2].a != 0.0)
  215.   {
  216.     while (num == 0.0) rq$sleep(0,&status);
  217.     res = num / (2 * y[index2].a);
  218.     num = 0.0;
  219.     fprintf(fp, "Coeffs = %.1f,%.1f,%.1f  root = %7.2f\n",
  220.                             y[index2].a, y[index2].b, y[index2].c, res);
  221.   }
  222.   rq$delete$task(0,&status);    /* Delete self */
  223. }
  224.  
  225.  
  226.