← Back to branch summary

~ubuntu-branches/ubuntu/trusty/nwchem/trusty-proposed

« back to all changes in this revision

Viewing changes to src/tools/ga-5-2/armci/src/devices/dcmf/dcmf2/armcix_acc.c

  • Committer: Package Import Robot
  • Author(s): Michael Banck, Daniel Leidert, Andreas Tille, Michael Banck
  • Date: 2013-07-04 12:14:55 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130704121455-5tvsx2qabor3nrui
Tags: 6.3-1
http://bugs.debian.org/696361
* New upstream release.
* Fixes anisotropic properties (Closes: #696361).
* New features include:
  + Multi-reference coupled cluster (MRCC) approaches
  + Hybrid DFT calculations with short-range HF 
  + New density-functionals including Minnesota (M08, M11) and HSE hybrid
    functionals
  + X-ray absorption spectroscopy (XAS) with TDDFT
  + Analytical gradients for the COSMO solvation model
  + Transition densities from TDDFT 
  + DFT+U and Electron-Transfer (ET) methods for plane wave calculations
  + Exploitation of space group symmetry in plane wave geometry optimizations
  + Local density of states (LDOS) collective variable added to Metadynamics
  + Various new XC functionals added for plane wave calculations, including
    hybrid and range-corrected ones
  + Electric field gradients with relativistic corrections 
  + Nudged Elastic Band optimization method
  + Updated basis sets and ECPs 

[ Daniel Leidert ]
* debian/watch: Fixed.

[ Andreas Tille ]
* debian/upstream: References

[ Michael Banck ]
* debian/upstream (Name): New field.
* debian/patches/02_makefile_flags.patch: Refreshed.
* debian/patches/06_statfs_kfreebsd.patch: Likewise.
* debian/patches/07_ga_target_force_linux.patch: Likewise.
* debian/patches/05_avoid_inline_assembler.patch: Removed, no longer needed.
* debian/patches/09_backported_6.1.1_fixes.patch: Likewise.
* debian/control (Build-Depends): Added gfortran-4.7 and gcc-4.7.
* debian/patches/10_force_gcc-4.7.patch: New patch, explicitly sets
  gfortran-4.7 and gcc-4.7, fixes test suite hang with gcc-4.8 (Closes:
  #701328, #713262).
* debian/testsuite: Added tests for COSMO analytical gradients and MRCC.
* debian/rules (MRCC_METHODS): New variable, required to enable MRCC methods.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tools/ga-5-2/armci/src/devices/dcmf/dcmf2/armcix_acc.c
 
1
#if HAVE_CONFIG_H
 
2
#   include "config.h"
 
3
#endif
 
4
 
 
5
/* begin_generated_IBM_copyright_prolog                             */
 
6
/*                                                                  */
 
7
/* ---------------------------------------------------------------- */
 
8
/* (C)Copyright IBM Corp.  2007, 2008                               */
 
9
/* IBM BSD License                                                  */
 
10
/* ---------------------------------------------------------------- */
 
11
/*                                                                  */
 
12
/* end_generated_IBM_copyright_prolog                               */
 
13
/**
 
14
 * \file armci/src/x/dcmf/armcix_acc.c
 
15
 * \brief DCMF ARMCI Extension for accumulate operations.
 
16
 */
 
17
 
 
18
#include "armcix_impl.h"
 
19
 
 
20
typedef struct {
 
21
    float real;
 
22
    float imag;
 
23
} complex_t;
 
24
 
 
25
typedef struct {
 
26
    double real;
 
27
    double imag;
 
28
} dcomplex_t;
 
29
 
 
30
typedef union ARMCIX_DCMF_AccInfo_t
 
31
{
 
32
  DCQuad         raw[2];
 
33
  struct
 
34
  {
 
35
    void       * dst;
 
36
    int          datatype;
 
37
    unsigned     bytes;
 
38
    union
 
39
    {
 
40
      int        ival;
 
41
      long       lval;
 
42
      float      fval;
 
43
      double     dval;
 
44
      complex_t  cplxval;
 
45
      dcomplex_t dcplxval;
 
46
    };
 
47
  };
 
48
}
 
49
ARMCIX_DCMF_AccInfo_t __attribute__ ((__aligned__ (16)));
 
50
 
 
51
typedef struct ARMCIX_DCMF_AccNbInfo_t
 
52
{
 
53
  ARMCIX_DCMF_AccInfo_t      info;
 
54
  ARMCIX_DCMF_Connection_t * connection;
 
55
  void                     * buffer;
 
56
}
 
57
ARMCIX_DCMF_AccNbInfo_t;
 
58
 
 
59
#define ACCUMULATE( DTYPE, scale, elems, src, dst) {\
 
60
    int j;\
 
61
    DTYPE *a =(DTYPE *)(dst);\
 
62
    DTYPE *b =(DTYPE *)(src);\
 
63
    DTYPE alpha = *(DTYPE *)(scale);\
 
64
    for(j=0;j<(elems);j++)a[j] += alpha*b[j];\
 
65
}
 
66
        
 
67
#define CPL_ACCUMULATE( DTYPE, scale, elems, src, dst) {\
 
68
    int j;\
 
69
    DTYPE *a =(DTYPE *)(dst);\
 
70
    DTYPE *b =(DTYPE *)(src);\
 
71
    DTYPE alpha = *(DTYPE *)(scale);\
 
72
    for(j=0;j<(elems);j++){\
 
73
        a[j].real += alpha.real*b[j].real - alpha.imag*b[j].imag;\
 
74
        a[j].imag += alpha.imag*b[j].real + alpha.real*b[j].imag;\
 
75
    }\
 
76
}
 
