← Back to branch summary

~ubuntu-branches/ubuntu/saucy/nwchem/saucy

« back to all changes in this revision

Viewing changes to src/tools/ga-4-3/armci/src/elan4.c

  • Committer: Package Import Robot
  • Author(s): Michael Banck, Michael Banck, Daniel Leidert
  • Date: 2012-02-09 20:02:41 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120209200241-jgk03qfsphal4ug2
Tags: 6.1-1
http://bugs.debian.org/632611
https://launchpad.net/bugs/791308
* New upstream release.

[ Michael Banck ]
* debian/patches/02_makefile_flags.patch: Updated.
* debian/patches/02_makefile_flags.patch: Use internal blas and lapack code.
* debian/patches/02_makefile_flags.patch: Define GCC4 for LINUX and LINUX64
  (Closes: #632611 and LP: #791308).
* debian/control (Build-Depends): Added openssh-client.
* debian/rules (USE_SCALAPACK, SCALAPACK): Removed variables (Closes:
  #654658).
* debian/rules (LIBDIR, USE_MPIF4, ARMCI_NETWORK): New variables.
* debian/TODO: New file.
* debian/control (Build-Depends): Removed libblas-dev, liblapack-dev and
  libscalapack-mpi-dev.
* debian/patches/04_show_testsuite_diff_output.patch: New patch, shows the
  diff output for failed tests.
* debian/patches/series: Adjusted.
* debian/testsuite: Optionally run all tests if "all" is passed as option.
* debian/rules: Run debian/testsuite with "all" if DEB_BUILD_OPTIONS
  contains "checkall".

[ Daniel Leidert ]
* debian/control: Used wrap-and-sort. Added Vcs-Svn and Vcs-Browser fields.
  (Priority): Moved to extra according to policy section 2.5.
  (Standards-Version): Bumped to 3.9.2.
  (Description): Fixed a typo.
* debian/watch: Added.
* debian/patches/03_hurd-i386_define_path_max.patch: Added.
  - Define MAX_PATH if not defines to fix FTBFS on hurd.
* debian/patches/series: Adjusted.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tools/ga-4-3/armci/src/elan4.c
 
1
/* $Id: elan4.c,v 1.15.2.2 2007-07-02 05:19:42 d3p687 Exp $ */
 
2
#include <elan/elan.h>
 
3
#include <stdio.h>
 
4
#include <stdlib.h>
 
5
#include "armcip.h"
 
6
#include "copy.h"
 
7
#include "elandefs.h"
 
8
#include <elan/devent.h>
 
9
 
 
10
#define DEBUG_ 0
 
11
#define DEBUG_NOTIFY 0
 
12
#ifndef DOELAN4
 
13
 what are we doing here
 
14
#endif
 
15
 
 
16
#define DBL_BUF_SIZE 50000
 
17
#define MAX_BUFS 16
 
18
static double elan4_serv_bufs[MAX_BUFS][DBL_BUF_SIZE];
 
19
 
 
20
static ELAN_PGCTRL *_pgctrl;
 
21
static void *_pgsstate;
 
22
static void *_qd;
 
23
static void *zero=(void*)0;
 
24
extern void *pgs_init (ELAN_STATE *state, void *qMem);
 
25
extern void * pgs_ds_init (ELAN_STATE *state, void *qMem, void *dsqMem, int max);
 
26
 
 
27
static int _ELAN_SLOTSIZE=700;
 
28
static int server_can_poll=0;
 
29
 
 
30
/* TBD: why was VCALLS disabled if NB_NONCONT was defined */
 
31
#ifndef NB_NONCONT
 
32
#define VCALLS 1
 
33
#endif
 
34
 
 
35
#if !VCALLS
 
36
#define MAX_SLOTS 64
 
37
#define MIN_OUTSTANDING 6
 
38
static int max_pending=16; /* throttle number of outstanding nb calls */
 
39
#endif
 
40
 
 
41
#ifdef ELAN_ACC
 
42
static int armci_server_terminating=0;
 
43
static ELAN_MAIN_QUEUE *mq;
 
44
static int armci_request_from=-1;
 
45
static int armci_request_to=-1;
 
46
 
 
47
 
 
48
typedef struct{
 
49
        int *verify_seq_ar;
 
50
        int *wait_seq_ar;
 
51
        int** recv_verify_arr;
 
52
        int** recv_verify_smp_arr;
 
53
}armci_verify_wait_t;
 
54
armci_verify_wait_t __armci_verify_wait_struct;
 
55
armci_verify_wait_t *verify_wait = &__armci_verify_wait_struct;
 
56
 
 
57
static ops_t** armci_elan_fence_arr;
 
58
static ops_t *ops_pending_ar;
 
59
ops_t *rdma_ops_pending_ar;
 
60
static ops_t *ops_done_ar;
 
61
int notify_tmp[3];
 
62
static ELAN_EVENT* prevnotifydscr = (ELAN_EVENT *)0;
 
63
static ELAN_EVENT* prevnotifywaitdscr = (ELAN_EVENT *)0;
 
64
int **mynotify_epochs;
 
65
static int **notify_epoch_arr;
 
66
static int *mycurrent_epoch;
 
67
static int **current_epoch_seq;
 
68
static int numepochs = 2;
 
69
 
 
70
#define MSG_DATA_LEN (_ELAN_SLOTSIZE - sizeof(request_header_t))
 
71
 
 
72
#define MY_PUT2(src,dst,bytes,p) \
 
73
        elan_wait(elan_doput(_pgctrl,(src),(dst),(ELAN_ADDR)elanev[0],(bytes),p,0), elan_base->waitType)
 
74
 
 
75
#define MY_PUT(src,dst,bytes,p) \
 
76
        elan_wait(elan_put(elan_base->state,(src),(dst),(bytes),p), elan_base->waitType)
 
77
#define MY_GET(src,dst,len,p)\
 
78
        elan_wait(elan_get(elan_base->state,src,dst,len,p),elan_base->waitType)
 
79
 
 
80
 
 
81
#define _RAIL 0
 
82
#define NEWQAPI 1
 
83
 
 
84
#if NEWQAPI
 
85
static ELAN_QUEUE_TX *qtx;
 
86
static ELAN_QUEUE_RX *qrx;
 
87
#else
 
88
static ELAN_MAIN_QUEUE *mq;
 
89
#endif
 
90
 
 
91
#define NEVENTS (armci_nproc*numepochs) 
 
92
#define SETEVAL 1 
 
93
static ELAN_EVENT_ELAN *evdelan;
 
94
static ELAN_EVENT **elanev;
 
95
 
 
96
extern int elan_devent_completed(int setval, ELAN_EVENT *e);
 
97
#define DOPUT(_src, _dst, _bidx, _len, _p) \
 
98
        elan_doput(_pgctrl,_src,_dst,elan_destEvent(elanev[_bidx]),_len,_p,_RAIL)
 
99
#define DOWAIT(_bidx) elan_wait(elanev[_bidx],elan_base->waitType)
 
100
#define REPRIME(_bidx) elan_setWaitCount(elanev[_bidx],1)
 
101
 
 
102
void test_put(void *src, void *dst, int bytes, int p)
 
103
{
 
104
elan_wait(elan_doput(_pgctrl,(src),(dst),elan_destEvent(elanev[0]),(bytes),p,0), elan_base->waitType);
 
105
sleep(5);
 
106
elan_wait(elan_doput(_pgctrl,(src),(dst),elan_destEvent(elanev[0]),(bytes),p,0), elan_base->waitType);
 
107
sleep(2);
 
108
elan_wait(elan_doput(_pgctrl,(src),(dst),elan_destEvent(elanev[0]),(bytes),p,0), elan_base->waitType);
 
109
sleep(2);
 
110
elan_wait(elan_doput(_pgctrl,(src),(dst),elan_destEvent(elanev[0]),(bytes),p,0), elan_base->waitType);
 
111
}
 
112
 
 
113
void test_wait()
 
114
{
 
115
 
 
116
while(!elan_poll(elanev[0],0)){ 
 
117
   _elan_deventDump ("wait",elanev[0]); 
 
118
   printf("%d:completed %d\n",armci_me, elan_devent_completed(SETEVAL, elanev[0]));
 
119
   sleep(1);
 
120
}
 
121
/*elan_wait(elanev[0],0);*/
 
122
    _elan_deventDump ("wait",elanev[0]);
 
123
}
 
124
 
 
125
void test_dump()
 
126
{
 
127
    _elan_deventDump ("after wait",elanev[0]);
 
128
}
 
129
 
 
130
/*extern ELAN_EVENT *elan_getbflag(void *pgs,u_int destvp, long *retval);*/
 
131
extern ELAN_EVENT *elan_getbflag(void *pgs,u_int destvp, int lo, int hi, int w, long *retval);
 
132
extern void elan_clearbflag(void *pgs, int which);
 
133
extern void elan_deventDump (const char *label, ELAN_EVENT *e);
 
134
 
 
135
int armci_getbflag(int p)
 
136
{
 
137
static long retval=-1;
 
138
     elan_wait(elan_getbflag(_pgsstate,p,0,MAX_BUFS,1,&retval), elan_base->waitType);
 
139
     return(int)retval;
 
140
}
 
141
 
 
142
 
 
143
void armci_clearbflag(int which)
 
144
{
 
145
     elan_clearbflag(_pgsstate, which);
 
146
}
 
147
 
 
148
 
 
149
/* NOTE: for thread-safety we need to make put this in user buffer */
 
150
static ELAN_EVENT *event_getbflag=NULL;
 
151
static long _bidx=0;
 
152
 
 
153
#define BFLAG_PATH_SIZE (_ELAN_SLOTSIZE-sizeof(request_header_t))
 
154
#define BFLAG_PATH_SIZE_ 4000
 
155
 
 
156
int armcill_getbidx(int size, int proc, SERV_BUF_IDX_T *bufidx)
 
157
{
 
158
#if 1
 
159
    if(size > BFLAG_PATH_SIZE){ 
 
160
    int cluster = armci_clus_id(proc);
 
161
    int proc_serv = armci_clus_info[cluster].master;
 
162
    event_getbflag = elan_getbflag(_pgsstate,proc_serv,0,MAX_BUFS,0,bufidx);
 
163
    return 1;
 
164
  } 
 
165
#endif
 
166
  *bufidx = -1;
 
167
  return 0;
 
168
}
 
169
 
 
170
#ifdef ARMCI_ENABLE_GPC_CALLS
 
171
extern gpc_buf_t *gpc_req;
 
172
#endif
 
173
void armci_init_connections()
 
174
{
 
175
ELAN_QUEUE *q, *qs;
 
176
int nslots=armci_nproc+256, slotsize;
 
177
int R=0;
 
178
int i;
 
179
char *enval;
 
180
  
 
181
/*_ELAN_SLOTSIZE = elan_queueMaxSlotSize(elan_base->state);*/
 
182
    slotsize=_ELAN_SLOTSIZE;
 
183
#ifdef ARMCI_ENABLE_GPC_CALLS
 
184
    gpc_req = (gpc_buf_t *)malloc(MAX_GPC_REQ*sizeof(gpc_buf_t)+SIXTYFOUR);
 
185
#endif
 
186
    if ((q = elan_gallocQueue(elan_base, elan_base->allGroup)) == NULL)
 
187
            armci_die( "elan_gallocElan",0 );
 
188
#if NEWQAPI
 
189
    _armci_buf_init();
 
190
    if(!(qrx = elan_queueRxInit(elan_base->state, q, nslots, slotsize, R, 0))) 
 
191
               armci_die("Failed to initialise elan receive Q",0);
 
192
    if(!(qtx = elan_queueTxInit(elan_base->state, q, R, 0)))
 
193
      /*  if(!(qtx = elan_queueTxInit(elan_base->state, q, R, LIBELAN_QUEUEREUSEBUF)))*/
 
194
#else
 
195
    if(!(mq  = elan_mainQueueInit( elan_base->state, q, nslots, slotsize, 0)))
 
196
#endif
 
197
               armci_die("Failed to initialise elan Q",0);
 
198
 
 
199
#if VCALLS
 
200
    _qd = elan_gallocElan(elan_base, elan_base->allGroup, ELAN_QUEUE_ALIGN,
 
201
                              elan_pgvGlobalMemSize(elan_base->state));
 
202
 
 
203
    if(!_qd) armci_die("failed elan_gallocElan 1",0);
 
204
    elan_gsync(elan_base->allGroup);
 
205
    _pgctrl = elan_putgetInit(elan_base->state, _qd, 16, 4096, 4096, 32, ELAN_PGVINIT);
 
206
    if(!_pgctrl) armci_die("failed elan_gallocElan 2",0);
 
207
    elan_gsync(elan_base->allGroup);
 
208
    
 
209
 
 
210
    evdelan = elan_gallocElan(elan_base,elan_base->allGroup,32,NEVENTS*sizeof(ELAN_EVENT_ELAN));
 
211
    if(!evdelan) armci_die("failed elan_gallocElan for dest events",0);
 
212
    elanev = (ELAN_EVENT **)malloc(sizeof(ELAN_EVENT *)*NEVENTS);
 
213
    for(i=0;  i<NEVENTS; i++){
 
214
        elanev[i]= elan_initEvent(elan_base->state,elan_base->state->rail[_RAIL],evdelan+i,0);
 
215
        if(!elanev[i]) armci_die("elan_initEvent failed",i);
 
216
        /*print_event_info(elanev[i]); */
 
217
    }
 
218
    elan_gsync(elan_base->allGroup);
 
219
    /*_elan_deventDump ("init",elanev[0]); */
 
220
 
 
221
#endif
 
222
 
 
223
    /* pgs calls */
 
224
     qs = elan_gallocElan(elan_base, elan_base->allGroup, ELAN_QUEUE_ALIGN,
 
225
                        elan_pgsGlobalMemSize(elan_base->state));
 
226
     /*_pgsstate = pgs_init(elan_base->state, q); */
 
227
     _pgsstate = pgs_ds_init(elan_base->state, qs, q, MAX_BUFS);
 
228
 
 
229
    if(armci_me == armci_master) {
 
230
        if(!(ops_done_ar=(ops_t*)calloc(armci_nproc,sizeof(ops_t))))
 
231
             armci_die("malloc failed for ARMCI ops_done_ar",0);
 
232
    }
 
233
 
 
234
    armci_elan_fence_arr = (ops_t**)malloc(armci_nproc*sizeof(ops_t*));
 
235
    if(!armci_elan_fence_arr)armci_die("malloc failed for ARMCI fence array",0);
 
236
    if(PARMCI_Malloc((void**)armci_elan_fence_arr, armci_nclus*sizeof(ops_t)))
 
237
             armci_die("failed to allocate ARMCI fence array",0);
 
238
    bzero(armci_elan_fence_arr[armci_me],armci_nclus*sizeof(ops_t));
 
239
 
 
240
    if(!(rdma_ops_pending_ar=(ops_t*)calloc(armci_nproc,sizeof(ops_t))))
 
241
         armci_die("malloc failed for ARMCI rdma_ops_pending_ar",0);
 
242
 
 
243
 
 
244
    
 
245
#ifdef OLD_QSNETLIBS
 
246
    /* initialize control descriptor for put/get */
 
247
    armci_pgctrl = elan_putgetInit(elan_base->state, 32, 8);
 
248
    if(!armci_pgctrl) armci_die("armci_init_con: elan_putgetInit failed",0);
 
249
#endif
 
250
 
 
251
    /* check if we can poll in the server thread */
 
252
    enval = getenv("ARMCI_SERVER_CAN_POLL");
 
253
    if(enval != NULL){
 
254
       if((enval[0] != 'N') && (enval[0]!='n')) server_can_poll=1;
 
255
    } else {
 
256
      if(armci_clus_info[armci_clus_me].nslave < armci_getnumcpus()) server_can_poll=1;
 
257
    }
 
258
 
 
259
    if(MessageSndBuffer){
 
260
      ((request_header_t*)MessageSndBuffer)->tag.data_ptr = (void*)0;
 
261
    }else armci_die("armci_init_connections: buf not set",0);
 
262
}
 
263
 
 
264
void armci_elan_notify_init()
 
265
{
 
266
    int i;
 
267
    if(!(ops_pending_ar=(ops_t*)calloc(armci_nclus,sizeof(ops_t))))
 
268
         armci_die("malloc failed for ARMCI ops_pending_ar",0);
 
269
 
 
270
    notify_epoch_arr = (int **)malloc(sizeof(int *)*armci_nproc);
 
271
    if(!notify_epoch_arr)armci_die("malloc failed for notify_epoch_arr",0);
 
272
    if(PARMCI_Malloc((void**)notify_epoch_arr,armci_nproc*numepochs*sizeof(int)))
 
273
             armci_die("failed to allocate ARMCI fence array",0);
 
274
    bzero(notify_epoch_arr[armci_me],armci_nproc*numepochs*sizeof(int));
 
275
    mynotify_epochs = (int **)calloc(armci_nproc,sizeof(int *));
 
276
    current_epoch_seq = (int **)calloc(armci_nproc,sizeof(int*));
 
277
 
 
278
    for(i=0;i<armci_nproc;i++){
 
279
       mynotify_epochs[i] = notify_epoch_arr[armci_me]+i*numepochs;
 
280
       current_epoch_seq[i] = (int *)calloc(armci_nproc,sizeof(int));
 
281
    }
 
282
 
 
283
 
 
284
    if(!(verify_wait->verify_seq_ar=(int*)calloc(armci_nproc,sizeof(int))))
 
285
        armci_die("malloc failed for ARMCI verify_seq_ar",0);
 
286
    /*allocate an array for wait sequence array*/
 
287
    if(!(verify_wait->wait_seq_ar=(int*)calloc(armci_nproc,sizeof(int))))
 
288
        armci_die("malloc failed for ARMCI wait_seq_ar",0);
 
289
    for(i=0;i<armci_nproc;i++){
 
290
       verify_wait->verify_seq_ar[i]=1;
 
291
       verify_wait->wait_seq_ar[i]=1;
 
292
    }
 
293
 
 
294
    verify_wait->recv_verify_smp_arr = (int**)malloc(armci_nproc*sizeof(int*));
 
295
    if(!verify_wait->recv_verify_smp_arr)armci_die("malloc-recv_verify_smp",0);
 
296
    bzero(verify_wait->recv_verify_smp_arr ,armci_nproc*sizeof(ops_t*));
 
297
 
 
298
    verify_wait->recv_verify_arr = (int**)malloc(armci_nproc*sizeof(int*));
 
299
    if(!verify_wait->recv_verify_arr)armci_die("malloc fail-recv_verify_arr",0);
 
300
    bzero(verify_wait->recv_verify_arr ,armci_nproc*sizeof(int*));
 
301
 
 
302
    if(PARMCI_Malloc((void**)verify_wait->recv_verify_arr,
 
303
                    armci_nproc*3*sizeof(int)))
 
304
             armci_die("failed to allocate recv_verify_arr",0);
 
305
 
 
306
    if(PARMCI_Malloc((void**)verify_wait->recv_verify_smp_arr,
 
307
                    armci_nproc*sizeof(int)*2))
 
308
       armci_die("failed to allocate ARMCI fence array",0); 
 
309
}
 
310
 
 
311
 
 
312
 
 
313
/*\ server sends ACK to client when request is processed
 
314
\*/
 
315
static void armci_send_ack()
 
316
{
 
317
ops_t val=0;
 
318
ops_t *buf = armci_elan_fence_arr[armci_request_from] + armci_clus_me;
 
319
 
 
320
#if 0
 
321
    if(armci_me==0)
 
322
    printf("%d:server sends ack p=%d fence=%p slot %p got=%d\n", armci_me, 
 
323
           armci_request_from, armci_elan_fence_arr[armci_request_from],buf,
 
324
           ops_done_ar[armci_request_from]+1); fflush(stdout);
 
325
#endif
 
326
 
 
327
    val = ++ops_done_ar[armci_request_from];
 
328
    verify_wait->recv_verify_smp_arr[armci_request_to][armci_request_from]=val;
 
329
 
 
330
    MY_PUT(&val,buf,sizeof(ops_t),armci_request_from);
 
331
}
 
332
 
 
333
 
 
334
ops_t armci_check_int_val(ops_t *v)
 
335
{
 
336
  return (*v);
 
337
}
 
338
 
 
339
 
 
340
void armci_elan_fence(int p)
 
341
{
 
342
    long loop=0;
 
343
    int cluster = armci_clus_id(p);
 
344
    ops_t *buf = armci_elan_fence_arr[armci_me] + cluster;
 
345
    long res = ops_pending_ar[cluster] - armci_check_int_val(buf);
 
346
 
 
347
#if 0
 
348
    if(ops_pending_ar[cluster])
 
349
    printf("%d: client fencing proc=%d fence=%p slot %p pending=%d got=%d\n", 
 
350
           armci_me, p, armci_elan_fence_arr[armci_me], buf, 
 
351
           ops_pending_ar[cluster], armci_check_int_val(buf)); fflush(stdout);
 
352
#endif
 
353
 
 
354
    while(res){
 
355
       if(++loop == 1000) { loop=0; usleep(1);  }
 
356
       armci_util_spin(loop, buf);
 
357
       res = ops_pending_ar[cluster] - armci_check_int_val(buf);
 
358
    }
 
359
}
 
360
 
 
361
#if 0
 
362
void armci_send_q(int p, void *buf, int len)
 
363
{
 
364
extern ELAN_EVENT * armci_sendq(void *pgs,u_int destvp,void *buf, int len);
 
365
armci_sendq(_pgsstate, p, buf, len);
 
366
 
 
367
}
 
368
#endif
 
369
 
 
370
/*\ server sends data to client buffer
 
371
\*/
 
372
void armci_WriteToDirect(int dst, request_header_t *msginfo, void *buffer)
 
373
{
 
374
   armci_die("armci_WriteToDirect: should not be called in this case",0);
 
375
}
 
376
 
 
377
char *armci_ReadFromDirect(int proc, request_header_t * msginfo, int len)
 
378
{
 
379
    char *buf = (char*) msginfo;
 
380
    return(buf);
 
381
}
 
382
 
 
383
 
 
384
static long bidx=-1;
 
385
void armci_call_data_server()
 
386
{
 
387
long usec_to_poll;
 
388
 
 
389
    usec_to_poll = server_can_poll? ELAN_POLL_EVENT: 0;
 
390
 
 
391
    if(DEBUG_){
 
392
        printf("%d(server): waiting for request\n",armci_me); fflush(stdout);
 
393
    }
 
394
#ifdef ARMCI_ENABLE_GPC_CALLS
 
395
    unblock_thread_signal(GPC_COMPLETION_SIGNAL); 
 
396
#endif
 
397
    while(1){
 
398
#ifdef ARMCI_ENABLE_GPC_CALLS
 
399
        block_thread_signal(GPC_COMPLETION_SIGNAL);
 
400
#endif
 
401
#       if NEWQAPI
 
402
           void *buf;
 
403
           buf = elan_queueRxWait(qrx, NULL, usec_to_poll);  
 
404
#       else
 
405
           char buf[_ELAN_SLOTSIZE];
 
406
           elan_queueWait(mq, buf, usec_to_poll );
 
407
#       endif
 
408
        armci_data_server((char*)buf);
 
409
        armci_send_ack();
 
410
 
 
411
        /* free the buffer if used */
 
412
        if(bidx>=0) { armci_clearbflag(bidx); bidx =-1; }
 
413
#ifdef ARMCI_ENABLE_GPC_CALLS
 
414
        unblock_thread_signal(GPC_COMPLETION_SIGNAL);
 
415
#endif
 
416
    }
 
417
 
 
418
    if(DEBUG_) {printf("%d(server): done! closing\n",armci_me); fflush(stdout);}
 
419
}
 
420
 
 
421
/*\ server receives request 
 
422
\*/
 
423
void armci_rcv_req(void *mesg, void *phdr, void *pdescr, void *pdata, int *buflen)
 
424
{
 
425
int i;
 
426
char *MessageBuffer = MessageRcvBuffer;  
 
427
request_header_t *msginfo = (request_header_t *)mesg;
 
428
 
 
429
    *(void **)phdr = msginfo;
 
430
    armci_request_from = msginfo->from;
 
431
    armci_request_to = msginfo->to;
 
432
 
 
433
    if(DEBUG_ ) {
 
434
       printf("%d(server): got %d req (dscrlen=%d datalen=%d) from %d %p\n",
 
435
              armci_me, msginfo->operation, msginfo->dscrlen,
 
436
              msginfo->datalen, msginfo->from,msginfo->tag.data_ptr); fflush(stdout);
 
437
    }
 
438
 
 
439
    *buflen = MSG_BUFLEN - sizeof(request_header_t);
 
440
    *(void **)pdescr = msginfo+1;
 
441
    *(void **)pdata  = msginfo->dscrlen + (char*)(msginfo+1);
 
442
 
 
443
    if(msginfo->bytes){
 
444
 
 
445
       if(msginfo->operation != GET){
 
446
          int payload = msginfo->datalen;
 
447
          int off =0;
 
448
          char *rembuf = msginfo->tag.data_ptr;
 
449
   
 
450
          if(msginfo->inbuf){
 
451
                bidx = (long)msginfo->tag.ack;
 
452
                if(DEBUG_){
 
453
                  printf("%ds bidx=%ld\n",armci_me,bidx); fflush(stdout);
 
454
                }
 
455
                if(bidx>MAX_BUFS || bidx<0) 
 
456
                   armci_die2("got wrong buffer index",(int)bidx,MAX_BUFS);
 
457
                MessageBuffer= (char*) &elan4_serv_bufs[bidx][0];
 
458
          }else MessageBuffer = MessageRcvBuffer;
 
459
 
 
460
          if(msginfo->dscrlen > MSG_DATA_LEN){
 
461
             payload += msginfo->dscrlen;
 
462
             *(void **)pdescr = MessageBuffer;
 
463
             off = msginfo->dscrlen;
 
464
          }else rembuf += msginfo->dscrlen;
 
465
 
 
466
          if((msginfo->dscrlen+msginfo->datalen)> MSG_DATA_LEN){
 
467
 
 
468
             if(!msginfo->inbuf){
 
469
                void *flag_to_clear = ((void**)msginfo->tag.ack_ptr); 
 
470
                MY_GET(rembuf,MessageBuffer,payload, msginfo->from);
 
471
 
 
472
                /* mark sender buffer as free -- flag is before descriptor */
 
473
                MY_PUT(&zero,flag_to_clear,sizeof(void*),msginfo->from);
 
474
                if(DEBUG_){
 
475
                  printf("%d:serv &tag=%p tag=%p dscrlen=%d %d data to %p pdscr=%p pdata=%p\n",
 
476
                         armci_me, flag_to_clear, msginfo->tag.ack, msginfo->dscrlen, payload, 
 
477
                         MessageBuffer,*(void **)pdescr, *(void **)pdata); fflush(stdout);
 
478
                }
 
479
 
 
480
             }
 
481
             *(void **)pdata  = MessageBuffer + off; 
 
482
          }
 
483
        }
 
484
    }else
 
485
        *(void**)pdescr = NULL;
 
486
}
 
487
 
 
488
 
 
489
 
 
490
#if NEWQAPI
 
491
    ELAN_EVENT *qtxevent=(ELAN_EVENT*)0;
 
492
#endif
 
493
 
 
494
/*\ send request to server thread
 
495
\*/
 
496
int armci_send_req_msg(int proc, void *vbuf, int len)
 
497
{
 
498
    char *MessageBuffer;  
 
499
    char *buf = (char*)vbuf;
 
500
    request_header_t *msginfo = (request_header_t *)buf;
 
501
    int cluster = armci_clus_id(proc);
 
502
    int size=_ELAN_SLOTSIZE;
 
503
    int proc_serv = armci_clus_info[cluster].master;
 
504
    int off =sizeof(request_header_t);
 
505
    int payload=0;
 
506
    if(msginfo->operation==PUT || ARMCI_ACC(msginfo->operation))
 
507
       ops_pending_ar[cluster]++;
 
508
    msginfo->tag.ack_ptr = &msginfo->tag.ack;
 
509
    if(msginfo->inbuf){
 
510
         if(event_getbflag)elan_wait(event_getbflag,elan_base->waitType);
 
511
         else { 
 
512
           printf("%ds: slotsize=%d flag=%d size=%d\n",armci_me,_ELAN_SLOTSIZE,
 
513
                  event_getbflag,msginfo->dscrlen+msginfo->datalen);
 
514
           armci_die("protocol inconsitency",(int)(long)msginfo->tag.ack);
 
515
         }   
 
516
         event_getbflag=NULL;
 
517
    }
 
518
 
 
519
    if(msginfo->operation != GET){
 
520
      if((msginfo->dscrlen+msginfo->datalen)> MSG_DATA_LEN){
 
521
      /* choose remote buffer */
 
522
      long Bidx;
 
523
      extern ELAN_EVENT *armci_sendq(void *,u_int,void*,int,void*,void*, int);
 
524
 
 
525
        payload = msginfo->datalen;
 
526
        if(msginfo->dscrlen > MSG_DATA_LEN){
 
527
             payload += msginfo->dscrlen;
 
528
        }
 
529
        else off+= msginfo->dscrlen;
 
530
 
 
531
        if(msginfo->inbuf){
 
532
 
 
533
          Bidx = (long)msginfo->tag.ack;
 
534
          if(Bidx<0){ 
 
535
            msginfo->inbuf = 0;  /* no buf -> take the other path */
 
536
          }
 
537
          else {
 
538
            MessageBuffer= (char*) &elan4_serv_bufs[Bidx][0];
 
539
            if(DEBUG_){
 
540
              printf("%d:SQ %p len=%d tag=%ld\n",armci_me,vbuf,len-payload,Bidx); 
 
541
              fflush(stdout);
 
542
            }
 
543
            qtxevent =armci_sendq(_pgsstate, proc_serv, vbuf, len-payload, buf+off, 
 
544
                                  MessageBuffer,payload);
 
545
            buf -= sizeof(ELAN_EVENT*); *(ELAN_EVENT**)buf =  qtxevent;
 
546
 
 
547
            return 0;   /*********** DONE **********/
 
548
          }
 
549
        }
 
550
 
 
551
        /* set message tag -> has pointer to client buffer with descriptor+data */
 
552
        msginfo->tag.data_ptr = (void *)(buf + sizeof(request_header_t));
 
553
        /*
 
554
         printf("%d: SENDing for %d %p to %p %d bytes bidx=%d\n",armci_me,proc_serv,
 
555
             buf+off,MessageBuffer,payload,Bidx); fflush(stdout);
 
556
         MY_PUT(buf+off,MessageBuffer,payload, proc_serv);
 
557
        */
 
558
        if(DEBUG_){ printf("%d:in SEND &tag=%p %p tag=%p\n",armci_me,&msginfo->tag.ack,
 
559
                  msginfo->tag.ack_ptr,msginfo->tag.data_ptr); fflush(stdout); }
 
560
 
 
561
      } 
 
562
      else {
 
563
            msginfo->tag.data_ptr=NULL; /* null tag means sender buffer is free */
 
564
            msginfo->tag.ack=0L; /* tag=0 means sender buffer is free */
 
565
      }
 
566
    }
 
567
 
 
568
#   if NEWQAPI
 
569
#      ifdef BUF_EXTRA_FIELD_T
 
570
 
 
571
          qtxevent = elan_queueTx(qtx, proc_serv, vbuf, len-payload, 0);
 
572
          buf -= sizeof(ELAN_EVENT*); 
 
573
          *(ELAN_EVENT**)buf =  qtxevent;
 
574
#      else
 
575
          if(qtxevent)elan_wait(qtxevent,ELAN_POLL_EVENT);
 
576
          qtxevent = elan_queueTx(qtx, proc_serv, vbuf, len-payload, 0);
 
577
#      endif
 
578
 
 
579
#   else
 
580
       elan_queueReq(mq, proc_serv, vbuf, len-payload); /* vbuf is sent/copied out */
 
581
#   endif
 
582
    
 
583
#if 0
 
584
    if(armci_me==0){
 
585
      printf("%d sent request %d to (%d,%d)\n",armci_me,ops_pending_ar[proc], 
 
586
      proc,proc_serv); fflush(stdout);
 
587
    }
 
588
#endif
 
589
 
 
590
    return 0;
 
591
}
 
592
 
 
593
 
 
594
void armcill_clearbuf(ELAN_EVENT** handle)
 
595
{
 
596
request_header_t *msginfo = (request_header_t *)(handle+1);
 
597
 
 
598
     elan_wait(*handle, elan_base->waitType); 
 
599
     if(!msginfo->inbuf){
 
600
        while(msginfo->tag.ack){
 
601
          armci_util_spin(100,msginfo);
 
602
          msginfo->tag.data_ptr=NULL;
 
603
        }
 
604
     }
 
605
}
 
606
 
 
607
int armcill_testbuf(ELAN_EVENT** handle)
 
608
{
 
609
int ret;
 
610
request_header_t *msginfo = (request_header_t *)(handle+1);
 
611
 
 
612
     if(msginfo->inbuf)
 
613
        ret = !elan_poll(handle,1L);
 
614
     else
 
615
        ret = (msginfo->tag.ack)? 0: 1;
 
616
 
 
617
     return ret;
 
618
}
 
619
 
 
620
void armci_wait_for_server()
 
621
{
 
622
  armci_server_terminating=1;
 
623
}
 
624
 
 
625
void armci_transport_cleanup() {
 
626
  _elan_deventDump ("terminate",elanev[0]);
 
627
}
 
628
void armci_client_connect_to_servers(){}
 
629
void armci_server_initial_connection(){}
 
630
 
 
631
void armci_elan_put_with_tracknotify(char *src,char *dst,int n,int proc,
 
632
                ELAN_EVENT **phandle)
 
633
{
 
634
   int es;
 
635
   
 
636
   rdma_ops_pending_ar[proc]++; 
 
637
   es = current_epoch_seq[armci_me][proc]+1;
 
638
   es%=numepochs;
 
639
   *phandle = DOPUT(src,dst,numepochs*armci_me+es,n,proc); 
 
640
   if(DEBUG_){printf("\n%d:done put rdma=%d\n",armci_me,rdma_ops_pending_ar[proc]);fflush(stdout);}
 
641
}
 
642
 
 
643
int armci_inotify_proc(int proc)
 
644
{
 
645
int *remptr = verify_wait->recv_verify_arr[proc]+3*armci_me;
 
646
int *myptr = verify_wait->recv_verify_smp_arr[armci_me]+armci_nproc;
 
647
int loop=0;
 
648
                   
 
649
    if(SAMECLUSNODE(proc)){
 
650
       remptr = verify_wait->recv_verify_smp_arr[proc]+armci_me;
 
651
       *(remptr)=verify_wait->verify_seq_ar[proc]++;
 
652
       MEM_FENCE;
 
653
       return((*remptr));
 
654
    }
 
655
    else{
 
656
 
 
657
       if(prevnotifydscr)elan_wait(prevnotifydscr,elan_base->waitType); 
 
658
 
 
659
       ALIGN_PTR_LONG(int,myptr);
 
660
       myptr[0] = verify_wait->verify_seq_ar[proc]++;
 
661
       myptr[1] = ops_pending_ar[armci_clus_id(proc)];
 
662
       myptr[2] = rdma_ops_pending_ar[proc];
 
663
       rdma_ops_pending_ar[proc]=0;
 
664
        
 
665
       
 
666
       /*\
 
667
        * we wait before ensure that last epoch is complete, we do this because
 
668
        * we want to overlap the time it takes to recv message from server
 
669
       \*/
 
670
 
 
671
       mycurrent_epoch =mynotify_epochs[proc]+current_epoch_seq[armci_me][proc];
 
672
 
 
673
       if(DEBUG_NOTIFY){
 
674
         fprintf(stderr,"%d:waiting for %p from %d at ind %d to be 0",
 
675
               armci_me,mycurrent_epoch,proc,current_epoch_seq[armci_me][proc]);
 
676
       }
 
677
 
 
678
       while(armci_check_int_val(mycurrent_epoch)){
 
679
         if(++loop == 1000) { loop=0;usleep(1); }
 
680
         armci_util_spin(loop, mycurrent_epoch);
 
681
       }
 
682
 
 
683
       if(DEBUG_NOTIFY){
 
684
         fprintf(stderr,"%d:done waiting for %p from %d at ind %d to be 0",
 
685
               armci_me,mycurrent_epoch,proc,current_epoch_seq[armci_me][proc]);
 
686
       }
 
687
 
 
688
       current_epoch_seq[armci_me][proc]++;
 
689
       current_epoch_seq[armci_me][proc]%=numepochs;
 
690
       mycurrent_epoch =mynotify_epochs[proc]+current_epoch_seq[armci_me][proc];
 
691
       *mycurrent_epoch=1;
 
692
 
 
693
       /*prevnotifydscr = DOPUT(myptr,remptr,proc,sizeof(int)*3,proc);*/
 
694
       prevnotifydscr = elan_put(elan_base->state,myptr,remptr,sizeof(int)*3,
 
695
                       proc);
 
696
 
 
697
       if(DEBUG_NOTIFY){
 
698
         printf("\n%d: sending %d %d %d to %d at %p\n",armci_me,*(myptr),
 
699
                  *(myptr+1),*(myptr+2),proc,remptr);
 
700
         fflush(stdout);
 
701
       }
 
702
       fflush(stdout);
 
703
       return(myptr[0]);
 
704
    }
 
705
}
 
706
 
 
707
 
 
708
int armci_inotify_wait(int proc, int *pval)
 
709
{
 
710
int *buf_notify,serv_count,rdma_count,*myserv_count;
 
711
int wait_val,wait_fence=0,zer=0;
 
712
int res,eventcount,es;
 
713
int *myptr=verify_wait->recv_verify_smp_arr[armci_me]+armci_nproc;
 
714
long loop=0;
 
715
 
 
716
    wait_val = verify_wait->wait_seq_ar[proc]++;
 
717
 
 
718
    buf_notify = verify_wait->recv_verify_arr[armci_me]+3*proc;
 
719
 
 
720
    if(SAMECLUSNODE(proc)){
 
721
       buf_notify = verify_wait->recv_verify_smp_arr[armci_me]+proc;
 
722
       *pval = wait_val;
 
723
    }
 
724
 
 
725
    if(DEBUG_NOTIFY){
 
726
      printf("\n%d:expecting %d at %p from %d\n",armci_me,wait_val,buf_notify,
 
727
              proc);
 
728
      fflush(stdout);
 
729
    }
 
730
    /*first we wait for sequence to match*/
 
731
    if((wait_val - armci_check_int_val(buf_notify)) > 0) {
 
732
      if(DEBUG_NOTIFY){
 
733
        printf("\n%d:verifyseq expecting%d have %d",armci_me,
 
734
               wait_val,armci_check_int_val(buf_notify));fflush(stdout);
 
735
      }
 
736
      MEM_FENCE;      
 
737
      res = wait_val - armci_check_int_val(buf_notify);
 
738
      while(res>0){
 
739
        if(++loop == 1000) { loop=0;usleep(1); }
 
740
         armci_util_spin(loop, buf_notify);
 
741
        MEM_FENCE;
 
742
        res = wait_val - armci_check_int_val(buf_notify);
 
743
      }
 
744
      if(DEBUG_NOTIFY){
 
745
        printf("\n%d:arrived verifyseq expected %d have %d",armci_me,
 
746
               wait_val,armci_check_int_val(buf_notify));fflush(stdout);
 
747
      }
 
748
    }
 
749
 
 
750
    if(SAMECLUSNODE(proc))
 
751
       return wait_val;
 
752
 
 
753
    serv_count = verify_wait->recv_verify_arr[armci_me][3*proc+1];
 
754
    rdma_count = verify_wait->recv_verify_arr[armci_me][3*proc+2];
 
755
    myserv_count = verify_wait->recv_verify_smp_arr[armci_me]+proc;
 
756
    wait_fence = serv_count;
 
757
 
 
758
 
 
759
    MEM_FENCE;
 
760
    res = wait_fence - armci_check_int_val(myserv_count);
 
761
 
 
762
    if(DEBUG_NOTIFY){
 
763
      printf("\n%d:fence expecting%d have %d",
 
764
             armci_me,wait_fence,armci_check_int_val(myserv_count));
 
765
      fflush(stdout);
 
766
    }
 
767
 
 
768
    if(!SAMECLUSNODE(proc)){ 
 
769
      while(res>0){
 
770
        if(++loop == 1000) { loop=0;usleep(1); }
 
771
          armci_util_spin(loop, myserv_count);
 
772
        MEM_FENCE;
 
773
        wait_fence=serv_count =verify_wait->recv_verify_arr[armci_me][3*proc+1];
 
774
        res = wait_fence - armci_check_int_val(myserv_count);
 
775
      }
 
776
    }
 
777
    
 
778
    rdma_count = verify_wait->recv_verify_arr[armci_me][3*proc+2];
 
779
    current_epoch_seq[proc][armci_me]++;
 
780
    current_epoch_seq[proc][armci_me]%=numepochs;
 
781
    es = proc*numepochs+current_epoch_seq[proc][armci_me];
 
782
    if(rdma_count)
 
783
       armci_elan_wait_event(elanev[es],rdma_count);
 
784
            
 
785
    *pval = armci_check_int_val(buf_notify);
 
786
 
 
787
    *myptr = 0;
 
788
 
 
789
    if(prevnotifywaitdscr)elan_wait(prevnotifywaitdscr,elan_base->waitType); 
 
790
 
 
791
 
 
792
    if(DEBUG_NOTIFY){
 
793
       fprintf(stderr,"\n%d:clearing %d on %d at %p\n",armci_me,
 
794
               current_epoch_seq[proc][armci_me],proc,
 
795
               notify_epoch_arr[proc]+armci_me*numepochs+current_epoch_seq[proc][armci_me]);
 
796
    }
 
797
    prevnotifywaitdscr = elan_put(elan_base->state,myptr,
 
798
    notify_epoch_arr[proc]+armci_me*numepochs+current_epoch_seq[proc][armci_me],
 
799
    sizeof(int),proc);
 
800
 
 
801
 
 
802
    return(wait_val);
 
803
}
 
804
#endif
 
805
 
 
806
 
 
807
/************************************************************************/
 
808
#if defined(_ELAN_LOCK_H) 
 
809
 
 
810
#define MAX_LOCKS 4
 
811
static ELAN_LOCK *my_locks, *all_locks;
 
812
static int num_locks=0;
 
813
 
 
814
/* NOTE that if ELAN is defined the scope of locks is limited to SMP
 
815
   and we do not call the interfaces below */
 
816
 
 
817
 
 
818
/*\ allocate and initialize num locks on each processor (collective call)
 
819
\*/
 
820
void armcill_allocate_locks(int num)
 
821
{
 
822
   char *buf;
 
823
   int i,elems;
 
824
   long mod;
 
825
 
 
826
   if(MAX_LOCKS<num)armci_die2("too many locks",MAX_LOCKS,num);
 
827
   num_locks = num;
 
828
 
 
829
   /* allocate memory to hold lock info for all the processors */
 
830
   buf = malloc(armci_nproc*num *sizeof(ELAN_LOCK) + ELAN_LOCK_ALIGN);
 
831
   if(!buf) armci_die("armcill_init_locks: malloc failed",0);
 
832
 
 
833
   mod = ((long)buf) %ELAN_LOCK_ALIGN;
 
834
   all_locks = (ELAN_LOCK*)(buf +ELAN_LOCK_ALIGN-mod); 
 
835
   if(((long)all_locks) %ELAN_LOCK_ALIGN) 
 
836
        armci_die2("lock alligment failed",mod,ELAN_LOCK_ALIGN);
 
837
   bzero(all_locks,armci_nproc*num *sizeof(ELAN_LOCK));
 
838
 
 
839
   /* initialize local locks */
 
840
   my_locks = all_locks + armci_me * num;
 
841
   for(i=0; i<num; i++)
 
842
       elan_lockInit(elan_base->state, my_locks+i, ELAN_LOCK_NORMAL);
 
843
 
 
844
   /* now we use all-reduce to exchange locks info among everybody */
 
845
   elems = (num*armci_nproc*sizeof(ELAN_LOCK))/sizeof(long);
 
846
   if((num*sizeof(ELAN_LOCK))%sizeof(long)) 
 
847
       armci_die("armcill_init_locks: size mismatch",sizeof(ELAN_LOCK));
 
848
   armci_msg_lgop((long*)all_locks,elems,"+");
 
849
#if 0
 
850
   if(armci_me == 0){
 
851
     for(i=0; i<num*armci_nproc; i++) printf("%d:(%d) master=%d type=%d\n",i,elems,(all_locks+i)->lp_master, (all_locks+i)->lp_type);
 
852
   }
 
853
#endif
 
854
   armci_msg_barrier();
 
855
}
 
856
 
 
857
 
 
858
void armcill_lock(int m, int proc)
 
859
{
 
860
ELAN_LOCK *rem_locks = (ELAN_LOCK*)(all_locks + proc*num_locks);
 
861
 
 
862
   if(m<0 || m>= num_locks) armci_die2("armcill_lock: bad lock id",m,num_locks);
 
863
   if(proc<0 || proc>= armci_nproc) armci_die("armcill_lock: bad proc id",proc);
 
864
 
 
865
   elan_lockLock(elan_base->state, rem_locks + m, ELAN_LOCK_BUSY);
 
866
}
 
867
 
 
868
void armcill_unlock(int m, int proc)
 
869
{
 
870
ELAN_LOCK *rem_locks = (ELAN_LOCK*)(all_locks + proc*num_locks);
 
871
 
 
872
   if(m<0 || m>= num_locks) armci_die2("armcill_unlock:bad lockid",m,num_locks);
 
873
   if(proc<0 || proc>=armci_nproc)armci_die("armcill_unlock: bad proc id",proc);
 
874
 
 
875
   elan_lockUnLock(elan_base->state, rem_locks + m);
 
876
}
 
877
     
 
878
#endif
 
879
 
 
880
#if HAS_PUTS
 
881
extern ELAN_EVENT *elan_putss (void *pgs, void *src, void *dst, int *src_stride_arr, int *dst_stride_arr, u_int *count, u_int strides, u_int destvp);
 
882
 
 
883
 
 
884
void armcill_putS(int proc, void* src_ptr, int src_stride_arr[], void* dst_ptr,
 
885
                  int dst_stride_arr[], int count[], int stride_levels)
 
886
{
 
887
    elan_wait(elan_putss(_pgsstate,src_ptr,dst_ptr, src_stride_arr, 
 
888
              dst_stride_arr, count, stride_levels, proc),elan_base->waitType);
 
889
}
 
890
 
 
891
ELAN_EVENT * armcill_nbputS(int proc, void* src_ptr, int src_stride_arr[], 
 
892
             void* dst_ptr, int dst_stride_arr[], int count[], int stride_levels)
 
893
{
 
894
    return elan_putss(_pgsstate,src_ptr,dst_ptr, src_stride_arr,
 
895
              dst_stride_arr, count, stride_levels, proc);
 
896
}
 
897
#endif
 
898
 
 
899
#if HAS_GETS
 
900
extern ELAN_EVENT *elan_getss (void *pgs, void *src, void *dst, int *src_stride_arr, int *dst_stride_arr, u_int *count, u_int strides, u_int destvp);
 
901
void armcill_getS(int proc, void* src_ptr, int src_stride_arr[], void* dst_ptr,
 
902
                  int dst_stride_arr[], int count[], int stride_levels)
 
903
{
 
904
    elan_wait(elan_getss(_pgsstate,src_ptr,dst_ptr, src_stride_arr, 
 
905
              dst_stride_arr, count, stride_levels, proc),elan_base->waitType);
 
906
}
 
907
 
 
908
ELAN_EVENT* armcill_nbgetS(int proc, void* src_ptr, int src_stride_arr[],  
 
909
              void* dst_ptr, int dst_stride_arr[], int count[], int stride_levels)
 
910
{
 
911
    return elan_getss(_pgsstate,src_ptr,dst_ptr, src_stride_arr,
 
912
              dst_stride_arr, count, stride_levels, proc);
 
913
}
 
914
#endif
 
915
 
 
916
/************************************************************************/
 
917
#if VCALLS 
 
918
 
 
919
#define MAX_VECS 1024 
 
920
static void* _src[MAX_VECS], *_dst[MAX_VECS];
 
921
 
 
922
 
 
923
void armci_network_strided(int op, void* scale, int proc,void *src_ptr,
 
924
                   int src_stride_arr[], void* dst_ptr, int dst_stride_arr[],
 
925
                   int count[], int stride_levels, armci_ihdl_t nb_handle)
 
926
{
 
927
int rc=0;
 
928
int total_of_2D,i,j;    
 
929
char *src = (char*)src_ptr, *dst=(char*)dst_ptr;
 
930
char *bufptr;
 
931
int dsize=3*sizeof(void*);
 
932
ELAN_EVENT* o_cmpl;
 
933
extern ELAN_EVENT *elan_getss (void *pgs, void *src, void *dst, int *src_stride_arr, int *dst_stride_arr, u_int *count, u_int strides, u_int destvp);
 
934
extern ELAN_EVENT *elan_putss (void *pgs, void *src, void *dst, int *src_stride_arr, int *dst_stride_arr, u_int *count, u_int strides, u_int destvp);
 
935
    if(stride_levels==0){
 
936
       if(op==GET)
 
937
         o_cmpl = elan_get(elan_base->state,src,dst,count[0],proc);
 
938
       if(op==PUT){
 
939
         if(nb_handle) 
 
940
           armci_elan_put_with_tracknotify(src,dst,count[0],proc,&o_cmpl);
 
941
         else
 
942
           o_cmpl = elan_put(elan_base->state,src,dst,count[0],proc);
 
943
       }
 
944
    }
 
945
    else if(stride_levels==1){ 
 
946
      if(op==GET)
 
947
        o_cmpl = elan_getss(_pgsstate,src_ptr,dst_ptr, src_stride_arr,
 
948
                            dst_stride_arr, count, stride_levels, proc);
 
949
      else if(op==PUT)
 
950
        o_cmpl = elan_putss(_pgsstate,src_ptr,dst_ptr, src_stride_arr,
 
951
                           dst_stride_arr, count, stride_levels, proc);
 
952
      else
 
953
        armci_die("network strided called for accumulate",proc);
 
954
    }
 
955
    else if(stride_levels==2){
 
956
      if(op==GET)
 
957
        o_cmpl = elan_getss(_pgsstate,src_ptr,dst_ptr, src_stride_arr,
 
958
                           dst_stride_arr, count, stride_levels, proc);
 
959
      else if(op==PUT)
 
960
        o_cmpl = elan_putss(_pgsstate,src_ptr,dst_ptr, src_stride_arr,
 
961
                           dst_stride_arr, count, stride_levels, proc);
 
962
      else
 
963
        armci_die("network strided called for accumulate",proc);
 
964
    }
 
965
    else{
 
966
       armci_die("network strided called for stride_levels>=3",proc);
 
967
    }
 
968
    if(!nb_handle)
 
969
       elan_wait(o_cmpl,elan_base->waitType);
 
970
    else
 
971
       nb_handle->cmpl_info = o_cmpl;
 
972
}
 
973
 
 
974
void armcill_getv(int proc, int bytes, int count, void* src[], void* dst[])
 
975
{
 
976
int _j, issued=0;
 
977
 
 
978
#if 0
 
979
    printf("%d: getv %d\n", armci_me, count); fflush(stdout);
 
980
#endif
 
981
    for (_j = 0;  _j < count;  _j++ ){
 
982
        _src[issued] = src[_j];
 
983
        _dst[issued] = dst[_j]; 
 
984
        issued++;
 
985
        if(issued == MAX_VECS){
 
986
           elan_wait(elan_getv(_pgctrl,_src,_dst,bytes,issued,proc),elan_base->waitType);
 
987
           issued=0;
 
988
        }
 
989
    }
 
990
    if(issued)elan_wait(elan_getv(_pgctrl,_src,_dst,bytes,issued,proc),
 
991
                        elan_base->waitType);
 
992
}
 
993
 
 
994
 
 
995
void armcill_putv(int proc, int bytes, int count, void* src[], void* dst[])
 
996
{
 
997
int _j, issued=0;
 
998
 
 
999
#if 0
 
1000
    printf("%d: putv %d\n", armci_me, count); fflush(stdout);
 
1001
#endif
 
1002
 
 
1003
    for (_j = 0;  _j < count;  _j++ ){
 
1004
        _src[issued] = src[_j];
 
1005
        _dst[issued] = dst[_j];
 
1006
        issued++;
 
1007
        if(issued == MAX_VECS){
 
1008
           elan_wait(elan_putv(_pgctrl,_src,_dst,bytes,issued,proc),
 
1009
                               elan_base->waitType);
 
1010
           issued=0;
 
1011
        }
 
1012
    }
 
1013
    if(issued)elan_wait(elan_putv(_pgctrl,_src,_dst,bytes,issued,proc),
 
1014
                        elan_base->waitType);
 
1015
}
 
1016
 
 
1017
 
 
1018
 
 
1019
 
 
1020
 
 
1021
 
 
1022
#if HAS_PUTS_
 
1023
 
 
1024
void armcill_put2D(int proc, int bytes, int count, void* src_ptr,int src_stride,
 
1025
                                                   void* dst_ptr,int dst_stride)
 
1026
{
 
1027
u_int acount[2];
 
1028
acount[0]=bytes; 
 
1029
acount[1]=count; 
 
1030
elan_wait(elan_putss(_pgsstate,src_ptr,dst_ptr, &src_stride, &dst_stride, acount,1,proc),elan_base->waitType); 
 
1031
}
 
1032
 
 
1033
#else
 
1034
 
 
1035
void armcill_put2D(int proc, int bytes, int count, void* src_ptr,int src_stride,
 
1036
                                                   void* dst_ptr,int dst_stride)
 
1037
{
 
1038
int _j, issued=0;
 
1039
char *ps=src_ptr, *pd=dst_ptr;
 
1040
 
 
1041
#if 0
 
1042
    printf("%d: putv %d\n", armci_me, count); fflush(stdout);
 
1043
#endif
 
1044
 
 
1045
    for (_j = 0;  _j < count;  _j++ ){
 
1046
        _src[issued] = ps;
 
1047
        _dst[issued] = pd;
 
1048
        ps += src_stride;
 
1049
        pd += dst_stride;
 
1050
        issued++;
 
1051
        if(issued == MAX_VECS){
 
1052
           elan_wait(elan_putv(_pgctrl,_src,_dst,bytes,issued,proc),elan_base->waitType);
 
1053
           issued=0;
 
1054
        }
 
1055
    }
 
1056
    if(issued)elan_wait(elan_putv(_pgctrl,_src,_dst,bytes,issued,proc),elan_base->waitType);
 
1057
}
 
1058
 
 
1059
#endif
 
1060
 
 
1061
#if HAS_GETS_
 
1062
 
 
1063
void armcill_get2D(int proc, int bytes, int count, void* src_ptr,int src_stride,
 
1064
                                                   void* dst_ptr,int dst_stride)
 
1065
{
 
1066
   u_int acount[2];
 
1067
   acount[0]=bytes; 
 
1068
   acount[1]=count; 
 
1069
   elan_wait(elan_getss(_pgsstate,src_ptr,dst_ptr, &src_stride, &dst_stride, acount,1,proc),elan_base->waitType); 
 
1070
}
 
1071
#else
 
1072
 
 
1073
void armcill_get2D(int proc, int bytes, int count, void* src_ptr,int src_stride,
 
1074
                                                   void* dst_ptr,int dst_stride)
 
1075
{
 
1076
int _j, issued=0;
 
1077
char *ps=src_ptr, *pd=dst_ptr;
 
1078
    
 
1079
#if 0
 
1080
    printf("%d: getv %d\n", armci_me, count); fflush(stdout);
 
1081
#endif
 
1082
    for (_j = 0;  _j < count;  _j++ ){
 
1083
        _src[issued] = ps;
 
1084
        _dst[issued] = pd;
 
1085
        ps += src_stride;
 
1086
        pd += dst_stride;
 
1087
        issued++;
 
1088
        if(issued == MAX_VECS){
 
1089
           elan_wait(elan_getv(_pgctrl,_src,_dst,bytes,issued,proc),elan_base->waitType);
 
1090
           issued=0;
 
1091
        } 
 
1092
    }
 
1093
    if(issued)elan_wait(elan_getv(_pgctrl,_src,_dst,bytes,issued,proc),elan_base->waitType);
 
1094
#if 0
 
1095
    printf("%d: getv count=%d issued=%d\n", armci_me, count,issued); fflush(stdout);
 
1096
#endif
 
1097
}
 
1098
#endif
 
1099
 
 
1100
 
 
1101
void armcill_wait_get(){}
 
1102
void armcill_wait_put(){}
 
1103
 
 
1104
#elif 0 /*#else*/
 
1105
 
 
1106
#ifdef _ELAN_PUTGET_H
 
1107
 
 
1108
/* might have to use MAX_SLOTS<MAX_PENDING due to throttling a problem in Elan*/
 
1109
#define MAX_PENDING 6 
 
1110
#define ZR  (ELAN_EVENT*)0
 
1111
 
 
1112
static ELAN_EVENT* put_dscr[MAX_SLOTS]= {
 
1113
ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,
 
1114
ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR};
 
1115
 
 
1116
static ELAN_EVENT* get_dscr[MAX_SLOTS] = {
 
1117
ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,
 
1118
ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR,ZR};
 
1119
 
 
1120
static int cur_get=0;
 
1121
static int cur_put=0;
 
1122
static int pending_get=0;
 
1123
static int pending_put=0;
 
1124
 
 
1125
int kwach=0;
 
1126
/*\ strided put, nonblocking
 
1127
\*/
 
1128
void armcill_put2D(int proc, int bytes, int count, void* src_ptr,int src_stride,
 
1129
                                                   void* dst_ptr,int dst_stride)
 
1130
{
 
1131
int _j, i, batch, issued=0;
 
1132
char *ps=src_ptr, *pd=dst_ptr;
 
1133
 
 
1134
#if 1
 
1135
    for (_j = 0;  _j < count;  ){
 
1136
      /* how big a batch of requests can we issue */
 
1137
      batch = (count - _j )<max_pending ? count - _j : max_pending; 
 
1138
      _j += batch;
 
1139
      for(i=0; i< batch; i++){
 
1140
        if(put_dscr[cur_put])elan_wait(put_dscr[cur_put],100); 
 
1141
        else pending_put++;
 
1142
#if 1
 
1143
        put_dscr[cur_put]= elan_put(elan_base->state,ps, pd,(size_t)bytes,proc);
 
1144
#else
 
1145
        elan_wait(elan_put(elan_base->state, ps, pd, (size_t)bytes, proc),1000);
 
1146
#endif
 
1147
        issued++;
 
1148
        ps += src_stride;
 
1149
        pd += dst_stride;
 
1150
        cur_put++;
 
1151
        if(cur_put>=max_pending)cur_put=0;
 
1152
      }
 
1153
    }
 
1154
 
 
1155
    if(issued != count) 
 
1156
       armci_die2("armci-elan put:mismatch %d %d \n", count,issued);
 
1157
#else
 
1158
     for (_j = 0;  _j < count;  _j++){
 
1159
       elan_wait(elan_put(elan_base->state, ps, pd, (size_t)bytes, proc),1000);
 
1160
       ps += src_stride;
 
1161
       pd += dst_stride;
 
1162
     }
 
1163
#endif
 
1164
}
 
1165
 
 
1166
 
 
1167
/*\ blocking vector put
 
1168
\*/
 
1169
void armcill_putv(int proc, int bytes, int count, void* src[], void* dst[])
 
1170
{
 
1171
int _j, i, batch, issued=0;
 
1172
void *ps, *pd;
 
1173
 
 
1174
#if 0
 
1175
    printf("%d: putv %d\n", armci_me, count); fflush(stdout);
 
1176
#endif
 
1177
 
 
1178
    for (_j = 0;  _j < count;  ){
 
1179
      /* how big a batch of requests can we issue */
 
1180
      batch = (count - _j )<max_pending ? count - _j : max_pending; 
 
1181
      _j += batch;
 
1182
      for(i=0; i< batch; i++){
 
1183
        if(put_dscr[cur_put])elan_wait(put_dscr[cur_put],100); 
 
1184
        else pending_put++;
 
1185
        ps = src[issued];
 
1186
        pd = dst[issued];
 
1187
        put_dscr[cur_put]= elan_put(elan_base->state,ps, pd,(size_t)bytes,proc);
 
1188
        issued++;
 
1189
        cur_put++;
 
1190
        if(cur_put>=max_pending)cur_put=0;
 
1191
      }
 
1192
    }
 
1193
    if(issued != count) 
 
1194
       armci_die2("armci-elan putv:mismatch\n", count,issued);
 
1195
 
 
1196
    for(i=0; i<max_pending; i++) if(put_dscr[i]){
 
1197
        elan_wait(put_dscr[i],100);
 
1198
        put_dscr[i]=(ELAN_EVENT*)0;
 
1199
    }
 
1200
}
 
1201
 
 
1202
 
 
1203
 
 
1204
/*\ strided get, nonblocking
 
1205
\*/
 
1206
void armcill_get2D(int proc, int bytes, int count, void* src_ptr,int src_stride,
 
1207
                                                   void* dst_ptr,int dst_stride)
 
1208
{
 
1209
int _j, i, batch, issued=0;
 
1210
char *ps=src_ptr, *pd=dst_ptr;
 
1211
 
 
1212
#if 1
 
1213
    for (_j = 0;  _j < count;  ){
 
1214
      /* how big a batch of requests can we issue */
 
1215
      batch = (count - _j )<max_pending ? count - _j : max_pending;
 
1216
      _j += batch;
 
1217
      for(i=0; i< batch; i++){
 
1218
#if 1
 
1219
        if(get_dscr[cur_get])elan_wait(get_dscr[cur_get],100); 
 
1220
        else pending_get++;
 
1221
        get_dscr[cur_get]=elan_get(elan_base->state,ps,pd, (size_t)bytes, proc);
 
1222
#else
 
1223
        elan_wait(elan_get(elan_base->state, ps, pd, (size_t)bytes, proc),elan_base->waitType);
 
1224
#endif
 
1225
        issued++;
 
1226
        ps += src_stride;
 
1227
        pd += dst_stride;
 
1228
        cur_get++;
 
1229
        if(cur_get>=max_pending)cur_get=0;
 
1230
      }
 
1231
    }
 
1232
 
 
1233
    if(issued != count) 
 
1234
       armci_die2("armci-elan get:mismatch %d %d \n", count,issued);
 
1235
#else
 
1236
      for (_j = 0;  _j < count;  _j++){
 
1237
        elan_wait(elan_get(elan_base->state, ps, pd, (size_t)bytes, proc),elan_base->waitType);
 
1238
        ps += src_stride;
 
1239
        pd += dst_stride;
 
1240
      }
 
1241
#endif
 
1242
}
 
1243
 
 
1244
 
 
1245
/*\ blocking vector get 
 
1246
\*/
 
1247
void armcill_getv(int proc, int bytes, int count, void* src[], void* dst[])
 
1248
{
 
1249
int _j, i, batch, issued=0;
 
1250
void *ps, *pd;
 
1251
 
 
1252
#if 0
 
1253
    printf("%d: getv %d\n", armci_me, count); fflush(stdout);
 
1254
#endif
 
1255
 
 
1256
    for (_j = 0;  _j < count;  ){
 
1257
      /* how big a batch of requests can we issue */
 
1258
      batch = (count - _j )<max_pending ? count - _j : max_pending;
 
1259
      _j += batch;
 
1260
      for(i=0; i< batch; i++){
 
1261
        if(get_dscr[cur_get])elan_wait(get_dscr[cur_get],100);
 
1262
        else pending_get++;
 
1263
        ps = src[issued];
 
1264
        pd = dst[issued];
 
1265
        get_dscr[cur_get]= elan_get(elan_base->state,ps, pd,(size_t)bytes,proc);
 
1266
        issued++;
 
1267
        cur_get++;
 
1268
        if(cur_get>=max_pending)cur_get=0;
 
1269
      }
 
1270
    }
 
1271
    if(issued != count)
 
1272
       armci_die2("armci-elan getv:mismatch %d %d \n", count,issued);
 
1273
 
 
1274
    for(i=0; i<max_pending; i++) if(get_dscr[i]){
 
1275
        elan_wait(get_dscr[i],100);
 
1276
        get_dscr[i]=(ELAN_EVENT*)0;
 
1277
    }
 
1278
}
 
1279
 
 
1280
 
 
1281
void armcill_wait_get()
 
1282
{
 
1283
int i;
 
1284
    
 
1285
    if(!pending_get)return;
 
1286
    else pending_get=0;
 
1287
    for(i=0; i<max_pending; i++) if(get_dscr[i]){
 
1288
        elan_wait(get_dscr[i],100); 
 
1289
        get_dscr[i]=(ELAN_EVENT*)0;
 
1290
    }
 
1291
}
 
1292
 
 
1293
 
 
1294
void armcill_wait_put()
 
1295
{
 
1296
int i;
 
1297
    if(!pending_put)return;
 
1298
    else pending_put=0;
 
1299
    for(i=0; i<max_pending; i++) if(put_dscr[i]){
 
1300
        elan_wait(put_dscr[i],100); 
 
1301
        put_dscr[i]=(ELAN_EVENT*)0;
 
1302
    }
 
1303
}
 
1304
 
 
1305
#endif
 
1306
#endif