mdtools/mpi_implementation/mpiBASS.c


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define __mpiBASSEVENT
#include "mpiBASS.h"
#include "simError.h"


void mpiCatchEvent(void);


void mpiEventInit(void)
{
  int blockCounts[5] = {1,3,4,120,80};
  MPI_Aint dspls[5];
  MPI_Datatype types[5];
  mBEvent protoEvent;

  int i;  

  MPI_Address(&protoEvent.type, &dspls[0]);
  MPI_Address(&protoEvent.d1, &dspls[1]);
  MPI_Address(&protoEvent.i1, &dspls[2]);
  MPI_Address(&protoEvent.cArray, &dspls[3]);
  MPI_Address(&protoEvent.lhs   , &dspls[4]);


  types[0] = MPI_INT;
  types[1] = MPI_DOUBLE;
  types[2] = MPI_INT;
  types[3] = MPI_CHAR;
  types[4] = MPI_CHAR;


  for (i =4; i >= 0; i--) dspls[i] -= dspls[0];

  MPI_Type_struct(5,blockCounts,dspls,types,&mpiBASSEventType);
  MPI_Type_commit(&mpiBASSEventType);
}


void throwMPIEvent(event* the_event)
{
  mBEvent mpiEventContainer;
  int mpiStatus;
  int mpiError;


  if (the_event == NULL)     mpiStatus = MPI_INTERFACE_DONE;
  else                       mpiStatus = MPI_INTERFACE_CONTINUE;
  
  MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
  
  if (!mpiStatus){
    switch (the_event->event_type){
    case MOLECULE:
      mpiEventContainer.type = mpiMOLECULE;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int  
    break;

    case ATOM:
      mpiEventContainer.type = mpiATOM;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case BOND:
      mpiEventContainer.type = mpiBOND;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case BEND:
      mpiEventContainer.type = mpiBEND;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case TORSION:
      mpiEventContainer.type = mpiTORSION;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case COMPONENT:
      mpiEventContainer.type = mpiCOMPONENT;
      mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
      break;

    case POSITION:
      mpiEventContainer.type = mpiPOSITION;
      mpiEventContainer.d1 = the_event->evt.pos.x; // pack pos coord into d
      mpiEventContainer.d2 = the_event->evt.pos.y; 
      mpiEventContainer.d3 = the_event->evt.pos.z;   
      break;

    case ORIENTATION:
      mpiEventContainer.type = mpiORIENTATION;
      mpiEventContainer.d1 = the_event->evt.ornt.x; // pack orientation coord into d
      mpiEventContainer.d2 = the_event->evt.ornt.y; 
      mpiEventContainer.d3 = the_event->evt.ornt.z;   
      break;
      
    case CONSTRAINT:
      mpiEventContainer.type = mpiCONSTRAINT;
      mpiEventContainer.d1 = the_event->evt.cnstr; // pack constraint coord into d
      break;
      
    case MEMBER:
      mpiEventContainer.type = mpiMEMBER;
      mpiEventContainer.i1 = the_event->evt.mbr.a ; // pack member ints into i
      mpiEventContainer.i2 = the_event->evt.mbr.b; 
      mpiEventContainer.i3 = the_event->evt.mbr.c;   
      mpiEventContainer.i4 = the_event->evt.mbr.d;   
      break;
      
    case ASSIGNMENT:

      strcpy(mpiEventContainer.lhs,the_event->evt.asmt.lhs);

#ifdef MPIBASS_VERBOSE

      fprintf(stderr, 
              "mpiDiag at node %d: evt Assignment: \"%s\" = ?\n"
              "                    mpi Assignment: \"%s\" = ?\n",
              worldRank, 
              the_event->evt.asmt.lhs,
              mpiEventContainer.lhs);
#endif

      switch (the_event->evt.asmt.asmt_type){
      case STRING:
        mpiEventContainer.type = mpiASSIGNMENT_s;
        strcpy(mpiEventContainer.cArray,the_event->evt.asmt.rhs.sval);
        break;

      case INT:
        mpiEventContainer.type = mpiASSIGNMENT_i;
        mpiEventContainer.i1 = the_event->evt.asmt.rhs.ival;
        break;

      case DOUBLE:
        mpiEventContainer.type = mpiASSIGNMENT_d;
        mpiEventContainer.d1 = the_event->evt.asmt.rhs.dval;
        break;
      }
      break;

    case BLOCK_END:
      mpiEventContainer.type = mpiBLOCK_END;
      break;
    }


    MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);

    sprintf( checkPointMsg, 
             "BASS Event broadcast successful" );
    MPIcheckPoint();
  }
}