77
 
 
78
DCMF_Protocol_t __acc_protocol;
 
79
 
 
80
/**
 
81
 * \brief DCMF ARMCI Extention receive short accumulate operation callback
 
82
 *
 
83
 * \see DCMF_RecvSendShort
 
84
 */
 
85
void ARMCIX_DCMF_RecvAcc1 (void           * clientdata,
 
86
                           const DCQuad   * msginfo,
 
87
                           unsigned         count,
 
88
                           unsigned         peer,
 
89
                           const char     * src,
 
90
                           unsigned         bytes)
 
91
{
 
92
  //ARMCIX_DCMF_Connection_t * connection = (ARMCIX_DCMF_Connection_t *) clientdata;
 
93
  ARMCIX_DCMF_AccInfo_t * info = (ARMCIX_DCMF_AccInfo_t *) msginfo;
 
94
 
 
95
  switch (info->datatype)
 
96
  {
 
97
    case ARMCI_ACC_INT:
 
98
      ACCUMULATE( int, &info->ival, bytes/sizeof(int), src, info->dst);
 
99
      break;
 
100
    case ARMCI_ACC_DBL:
 
101
      ACCUMULATE( double, &info->dval, bytes/sizeof(double), src, info->dst);
 
102
      break;
 
103
    case ARMCI_ACC_FLT:
 
104
      ACCUMULATE( float, &info->fval, bytes/sizeof(float), src, info->dst);
 
105
      break;
 
106
    case ARMCI_ACC_CPL:
 
107
      CPL_ACCUMULATE( complex_t, &info->cplxval, bytes/sizeof(complex_t), src, info->dst);
 
108
      break;
 
109
    case ARMCI_ACC_DCP:
 
110
      CPL_ACCUMULATE( dcomplex_t, &info->dcplxval, bytes/sizeof(dcomplex_t), src, info->dst);
 
111
      break;
 
112
    case ARMCI_ACC_LNG:
 
113
      ACCUMULATE( long, &info->lval, bytes/sizeof(long), src, info->dst);
 
114
      break;
 
115
    default:
 
116
      assert (0);
 
117
      break;
 
118
  }
 
119
}
 
120
 
 
121
 
 
122
void ARMCIX_DCMF_AccReceiveComplete (ARMCIX_DCMF_AccNbInfo_t * nbinfo)
 
123
{
 
124
  ARMCIX_DCMF_AccInfo_t * info = (ARMCIX_DCMF_AccInfo_t *) &nbinfo->info;
 
125
 
 
126
  switch (info->datatype)
 
127
  {
 
128
    case ARMCI_ACC_INT:
 
129
      ACCUMULATE( int, &info->ival, info->bytes/sizeof(int), nbinfo->buffer, info->dst);
 
130
      break;
 
131
    case ARMCI_ACC_DBL:
 
132
      ACCUMULATE( double, &info->dval, info->bytes/sizeof(double), nbinfo->buffer, info->dst);
 
133
      break;
 
134
    case ARMCI_ACC_FLT:
 
135
      ACCUMULATE( float, &info->fval, info->bytes/sizeof(float), nbinfo->buffer, info->dst);
 
136
      break;
 
137
    case ARMCI_ACC_CPL:
 
138
      CPL_ACCUMULATE( complex_t, &info->cplxval, info->bytes/sizeof(complex_t), nbinfo->buffer, info->dst);
 
139
      break;
 
140
    case ARMCI_ACC_DCP:
 
141
      CPL_ACCUMULATE( dcomplex_t, &info->dcplxval, info->bytes/sizeof(dcomplex_t), nbinfo->buffer, info->dst);
 
142
      break;
 
143
    case ARMCI_ACC_LNG:
 
144
      ACCUMULATE( long, &info->lval, info->bytes/sizeof(long), nbinfo->buffer, info->dst);
 
145
      break;
 
146
    default:
 
147
      assert (0);
 
148
      break;
 
149
  }
 
150
 
 
151
  free (nbinfo);
 
152
}
 
153
 
 
154
 
 
155
/**
 
156
 * \brief DCMF ARMCI Extention receive accumulate operation callback
 
157
 *
 
158
 * \see DCMF_RecvSend
 
159
 */
 
