*** empty log message ***
authorJosh Yelon <jyelon@uiuc.edu>
Tue, 2 Jul 1996 21:25:22 +0000 (21:25 +0000)
committerJosh Yelon <jyelon@uiuc.edu>
Tue, 2 Jul 1996 21:25:22 +0000 (21:25 +0000)
src/arch/tcp-hp/conv-mach.csh
src/arch/uth/machine.c

index 1a669cabd43a21807a2647febecdcb0ea26e66d4..f5af4e4b20cf1c02a06e677e48e231e94bae2fe9 100644 (file)
 # REVISION HISTORY:
 #
 # $Log$
-# Revision 2.14  1996-04-16 22:45:34  jyelon
+# Revision 2.15  1996-07-02 21:25:22  jyelon
+# *** empty log message ***
+#
+# Revision 2.14  1996/04/16 22:45:34  jyelon
 # *** empty log message ***
 #
 # Revision 2.13  1996/04/09 22:56:35  jyelon
@@ -63,7 +66,7 @@ set CMK_C_DEBUG='-g'
 set CMK_C_OPTIMIZE='-O'
 set CMK_CXX_DEBUG='-g'
 set CMK_CXX_OPTIMIZE='-O'
-set CMK_LD='gcc -s'
+set CMK_LD='gcc'
 set CMK_LDXX='g++'
 set CMK_LD77=''
 set CMK_M4='m4'
index 3cf7c6dfd2f6f6343a5df3ad2e6aabb97a70d2fa..947dc43f95c498eb5a082a1e0312b2a6bf163900 100644 (file)
  * REVISION HISTORY:
  *
  * $Log$
- * Revision 1.13  1996-02-10 18:57:29  sanjeev
+ * Revision 1.14  1996-07-02 21:25:22  jyelon
+ * *** empty log message ***
+ *
+ * Revision 1.13  1996/02/10 18:57:29  sanjeev
  * fixed bugs in CmiGetNodeNeighbours, CmiNeighboursIndex
  *
  * Revision 1.12  1996/02/10 18:54:24  sanjeev
@@ -218,6 +221,7 @@ Fifo      *CmiQueues;
 int       *CmiBarred;
 int        CmiNumBarred=0;
 
+Fifo FIFO_Create();
 CpvDeclare(Fifo, CmiLocalQueue);
 
 /******************************************************************************
@@ -332,12 +336,126 @@ void CmiNodeBarrier()
   CmiYield();
 }
 
-/********************* MESSAGE RECEIVE FUNCTIONS ******************/
+/*****************************************************************************
+ *
+ * The following are the CmiDeliverXXX functions.
+ *
+ * void CmiDeliversInit()
+ *
+ *      - CmiInit promises to call this before calling CmiDeliverMsgs
+ *        or any of the other functions in this section.
+ *
+ * int CmiDeliverMsgs(int maxmsgs)
+ *
+ *      - CmiDeliverMsgs will retrieve up to maxmsgs that were transmitted
+ *        with the Cmi, and will invoke their handlers.  It does not wait
+ *        if no message is unavailable.  Instead, it returns the quantity
+ *        (maxmsgs-delivered), where delivered is the number of messages it
+ *        delivered.
+ *
+ * void CmiDeliverSpecificMsg(int handlerno)
+ *
+ *      - Waits for a message with the specified handler to show up, then
+ *        invokes the message's handler.  Note that unlike CmiDeliverMsgs,
+ *        This function _does_ wait.
+ *
+ * void CmiGrabBuffer(void **bufptrptr)
+ *
+ *      - When CmiDeliverMsgs or CmiDeliverSpecificMsgs calls a handler,
+ *        the handler receives a pointer to a buffer containing the message.
+ *        The buffer does not belong to the handler, eg, the handler may not
+ *        free the buffer.  Instead, the buffer will be automatically reused
+ *        or freed as soon as the handler returns.  If the handler wishes to
+ *        keep a copy of the data after the handler returns, it may do so by
+ *        calling CmiGrabBuffer and passing it a pointer to a variable which
+ *        in turn contains a pointer to the system buffer.  The variable will
+ *        be updated to contain a pointer to a handler-owned buffer containing
+ *        the same data as before.  The handler then has the responsibility of
+ *        making sure the buffer eventually gets freed.  Example:
+ *
+ * void myhandler(void *msg)
+ * {
+ *    CmiGrabBuffer(&msg);      // Claim ownership of the message buffer
+ *    ... rest of handler ...
+ *    CmiFree(msg);             // I have the right to free it or
+ *                              // keep it, as I wish.
+ * }
+ *
+ *
+ * For this common implementation to work, the machine layer must provide the
+ * following:
+ *
+ * void *CmiGetNonLocal()
+ *
+ *      - returns a message just retrieved from some other PE, not from
+ *        local.  If no such message exists, returns 0.
+ *
+ * CpvExtern(FIFO_Queue, CmiLocalQueue);
+ *
+ *      - a FIFO queue containing all messages from the local processor.
+ *
+ *****************************************************************************/
+
+CpvStaticDeclare(int, CmiBufferGrabbed);
+CpvExtern(void*, CmiLocalQueue);
 