// Everybody but node 0 runs this
void mpiEventLoop(void)
{
  int mpiError;
  int mpiContinue;

#ifdef MPIBASS_VERBOSE
  fprintf(stderr, 
          "event key List at node %d:\n"
          "  MOLECULE    %d\n"
          "  ATOM        %d\n"
          "  BOND        %d\n"
          "  BEND        %d\n"
          "  TORSION     %d\n"
          "  COMPONENT   %d\n"
          "  POSITION    %d\n"
          "  ASSIGNMENT  %d\n"
          "  MEMBER      %d\n"
          "  CONSTRAINT  %d\n"
          "  ORIENTATION %d\n"
          "  START_INDEX %d\n"
          "  BLOCK_END   %d\n"
          "\n",
          worldRank,
          MOLECULE, ATOM, BOND, BEND, TORSION, COMPONENT, 
          POSITION, ASSIGNMENT, MEMBER, CONSTRAINT, ORIENTATION,
          START_INDEX, BLOCK_END );
#endif

  MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);

  while(!mpiContinue){
    
    mpiCatchEvent();

    MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
  }

  if (mpiContinue == MPI_INTERFACE_ABORT){
    MPI_Finalize();
    exit (0);
  }
}

void mpiCatchEvent(void)
{
  event the_event;
  mBEvent mpiEventContainer;
  int mpiError;


  MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);

  switch (mpiEventContainer.type){
  case mpiMOLECULE:
    the_event.event_type = MOLECULE;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;
    
  case mpiATOM:
    the_event.event_type = ATOM;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;
    
  case mpiBOND:
    the_event.event_type = BOND;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;
      
  case mpiBEND:
    the_event.event_type = BEND;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;

  case mpiTORSION:
    the_event.event_type = TORSION;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;
    
  case mpiCOMPONENT:
    the_event.event_type = COMPONENT;
    the_event.evt.blk_index = mpiEventContainer.i1;
    break;


  case mpiPOSITION:
    the_event.event_type = POSITION;
    the_event.evt.pos.x = mpiEventContainer.d1; 
    the_event.evt.pos.y = mpiEventContainer.d2; 
    the_event.evt.pos.z = mpiEventContainer.d3;   
    break;

  case mpiORIENTATION:
    the_event.event_type = ORIENTATION;
    the_event.evt.ornt.x = mpiEventContainer.d1; 
    the_event.evt.ornt.y = mpiEventContainer.d2; 
    the_event.evt.ornt.z = mpiEventContainer.d3;   
    break;
      
  case mpiCONSTRAINT:
    the_event.event_type = CONSTRAINT;
    the_event.evt.cnstr = mpiEventContainer.d1; 
    break;
    
  case mpiMEMBER:
    the_event.event_type = MEMBER;
    the_event.evt.mbr.a = mpiEventContainer.i1; 
    the_event.evt.mbr.b = mpiEventContainer.i2; 
    the_event.evt.mbr.c = mpiEventContainer.i3;   
    the_event.evt.mbr.d = mpiEventContainer.i4;   
    break;
    
  case mpiASSIGNMENT_s:
    the_event.event_type = ASSIGNMENT;
    the_event.evt.asmt.asmt_type = STRING;
    strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
    strcpy(the_event.evt.asmt.rhs.sval,mpiEventContainer.cArray);
    
#ifdef MPIBASS_VERBOSE

    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %s\n", worldRank, 
            the_event.evt.asmt.lhs,
            the_event.evt.asmt.rhs.sval );
#endif

    break;

  case mpiASSIGNMENT_i:
    the_event.event_type = ASSIGNMENT;
    the_event.evt.asmt.asmt_type = INT;
    strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
    the_event.evt.asmt.rhs.ival = mpiEventContainer.i1;      

#ifdef MPIBASS_VERBOSE

    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %d\n", worldRank, 
            the_event.evt.asmt.lhs,
            the_event.evt.asmt.rhs.ival );
#endif

    break;

  case mpiASSIGNMENT_d:
    the_event.event_type = ASSIGNMENT;
    the_event.evt.asmt.asmt_type = DOUBLE;
    strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
    the_event.evt.asmt.rhs.dval = mpiEventContainer.d1;      

#ifdef MPIBASS_VERBOSE

    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %lf\n", worldRank, 
            the_event.evt.asmt.lhs,
            the_event.evt.asmt.rhs.dval );