160
DCMF_Request_t * ARMCIX_DCMF_RecvAcc2 (void             * clientdata,
 
161
                                       const DCQuad     * msginfo,
 
162
                                       unsigned           count,
 
163
                                       unsigned           peer,
 
164
                                       unsigned           sndlen,
 
165
                                       unsigned         * rcvlen,
 
166
                                       char            ** rcvbuf,
 
167
                                       DCMF_Callback_t  * cb_done)
 
168
{
 
169
  ARMCIX_DCMF_Connection_t * connection = (ARMCIX_DCMF_Connection_t *) clientdata;
 
170
 
 
171
  ARMCIX_DCMF_AccNbInfo_t * nbinfo = (ARMCIX_DCMF_AccNbInfo_t *) malloc (sizeof(ARMCIX_DCMF_AccNbInfo_t) + sndlen);
 
172
 
 
173
  memcpy (&nbinfo->info, msginfo, sizeof(ARMCIX_DCMF_AccInfo_t));
 
174
  nbinfo->connection = &connection[peer];
 
175
  nbinfo->buffer = (void *)(((char *) nbinfo) + sizeof(ARMCIX_DCMF_AccNbInfo_t));
 
176
 
 
177
  *rcvlen = sndlen;
 
178
  *rcvbuf = nbinfo->buffer;
 
179
 
 
180
  cb_done->function   = (void *) ARMCIX_DCMF_AccReceiveComplete;
 
181
  cb_done->clientdata = (void *) nbinfo;
 
182
 
 
183
  return &connection[peer].request;
 
184
}
 
185
 
 
186
 
 
187
/**
 
188
 * \brief Register the DCMF ARMCI Extention accumulate operation.
 
189
 *
 
190
 * \param[in]  connection_array Connection array
 
191
 *
 
192
 * \see DCMF_Send_register
 
193
 */
 
194
void ARMCIX_DCMF_Acc_register (ARMCIX_DCMF_Connection_t * connection_array)
 
195
{
 
196
  DCMF_CriticalSection_enter (0);
 
197
 
 
198
  DCMF_Send_Configuration_t configuration = {
 
199
    DCMF_DEFAULT_SEND_PROTOCOL,
 
200
    ARMCIX_DCMF_RecvAcc1,
 
201
    connection_array,
 
202
    ARMCIX_DCMF_RecvAcc2,
 
203
    connection_array
 
204
  };
 
205
  DCMF_Send_register (&__acc_protocol, &configuration);
 
206
 
 
207
  DCMF_CriticalSection_exit (0);
 
208
}
 
209
 
 
210
/**
 
211
 * \brief ARMCI Extension blocking accumulate operation.
 
212
 *
 
213
 * \param[in] datatype  accumulate datatype (operation code)
 
214
 * \param[in] scale     opaque pointer to the scaling factor for accumulate
 
215
 * \param[in] src       Source buffer on the local node
 
216
 * \param[in] dst       Destination buffer on the remote node
 
217
 * \param[in] bytes     Number of bytes to transfer
 
218
 * \param[in] proc      Remote node rank
 
219
 *
 
220
 * \return ???
 
221
 */
 
222
int ARMCIX_Acc (int datatype, void * scale, void * src, void * dst, int bytes, int proc)
 
223
{
 
224
  DCMF_CriticalSection_enter (0);
 
225
 
 
226
  volatile unsigned active = 1;
 
227
  DCMF_Callback_t cb_wait = { ARMCIX_DCMF_cb_decrement, (void *)&active };
 
228
  DCMF_Request_t request;
 
229
 
 
230
  ARMCIX_DCMF_AccInfo_t info;
 
231
  info.dst = dst;
 
232
  info.bytes = bytes;
 
233
  info.datatype = datatype;
 
234
  switch (datatype)
 
235
  {
 
236
    case ARMCI_ACC_INT:
 
237
      info.ival = *((int *)scale);
 
238
      break;
 
239
    case ARMCI_ACC_DBL:
 
240
      info.dval = *((double *)scale);
 
241
      break;
 
242
    case ARMCI_ACC_FLT:
 
243
      info.fval = *((float *)scale);
 
244
      break;
 
245
    case ARMCI_ACC_CPL:
 
246
      info.cplxval.real = ((complex_t *)scale)->real;
 
247
      info.cplxval.imag = ((complex_t *)scale)->imag;
 
248
      break;
 
249
    case ARMCI_ACC_DCP:
 
250
      info.dcplxval.real = ((dcomplex_t *)scale)->real;
 
251
      info.dcplxval.imag = ((dcomplex_t *)scale)->imag;
 
252
      break;
 
253
    case ARMCI_ACC_LNG:
 
254
      info.lval = *((long *)scale);
 
255
      break;
 
256
    default:
 
257
      assert (0);
 
258
      break;
 
259
  }
 
260
 
 
261
  DCMF_Send ( &__acc_protocol,
 
262
              &request,
 
263
              cb_wait,
 
264
              DCMF_SEQUENTIAL_CONSISTENCY,
 
265
              proc,
 
266
              bytes,
 
267
              (char *) src,
 
268
              (DCQuad *) &info,
 
269
              2);
 
270
 
 
271
#ifdef BLOCKING_OPERATIONS_REQUIRE_FENCE
 
272
  ARMCIX_Fence (proc);
 
273
#else
 
274
  while (active) DCMF_Messager_advance ();
 
275
#endif
 
276
 
 
277
  DCMF_CriticalSection_exit  (0);
 
278
 
 
279
  return 0;
 
280
}
 
