mdtools/interface_implementation/mpiInterface.c


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "mpiInterface.h"


void mpiCatchEvent(void);


mpiEventInit()
{
  int blockCounts[4] = {1,3,4,120}
  MPI_Aint dspls[4];
  MPI_Datatype types[4];
  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]);


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


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

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


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

  if (the_event == NULL)     mpiStatus = MPI_INTERFACE_DONE;
  else                       mpiStatus = MPI_INTERFACE_CONTINUE;
  
  mpiError = MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
  if (mpiError != MPI_SUCCESS){
      mpiError = MPI_Finalize();
      if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
      exit (0);
    }

  if (!mpiStatus){
    switch (the_event->event_type){
    case MOLECULE:
      mpiEventContainer.type = mpiMOLECULE;
      mpiEventContainer.i1 = the_event->evt.block_index; // pack block index into first int  
    break;

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

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

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

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

    case COMPONENT:
      mpiEventContainer.type = mpiCOMPONENT;
      mpiEventContainer.i1 = the_event->evt.block_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:
      switch (the_event->evt.asmt.asmt_type){
      case STRING:
        mpiEventContainer.type = mpiASSIGNMENT_s;
        strcpy(mpiEventContainer.cArray,the_event->evt.asmt.sval);
        break;

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

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

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


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

    if (mpiError != MPI_SUCCESS){
      mpiError = MPI_Finalize();
      if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
      exit (0);
    }
  }
}


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

  mpiError = MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
  if (mpiError != MPI_SUCCESS){
      mpiError = MPI_Finalize();
      if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
      exit (0);
    }


  while(!mpiContinue){
    
    mpiCatchEvent();

    mpiError = MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
    if (mpiError != MPI_SUCCESS){
      mpiError = MPI_Finalize();
      if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
      exit (0);
    }
  }

  if (mpiContinue == MPI_INTERFACE_ABORT){
    mpiError = MPI_Finalize();
    if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
    exit (0);
  }
}

