charj: get rid of extra malloc in jacobi implementation
[charm.git] / src / langs / pvmc / pvmc_pack.c
1 #include <stddef.h>
2 #include "converse.h"
3 #include "pvmc.h"
4
5 #ifdef PVM_DEBUG
6 #define PARG(x) PRINTF("Pe(%d) %s:%d %s(,%d,%d) called.\n",MYPE(),__FILE__,__LINE__,x,cnt,std);
7 #endif
8
9 int pvm_upkbyte(char *cp, int cnt, int std)
10 {
11   int i, n_bytes;
12   char *buf;
13
14 #ifdef PVM_DEBUG
15   PARG("pvm_upkbyte");
16 #endif
17
18   n_bytes = cnt * sizeof(char);
19
20   buf = (char *)pvmc_getitem(n_bytes,PVM_BYTE);
21
22   if (buf==(char *)NULL) {
23     PRINTF("%s:%d pvm_upkbyte() no data mem\n",
24            __FILE__,__LINE__);
25     return -1;
26   }
27
28   if (std==1) {
29     memcpy(cp, buf, n_bytes);
30   } else {
31     /* For characters, word alignment doesn't matter, so do C copies */
32     for(i=0; i<cnt; i++)
33       cp[i*std] = buf[i];
34   }
35   return 0;
36 }
37
38 int pvm_upkcplx(float *xp, int cnt, int std)
39 {
40   int i, n_bytes;
41   float *buf;
42
43 #ifdef PVM_DEBUG
44   PARG("pvm_upkcplx");
45 #endif
46
47   n_bytes = cnt * 2 * sizeof(float);
48
49   buf = (float *)pvmc_getitem(n_bytes,PVM_CPLX);
50
51   if (buf==(float *)NULL) {
52     PRINTF("%s:%d pvm_upkcplx() no data mem\n",
53            __FILE__,__LINE__);
54     return -1;
55   }
56
57   if (std==1) {
58     memcpy(xp, buf, n_bytes);
59   } else {
60     /* do a separate memcopy for each pair of elements.  Very ugly,
61      * but otherwise, word alignment problems
62      */
63     for(i=0; i<cnt; i++)
64       memcpy(xp+2*i*std,buf+2*i,2*sizeof(float));
65   }
66   return 0;
67 }
68
69 int pvm_upkdcplx(double *zp, int cnt, int std)
70 {
71   int i, n_bytes;
72   double *buf;
73
74 #ifdef PVM_DEBUG
75   PARG("pvm_upkdcplx");
76 #endif
77
78   n_bytes = cnt * 2 * sizeof(double);
79
80   buf = (double *)pvmc_getitem(n_bytes,PVM_DCPLX);
81
82   if (buf==(double *)NULL) {
83     PRINTF("%s:%d pvm_upkdcplx() no data mem\n",
84            __FILE__,__LINE__);
85     return -1;
86   }
87
88   if (std==1) {
89     memcpy(zp, buf, n_bytes);
90   } else {
91     for(i=0; i<cnt; i++)
92       memcpy(zp+2*i*std,buf+2*i,2*sizeof(double));
93   }
94   return 0;
95 }
96
97 int pvm_upkdouble(double *dp, int cnt, int std)
98 {
99   int i, n_bytes;
100   double *buf;
101
102 #ifdef PVM_DEBUG
103   PARG("pvm_upkdouble");
104 #endif
105
106   n_bytes = cnt * sizeof(double);
107
108   buf = (double *)pvmc_getitem(n_bytes,PVM_DOUBLE);
109
110   if (buf==(double *)NULL) {
111     PRINTF("%s:%d pvm_upkdouble() no data mem\n",
112            __FILE__,__LINE__);
113     return -1;
114   }
115
116   if (std==1) {
117     memcpy(dp, buf, n_bytes);
118   } else {
119     for(i=0; i<cnt; i++)
120       memcpy(dp+i*std,buf+i,sizeof(double));
121   }
122
123   return 0;
124 }
125
126 int pvm_upkfloat(float *fp, int cnt, int std)
127 {
128   int i, n_bytes;
129   float *buf;
130
131 #ifdef PVM_DEBUG
132   PARG("pvm_upkfloat");
133 #endif
134
135   n_bytes = cnt * sizeof(float);
136
137   buf = (float *)pvmc_getitem(n_bytes,PVM_FLOAT);
138
139   if (buf==(float *)NULL) {
140     PRINTF("%s:%d pvm_upkfloat() no data mem\n",
141            __FILE__,__LINE__);
142     return -1;
143   }
144
145   if (std==1) {
146     memcpy(fp, buf, n_bytes);
147   } else {
148     for(i=0; i<cnt; i++)
149       memcpy(fp+i*std,buf+i,sizeof(float));
150   }
151   return 0;
152 }
153
154 int pvm_upkint(int *np, int cnt, int std)
155 {
156   int i, n_bytes;
157   int *buf;
158
159 #ifdef PVM_DEBUG
160   PARG("pvm_upkint");
161 #endif
162
163   n_bytes = cnt * sizeof(int);
164
165   buf = (int *)pvmc_getitem(n_bytes,PVM_INT);
166
167   if (buf==(int *)NULL) {
168     PRINTF("%s:%d pvm_upkint() no data mem\n",
169            __FILE__,__LINE__);
170     return -1;
171   }
172
173   if (std==1) {
174     memcpy(np, buf, n_bytes);
175   } else {
176     for(i=0; i<cnt; i++)
177       memcpy(np+i*std,buf+i,sizeof(int));
178   }
179   return 0;
180 }
181
182 int pvm_upkuint(unsigned int *np, int cnt, int std)
183 {
184   int i, n_bytes;
185   unsigned int *buf;
186
187 #ifdef PVM_DEBUG
188   PARG("pvm_upkuint");
189 #endif
190
191   n_bytes = cnt * sizeof(unsigned int);
192
193   buf = (unsigned int *)pvmc_getitem(n_bytes,PVM_UINT);
194
195   if (buf==(unsigned int *)NULL) {
196     PRINTF("%s:%d pvm_upkuint() no data mem\n",
197            __FILE__,__LINE__);
198     return -1;
199   }
200
201   if (std==1) {
202     memcpy(np, buf, n_bytes);
203   } else {
204     for(i=0; i<cnt; i++)
205       memcpy(np+i*std,buf+i,sizeof(unsigned int));
206   }
207   return 0;
208 }
209
210 int pvm_upklong(long *np, int cnt, int std)
211 {
212   int i, n_bytes;
213   long *buf;
214
215 #ifdef PVM_DEBUG
216   PARG("pvm_upklong");
217 #endif
218
219   n_bytes = cnt * sizeof(long);
220
221   buf = (long *)pvmc_getitem(n_bytes,PVM_LONG);
222
223   if (buf==(long *)NULL) {
224     PRINTF("%s:%d pvm_upklong() no data mem\n",
225            __FILE__,__LINE__);
226     return -1;
227   }
228
229   if (std==1) {
230     memcpy(np, buf, n_bytes);
231   } else {
232     for(i=0; i<cnt; i++)
233       memcpy(np+i*std,buf+i,sizeof(long));
234   }
235   return 0;
236 }
237
238 int pvm_upkulong(unsigned long *np, int cnt, int std)
239 {
240   int i, n_bytes;
241   unsigned long *buf;
242
243 #ifdef PVM_DEBUG
244   PARG("pvm_upkulong");
245 #endif
246
247   n_bytes = cnt * sizeof(unsigned long);
248
249   buf = (unsigned long *)pvmc_getitem(n_bytes,PVM_ULONG);
250
251   if (buf==(unsigned long *)NULL) {
252     PRINTF("%s:%d pvm_upkulong() no data mem\n",
253            __FILE__,__LINE__);
254     return -1;
255   }
256
257   if (std==1) {
258     memcpy(np, buf, n_bytes);
259   } else {
260     for(i=0; i<cnt; i++)
261       memcpy(np+i*std,buf+i,sizeof(unsigned long));
262   }
263   return 0;
264 }
265
266 int pvm_upkshort(short *np, int cnt, int std)
267 {
268   int i, n_bytes;
269   short *buf;
270
271 #ifdef PVM_DEBUG
272   PARG("pvm_upkshort");
273 #endif
274
275   n_bytes = cnt * sizeof(short);
276
277   buf = (short *)pvmc_getitem(n_bytes,PVM_SHORT);
278
279   if (buf==(short *)NULL) {
280     PRINTF("%s:%d pvm_upkshort() no data mem\n",
281            __FILE__,__LINE__);
282     return -1;
283   }
284
285   if (std==1) {
286     memcpy(np, buf, n_bytes);
287   } else {
288     for(i=0; i<cnt; i++)
289       memcpy(np+i*std,buf+i,sizeof(short));
290   }
291   return 0;
292 }
293
294 int pvm_upkushort(unsigned short *np, int cnt, int std)
295 {
296   int i, n_bytes;
297   unsigned short *buf;
298
299 #ifdef PVM_DEBUG
300   PARG("pvm_upkushort");
301 #endif
302
303   n_bytes = cnt * sizeof(unsigned short);
304
305   buf = (unsigned short *)pvmc_getitem(n_bytes,PVM_USHORT);
306
307   if (buf==(unsigned short *)NULL) {
308     PRINTF("%s:%d pvm_upkushort() no data mem\n",
309            __FILE__,__LINE__);
310     return -1;
311   }
312
313   if (std==1) {
314     memcpy(np, buf, n_bytes);
315   } else {
316     for(i=0; i<cnt; i++)
317       memcpy(np+i*std,buf+i,sizeof(unsigned short));
318   }
319   return 0;
320 }
321
322 int pvm_upkstr(char *cp)
323 {
324   int i, n_bytes;
325   short *buf;
326
327 #ifdef PVM_DEBUG
328   PRINTF("%s:%d %s() called.",__FILE__,__LINE__,"pvm_upkstr");
329 #endif
330
331   buf = (short *)pvmc_getstritem(&n_bytes);
332
333   if (buf==(short *)NULL) {
334     PRINTF("%s:%d pvm_upkshort() no data mem\n",
335            __FILE__,__LINE__);
336     return -1;
337   }
338
339   memcpy(cp, buf, n_bytes);
340   cp[n_bytes]='\0';
341
342   return 0;
343 }
344
345 /**********************************************************************/
346
347 int pvm_pkbyte(char *cp, int cnt, int std)
348 {
349   int i, n_bytes;
350   char *buf;
351
352 #ifdef PVM_DEBUG
353   PARG("pvm_pkbyte");
354 #endif
355
356   n_bytes = cnt * sizeof(char);
357
358   buf = (char *)pvmc_mkitem(n_bytes,PVM_BYTE);
359
360   if (buf==(char *)NULL) {
361     PRINTF("%s:%d pvm_pkbyte() no data mem\n",
362            __FILE__,__LINE__);
363     return -1;
364   }
365
366   if (cnt==1)
367     *buf=*cp;
368   else if (std==1) {
369     memcpy(buf, cp, n_bytes);
370   } else {
371     for(i=0; i<cnt; i++)
372       buf[i]=cp[i*std];
373   }
374   return 0;
375 }
376
377 int pvm_pkcplx(float *xp, int cnt, int std)
378 {
379   int i, n_bytes;
380   float *buf;
381
382 #ifdef PVM_DEBUG
383   PARG("pvm_pkcplx");
384 #endif
385
386   n_bytes = cnt*2*sizeof(float);
387
388   buf = (float *)pvmc_mkitem(n_bytes,PVM_CPLX);
389
390   if (buf==(float *)NULL) {
391     PRINTF("%s:%d pvm_pkcplx() no data mem\n",
392            __FILE__,__LINE__);
393     return -1;
394   }
395
396   if (cnt==1)
397     *buf=*xp;
398   else if (std==1) {
399     memcpy(buf, xp, n_bytes);
400   } else {
401     for(i=0; i<cnt; i++) {
402       buf[2*i]=xp[i*std];
403       buf[2*i+1]=xp[i*std+1];
404     }
405   }
406   return 0;
407 }
408
409 int pvm_pkdcplx(double *zp, int cnt, int std)
410 {
411   int i, n_bytes;
412   double *buf;
413
414 #ifdef PVM_DEBUG
415   PARG("pvm_pkdcplx");
416 #endif
417
418   n_bytes = cnt*2*sizeof(double);
419
420   buf = (double *)pvmc_mkitem(n_bytes,PVM_DCPLX);
421   if (buf==(double *)NULL) {
422     PRINTF("%s:%d pvm_pkdcplx() no data mem\n",
423            __FILE__,__LINE__);
424     return -1;
425   }
426
427   if (cnt==1)
428     *buf=*zp;
429   else if (std==1) {
430     memcpy(buf, zp, n_bytes);
431   } else {
432     for(i=0; i<cnt; i++) {
433       buf[2*i]=zp[i*std];
434       buf[2*i+1]=zp[i*std+1];
435     }
436   }
437   return 0;
438 }
439
440 int pvm_pkdouble(double *dp, int cnt, int std)
441 {
442   int i, n_bytes;
443   double *buf;
444
445 #ifdef PVM_DEBUG
446   PARG("pvm_pkdouble");
447 #endif
448
449   n_bytes = cnt*sizeof(double);
450
451   buf = (double *)pvmc_mkitem(n_bytes,PVM_DOUBLE);
452   if (buf==(double *)NULL) {
453     PRINTF("%s:%d pvm_pkdouble() no data mem\n",
454            __FILE__,__LINE__);
455     return -1;
456   }
457
458   if (cnt==1)
459     *buf=*dp;
460   else if (std==1) {
461     memcpy(buf, dp, n_bytes);
462   } else {
463     for(i=0; i<cnt; i++) {
464       buf[i]=dp[i*std];
465     }
466   }
467   return 0;
468 }
469
470 int pvm_pkfloat(float *fp, int cnt, int std)
471 {
472   int i, n_bytes;
473   float *buf;
474
475 #ifdef PVM_DEBUG
476   PARG("pvm_pkfloat");
477 #endif
478
479   n_bytes = cnt*sizeof(float);
480
481   buf = (float *)pvmc_mkitem(n_bytes,PVM_FLOAT);
482   if (buf==(float *)NULL) {
483     PRINTF("%s:%d pvm_pkfloat() no data mem\n",
484            __FILE__,__LINE__);
485     return -1;
486   }
487
488   if (cnt==1)
489     *buf=*fp;
490   else if (std==1) {
491     memcpy(buf, fp, n_bytes);
492   } else {
493     for(i=0; i<cnt; i++) {
494       buf[i]=fp[i*std];
495     }
496   }
497   return 0;
498 }
499
500 int pvm_pkint(int *np, int cnt, int std)
501 {
502   int i, n_bytes;
503   int *buf;
504
505 #ifdef PVM_DEBUG
506   PARG("pvm_pkint");
507 #endif
508
509   n_bytes = cnt*sizeof(int);
510
511   buf = (int *)pvmc_mkitem(n_bytes,PVM_INT);
512   if (buf==(int *)NULL) {
513     PRINTF("%s:%d pvm_pkint() no data mem\n",
514            __FILE__,__LINE__);
515     return -1;
516   }
517
518   if (cnt==1)
519     *buf=*np;
520   else if (std==1) {
521     memcpy(buf, np, n_bytes);
522   } else {
523     for(i=0; i<cnt; i++) {
524       buf[i]=np[i*std];
525     }
526   }
527   return 0;
528 }
529
530 int pvm_pkuint(unsigned int *np, int cnt, int std)
531 {
532   int i, n_bytes;
533   unsigned int *buf;
534
535 #ifdef PVM_DEBUG
536   PARG("pvm_pkuint");
537 #endif
538
539   n_bytes = cnt*sizeof(unsigned int);
540
541   buf = (unsigned int *)pvmc_mkitem(n_bytes,PVM_UINT);
542   if (buf==(unsigned int *)NULL) {
543     PRINTF("%s:%d pvm_pkuint() no data mem\n",
544            __FILE__,__LINE__);
545     return -1;
546   }
547
548   if (cnt==1)
549     *buf=*np;
550   else if (std==1) {
551     memcpy(buf, np, n_bytes);
552   } else {
553     for(i=0; i<cnt; i++) {
554       buf[i]=np[i*std];
555     }
556   }
557   return 0;
558 }
559
560 int pvm_pklong(long *np, int cnt, int std)
561 {
562   int i, n_bytes;
563   long *buf;
564
565 #ifdef PVM_DEBUG
566   PARG("pvm_pklong");
567 #endif
568
569   n_bytes = cnt*sizeof(long);
570
571   buf = (long *)pvmc_mkitem(n_bytes,PVM_LONG);
572   if (buf==(long *)NULL) {
573     PRINTF("%s:%d pvm_pklong() no data mem\n",
574            __FILE__,__LINE__);
575     return -1;
576   }
577
578   if (cnt==1)
579     *buf=*np;
580   else if (std==1) {
581     memcpy(buf, np, n_bytes);
582   } else {
583     for(i=0; i<cnt; i++) {
584       buf[i]=np[i*std];
585     }
586   }
587   return 0;
588 }
589
590 int pvm_pkulong(unsigned long *np, int cnt, int std)
591 {
592   int i, n_bytes;
593   unsigned long *buf;
594
595 #ifdef PVM_DEBUG
596   PARG("pvm_pkulong");
597 #endif
598
599   n_bytes = cnt*sizeof(unsigned long);
600
601   buf = (unsigned long *)pvmc_mkitem(n_bytes,PVM_ULONG);
602   if (buf==(unsigned long *)NULL) {
603     PRINTF("%s:%d pvm_pkulong() no data mem\n",
604            __FILE__,__LINE__);
605     return -1;
606   }
607
608   if (cnt==1)
609     *buf=*np;
610   else if (std==1) {
611     memcpy(buf, np, n_bytes);
612   } else {
613     for(i=0; i<cnt; i++) {
614       buf[i]=np[i*std];
615     }
616   }
617   return 0;
618 }
619
620 int pvm_pkshort(short *np, int cnt, int std)
621 {
622   int i, n_bytes;
623   short *buf;
624
625 #ifdef PVM_DEBUG
626   PARG("pvm_pkshort");
627 #endif
628
629   n_bytes = cnt*sizeof(short);
630
631   buf = (short *)pvmc_mkitem(n_bytes,PVM_SHORT);
632   if (buf==(short *)NULL) {
633     PRINTF("%s:%d pvm_pkshort() no data mem\n",
634            __FILE__,__LINE__);
635     return -1;
636   }
637
638   if (cnt==1)
639     *buf=*np;
640   else if (std==1) {
641     memcpy(buf, np, n_bytes);
642   } else {
643     for(i=0; i<cnt; i++) {
644       buf[i]=np[i*std];
645     }
646   }
647   return 0;
648 }
649
650 int pvm_pkushort(unsigned short *np, int cnt, int std)
651 {
652   int i, n_bytes;
653   unsigned short *buf;
654
655 #ifdef PVM_DEBUG
656   PARG("pvm_pkushort");
657 #endif
658
659   n_bytes = cnt*sizeof(unsigned short);
660
661   buf = (unsigned short *)pvmc_mkitem(n_bytes,PVM_USHORT);
662   if (buf==(unsigned short *)NULL) {
663     PRINTF("%s:%d pvm_pkushort() no data mem\n",
664            __FILE__,__LINE__);
665     return -1;
666   }
667
668   if (cnt==1)
669     *buf=*np;
670   else if (std==1) {
671     memcpy(buf, np, n_bytes);
672   } else {
673     for(i=0; i<cnt; i++) {
674       buf[i]=np[i*std];
675     }
676   }
677   return 0;
678 }
679
680 int pvm_pkstr(char *cp)
681 {
682   int i, n_bytes;
683   char *buf;
684
685 #ifdef PVM_DEBUG
686   PRINTF("%s:%d %s() called.",__FILE__,__LINE__,"pvm_pkstr");
687 #endif
688
689   n_bytes = strlen(cp);
690
691   buf = (char *)pvmc_mkitem(n_bytes,PVM_STR);
692   if (buf==(char *)NULL) {
693     PRINTF("%s:%d pvm_pkstr() no data mem\n",
694            __FILE__,__LINE__);
695     return -1;
696   }
697
698   memcpy(buf, cp, n_bytes);
699
700   return 0;
701 }
702