281
 
 
282
 
 
283
/**
 
284
 * \brief ARMCI Extension non-blocking accumulate operation.
 
285
 *
 
286
 * \param[in] datatype  accumulate datatype (operation code)
 
287
 * \param[in] scale     opaque pointer to the scaling factor for accumulate
 
288
 * \param[in] src       Source buffer on the local node
 
289
 * \param[in] dst       Destination buffer on the remote node
 
290
 * \param[in] bytes     Number of bytes to transfer
 
291
 * \param[in] proc      Remote node rank
 
292
 * \param[in] nb_handle ARMCI non-blocking handle
 
293
 *
 
294
 * \return ???
 
295
 */
 
296
int ARMCIX_NbAcc (int datatype, void * scale, void * src, void * dst, int bytes, int proc, armci_ihdl_t nb_handle)
 
297
{
 
298
  DCMF_CriticalSection_enter (0);
 
299
 
 
300
  armcix_dcmf_opaque_t * dcmf = (armcix_dcmf_opaque_t *) &nb_handle->cmpl_info;
 
301
  dcmf->active++;
 
302
  dcmf->connection = &__connection[proc];
 
303
 
 
304
  __connection[proc].active++;
 
305
  __global_connection.active++;
 
306
 
 
307
  DCMF_Callback_t cb_free = { ARMCIX_DCMF_NbOp_cb_done, nb_handle };
 
308
  ARMCIX_DCMF_Request_t * new_request = ARMCIX_DCMF_request_allocate (cb_free);
 
309
  DCMF_Callback_t cb_done = { (void(*)(void *)) ARMCIX_DCMF_request_free, new_request };
 
310
 
 
311
  ARMCIX_DCMF_AccInfo_t * info = (ARMCIX_DCMF_AccInfo_t *) &(new_request->quad[0]);
 
312
  info->dst = dst;
 
313
  info->bytes = bytes;
 
314
  info->datatype = datatype;
 
315
  switch (datatype)
 
316
  {
 
317
    case ARMCI_ACC_INT:
 
318
      info->ival = *((int *)scale);
 
319
      break;
 
320
    case ARMCI_ACC_DBL:
 
321
      info->dval = *((double *)scale);
 
322
      break;
 
323
    case ARMCI_ACC_FLT:
 
324
      info->fval = *((float *)scale);
 
325
      break;
 
326
    case ARMCI_ACC_CPL:
 
327
      info->cplxval.real = ((complex_t *)scale)->real;
 
328
      info->cplxval.imag = ((complex_t *)scale)->imag;
 
329
      break;
 
330
    case ARMCI_ACC_DCP:
 
331
      info->dcplxval.real = ((dcomplex_t *)scale)->real;
 
332
      info->dcplxval.imag = ((dcomplex_t *)scale)->imag;
 
333
      break;
 
334
    case ARMCI_ACC_LNG:
 
335
      info->lval = *((long *)scale);
 
336
      break;
 
337
    default:
 
338
      assert (0);
 
339
      break;
 
340
  }
 
341
 
 
342
  DCMF_Send ( &__acc_protocol,
 
343
              &(new_request->request),
 
344
              cb_done,
 
345
              DCMF_SEQUENTIAL_CONSISTENCY,
 
346
              proc,
 
347
              bytes,
 
348
              (char *) src,
 
349
              (DCQuad *) info,
 
350
              2);
 
351
 
 
352
  DCMF_CriticalSection_exit  (0);
 
353
 
 
354
  return 0;
 
355
}
 
356
 
 
357
 
 
358
/**
 
359
 * \brief ARMCI Extension blocking vector accumulate operation.
 
360
 *
 
361
 * \todo something goofy with AccV .. should be able to replace with combination of
 
362
 *       ARMCIX_AccV and ARMCIX_Wait, but that causes test-ibm.x to hang. Maybe
 
363
 *       related to interrupts?
 
364
 *
 
365
 * \param[in] datatype accumulate datatype (operation code)
 
366
 * \param[in] scale opaque pointer to the scaling factor for accumulate
 
367
 * \param[in] darr descriptor array
 
368
 * \param[in] len length of the descriptor array
 
369
 * \param[in] proc process(or) ID
 
370
 */
 
371
int ARMCIX_AccV (int datatype, void * scale, armci_giov_t * darr, int len, int proc)
 
