home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / adaptor.zip / adapt.zip / adaptor / dalib / pvm3 / schedul0.c < prev    next >
C/C++ Source or Header  |  1993-11-29  |  19KB  |  500 lines
  1. /**************************************************************************
  2. *                                                                         *
  3. *  Author      : Dr. Thomas Brandes, GMD, I1.HR                           *
  4. *  Copyright   : GMD St. Augustin, Germany                                *
  5. *  Date        : Apr 93                                                   *
  6. *  Last Update : Jun 93                                                   *
  7. *                                                                         *
  8. *  This Module is part of the DALIB                                       *
  9. *                                                                         *
  10. *  Module      : schedule0.c                                              *
  11. *                                                                         *
  12. *  Function    : Operations for indirect addressing of local arrays       *
  13. *                                                                         *
  14. *  Export : FORTRAN Interface                                             *
  15. *                                                                         *
  16. *  - A, P, Q, ... are conform and are local                               *
  17. *  - B must be a local array                                              *
  18. *  - B is indirect accessed, rank determines number of P, Q, ...          *
  19. *  - A and B have same type                                               *
  20. *                                                                         *
  21. *  A = B [P]  : A[j] = B[P[j]]    for all j                               *
  22. *                                                                         *
  23. *  void dalib_local_getm1_ (a, a_size, a_elems,                           *
  24. *                            b, b_N1, p, mask   )                         *
  25. *                                                                         *
  26. *  B [P] = A  : B[P[j]] = A[j]    for all j                               *
  27. *                                                                         *
  28. *  void dalib_local_setm1_ (op, b, b_N1, p,                               *
  29. *                            a, a_size, a_elems, mask)                    *
  30. *                                                                         *
  31. *  A = B [P,Q]  : A[j] = B[P[j],Q[j]]    for all j                        *
  32. *                                                                         *
  33. *  void dalib_local_getm2_ (a, a_size, a_elems,                           *
  34. *                            b, b_N1, b_N2, p, q, mask   )                *
  35. *                                                                         *
  36. *  B [P,Q] = A  : B[P[j],Q[j]] = A[j]    for all j                        *
  37. *                                                                         *
  38. *  void dalib_local_setm2_ (op, b, b_N1, b_N2, p, q,                      *
  39. *                            a, a_size, a_elems, mask)                    *
  40. *                                                                         *
  41. **************************************************************************/
  42.  
  43. #undef DEBUG
  44. #include "system.h"
  45. #include <stdio.h>
  46.  
  47. /*******************************************************************
  48. *                                                                  *
  49. *  MASK:  A[j] = B[P[j]]    for all j with MASK(j)                 *
  50. *                                                                  *
  51. *  operations for different sizes of elements                      *
  52. *                                                                  *
  53. *******************************************************************/
  54.  
  55. void dalib_lget1_1  (a, b, p, mask, N)
  56. unsigned char *a, *b;
  57. int *p, *mask, N;
  58. { int i;
  59.   if (mask == p)
  60.     { for (i=0; i<N; i++)
  61.          a[i] = b[p[i]];
  62.     }
  63.    else
  64.     { for (i=0; i<N; i++)
  65.          if (mask[i]) a[i] = b[p[i]];
  66.     }
  67. }
  68.  
  69. void dalib_lget1_4  (a, b, p, mask, N)
  70. int *a, *b;
  71. int *p, *mask, N;
  72. { int i;
  73.   if (mask == p)
  74.     { for (i=0; i<N; i++)
  75.          a[i] = b[p[i]];
  76.     }
  77.    else
  78.     { for (i=0; i<N; i++)
  79.          if (mask[i]) a[i] = b[p[i]];
  80.     }
  81. }
  82.  
  83. void dalib_lget1_8  (a, b, p, mask, N)
  84. double *a, *b;
  85. int *p, *mask, N;
  86. { int i;
  87.   if (mask == p)
  88.     { for (i=0; i<N; i++)
  89.        a[i] = b[p[i]];
  90.     }
  91.    else
  92.     { for (i=0; i<N; i++)
  93.        if (mask[i]) a[i] = b[p[i]];
  94.     }
  95. }
  96.  
  97. /*******************************************************************
  98. *                                                                  *
  99. *  MASK: A = B [P]  : A[j] = B[P[j]]    for all j with MASK(j)     *
  100. *                                                                  *
  101. *  void dalib_local_getm1_ (a, a_size, a_elems,                    *
  102. *                           b, b_N1, p, mask   )                   *
  103. *                                                                  *
  104. *******************************************************************/
  105.  
  106. void dalib_local_getm1_ (a, a_size, a_elems, b, b_N1, p, mask)
  107.  
  108. int *a_size;         /* number of local elements of a and p */
  109. int *a_elems;        /* number of elemens in a, p           */
  110. int *b_N1;           /* number of elements of b             */
  111. int *p, *mask;       /* p == mask if mask is not available  */
  112. unsigned char *a, *b;
  113.  
  114. { int i, j, bytes;
  115.   unsigned char *a1_ptr, *b1_ptr;
  116.  
  117.   bytes = *a_size;
  118.  
  119.   if (bytes == 4)
  120.     dalib_lget1_4 (a, b-4, p, mask, *a_elems);  /* b-4 is fiktive zero */
  121.   else if (bytes == 8)
  122.     dalib_lget1_8 (a, b-8, p, mask, *a_elems);  /* b-8 is fiktive zero */
  123.   else if (bytes == 1)
  124.     dalib_lget1_1 (a, b-1, p, mask, *a_elems);  /* b-1 is fiktive zero */
  125.   else
  126.     { for (i=0, a1_ptr=a ; i<*a_elems; i++, a1_ptr+=bytes)
  127.           if ((mask == p) || (mask[i]))
  128.             { b1_ptr = b + (p[i] - 1) * bytes;
  129.               for (j=0; j < bytes; j++)
  130.                  a1_ptr[j] = b1_ptr[j];
  131.             }  /* mask[i] == true */
  132.      }  /* end of loop for all elements */
  133. } /* dalib_local_getm1 */
  134.  
  135. /*******************************************************************
  136. *                                                                  *
  137. *  MASK:  B[P[j]] = A[j]   for all j with MASK(j)                  *
  138. *                                                                  *
  139. *  operations for different sizes of elements                      *
  140. *                                                                  *
  141. *******************************************************************/
  142.  
  143. void dalib_lset1_1  (a, b, p, mask, N)
  144. unsigned char *a, *b;
  145. int *p, *mask, N;
  146. { int i;
  147.   if (mask == p)
  148.     { for (i=0; i<N; i++)
  149.          b[p[i]] = a[i];
  150.     }
  151.    else
  152.     { for (i=0; i<N; i++)
  153.          if (mask[i]) b[p[i]] = a[i];
  154.     }
  155. }
  156.  
  157. void dalib_lset1_4  (a, b, p, mask, N)
  158. int *a, *b;
  159. int *p, *mask, N;
  160. { int i;
  161.   if (mask == p)
  162.     { for (i=0; i<N; i++)
  163.          b[p[i]] = a[i];
  164.     }
  165.    else
  166.     { for (i=0; i<N; i++)
  167.          if (mask[i]) b[p[i]] = a[i];
  168.     }
  169. }
  170.  
  171. void dalib_lset1_8  (a, b, p, mask, N)
  172. double *a, *b;
  173. int *p, *mask, N;
  174. { int i;
  175.   if (mask == p)
  176.     { for (i=0; i<N; i++)
  177.          b[p[i]] = a[i];
  178.     }
  179.    else
  180.     { for (i=0; i<N; i++)
  181.          if (mask[i]) b[p[i]] = a[i];
  182.     }
  183. }
  184.  
  185. /*******************************************************************
  186. *                                                                  *
  187. *  MASK: B [P] = A  : B[P[j]] = A[j]    for all j with MASK(j)     *
  188. *                                                                  *
  189. *  void dalib_local_setm1_ (op, b, b_N1, p,                        *
  190. *                           a, a_size, a_elems, mask)              *
  191. *                                                                  *
  192. *******************************************************************/
  193.  
  194. void dalib_local_setm1_ (op, b, b_N1, p, a, a_size, a_elems, mask)
  195.  
  196. unsigned char *a, *b;
  197. int *op;
  198. int *a_size, *a_elems;
  199. int *p, *mask;
  200. int *b_N1;
  201.  
  202. { int i, j, bytes;
  203.   unsigned char *a_ptr, *b_ptr;
  204.  
  205.   bytes = *a_size;
  206.  
  207.   if (*op == 0)
  208.      { if (bytes == 1)
  209.          dalib_lset1_1  (a, b-1, p, mask, *a_elems);
  210.        else if (bytes == 4)
  211.          dalib_lset1_4  (a, b-4, p, mask, *a_elems);
  212.        else if (bytes == 8)
  213.          dalib_lset1_8  (a, b-8, p, mask, *a_elems);
  214.        else
  215.          { for (i=0, a_ptr = a; i<*a_elems; i++, a_ptr+=bytes )
  216.              if ((mask == p) || (mask[i]))
  217.                { b_ptr = b + (p[i] - 1) * bytes;
  218.                  for (j=0; j < bytes; j++)
  219.                        b_ptr[j] = a_ptr[j];
  220.                }
  221.          }
  222.      }
  223.  
  224.   else
  225.    
  226.   { for (i=0, a_ptr = a; i<*a_elems; i++, a_ptr+=bytes )
  227.       if ((mask == p) || (mask[i]))
  228.         { b_ptr = b + (p[i] - 1) * bytes;
  229.           switch (*op) {
  230.           case  1 : min_ints (b_ptr, a_ptr); break;
  231.           case  2 : min_reals (b_ptr, a_ptr); break;
  232.           case  3 : min_doubles (b_ptr, a_ptr); break;
  233.           case  4 : max_ints (b_ptr, a_ptr); break;
  234.           case  5 : max_reals (b_ptr, a_ptr); break;
  235.           case  6 : max_doubles (b_ptr, a_ptr); break;
  236.           case  7 : add_ints (b_ptr, a_ptr); break;
  237.           case  8 : add_reals (b_ptr, a_ptr); break;
  238.           case  9 : add_doubles (b_ptr, a_ptr); break;
  239.           case 10 : mult_ints (b_ptr, a_ptr); break;
  240.           case 11 : mult_reals (b_ptr, a_ptr); break;
  241.           case 12 : mult_doubles (b_ptr, a_ptr); break;
  242.           case 13 : and_ints (b_ptr, a_ptr); break;
  243.           case 14 : or_ints (b_ptr, a_ptr); break;
  244.           case 15 : eor_ints (b_ptr, a_ptr); break;
  245.           case 16 : and_bools (b_ptr, a_ptr); break;
  246.           case 17 : or_bools (b_ptr, a_ptr); break;
  247.           case 18 : neq_bools (b_ptr, a_ptr); break;
  248.           default : printf ("illegal operation in dalib_local_set\n");
  249.                     exit(-1);
  250.                     break;
  251.           } /* switch operation */
  252.         } /* end of get b[p[i] to a[i] */
  253.   } /* end of for */
  254. } /* dalib_local_setm1 */
  255.  
  256. /*******************************************************************
  257. *                                                                  *
  258. *  MASK:  A[j] = B[P[j],Q[j]]    for all j with MASK(j)            *
  259. *                                                                  *
  260. *  operations for different sizes of elements                      *
  261. *                                                                  *
  262. *******************************************************************/
  263.  
  264. void dalib_lget2_1  (a, b, S, p, q, mask, N)
  265. unsigned char *a, *b; 
  266. int *p, *q, *mask, N, S;
  267. { int i;
  268.   if (mask == q)
  269.     { for (i=0; i<N; i++)
  270.          a[i] = b[p[i]*S+q[i]];
  271.     }
  272.    else
  273.     { for (i=0; i<N; i++)
  274.          if (mask[i]) a[i] = b[p[i]*S+q[i]];
  275.     }
  276. }
  277.  
  278. void dalib_lget2_4  (a, b, S, p, q, mask, N)
  279. int *a, *b; 
  280. int *p, *q, *mask, N, S;
  281. { int i;
  282.   if (mask == q)
  283.     { for (i=0; i<N; i++)
  284.          a[i] = b[p[i]*S+q[i]];
  285.     }
  286.    else
  287.     { for (i=0; i<N; i++)
  288.          if (mask[i]) a[i] = b[p[i]*S+q[i]];
  289.     }
  290. }
  291.  
  292. void dalib_lget2_8  (a, b, S, p, q, mask, N)
  293. double *a, *b; 
  294. int *p, *q, *mask, N, S;
  295. { int i;
  296.   if (mask == q)
  297.     { for (i=0; i<N; i++)
  298.          a[i] = b[p[i]*S+q[i]];
  299.     }
  300.    else
  301.     { for (i=0; i<N; i++)
  302.          if (mask[i]) a[i] = b[p[i]*S+q[i]];
  303.     }
  304. }
  305.  
  306. /***********************************************************************
  307. *                                                                      *
  308. *  MASK: A = B [P,Q]  : A[j] = B[P[j],Q[j]]    for all j with MASK(j)  *
  309. *                                                                      *
  310. *  void dalib_global_getm2_ (a, a_size, a_elems,                       *
  311. *                            b, b_N1, b_N2, p, q, mask   )             *
  312. *                                                                      *
  313. ***********************************************************************/
  314.  
  315. void dalib_local_getm2_ (a, a_size, a_elems, b, b_N1, b_N2, p, q, mask)
  316.  
  317. int *a_size;         /* number of local elements of a and p */
  318. int *a_elems;        /* number of elemens in a, p           */
  319. int *b_N1, *b_N2;    /* number of elements of b             */
  320. int *p, *q, *mask;   /* q == mask if mask is not available  */
  321. unsigned char *a, *b;
  322.  
  323. { int i, j, bytes, N1;
  324.   unsigned char *a1_ptr, *b1_ptr;
  325.  
  326.   bytes = *a_size;
  327.   N1    = *b_N1;
  328.  
  329.   if (bytes == 4)
  330.     dalib_lget2_4 (a, b-(N1+1)*4, N1, p, q, mask, *a_elems);
  331.   else if (bytes == 8)
  332.     dalib_lget2_8 (a, b-(N1+1)*8, N1, p, q, mask, *a_elems);
  333.   else if (bytes == 1)
  334.     dalib_lget2_1 (a, b-(N1+1)*1, N1, p, q, mask, *a_elems);
  335.   else 
  336.     { for (i=0, a1_ptr=a ; i<*a_elems; i++, a1_ptr+= bytes)
  337.          if ((mask == p) || (mask[i]))
  338.            { b1_ptr = b + ( (p[i]-1) * *b_N1 + q[i]-1) * bytes;
  339.              for (j=0; j < bytes; j++)
  340.                 a1_ptr[j] = b1_ptr[j];
  341.            }  /* mask[i] == true */
  342.     }
  343. } /* dalib_local_getm2 */
  344.  
  345. /*******************************************************************
  346. *                                                                  *
  347. *  MASK:  B[P[j],Q[j]] = A[j]   for all j with MASK(j)             *
  348. *                                                                  *
  349. *  operations for different sizes of elements                      *
  350. *                                                                  *
  351. *******************************************************************/
  352.  
  353. void dalib_lset2_1  (a, b, S, p, q, mask, N)
  354. unsigned char *a, *b;
  355. int *p, *q, *mask, N, S;
  356. { int i;
  357.   if (mask == q)
  358.     { for (i=0; i<N; i++)
  359.          b[p[i]*S+q[i]] = a[i];
  360.     }
  361.    else
  362.     { for (i=0; i<N; i++)
  363.          if (mask[i]) b[p[i]*S+q[i]] = a[i];
  364.     }
  365. }
  366.  
  367. void dalib_lset2_4  (a, b, S, p, q, mask, N)
  368. int *a, *b;
  369. int *p, *q, *mask, N, S;
  370. { int i;
  371.   if (mask == q)
  372.     { for (i=0; i<N; i++)
  373.          b[p[i]*S+q[i]] = a[i];
  374.     }
  375.    else
  376.     { for (i=0; i<N; i++)
  377.          if (mask[i]) b[p[i]*S+q[i]] = a[i];
  378.     }
  379. }
  380.  
  381. void dalib_lset2_8  (a, b, S, p, q, mask, N)
  382. double *a, *b;
  383. int *p, *q, *mask, N, S;
  384. { int i;
  385.   if (mask == q)
  386.     { for (i=0; i<N; i++)
  387.          b[p[i]*S+q[i]] = a[i];
  388.     }
  389.    else
  390.     { for (i=0; i<N; i++)
  391.          if (mask[i]) b[p[i]*S+q[i]] = a[i];
  392.     }
  393. }
  394.  
  395. /***********************************************************************
  396. *                                                                      *
  397. *  MASK: B [P,Q] = A  : B[P[j],Q[j]] = A[j]    for all j with MASK(j)  *
  398. *                                                                      *
  399. *  void dalib_global_setm2_ (op, b, b_N1, b-N2, p, q                   *
  400. *                            a, a_size, a_elems, mask)                 *
  401. *                                                                      *
  402. ***********************************************************************/
  403.  
  404. void dalib_local_setm2_ (op, b, b_N1, b_N2, p, q,
  405.                               a, a_size, a_elems,   mask)
  406. int *op;
  407. int *a_size;        /* number of bytes for elem size of a and b */
  408. int *a_elems;       /* number of local elements in a, p, q */
  409. int *b_N1, *b_N2;   /* global dimensions of b */
  410. int *p, *q, *mask;  /* q == mask if mask is not available */
  411. unsigned char *a, *b;
  412.  
  413. { int i, j, bytes, S;
  414.   unsigned char *a_ptr, *b_ptr;
  415.   int index;
  416.  
  417.   bytes = *a_size;
  418.   S = *b_N1;
  419.  
  420.   if (*op == 0)
  421.      { if (bytes == 1)
  422.          dalib_lset2_1  (a, b-(S+1)*1, S, p, q, mask, *a_elems);
  423.        else if (bytes == 4)
  424.          dalib_lset2_4  (a, b-(S+1)*4, S, p, q, mask, *a_elems);
  425.        else if (bytes == 8)
  426.          dalib_lset2_8  (a, b-(S+1)*8, S, p, q, mask, *a_elems);
  427.        else
  428.          { for (i=0, a_ptr = a; i<*a_elems; i++, a_ptr+=bytes )
  429.              if ((mask == p) || (mask[i]))
  430.                { b_ptr = b + (p[i] - 1) * bytes;
  431.                  for (j=0; j < bytes; j++)
  432.                        b_ptr[j] = a_ptr[j];
  433.                }
  434.          }
  435.       }
  436.   else
  437.    { for (i=0, a_ptr=a ; i<*a_elems; i++, a_ptr+=bytes)
  438.       if ((mask == p) || (mask[i]))
  439.         { /* compute always new indirect address in b */
  440.           b_ptr = b + ( (p[i]-1) * S + q[i]-1) * bytes;
  441.           switch (*op) {
  442.           case  1 : min_ints (b_ptr, a_ptr); break;
  443.           case  2 : min_reals (b_ptr, a_ptr); break;
  444.           case  3 : min_doubles (b_ptr, a_ptr); break;
  445.           case  4 : max_ints (b_ptr, a_ptr); break;
  446.           case  5 : max_reals (b_ptr, a_ptr); break;
  447.           case  6 : max_doubles (b_ptr, a_ptr); break;
  448.           case  7 : add_ints (b_ptr, a_ptr); break;
  449.           case  8 : add_reals (b_ptr, a_ptr); break;
  450.           case  9 : add_doubles (b_ptr, a_ptr); break;
  451.           case 10 : mult_ints (b_ptr, a_ptr); break;
  452.           case 11 : mult_reals (b_ptr, a_ptr); break;
  453.           case 12 : mult_doubles (b_ptr, a_ptr); break;
  454.           case 13 : and_ints (b_ptr, a_ptr); break;
  455.           case 14 : or_ints (b_ptr, a_ptr); break;
  456.           case 15 : eor_ints (b_ptr, a_ptr); break;
  457.           case 16 : and_bools (b_ptr, a_ptr); break;
  458.           case 17 : or_bools (b_ptr, a_ptr); break;
  459.           case 18 : neq_bools (b_ptr, a_ptr); break;
  460.           default : printf ("illegal operation in dalib_local_set\n");
  461.                     exit(-1);
  462.                     break;
  463.           } /* switch operation */
  464.         } /* end of get b[p[i] to a[i] */
  465.     } /* end of for loop */
  466. } /* dalib_local_setm2 */
  467.  
  468. /*******************************************************************
  469. *                                                                  *
  470. *  FORTRAN INTERFACE                                               *
  471. *                                                                  *
  472. *    - subroutines without a mask parameter                        *
  473. *                                                                  *
  474. *******************************************************************/
  475.  
  476. void dalib_local_get1__ (a, a_size, a_elems, b, b_N1, p)
  477.  
  478. int *a_size;    /* size of elements of a and b in Bytes */
  479. int *a_elems;   /* number of elements in a and p        */
  480. int *b_N1;      /* number of elements of b */
  481. int *p;
  482. unsigned char *a, *b;
  483.  
  484. { /* mask = p means no mask */
  485.  
  486.    dalib_local_getm1_ (a, a_size, a_elems, b, b_N1, p, p);
  487. }
  488.  
  489. void dalib_local_get2__ (a, a_size, a_elems, b, b_N1, b_N2, p, q)
  490. int *a_size;        /* number of bytes for elem size of a and b */
  491. int *a_elems;       /* number of local elements in a, p, q */
  492. int *b_N1, b_N2;    /* global dimensions of b */
  493. int *p, *q;
  494. unsigned char *a, *b;
  495.  
  496. { /* mask = p means no mask */
  497.    dalib_local_getm2_ (a, a_size, a_elems, b, b_N1, b_N2, p, q, q);
  498. }
  499.  
  500.