home *** CD-ROM | disk | FTP | other *** search
/ Shareware Supreme Volume 6 #1 / swsii.zip / swsii / 215 / DDJ9208.ZIP / PARA_C.ASC < prev    next >
Text File  |  1992-07-06  |  9KB  |  366 lines
  1. _PARALLEL C EXTENSIONS_
  2. by Barr E. Bauer
  3.  
  4. [LISTING ONE]
  5.  
  6. /* Loop parallelism sum reduction critical block within loop nest
  7.  * B. E. Bauer 1992 -- compiled using the following on the IRIS:
  8.  *     parallel: cc -O2 -o example1p -mp example1.c
  9.  *     serial: cc -O2 -o example1 example1.c  */
  10. #include <stdio.h>
  11. #define MAX 1536
  12. double a[MAX][MAX], b[MAX][MAX];
  13. main()
  14. {
  15.     int i, j, k, k1;
  16.     double sum=0.0, temp;
  17.     /* shared arrays filled; values not important, just order */
  18.     for (i=0; i<MAX; i++) { 
  19.         for (j=0; j<MAX; j++) {
  20.             a[i][j] = (double)i;
  21.             b[i][j] = (double)j;
  22.         }
  23.     }     
  24.     k1 = 256; /* inner loop delay factor */
  25.     /* start of parallel region */
  26.     #pragma parallel shared(a,b,sum) local(i,j,k,temp) byvalue(k1)
  27.     {
  28.         /* pfor block */
  29.         #pragma pfor iterate(i=0; MAX; 1)
  30.             for (i=0; i<MAX; i++) {
  31.                 for (j=0; j<MAX; j++) {
  32.                     temp = a[i][j]-b[i][j];
  33.                     for (k=0; k<k1; k++) /* lengthen execution time */
  34.                         temp += 0.01;
  35.                     #pragma critical
  36.                     {
  37.                         sum += temp;  /* summation in inner loop */
  38.                     }
  39.                 }
  40.             } 
  41.     }
  42.     printf("\nDone! sum = %24.15f\n", sum);
  43. }
  44.  
  45.  
  46. [LISTING TWO]
  47.  
  48. /* Loop parallelism sum reduction critical block moved into local code
  49.  * B. E. Bauer 1992 -- compiled using the following on the IRIS:
  50.  *     parallel: cc -O2 -o example2p -mp example2.c
  51.  *     serial: cc -O2 -o example2 example2.c  */
  52.  
  53. #include <stdio.h>
  54. #define MAX 1536
  55. double a[MAX][MAX], b[MAX][MAX];
  56. main()
  57. {
  58.     int i, j, k, k1;
  59.     double sum=0.0, temp, st;   /* st = local code subtotal */
  60.     /* shared arrays filled; values not important, just order */
  61.     for (i=0; i<MAX; i++) { 
  62.         for (j=0; j<MAX; j++) {
  63.             a[i][j] = (double)i;
  64.             b[i][j] = (double)j;
  65.         }
  66.     }     
  67.     k1 = 256; /* inner loop delay factor */
  68.     /* start of parallel region */
  69.     #pragma parallel shared(a,b,sum) local(i,j,k,temp,st) byvalue(k1)
  70.     {
  71.         st = 0.0;   /* st initialized in each thread */
  72.         /* pfor block */
  73.         #pragma pfor iterate(i=0; MAX; 1)
  74.             for (i=0; i<MAX; i++) {
  75.                 for (j=0; j<MAX; j++) {
  76.                     temp = a[i][j]-b[i][j];
  77.                     for (k=0; k<k1; k++) /* lengthens execution time */
  78.                         temp += 0.01;
  79.                     st += temp;
  80.                 }
  81.             } 
  82.         /* local code grand summation */
  83.         #pragma critical
  84.         {
  85.             sum += st;
  86.         }
  87.     }
  88.     printf("\nDone! sum = %24.15f\n", sum);
  89. }
  90.  
  91.  
  92. [LISTING THREE]
  93.  
  94. /* Block parallelism, producer-consumer problem
  95.  * B. E. Bauer 1992 -- Taken from "Practical Parallel Programming" pp 214-225
  96.  * (C) 1992 Academic Press, Inc. All Rights Reserved. Used with permission. */
  97.  
  98. #include <stdio.h> 
  99. #define MAXCONSUMERS 3
  100. #define MAXPRODUCTS 10000
  101. #define STOP_TOKEN -1
  102. #define NULL_ITEM (node_t *)NULL 
  103. /* the product is defined here */ 
  104. struct node  
  105. { 
  106.     int productid; 
  107.     struct node *next; 
  108. }; 
  109. typedef struct node node_t;  /* the typedef is convenient */ 
  110. node_t *root = NULL_ITEM;  /* linked list root */ 
  111. int max_depth = 0; 
  112. /* ----- create a new "product" -------------------------------- */ 
  113. node_t *make_product(node_t *item, int prodid) 
  114. { 
  115.     item = (node_t *)malloc(sizeof(node_t)); 
  116.     if (item != NULL_ITEM) { 
  117.         item->productid = prodid;
  118.       item->next = NULL_ITEM; 
  119.     } 
  120.     else  
  121.       printf("problems with production, boss...\n"); 
  122.       return (item); 
  123. } 
  124. /* ----- add a "product" to the end of the list ---------------- */ 
  125. node_t *ship_product(node_t *new) 
  126. {
  127.     int cur_depth = 0;
  128.     node_t *list = root;
  129.  
  130.     if (root == NULL_ITEM) 
  131.         root = new;
  132.     else 
  133.     {
  134.         while (list->next != NULL_ITEM)
  135.         {
  136.             list = list->next;
  137.             cur_depth++;
  138.         }
  139.         cur_depth++;
  140.         list->next = new;
  141.     }
  142.     if (cur_depth > max_depth)
  143.         max_depth = cur_depth;
  144. } 
  145. /* ----- pop the product off the beginning of the list --------- */
  146. node_t *receive_product()
  147. {
  148.     node_t *item = root;
  149.     if (root != NULL_ITEM)
  150.         root = root->next;
  151.     return(item);
  152. }
  153. /* ----- consume the product by freeing its memory ------------- */
  154. void consume_product(node_t *item)
  155. {
  156.     if (item != NULL_ITEM)
  157.         free (item);
  158. }
  159. /* ----- the producer ------------------------------------------ */ 
  160. void producer(int cnt) 
  161. { 
  162.     node_t *temp; 
  163.     int i;
  164.     /* make "products" cnt times (limits simulation) */ 
  165.     for (i=0; i<=cnt; i++)
  166.     { 
  167.         if ((temp = make_product(temp,i)) == NULL_ITEM) 
  168.             break; 
  169.         #pragma critical 
  170.         {
  171.             ship_product(temp); 
  172.         }    
  173.     } 
  174.     /* load on stop tokens */ 
  175.     for (i=0; i<MAXCONSUMERS; i++) 
  176.     { 
  177.         if ((temp = make_product(temp, STOP_TOKEN)) == NULL_ITEM) 
  178.             break; 
  179.         #pragma critical 
  180.         {
  181.             ship_product(temp); 
  182.         }         
  183.     } 
  184.     printf("producer calls it quits\n"); 
  185. } 
  186. /* ----- the consumer (created 3 times) ------------------------ */ 
  187. long consumer(int myid) 
  188. { 
  189.     /* local variables */ 
  190.     int consuming = 1, j;
  191.     long consumed = 0;    /* count of "products" */ 
  192.     node_t *item;
  193.     double temp;
  194.     printf("consumer %d starts the shopping day\n", myid);
  195.     while (consuming)     /* loop until stop token seen */ 
  196.     { 
  197.         for (j=0; j<32000; j++)
  198.             temp *= (double)j;
  199.  
  200.         #pragma critical 
  201.         {
  202.             item = receive_product();
  203.         }
  204.         if (item != NULL_ITEM)
  205.         {
  206.             if (item->productid != STOP_TOKEN) 
  207.             {
  208.                 if (item->productid)
  209.                     ++consumed;
  210.                 printf("consumer %d consuming product %d\n", 
  211.                                                      myid, item->productid);
  212.             }
  213.             else
  214.             {
  215.                 consuming = 0;
  216.                 printf("consumer %d ran out of products\n", myid);
  217.             }
  218.             consume_product(item);
  219.         }
  220.     }
  221.     printf("consumer %d consumed %d products\n", myid, consumed);
  222.     return(consumed); 
  223. } 
  224. main() 
  225. { 
  226.     long total, sum[MAXCONSUMERS]; 
  227.     int i; 
  228.     printf("business starts with %d products\n",MAXPRODUCTS); 
  229.     #pragma parallel shared(sum)
  230.     { 
  231.         #pragma independent 
  232.         {
  233.             producer(MAXPRODUCTS); /* start producer */
  234.         }
  235.         #pragma independent 
  236.         {
  237.             sum[0] = consumer(1);  /* start consumer 1 */ 
  238.         }     
  239.         #pragma independent 
  240.         {
  241.             sum[1] = consumer(2);  /* start consumer 2 */ 
  242.         }     
  243.         #pragma independent 
  244.         {
  245.             sum[2] = consumer(3);  /* start consumer 3 */ 
  246.         }
  247.     } 
  248.     for (i=0, total = 0L; i<MAXCONSUMERS; i++) 
  249.         total += sum[i];  /* sum up the products consumed by each */ 
  250.     printf("business over, %d products exchanged\n", total); 
  251.     printf("maximum products in list = %d\n", max_depth-MAXCONSUMERS);
  252. } 
  253.  
  254.  
  255. Example 1:
  256.  
  257. (a)
  258.  
  259. for (sum=i=0; i<max; i++)
  260.     sum += a[i];
  261.  
  262. (b)
  263.  
  264.  
  265. for (i=1; i<max; i++)
  266.     a[i] = b[i] * a[i-1];
  267.  
  268.  
  269. Example  2:
  270.  
  271. (a)
  272.  
  273. Code Block becomes
  274.  
  275. #pragma parallel
  276. #pragma shared (arrayvar1, arrayvar2..., grandtotal)
  277. #pragma local (index1, index2, subtotal1,...)
  278. #pragma byvalue(shared_constant1,...)
  279. {
  280.     Code Block
  281. }
  282.  
  283. or, the equivalent
  284.  
  285. #pragma parallel shared(list) local(list) byvalue(list)
  286. {
  287.     Code Block
  288. }
  289.  
  290.  
  291. (b)
  292.  
  293. /* strictly local code */
  294. #pragma parallel
  295. #pragma local(i, j)
  296. {
  297.     for (i=sum=0; i<1000; i++)
  298.         sum += i;
  299.     printf("sum = %d\n", sum);
  300. }
  301.  
  302.  
  303. Example 3:
  304.  
  305. for (i=0; i<max; i++)
  306.         b[i] = const*a[i];
  307.  
  308. becomes
  309.  
  310. #pragma parallel shared(a,b) local(i) byvalue(max,const)
  311. {
  312.     #pragma pfor iterate(i=0; max; 1)
  313.         for (i=0; i<max; i++)
  314.             b[i] = const*a[i];
  315. }
  316.  
  317.  
  318.  
  319.  
  320. Example 4:
  321.  
  322.  
  323. code block 1
  324. code block 2
  325.  
  326. becomes
  327.  
  328. #pragma parallel shared(list) local(list) byvalue(list)
  329. {
  330.     #pragma independent
  331.     {
  332.         code block 1
  333.     }
  334.     #pragma independent
  335.     {
  336.         code block 2
  337.     }
  338. }
  339.  
  340.  
  341. Example 5:
  342.  
  343. (a)
  344.  
  345. sum = 0.0;
  346. #pragma parallel shared (sum, a) local(i) byvalue(max)
  347. {
  348.     #pragma pfor iterate (i=0; max; 1)
  349.         for (i=0; i<max; i++)
  350.             sum +=  a[i];
  351. }
  352.  
  353. (b)
  354.  
  355. sum = 0.0;
  356. #pragma parallel shared (sum, a) local(i) byvalue(max)
  357. {
  358.     #pragma pfor iterate (i=0; max; 1)
  359.         for (i=0; i<max; i++)
  360.             #pragma critical
  361.         {
  362.         sum += a[i];
  363.         }
  364. }
  365.  
  366.