372
{
 
373
#if 0
 
374
#error causes test-ibm.x to hang!
 
375
  armci_ireq_t nb_request;
 
376
  armci_ihdl_t nb_handle = (armci_ihdl_t) &nb_request;
 
377
  ARMCIX_NbAccV (datatype, scale, darr, len, proc, nb_handle);
 
378
#warning remove this ARMCIX_Fence() and implement some sort of ack scheme.
 
379
  ARMCIX_Fence (proc);
 
380
  ARMCIX_Wait (&nb_handle->cmpl_info);
 
381
#else
 
382
  DCMF_CriticalSection_enter (0);
 
383
 
 
384
  // Calculate the number of requests
 
385
  unsigned n = 0;
 
386
  unsigned i, j;
 
387
  for (i = 0; i < len; i++)
 
388
    for (j = 0; j < darr[i].ptr_array_len; j++)
 
389
      n++;
 
390
 
 
391
  volatile unsigned active = n;
 
392
  DCMF_Callback_t cb_wait = { ARMCIX_DCMF_cb_decrement, (void *)&active };
 
393
  DCMF_Request_t request[n];
 
394
 
 
395
  ARMCIX_DCMF_AccInfo_t info;
 
396
  info.datatype = datatype;
 
397
  switch (datatype)
 
398
  {
 
399
    case ARMCI_ACC_INT:
 
400
      info.ival = *((int *)scale);
 
401
      break;
 
402
    case ARMCI_ACC_DBL:
 
403
      info.dval = *((double *)scale);
 
404
      break;
 
405
    case ARMCI_ACC_FLT:
 
406
      info.fval = *((float *)scale);
 
407
      break;
 
408
    case ARMCI_ACC_CPL:
 
409
      info.cplxval.real = ((complex_t *)scale)->real;
 
410
      info.cplxval.imag = ((complex_t *)scale)->imag;
 
411
      break;
 
412
    case ARMCI_ACC_DCP:
 
413
      info.dcplxval.real = ((dcomplex_t *)scale)->real;
 
414
      info.dcplxval.imag = ((dcomplex_t *)scale)->imag;
 
415
      break;
 
416
    case ARMCI_ACC_LNG:
 
417
      info.lval = *((long *)scale);
 
418
      break;
 
419
    default:
 
420
      assert (0);
 
421
      break;
 
422
  }
 
423
 
 
424
  for (i = 0; i < len; i++)
 
425
  {
 
426
    info.bytes = darr[i].bytes;
 
427
    for (j = 0; j < darr[i].ptr_array_len; j++)
 
428
    {
 
429
      info.dst = darr[i].dst_ptr_array[j];
 
430
      DCMF_Send ( &__acc_protocol,
 
431
                  &request[--n],
 
432
                  cb_wait,
 
433
                  DCMF_SEQUENTIAL_CONSISTENCY,
 
434
                  proc,
 
435
                  info.bytes,
 
436
                  (char *) darr[i].src_ptr_array[j],
 
437
                  (DCQuad *) &info,
 
438
                  2);
 
439
    }
 
440
  }
 
441
 
 
442
#ifdef BLOCKING_OPERATIONS_REQUIRE_FENCE
 
443
  ARMCIX_Fence (proc);
 
444
#else
 
445
  // Poll until all accumulate messages have been sent.
 
446
  while (active) DCMF_Messager_advance ();
 
447
#endif
 
448
 
 
449
  DCMF_CriticalSection_exit  (0);
 
450
#endif
 
451
  return 0;
 
452
}
 
453
 
 
454
 
 
455
/**
 
456
 * \brief ARMCI Extension non-blocking vector accumulate operation.
 
457
 *
 
458
 * \param[in] datatype  accumulate datatype (operation code)
 
459
 * \param[in] scale     opaque pointer to the scaling factor for accumulate
 
460
 * \param[in] darr      Descriptor array
 
461
 * \param[in] len       Length of descriptor array
 
462
 * \param[in] proc      Remote process(or) ID
 
463
 * \param[in] nb_handle ARMCI non-blocking handle
 
464
 *
 
465
 * \return ???
 
466
 */
 
467
int ARMCIX_NbAccV (int datatype, void * scale, armci_giov_t * darr, int len, int proc, armci_ihdl_t nb_handle)
 
