First commmit to enable replica logic - added the concepts of localrank, and
authorNikhil Jain <nikhil@illinois.edu>
Mon, 29 Oct 2012 05:05:34 +0000 (00:05 -0500)
committerNikhil Jain <nikhil@illinois.edu>
Mon, 29 Oct 2012 05:08:35 +0000 (00:08 -0500)
global ranks; modifying LRTS to receive destNode; modifying converse to pass
global dest rank; trying to take care of smp, may not work yet; also addressing
optimization such as pxshm, xpmem, persistent - too much for one go; attempt is
to get it working for mpi layer, and then see how much effort is needed to other
layers - if I have planned it correct, the effort should be minimal; finally
only trying to get things working for layers that support Lrts

src/arch/mpi/machine.c
src/arch/util/machine-common-core.c
src/conv-core/converse.h

index 5c9a82156f2c660f1b5367528df69499675cc72e..243ef585bb44bf97303ee96aa4fae1548839e0ca 100644 (file)
@@ -479,15 +479,13 @@ static CmiCommHandle MPISendOneMsg(SMSG_LIST *smsg) {
     return (CmiCommHandle) &(smsg->req);
 }
 
-CmiCommHandle LrtsSendFunc(int destPE, int size, char *msg, int mode) {
+CmiCommHandle LrtsSendFunc(int destNode, int size, char *msg, int mode) {
     /* Ignoring the mode for MPI layer */
 
-    int destNode = CmiNodeOf(destPE);
     CmiState cs = CmiGetState();
     SMSG_LIST *msg_tmp;
-    int  rank;
 
-    CmiAssert(destNode != CmiMyNode());
+    CmiAssert(destNode != CmiMyNodeGlobal());
 #if CMK_SMP
     if (Cmi_smp_mode_setting == COMM_THREAD_SEND_RECV) {
       EnqueueMsg(msg, size, destNode, mode);
index 3c3e112256f0b6d93ee652b8f34eac8ce072d254..d2c2ad794d29f22335a41f28c52e1858d9f876ab 100644 (file)
@@ -134,9 +134,16 @@ void CmiFreeNodeBroadcastAllFn(int size, char *msg);
 #define DGRAM_NODEMESSAGE   (0x1FFB)
 #endif
 
-/* Node state structure */
-int               _Cmi_mynode;    /* Which address space am I */
+// global state, equals local if running one replica
+PartitionInfo partitionInfo;
+int _Cmi_mype_global;
+int _Cmi_numpes_global;
+int _Cmi_mynode_global;
+int _Cmi_numnodes_global;
+
+// Node state structure, local information for the replica
 int               _Cmi_mynodesize;/* Number of processors in my address space */
+int               _Cmi_mynode;    /* Which address space am I */
 int               _Cmi_numnodes;  /* Total number of address spaces */
 int               _Cmi_numpes;    /* Total number of processors */
 
@@ -328,12 +335,23 @@ static void CmiStartThreads(char **argv) {
     CmiStateInit(Cmi_nodestart, 0, &Cmi_state);
     _Cmi_mype = Cmi_nodestart;
     _Cmi_myrank = 0;
+    _Cmi_mype_global = _Cmi_mynode_global;
+}
+
+INLINE_KEYWORD int CmiNodeSpan() {
+  return 1;
 }
 #else
 /************** SMP *******************/
 INLINE_KEYWORD int CmiMyPe() {
     return CmiGetState()->pe;
 }
+INLINE_KEYWORD int CmiNodeSpan() {
+  return (CmiMyNodeSize() + 1);
+}
+INLINE_KEYWORD int CmiMyPeGlobal() {
+    return CmiGetState()->pe + (CmiMyNodeGlobal()*CmiNodeSpan());
+}
 INLINE_KEYWORD int CmiMyRank() {
     return CmiGetState()->rank;
 }
@@ -490,17 +508,18 @@ inline
 CmiCommHandle CmiSendNetworkFunc(int destPE, int size, char *msg, int mode)
 {
         int rank;
-        int destNode = CmiNodeOf(destPE); 
+        int destLocalNode = CmiNodeOf(destPE); 
+        int destNode = CmiGetNodeGlobal(CmiNodeOf(destPE),partitionInfo.myPartition); 
 #if CMK_USE_PXSHM
-        if (CmiValidPxshm(destNode, size)) {
-          CmiSendMessagePxshm(msg, size, destNode, &refcount);
+        if (CmiValidPxshm(destLocalNode, size)) {
+          CmiSendMessagePxshm(msg, size, destLocalNode, &refcount);
           //for (int i=0; i<refcount; i++) CmiReference(msg);
           return 0;
         }
 #endif
 #if CMK_USE_XPMEM
-        if (CmiValidXpmem(destNode, size)) {
-          CmiSendMessageXpmem(msg, size, destNode, &refcount);
+        if (CmiValidXpmem(destLocalNode, size)) {
+          CmiSendMessageXpmem(msg, size, destLocalNode, &refcount);
           //for (int i=0; i<refcount; i++) CmiReference(msg);
           return 0;
         }
@@ -526,7 +545,7 @@ if (MSG_STATISTIC)
 #if CMK_USE_OOB
     if (CpvAccess(_urgentSend)) mode |= OUT_OF_BAND;
 #endif
-    return LrtsSendFunc(destPE, size, msg, mode);
+    return LrtsSendFunc(destNode, size, msg, mode);
 }
 
 void CmiFreeSendFn(int destPE, int size, char *msg) {
@@ -642,6 +661,45 @@ if (  MSG_STATISTIC)
 #endif
 #endif
 
+// functions related to replica
+void CmiCreatePartitions(char **argv) {
+  partitionInfo.numPartitions = 1; 
+  CmiGetArgInt(argv,"+partitions", &partitionInfo.numPartitions);
+
+  _Cmi_numnodes_global = _Cmi_numnodes;
+  _Cmi_mynode_global = _Cmi_mynode;
+  _Cmi_numpes_global = _Cmi_numnodes_global * _Cmi_mynodesize;
+  //still need to set _Cmi_mype_global
+
+  CmiAssert(partitionInfo.numPartitions <= _Cmi_numnodes_global);
+  CmiAssert((_Cmi_numnodes_global % partitionInfo.numPartitions) == 0);
+  
+  //simple partition, this will be made more complex in future
+  partitionInfo.partitionSize = _Cmi_numnodes_global / partitionInfo.numPartitions;
+  partitionInfo.myPartition = _Cmi_mynode_global / partitionInfo.partitionSize;
+
+  //reset local variables
+  _Cmi_mynode = node_gToLTranslate(_Cmi_mynode);
+  _Cmi_numnodes = CmiPartitionSize();
+  //mype and numpes will be set following this
+}
+
+INLINE_KEYWORD int node_lToGTranslate(int node, int partition) {
+  return (partition*partitionInfo.partitionSize)+node;
+}
+
+INLINE_KEYWORD int node_gToLTranslate(int node) {
+  return (node % partitionInfo.partitionSize);
+}
+
+INLINE_KEYWORD int pe_lToGTranslate(int pe, int partition) {
+  return (pe + partition*CmiNumNodes()*CmiNodeSpan());
+}
+int pe_gToLTranslate(int pe) {
+  return (pe % (CmiNumNodes()*CmiNodeSpan()));
+}
+//end of functions related to replica
+
 /* ##### Beginning of Functions Related with Machine Startup ##### */
 void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret) {
     int _ii;
@@ -697,6 +755,8 @@ if (  MSG_STATISTIC)
 #endif
        }
 
+    CmiCreatePartitions(argv);
+
     _Cmi_numpes = _Cmi_numnodes * _Cmi_mynodesize;
     Cmi_nodestart = _Cmi_mynode * _Cmi_mynodesize;
     Cmi_argvcopy = CmiCopyArgs(argv);
index a9d0d27de7e1d73716154d554de63716b963a319..98e744624c64cf2bec198d21951397c3235c30d5 100644 (file)
@@ -126,6 +126,48 @@ void setMemoryOwnedBy(void *p, int id);
 
 extern int CmiMyRank_();
 
+//variables and functions for replica
+typedef struct {
+  int numPartitions;
+  int partitionSize;
+  int myPartition;
+} PartitionInfo;
+
+void CmiCreatePartitions(char **argv);
+
+extern int _Cmi_mype_global;
+extern int _Cmi_numpes_global;
+extern int _Cmi_mynode_global;
+extern int _Cmi_numnodes_global;
+
+#define CmiMyPartition()         partitionInfo.myPartition
+#define CmiPartitionSize()       partitionInfo.partitionSize
+#define CmiNumPartition()        partitionInfo.numPartitions
+#define CmiNumNodesGlobal()     _Cmi_numnodes_global
+#define CmiMyNodeGlobal()       _Cmi_mynode_global
+#define CmiNumPesGlobal()       _Cmi_numpes_global
+//we need different implementations of this based on SMP or non-smp
+#if !CMK_SMP
+#define CmiMyPeGlobal()         _Cmi_mype_global
+extern int _Cmi_mynodesize;
+#else
+extern int CmiMyPeGlobal();
+#endif
+
+//we need nodeSpan to find how many pes each node cover
+int CmiNodeSpan();
+
+int node_lToGTranslate(int node, int partition);
+int node_gToLTranslate(int node);
+int pe_lToGTranslate(int pe, int partition);
+int pe_gToLTranslate(int pe);
+
+#define CmiGetPeGlobal(pe,part)         pe_lToGTranslate(pe,part)
+#define CmiGetNodeGlobal(node,part)     node_lToGTranslate(node,part)
+#define CmiGetPeLocal(pe)               pe_gToLTranslate(pe)
+#define CmiGetNodeLocal(node)           node_gToLTranslate(node)
+//end of variables and functions for replica
+
 #if CMK_SHARED_VARS_UNAVAILABLE /* Non-SMP version of shared vars. */
 extern int _Cmi_mype;
 extern int _Cmi_numpes;