mdtools/mpi_implementation/mpiBASS.c


#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define __mpiBASSEVENT
#include "mpiBASS.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;
  int mynode;

  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(MPI_COMM_WORLD,0);
      exit (0);
    }

  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 D_VERBOSE
      mpiError = MPI_Comm_rank(MPI_COMM_WORLD,&mynode);
      fprintf(stderr, 
              "mpiDiag at node %d: evt Assignment: \"%s\" = ?\n"
              "                    mpi Assignment: \"%s\" = ?\n",
              mynode, 
              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;
    }


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

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


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

#ifdef D_VERBOSE
  mpiError = MPI_Comm_rank(MPI_COMM_WORLD,&mynode);
  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",
          mynode,
          MOLECULE, ATOM, BOND, BEND, TORSION, COMPONENT, 
          POSITION, ASSIGNMENT, MEMBER, CONSTRAINT, ORIENTATION,
          START_INDEX, BLOCK_END );
#endif

  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(MPI_COMM_WORLD,0);
      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(MPI_COMM_WORLD,0);
      exit (0);
    }
  }

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

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

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

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


  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 D_VERBOSE
    mpiError = MPI_Comm_rank(MPI_COMM_WORLD,&mynode);
    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %s\n", mynode, 
            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 D_VERBOSE
    mpiError = MPI_Comm_rank(MPI_COMM_WORLD,&mynode);
    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %d\n", mynode, 
            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 D_VERBOSE
    mpiError = MPI_Comm_rank(MPI_COMM_WORLD,&mynode);
    fprintf(stderr, "mpiDiag at node %d: Assignment:  %s = %lf\n", mynode, 
            the_event.evt.asmt.lhs,
            the_event.evt.asmt.rhs.dval );
#endif

    break;

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

#ifdef D_VERBOSE
  mpiError = MPI_Comm_rank(MPI_COMM_WORLD,&mynode);
  fprintf(stderr, "mpiDiag at node %d: event type is %d\n", mynode, 
          the_event.event_type);
#endif

  if (!event_handler(&the_event)){ 
    mpiError = MPI_Comm_rank(MPI_COMM_WORLD,&mynode); 
    fprintf(stderr,"MPI event handling error at node %d => %s\n",mynode,the_event.err_msg);
    //  mpiError = MPI_Finalize();
    //     if (mpiError != MPI_SUCCESS) 
    mpiError = MPI_Abort(MPI_COMM_WORLD,0);
    exit (0);
  }
}


void mpiInterfaceExit(void){
  int mpiError;
  int mpiStatus = MPI_INTERFACE_ABORT;
  
  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(MPI_COMM_WORLD,0);
    exit (0);
  } 

  mpiError = MPI_Finalize();
  if (mpiError != MPI_SUCCESS) mpiError = MPI_Abort(MPI_COMM_WORLD,0);
  exit (0);

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