468
{
 
469
  DCMF_CriticalSection_enter (0);
 
470
 
 
471
  // Calculate the number of requests
 
472
  unsigned n = 0;
 
473
  unsigned i, j;
 
474
  for (i = 0; i < len; i++)
 
475
    for (j = 0; j < darr[i].ptr_array_len; j++)
 
476
      n++;
 
477
 
 
478
  armcix_dcmf_opaque_t * dcmf = (armcix_dcmf_opaque_t *) &nb_handle->cmpl_info;
 
479
  dcmf->connection = &__connection[proc];
 
480
  dcmf->active += n;
 
481
 
 
482
  __connection[proc].active += n;
 
483
  __global_connection.active += n;
 
484
#if 0
 
485
  ARMCIX_DCMF_AccInfo_t info;
 
486
  info.datatype = datatype;
 
487
  switch (datatype)
 
488
  {
 
489
    case ARMCI_ACC_INT:
 
490
      info.ival = *((int *)scale);
 
491
      break;
 
492
    case ARMCI_ACC_DBL:
 
493
      info.dval = *((double *)scale);
 
494
      break;
 
495
    case ARMCI_ACC_FLT:
 
496
      info.fval = *((float *)scale);
 
497
      break;
 
498
    case ARMCI_ACC_CPL:
 
499
      info.cplxval.real = ((complex_t *)scale)->real;
 
500
      info.cplxval.imag = ((complex_t *)scale)->imag;
 
501
      break;
 
502
    case ARMCI_ACC_DCP:
 
503
      info.dcplxval.real = ((dcomplex_t *)scale)->real;
 
504
      info.dcplxval.imag = ((dcomplex_t *)scale)->imag;
 
505
      break;
 
506
    case ARMCI_ACC_LNG:
 
507
      info.lval = *((long *)scale);
 
508
      break;
 
509
    default:
 
510
      assert (0);
 
511
      break;
 
512
  }
 
513
#endif
 
514
 
 
515
  for (i = 0; i < len; i++)
 
516
  {
 
517
    //info.bytes = darr[i].bytes;
 
518
    for (j = 0; j < darr[i].ptr_array_len; j++)
 
519
    {
 
520
      DCMF_Callback_t cb_free = { ARMCIX_DCMF_NbOp_cb_done, nb_handle };
 
521
      ARMCIX_DCMF_Request_t * new_request = ARMCIX_DCMF_request_allocate (cb_free);
 
522
      DCMF_Callback_t cb_done = { (void(*)(void *)) ARMCIX_DCMF_request_free, new_request };
 
523
 
 
524
      ARMCIX_DCMF_AccInfo_t * info = (ARMCIX_DCMF_AccInfo_t *) &(new_request->quad[0]);
 
525
      //info->dst = dst;
 
526
      //info->bytes = bytes;
 
527
      info->datatype = datatype;
 
528
      info->bytes = darr[i].bytes;
 
529
      switch (datatype)
 
530
      {
 
531
        case ARMCI_ACC_INT:
 
532
          info->ival = *((int *)scale);
 
533
          break;
 
534
        case ARMCI_ACC_DBL:
 
535
          info->dval = *((double *)scale);
 
536
          break;
 
537
        case ARMCI_ACC_FLT:
 
538
          info->fval = *((float *)scale);
 
539
          break;
 
540
        case ARMCI_ACC_CPL:
 
541
          info->cplxval.real = ((complex_t *)scale)->real;
 
542
          info->cplxval.imag = ((complex_t *)scale)->imag;
 
543
          break;
 
544
        case ARMCI_ACC_DCP:
 
545
          info->dcplxval.real = ((dcomplex_t *)scale)->real;
 
546
          info->dcplxval.imag = ((dcomplex_t *)scale)->imag;
 
547
          break;
 
548
        case ARMCI_ACC_LNG:
 
549
          info->lval = *((long *)scale);
 
550
          break;
 
551
        default:
 
552
          assert (0);
 
553
          break;
 
554
      }
 
555
 
 
556
      info->dst = darr[i].dst_ptr_array[j];
 
557
      DCMF_Send ( &__acc_protocol,
 
558
                  &(new_request->request),
 
559
                  cb_done,
 
560
                  DCMF_SEQUENTIAL_CONSISTENCY,
 
561
                  proc,
 
562
                  info->bytes,
 
563
                  (char *) darr[i].src_ptr_array[j],
 
564
                  (DCQuad *) info,
 
565
                  2);
 
566
    }
 
567
  }
 
568
 
 
569
  DCMF_CriticalSection_exit  (0);
 
570
 
 
571
  return 0;
 
572
}
 
573
 
 
574
 
 
575
 
 
576
 
 
577
unsigned ARMCIX_DCMF_AccS_recurse (int datatype, void * scale,
 
578
                                   void * src_ptr, int * src_stride_arr,
 
579
                                   void * dst_ptr, int * dst_stride_arr,
 
580
                                   int * seg_count, int stride_levels, int proc,
 
581
                                   armci_ihdl_t nb_handle)
 