-void *CmiGetNonLocal()
+void CmiDeliversInit()
 {
-  CmiYield();
-  return 0; /* Messages are always in local queue */
+  CpvInitialize(int, CmiBufferGrabbed);
+  CpvAccess(CmiBufferGrabbed) = 0;
+}
+
+void CmiGrabBuffer()
+{
+  CpvAccess(CmiBufferGrabbed) = 1;
+}
+
+int CmiDeliverMsgs(maxmsgs)
+int maxmsgs;
+{
+  void *msg;
+  
+  while (1) {
+    CmiYield();
+    FIFO_DeQueue(CpvAccess(CmiLocalQueue), &msg);
+    if (msg==0) break;
+    CpvAccess(CmiBufferGrabbed)=0;
+    (CmiGetHandlerFunction(msg))(msg);
+    if (!CpvAccess(CmiBufferGrabbed)) CmiFree(msg);
+    maxmsgs--; if (maxmsgs==0) break;
+  }
+  return maxmsgs;
+}
+
+/*
+ * CmiDeliverSpecificMsg(lang)
+ *
+ * - waits till a message with the specified handler is received,
+ *   then delivers it.
+ *
+ */
+
+void CmiDeliverSpecificMsg(handler)
+int handler;
+{
+  void *tmpqueue = FIFO_Create(); int *msg;
+  
+  while (1) {
+    FIFO_DeQueue(CpvAccess(CmiLocalQueue), &msg);
+    if (msg == 0) { CmiYield(); continue; }
+    if (CmiGetHandler(msg)==handler) {
+      CpvAccess(CmiBufferGrabbed)=0;
+      (CmiGetHandlerFunction(msg))(msg);
+      if (!CpvAccess(CmiBufferGrabbed)) CmiFree(msg);
+      break;
+    } else FIFO_EnQueue(tmpqueue, msg);
+  }
+  while (1) {
+    FIFO_DeQueue(tmpqueue, &msg);
+    if (msg==0) break;
+    FIFO_EnQueue(CpvAccess(CmiLocalQueue), msg);
+  }
+  FIFO_Destroy(tmpqueue);
 }
 
 /********************* MESSAGE SEND FUNCTIONS ******************/
@@ -490,7 +608,7 @@ char *argv[];
     t = (i==0) ? CthSelf() : CthCreate(CmiCallMain, 0, Cmi_stacksize);
     CmiThreads[i] = t;
     CmiBarred[i] = 0;
-    CmiQueues[i] = (Fifo)FIFO_Create();
+    CmiQueues[i] = FIFO_Create();
   }
   Cmi_mype = 0;
   CmiCallMain();