#endif

    break;

  case mpiBLOCK_END:
    the_event.event_type = BLOCK_END;
    break;
  }

#ifdef MPIBASS_VERBOSE

  fprintf(stderr, "mpiDiag at node %d: event type is %d\n", worldRank, 
          the_event.event_type);
#endif

  if (!event_handler(&the_event)){ 

    sprintf(painCave.errMsg,
            "MPI event handling error at node %d => %s\n",
            worldRank,
            the_event.err_msg);
    painCave.isFatal = 1;
    simError();
  }
  MPIcheckPoint();
}


void mpiInterfaceExit(void){
  int mpiError;
  int mpiStatus = MPI_INTERFACE_ABORT;
  
  MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
  MPI_Finalize();
  exit (0);

}
Revision:	164
Committed:	Tue Nov 5 22:04:46 2002 UTC (22 years, 5 months ago) by mmeineke
Content type:	text/plain
File size:	8718 byte(s)
Log Message:	* empty log message *
#	User	Rev	Content
1	chuckv	139
2			#include <stdlib.h>
3			#include <stdio.h>
4			#include <string.h>
5			#define __mpiBASSEVENT
6			#include "mpiBASS.h"
7	mmeineke	164	#include "simError.h"
8	chuckv	139
9
10			void mpiCatchEvent(void);
11
12
13
14
15			void mpiEventInit(void)
16			{
17			int blockCounts[5] = {1,3,4,120,80};
18			MPI_Aint dspls[5];
19			MPI_Datatype types[5];
20			mBEvent protoEvent;
21
22			int i;
23
24			MPI_Address(&protoEvent.type, &dspls[0]);
25			MPI_Address(&protoEvent.d1, &dspls[1]);
26			MPI_Address(&protoEvent.i1, &dspls[2]);
27			MPI_Address(&protoEvent.cArray, &dspls[3]);
28			MPI_Address(&protoEvent.lhs , &dspls[4]);
29
30
31			types[0] = MPI_INT;
32			types[1] = MPI_DOUBLE;
33			types[2] = MPI_INT;
34			types[3] = MPI_CHAR;
35			types[4] = MPI_CHAR;
36
37
38			for (i =4; i >= 0; i--) dspls[i] -= dspls[0];
39
40			MPI_Type_struct(5,blockCounts,dspls,types,&mpiBASSEventType);
41			MPI_Type_commit(&mpiBASSEventType);
42			}
43
44
45			void throwMPIEvent(event* the_event)
46			{
47			mBEvent mpiEventContainer;
48			int mpiStatus;
49			int mpiError;
50
51	mmeineke	164
52	chuckv	139	if (the_event == NULL) mpiStatus = MPI_INTERFACE_DONE;
53			else mpiStatus = MPI_INTERFACE_CONTINUE;
54
55	mmeineke	164	MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
56
57	chuckv	139	if (!mpiStatus){
58			switch (the_event->event_type){
59			case MOLECULE:
60			mpiEventContainer.type = mpiMOLECULE;
61			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
62			break;
63
64			case ATOM:
65			mpiEventContainer.type = mpiATOM;
66			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
67			break;
68
69			case BOND:
70			mpiEventContainer.type = mpiBOND;
71			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
72			break;
73
74			case BEND:
75			mpiEventContainer.type = mpiBEND;
76			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
77			break;
78
79			case TORSION:
80			mpiEventContainer.type = mpiTORSION;
81			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
82			break;
83
84			case COMPONENT:
85			mpiEventContainer.type = mpiCOMPONENT;
86			mpiEventContainer.i1 = the_event->evt.blk_index; // pack block index into first int
87			break;
88
89			case POSITION:
90			mpiEventContainer.type = mpiPOSITION;
91			mpiEventContainer.d1 = the_event->evt.pos.x; // pack pos coord into d
92			mpiEventContainer.d2 = the_event->evt.pos.y;
93			mpiEventContainer.d3 = the_event->evt.pos.z;
94			break;
95
96			case ORIENTATION:
97			mpiEventContainer.type = mpiORIENTATION;
98			mpiEventContainer.d1 = the_event->evt.ornt.x; // pack orientation coord into d
99			mpiEventContainer.d2 = the_event->evt.ornt.y;
100			mpiEventContainer.d3 = the_event->evt.ornt.z;
101			break;
102
103			case CONSTRAINT:
104			mpiEventContainer.type = mpiCONSTRAINT;
105			mpiEventContainer.d1 = the_event->evt.cnstr; // pack constraint coord into d
106			break;
107
108			case MEMBER:
109			mpiEventContainer.type = mpiMEMBER;
110			mpiEventContainer.i1 = the_event->evt.mbr.a ; // pack member ints into i
111			mpiEventContainer.i2 = the_event->evt.mbr.b;
112			mpiEventContainer.i3 = the_event->evt.mbr.c;
113			mpiEventContainer.i4 = the_event->evt.mbr.d;
114			break;
115
116			case ASSIGNMENT:
117
118			strcpy(mpiEventContainer.lhs,the_event->evt.asmt.lhs);
119
120	mmeineke	164	#ifdef MPIBASS_VERBOSE
121
122	chuckv	139	fprintf(stderr,
123			"mpiDiag at node %d: evt Assignment: \"%s\" = ?\n"
124			" mpi Assignment: \"%s\" = ?\n",
125	mmeineke	164	worldRank,
126	chuckv	139	the_event->evt.asmt.lhs,
127			mpiEventContainer.lhs);
128			#endif
129
130			switch (the_event->evt.asmt.asmt_type){
131			case STRING:
132			mpiEventContainer.type = mpiASSIGNMENT_s;
133			strcpy(mpiEventContainer.cArray,the_event->evt.asmt.rhs.sval);
134			break;
135
136			case INT:
137			mpiEventContainer.type = mpiASSIGNMENT_i;
138			mpiEventContainer.i1 = the_event->evt.asmt.rhs.ival;
139			break;
140
141			case DOUBLE:
142			mpiEventContainer.type = mpiASSIGNMENT_d;
143			mpiEventContainer.d1 = the_event->evt.asmt.rhs.dval;
144			break;
145			}
146			break;
147
148			case BLOCK_END:
149			mpiEventContainer.type = mpiBLOCK_END;
150			break;
151			}
152
153
154	mmeineke	164	MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);
155	chuckv	139
156	mmeineke	164	sprintf( checkPointMsg,
157			"BASS Event broadcast successful" );
158			MPIcheckPoint();
159	chuckv	139	}
160			}
161
162
163			// Everybody but node 0 runs this
164			void mpiEventLoop(void)
165			{
166			int mpiError;
167			int mpiContinue;
168
169	mmeineke	164	#ifdef MPIBASS_VERBOSE
170	chuckv	139	fprintf(stderr,
171			"event key List at node %d:\n"
172			" MOLECULE %d\n"
173			" ATOM %d\n"
174			" BOND %d\n"
175			" BEND %d\n"
176			" TORSION %d\n"
177			" COMPONENT %d\n"
178			" POSITION %d\n"
179			" ASSIGNMENT %d\n"
180			" MEMBER %d\n"
181			" CONSTRAINT %d\n"
182			" ORIENTATION %d\n"
183			" START_INDEX %d\n"
184			" BLOCK_END %d\n"
185			"\n",
186	mmeineke	164	worldRank,
187	chuckv	139	MOLECULE, ATOM, BOND, BEND, TORSION, COMPONENT,
188			POSITION, ASSIGNMENT, MEMBER, CONSTRAINT, ORIENTATION,
189			START_INDEX, BLOCK_END );
190			#endif
191
192	mmeineke	164	MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
193	chuckv	139
194			while(!mpiContinue){
195
196			mpiCatchEvent();
197
198	mmeineke	164	MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
199	chuckv	139	}
200
201			if (mpiContinue == MPI_INTERFACE_ABORT){
202	mmeineke	164	MPI_Finalize();
203	chuckv	139	exit (0);
204			}
205			}
206
207			void mpiCatchEvent(void)
208			{
209			event the_event;
210			mBEvent mpiEventContainer;
211			int mpiError;
212
213	mmeineke	164
214	chuckv	139
215	mmeineke	164	MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);
216	chuckv	139
217			switch (mpiEventContainer.type){
218			case mpiMOLECULE:
219			the_event.event_type = MOLECULE;
220			the_event.evt.blk_index = mpiEventContainer.i1;
221			break;
222
223			case mpiATOM:
224			the_event.event_type = ATOM;
225			the_event.evt.blk_index = mpiEventContainer.i1;
226			break;
227
228			case mpiBOND:
229			the_event.event_type = BOND;
230			the_event.evt.blk_index = mpiEventContainer.i1;
231			break;
232
233			case mpiBEND:
234			the_event.event_type = BEND;
235			the_event.evt.blk_index = mpiEventContainer.i1;
236			break;
237
238			case mpiTORSION:
239			the_event.event_type = TORSION;
240			the_event.evt.blk_index = mpiEventContainer.i1;
241			break;
242
243			case mpiCOMPONENT:
244			the_event.event_type = COMPONENT;
245			the_event.evt.blk_index = mpiEventContainer.i1;
246			break;
247
248
249			case mpiPOSITION:
250			the_event.event_type = POSITION;
251			the_event.evt.pos.x = mpiEventContainer.d1;
252			the_event.evt.pos.y = mpiEventContainer.d2;
253			the_event.evt.pos.z = mpiEventContainer.d3;
254			break;
255
256			case mpiORIENTATION:
257			the_event.event_type = ORIENTATION;
258			the_event.evt.ornt.x = mpiEventContainer.d1;
259			the_event.evt.ornt.y = mpiEventContainer.d2;
260			the_event.evt.ornt.z = mpiEventContainer.d3;
261			break;
262
263			case mpiCONSTRAINT:
264			the_event.event_type = CONSTRAINT;
265			the_event.evt.cnstr = mpiEventContainer.d1;
266			break;
267
268			case mpiMEMBER:
269			the_event.event_type = MEMBER;
270			the_event.evt.mbr.a = mpiEventContainer.i1;
271			the_event.evt.mbr.b = mpiEventContainer.i2;
272			the_event.evt.mbr.c = mpiEventContainer.i3;
273			the_event.evt.mbr.d = mpiEventContainer.i4;
274			break;
275
276			case mpiASSIGNMENT_s:
277			the_event.event_type = ASSIGNMENT;
278			the_event.evt.asmt.asmt_type = STRING;
279			strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
280			strcpy(the_event.evt.asmt.rhs.sval,mpiEventContainer.cArray);
281
282	mmeineke	164	#ifdef MPIBASS_VERBOSE
283
284			fprintf(stderr, "mpiDiag at node %d: Assignment: %s = %s\n", worldRank,
285	chuckv	139	the_event.evt.asmt.lhs,
286			the_event.evt.asmt.rhs.sval );
287			#endif
288
289			break;
290
291			case mpiASSIGNMENT_i:
292			the_event.event_type = ASSIGNMENT;
293			the_event.evt.asmt.asmt_type = INT;
294			strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
295			the_event.evt.asmt.rhs.ival = mpiEventContainer.i1;
296
297	mmeineke	164	#ifdef MPIBASS_VERBOSE
298
299			fprintf(stderr, "mpiDiag at node %d: Assignment: %s = %d\n", worldRank,
300	chuckv	139	the_event.evt.asmt.lhs,
301			the_event.evt.asmt.rhs.ival );
302			#endif
303
304			break;
305
306			case mpiASSIGNMENT_d:
307			the_event.event_type = ASSIGNMENT;
308			the_event.evt.asmt.asmt_type = DOUBLE;
309			strcpy(the_event.evt.asmt.lhs,mpiEventContainer.lhs);
310			the_event.evt.asmt.rhs.dval = mpiEventContainer.d1;
311
312	mmeineke	164	#ifdef MPIBASS_VERBOSE
313
314			fprintf(stderr, "mpiDiag at node %d: Assignment: %s = %lf\n", worldRank,
315	chuckv	139	the_event.evt.asmt.lhs,
316			the_event.evt.asmt.rhs.dval );
317			#endif
318
319			break;
320
321			case mpiBLOCK_END:
322			the_event.event_type = BLOCK_END;
323			break;
324			}
325
326	mmeineke	164	#ifdef MPIBASS_VERBOSE
327
328			fprintf(stderr, "mpiDiag at node %d: event type is %d\n", worldRank,
329	chuckv	139	the_event.event_type);
330			#endif
331
332			if (!event_handler(&the_event)){
333	mmeineke	164
334			sprintf(painCave.errMsg,
335			"MPI event handling error at node %d => %s\n",
336			worldRank,
337			the_event.err_msg);
338			painCave.isFatal = 1;
339			simError();
340	chuckv	139	}
341	mmeineke	164	MPIcheckPoint();
342	chuckv	139	}
343
344
345			void mpiInterfaceExit(void){
346			int mpiError;
347			int mpiStatus = MPI_INTERFACE_ABORT;
348
349	mmeineke	164	MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
350			MPI_Finalize();
351	chuckv	139	exit (0);
352
353			}