582
{
 
583
  unsigned num_requests = 0;
 
584
 
 
585
  //fprintf (stderr, "ARMCIX_DCMF_AccS_recurse() >> \n");
 
586
 
 
587
  if (stride_levels == 0)
 
588
  {
 
589
    DCMF_Callback_t cb_free = { ARMCIX_DCMF_NbOp_cb_done, nb_handle };
 
590
    ARMCIX_DCMF_Request_t * new_request = ARMCIX_DCMF_request_allocate (cb_free);
 
591
    DCMF_Callback_t cb_done = { (void(*)(void *)) ARMCIX_DCMF_request_free, new_request };
 
592
 
 
593
    ARMCIX_DCMF_AccInfo_t * info = (ARMCIX_DCMF_AccInfo_t *) &(new_request->quad[0]);
 
594
    //info->dst = dst;
 
595
    //info->bytes = bytes;
 
596
    info->datatype = datatype;
 
597
    switch (datatype)
 
598
    {
 
599
      case ARMCI_ACC_INT:
 
600
        info->ival = *((int *)scale);
 
601
        break;
 
602
      case ARMCI_ACC_DBL:
 
603
        info->dval = *((double *)scale);
 
604
        break;
 
605
      case ARMCI_ACC_FLT:
 
606
        info->fval = *((float *)scale);
 
607
        break;
 
608
      case ARMCI_ACC_CPL:
 
609
        info->cplxval.real = ((complex_t *)scale)->real;
 
610
        info->cplxval.imag = ((complex_t *)scale)->imag;
 
611
        break;
 
612
      case ARMCI_ACC_DCP:
 
613
        info->dcplxval.real = ((dcomplex_t *)scale)->real;
 
614
        info->dcplxval.imag = ((dcomplex_t *)scale)->imag;
 
615
        break;
 
616
      case ARMCI_ACC_LNG:
 
617
        info->lval = *((long *)scale);
 
618
        break;
 
619
      default:
 
620
        assert (0);
 
621
        break;
 
622
      }
 
623
#if 0
 
624
    ARMCIX_DCMF_AccInfo_t info;
 
625
    info.datatype = datatype;
 
626
    switch (datatype)
 
627
    {
 
628
      case ARMCI_ACC_INT:
 
629
        info.ival = *((int *)scale);
 
630
        break;
 
631
      case ARMCI_ACC_DBL:
 
632
        info.dval = *((double *)scale);
 
633
        break;
 
634
      case ARMCI_ACC_FLT:
 
635
        info.fval = *((float *)scale);
 
636
        break;
 
637
      case ARMCI_ACC_CPL:
 
638
        info.cplxval.real = ((complex_t *)scale)->real;
 
639
        info.cplxval.imag = ((complex_t *)scale)->imag;
 
640
        break;
 
641
      case ARMCI_ACC_DCP:
 
642
        info.dcplxval.real = ((dcomplex_t *)scale)->real;
 
643
        info.dcplxval.imag = ((dcomplex_t *)scale)->imag;
 
644
        break;
 
645
      case ARMCI_ACC_LNG:
 
646
        info.lval = *((long *)scale);
 
647
        break;
 
648
      default:
 
649
        assert (0);
 
650
        break;
 
651
    }
 
652
 
 
653
    DCMF_Callback_t cb_free = { ARMCIX_DCMF_NbOp_cb_done, nb_handle };
 
654
    DCMF_Request_t * new_request = ARMCIX_DCMF_request_allocate (cb_free);
 
655
    DCMF_Callback_t cb_done = { (void(*)(void *)) ARMCIX_DCMF_request_free, new_request };
 
656
#endif
 
657
    info->bytes = seg_count[0];
 
658
    info->dst = dst_ptr;
 
659
 
 
660
    DCMF_Send ( &__acc_protocol,
 
661
                &(new_request->request),
 
662
                cb_done,
 
663
                DCMF_SEQUENTIAL_CONSISTENCY,
 
664
                proc,
 
665
                info->bytes,
 
666
                (char *) src_ptr,
 
667
                (DCQuad *) info,
 
668
                2);
 
669
 
 
670
    num_requests++;
 
671
  }
 
672
  else
 
673
  {
 
674
    char * src_tmp = (char *) src_ptr;
 
675
    char * dst_tmp = (char *) dst_ptr;
 
676
    unsigned i;
 
677
    for (i = 0; i < seg_count[stride_levels]; i++)
 
678
    {
 
679
      num_requests += ARMCIX_DCMF_AccS_recurse (datatype, scale,
 
680
                                                src_tmp, src_stride_arr,
 
681
                                                dst_tmp, dst_stride_arr,
 
682
                                                seg_count, (stride_levels-1), proc,
 
683
                                                nb_handle);
 
684
 
 
685
      src_tmp += src_stride_arr[(stride_levels-1)];
 
686
      dst_tmp += dst_stride_arr[(stride_levels-1)];
 
687
    }
 
688
  }
 
689
 
 
690
  //fprintf (stderr, "ARMCIX_DCMF_AccS_recurse() << num_requests = %d\n", num_requests);
 
691
 
 
692
  return num_requests;
 
693
}
 
694
 
 
695
 
 
696
/**
 
697
 * \brief ARMCI Extension blocking strided accumulate operation.
 
698
 *
 
699
 * \param[in] datatype       accumulate datatype (operation code)
 
700
 * \param[in] scale          opaque pointer to the scaling factor for accumulate
 
701
 * \param[in] src_ptr        pointer to 1st segment at source
 
702
 * \param[in] src_stride_arr array of strides at source
 
703
 * \param[in] dst_ptr        pointer to 1st segment at destination
 
704
 * \param[in] dst_stride_arr array of strides at destination
 
705
 * \param[in] seg_count      number of segments at each stride levels: count[0]=bytes
 
706
 * \param[in] stride_levels  number of stride levels
 
707
 * \param[in] proc           remote process(or) ID
 
708
 *
 
709
 * \return ???
 
710
 */
 
711
int ARMCIX_AccS (int datatype, void * scale,
 
712
                 void * src_ptr, int * src_stride_arr, 
 
713
                 void * dst_ptr, int * dst_stride_arr, 
 
714
                 int * seg_count, int stride_levels, int proc)
 