mpiCatchEvent()
{
  event the_event;
  mBEvent mpiBEventContainer;
  int mpiError;

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

  if (mpiError != MPI_SUCCESS){
    mpiError = MPI_Finalize();
    if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
    exit (0);
  }


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

  case mpiTORSION:
    the_event.event_type = TORSION;
    the_event.evt.block_index = mpiEventContainer.i1;
    break;
    
  case mpiCOMPONENT:
    the_event.event_type = COMPONENT;
    the_event.evt.block_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.sval,mpiEventContainer.cArray);
    break;

  case mpiASSIGNMENT_i:
    the_event.event_type = ASSIGNMENT;
    the_event.evt.asmt.asmt_type = INT;
    the_event.evt.asmt.ival = mpiEventContainer.i1;      
    break;

  case mpiASSIGNMENT_d:
    the_event.event_type = ASSIGNMENT;
    the_event.evt.asmt.asmt_type = DOUBLE;
    the_event.evt.asmt.dval = mpiEventContainer.d1;      
    break;

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

  
  if (!event_handler(&the_event)){
    sprintf(stderr,"MPI event handling error => %s\n",the_event.err_msg);
        mpiError = MPI_Finalize();
    if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
    exit (0);
  }
}
Revision:	120
Committed:	Thu Sep 26 21:36:19 2002 UTC (22 years, 7 months ago) by chuckv
Content type:	text/plain
File size:	7438 byte(s)
Log Message:	Addition of mpiInterface to code base.
#	User	Rev	Content
1	chuckv	120
2			#include <stdlib.h>
3			#include <stdio.h>
4			#include <string.h>
5			#include "mpiInterface.h"
6
7
8			void mpiCatchEvent(void);
9
10
11
12
13			mpiEventInit()
14			{
15			int blockCounts[4] = {1,3,4,120}
16			MPI_Aint dspls[4];
17			MPI_Datatype types[4];
18			mBEvent protoEvent;
19
20			int i;
21
22			MPI_Address(&protoEvent.type, dspls[0]);
23			MPI_Address(&protoEvent.d1, dspls[1]);
24			MPI_Address(&protoEvent.i1, dspls[2]);
25			MPI_Address(&protoEvent.cArray, dspls[3]);
26
27
28			types[0] = MPI_INT;
29			types[1] = MPI_DOUBLE;
30			types[2] = MPI_INT;
31			types[3] = MPI_CHAR;
32
33
34			for (i =3; i >= 0; i--) dspls[i] -= dspls[0];
35
36			MPI_Type_struct(4,blockCounts,dspls,types,&mpiBASSEventType);
37			MPI_Type_commit(&mpiBASSEventType);
38			}
39
40
41			throwMPIEvent(event* the_event)
42			{
43			mBEvent mpiBEventContainer;
44			int mpiStatus;
45			int mpiError;
46
47			if (the_event == NULL) mpiStatus = MPI_INTERFACE_DONE;
48			else mpiStatus = MPI_INTERFACE_CONTINUE;
49
50			mpiError = MPI_Bcast(&mpiStatus,1,MPI_INT,0,MPI_COMM_WORLD);
51			if (mpiError != MPI_SUCCESS){
52			mpiError = MPI_Finalize();
53			if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
54			exit (0);
55			}
56
57			if (!mpiStatus){
58			switch (the_event->event_type){
59			case MOLECULE:
60			mpiEventContainer.type = mpiMOLECULE;
61			mpiEventContainer.i1 = the_event->evt.block_index; // pack block index into first int
62			break;
63
64			case ATOM:
65			mpiEventContainer.type = mpiATOM;
66			mpiEventContainer.i1 = the_event->evt.block_index; // pack block index into first int
67			break;
68
69			case BOND:
70			mpiEventContainer.type = mpiBOND;
71			mpiEventContainer.i1 = the_event->evt.block_index; // pack block index into first int
72			break;
73
74			case BEND:
75			mpiEventContainer.type = mpiBEND;
76			mpiEventContainer.i1 = the_event->evt.block_index; // pack block index into first int
77			break;
78
79			case TORSION:
80			mpiEventContainer.type = mpiTORSION;
81			mpiEventContainer.i1 = the_event->evt.block_index; // pack block index into first int
82			break;
83
84			case COMPONENT:
85			mpiEventContainer.type = mpiCOMPONENT;
86			mpiEventContainer.i1 = the_event->evt.block_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			switch (the_event->evt.asmt.asmt_type){
118			case STRING:
119			mpiEventContainer.type = mpiASSIGNMENT_s;
120			strcpy(mpiEventContainer.cArray,the_event->evt.asmt.sval);
121			break;
122
123			case INT:
124			mpiEventContainer.type = mpiASSIGNMENT_i;
125			mpiEventContainer.i1 = the_event->evt.asmt.ival;
126			break;
127
128			case DOUBLE:
129			mpiEventContainer.type = mpiASSIGNMENT_d;
130			mpiEventContainer.d1 = the_event->evt.asmt.dval;
131			break;
132			}
133			break;
134
135			case BLOCK_END:
136			mpiEventContainer.type = mpiBLOCK_END;
137			break;
138			}
139
140
141			mpiError = MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);
142
143			if (mpiError != MPI_SUCCESS){
144			mpiError = MPI_Finalize();
145			if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
146			exit (0);
147			}
148			}
149			}
150
151
152			// Everybody but node 0 runs this
153			mpiEventLoop()
154			{
155			int mpiError;
156			int mpiContinue;
157
158			mpiError = MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
159			if (mpiError != MPI_SUCCESS){
160			mpiError = MPI_Finalize();
161			if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
162			exit (0);
163			}
164
165
166			while(!mpiContinue){
167
168			mpiCatchEvent();
169
170			mpiError = MPI_Bcast(&mpiContinue,1,MPI_INT,0,MPI_COMM_WORLD);
171			if (mpiError != MPI_SUCCESS){
172			mpiError = MPI_Finalize();
173			if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
174			exit (0);
175			}
176			}
177
178			if (mpiContinue == MPI_INTERFACE_ABORT){
179			mpiError = MPI_Finalize();
180			if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
181			exit (0);
182			}
183			}
184
185			mpiCatchEvent()
186			{
187			event the_event;
188			mBEvent mpiBEventContainer;
189			int mpiError;
190
191
192			mpiError = MPI_Bcast(&mpiEventContainer,1,mpiBASSEventType,0,MPI_COMM_WORLD);
193
194			if (mpiError != MPI_SUCCESS){
195			mpiError = MPI_Finalize();
196			if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
197			exit (0);
198			}
199
200
201			switch (mpiEventContainer.type){
202			case mpiMOLECULE:
203			the_event.event_type = MOLECULE;
204			the_event.evt.block_index = mpiEventContainer.i1;
205			break;
206
207			case mpiATOM:
208			the_event.event_type = ATOM;
209			the_event.evt.block_index = mpiEventContainer.i1;
210			break;
211
212			case mpiBOND:
213			the_event.event_type = BOND;
214			the_event.evt.block_index = mpiEventContainer.i1;
215			break;
216
217			case mpiBEND:
218			the_event.event_type = BEND;
219			the_event.evt.block_index = mpiEventContainer.i1;
220			break;
221
222			case mpiTORSION:
223			the_event.event_type = TORSION;
224			the_event.evt.block_index = mpiEventContainer.i1;
225			break;
226
227			case mpiCOMPONENT:
228			the_event.event_type = COMPONENT;
229			the_event.evt.block_index = mpiEventContainer.i1;
230			break;
231
232
233			case mpiPOSITION:
234			the_event.event_type = POSITION;
235			the_event.evt.pos.x = mpiEventContainer.d1;
236			the_event.evt.pos.y = mpiEventContainer.d2;
237			the_event.evt.pos.z = mpiEventContainer.d3;
238			break;
239
240			case mpiORIENTATION:
241			the_event.event_type = ORIENTATION;
242			the_event.evt.ornt.x = mpiEventContainer.d1;
243			the_event.evt.ornt.y = mpiEventContainer.d2;
244			the_event.evt.ornt.z = mpiEventContainer.d3;
245			break;
246
247			case mpiCONSTRAINT:
248			the_event.event_type = CONSTRAINT;
249			the_event.evt.cnstr = mpiEventContainer.d1;
250			break;
251
252			case mpiMEMBER:
253			the_event.event_type = MEMBER;
254			the_event.evt.mbr.a = mpiEventContainer.i1;
255			the_event.evt.mbr.b = mpiEventContainer.i2;
256			the_event.evt.mbr.c = mpiEventContainer.i3;
257			the_event.evt.mbr.d = mpiEventContainer.i4;
258			break;
259
260			case mpiASSIGNMENT_s:
261			the_event.event_type = ASSIGNMENT;
262			the_event.evt.asmt.asmt_type = STRING;
263			strcpy(the_event.evt.asmt.sval,mpiEventContainer.cArray);
264			break;
265
266			case mpiASSIGNMENT_i:
267			the_event.event_type = ASSIGNMENT;
268			the_event.evt.asmt.asmt_type = INT;
269			the_event.evt.asmt.ival = mpiEventContainer.i1;
270			break;
271
272			case mpiASSIGNMENT_d:
273			the_event.event_type = ASSIGNMENT;
274			the_event.evt.asmt.asmt_type = DOUBLE;
275			the_event.evt.asmt.dval = mpiEventContainer.d1;
276			break;
277
278			case mpiBLOCK_END:
279			the_event.event_type = BLOCK_END;
280			break;
281			}
282
283
284			if (!event_handler(&the_event)){
285			sprintf(stderr,"MPI event handling error => %s\n",the_event.err_msg);
286			mpiError = MPI_Finalize();
287			if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort();
288			exit (0);
289			}
290			}