715
{
 
716
#if 0
 
717
#error causes test-ibm.x to hang!
 
718
  armci_ireq_t nb_request;
 
719
  armci_ihdl_t nb_handle = (armci_ihdl_t) &nb_request;
 
720
  ARMCIX_NbAccS (datatype, scale,
 
721
                 src_ptr, src_stride_arr,
 
722
                 dst_ptr, dst_stride_arr,
 
723
                 seg_count, stride_levels, proc,
 
724
                 nb_handle);
 
725
#warning remove this ARMCIX_Fence() and implement some sort of ack scheme.
 
726
  ARMCIX_Fence (proc);
 
727
  ARMCIX_Wait (&nb_handle->cmpl_info);
 
728
#else
 
729
  DCMF_CriticalSection_enter (0);
 
730
 
 
731
  //fprintf (stderr, "ARMCIX_AccS() >> \n");
 
732
  //fprintf (stderr, "ARMCIX_AccS() -- __connection[%d].sequence.origin=%d, __connection[%d].active=%d, __global_connection.active=%d\n", proc, __connection[proc].sequence.origin, proc, __connection[proc].active, __global_connection.active);
 
733
 
 
734
  // Calculate the number of requests
 
735
  unsigned i;
 
736
  unsigned n = 1;
 
737
  for (i = 0; i < stride_levels; i++) n = n * seg_count[i+1];
 
738
 
 
739
  armci_ireq_t nb_handle;
 
740
  armcix_dcmf_opaque_t * dcmf = (armcix_dcmf_opaque_t *) &nb_handle.cmpl_info;
 
741
  dcmf->connection = &__connection[proc];
 
742
  dcmf->active = n;
 
743
 
 
744
  __connection[proc].active += n;
 
745
  __global_connection.active += n;
 
746
 
 
747
  unsigned count;
 
748
  count = ARMCIX_DCMF_AccS_recurse (datatype, scale,
 
749
                                    src_ptr, src_stride_arr,
 
750
                                    dst_ptr, dst_stride_arr,
 
751
                                    seg_count, stride_levels, proc,
 
752
                                    (armci_ihdl_t) &nb_handle);
 
753
 
 
754
#ifdef BLOCKING_OPERATIONS_REQUIRE_FENCE
 
755
  ARMCIX_Fence (proc);
 
756
#else
 
757
  assert (n == count);
 
758
  while (dcmf->active) DCMF_Messager_advance ();
 
759
#endif
 
760
 
 
761
  //fprintf (stderr, "ARMCIX_AccS() << \n");
 
762
 
 
763
  DCMF_CriticalSection_exit  (0);
 
764
#endif
 
765
  return 0;
 
766
}
 
767
 
 
768
/**
 
769
 * \brief ARMCI Extension non-blocking strided accumulate operation.
 
770
 *
 
771
 * \param[in] datatype       accumulate datatype (operation code)
 
772
 * \param[in] scale          opaque pointer to the scaling factor for accumulate
 
773
 * \param[in] src_ptr        pointer to 1st segment at source
 
774
 * \param[in] src_stride_arr array of strides at source
 
775
 * \param[in] dst_ptr        pointer to 1st segment at destination
 
776
 * \param[in] dst_stride_arr array of strides at destination
 
777
 * \param[in] seg_count      number of segments at each stride levels: count[0]=bytes
 
778
 * \param[in] stride_levels  number of stride levels
 
779
 * \param[in] proc           remote process(or) ID
 
780
 * \param[in] nb_handle      ARMCI non-blocking handle
 
781
 *
 
782
 * \return ???
 
783
 */
 
784
int ARMCIX_NbAccS (int datatype, void * scale,
 
785
                   void * src_ptr, int * src_stride_arr, 
 
786
                   void * dst_ptr, int * dst_stride_arr, 
 
787
                   int * seg_count, int stride_levels, int proc,
 
788
                   armci_ihdl_t nb_handle)
 
789
{
 
790
  DCMF_CriticalSection_enter (0);
 
791
 
 
792
  // Calculate the number of requests
 
793
  unsigned i;
 
794
  unsigned n = 1;
 
795
  for (i = 0; i < stride_levels; i++) n = n * seg_count[i+1];
 
796
 
 
797
  armcix_dcmf_opaque_t * dcmf = (armcix_dcmf_opaque_t *) &nb_handle->cmpl_info;
 
798
  dcmf->connection = &__connection[proc];
 
799
  dcmf->active += n;
 
800
 
 
801
  __connection[proc].active += n;
 
802
  __global_connection.active += n;
 
803
 
 
804
  unsigned count;
 
805
  count = ARMCIX_DCMF_AccS_recurse (datatype, scale,
 
806
                                    src_ptr, src_stride_arr, 
 
807
                                    dst_ptr, dst_stride_arr, 
 
808
                                    seg_count, stride_levels, proc,
 
809
                                    nb_handle);
 
810
 
 
811
  assert (n == count);
 
812
 
 
813
  DCMF_CriticalSection_exit  (0);
 
814
 
 
815
  return 0;
 
816
}