Bug #2037: Execute callbacks to inline EMs in an inline manner 57/4857/5
authorNitin Bhat <nbhat4@illinois.edu>
Mon, 10 Dec 2018 22:42:15 +0000 (16:42 -0600)
committerEvan Ramos <evan@hpccharm.com>
Fri, 15 Feb 2019 19:08:28 +0000 (13:08 -0600)
Previously, callbacks targeting inline entry methods had to be
declared with a 'true' value for the doInline variable to specify
inline execution. With this fix, callbacks execute inline when
the target is an inline entry method. The CkCallback constructors
still have the 'doInline' variable, now called 'forceInline', to
preserve existing behavior.

Co-authored-by: Evan Ramos <evan@hpccharm.com>
Change-Id: I2b21c7848b2428a367e79cdbaa9424f929c27ee1

src/ck-core/charm.h
src/ck-core/ckcallback.C
src/ck-core/ckcallback.h
src/ck-core/register.C
src/ck-core/register.h
src/xlat-i/xi-Entry.C

index b27c7b0ebc4f84b244ce497cdc740066c1cf6373..98ea93dfa1ce430fa41d4a6016ab6c7d8c347b74 100644 (file)
@@ -161,6 +161,7 @@ extern int CkRegisterMsg(const char *name, CkPackFnPtr pack,
 #define CK_EP_MEMCRITICAL (1<<5)
 #define CK_EP_APPWORK     (1<<6)
 #define CK_EP_IMMEDIATE   (1<<7)
+#define CK_EP_INLINE      (1<<8)
 
 /** type of a chare */
 #if CMK_MESSAGE_LOGGING
index 61fcf83528c8cbd0f9d9f6f7ceab30c9a2d96d62..45cc2e4b41632c1d99f89261450900058b21e59c 100644 (file)
@@ -90,30 +90,30 @@ void *CkCallback::impl_thread_delay(void) const
 /*These can't be defined in the .h file like the other constructors
  * because we need CkCallback before CProxyElement* are defined.
  */
-CkCallback::CkCallback(Chare *p, int ep, bool doInline) {
+CkCallback::CkCallback(Chare *p, int ep, bool forceInline) {
 #if CMK_ERROR_CHECKING
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendChare:sendChare;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendChare : sendChare;
        d.chare.ep=ep; 
        d.chare.id=p->ckGetChareID();
         d.chare.hasRefnum= false;
         d.chare.refnum = 0;
 }
-CkCallback::CkCallback(Group *p, int ep, bool doInline) {
+CkCallback::CkCallback(Group *p, int ep, bool forceInline) {
 #if CMK_ERROR_CHECKING
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendGroup:sendGroup;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendGroup : sendGroup;
        d.group.ep=ep; d.group.id=p->ckGetGroupID(); d.group.onPE=CkMyPe();
         d.group.hasRefnum= false;
         d.group.refnum = 0;
 }
-CkCallback::CkCallback(NodeGroup *p, int ep, bool doInline) {
+CkCallback::CkCallback(NodeGroup *p, int ep, bool forceInline) {
 #if CMK_ERROR_CHECKING
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendNodeGroup:sendNodeGroup;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendNodeGroup : sendNodeGroup;
        d.group.ep=ep; d.group.id=p->ckGetGroupID(); d.group.onPE=CkMyNode();
         d.group.hasRefnum= false;
         d.group.refnum = 0;
@@ -129,21 +129,21 @@ CkCallback::CkCallback(int ep,const CProxy_NodeGroup &ngp) {
         d.group.refnum = 0;
 }
 
-CkCallback::CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,bool doInline) {
+CkCallback::CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,bool forceInline) {
 #if CMK_ERROR_CHECKING
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendNodeGroup:sendNodeGroup;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendNodeGroup : sendNodeGroup;
        d.group.ep=ep; d.group.id=ngp.ckGetGroupID(); d.group.onPE=onPE;
         d.group.hasRefnum= false;
         d.group.refnum = 0;
 }
 
-CkCallback::CkCallback(int ep,const CProxyElement_Group &grpElt,bool doInline) {
+CkCallback::CkCallback(int ep,const CProxyElement_Group &grpElt,bool forceInline) {
 #if CMK_ERROR_CHECKING
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendGroup:sendGroup;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendGroup : sendGroup;
        d.group.ep=ep; 
        d.group.id=grpElt.ckGetGroupID(); 
        d.group.onPE=grpElt.ckGetGroupPe();
@@ -151,11 +151,11 @@ CkCallback::CkCallback(int ep,const CProxyElement_Group &grpElt,bool doInline) {
         d.group.refnum = 0;
 }
 
-CkCallback::CkCallback(int ep, const CProxyElement_NodeGroup &grpElt, bool doInline) {
+CkCallback::CkCallback(int ep, const CProxyElement_NodeGroup &grpElt, bool forceInline) {
 #if CMK_ERROR_CHECKING
   memset(this, 0, sizeof(CkCallback));
 #endif
-  type = doInline ? isendNodeGroup : sendNodeGroup;
+  type = (forceInline || _entryTable[ep]->isInline) ? isendNodeGroup : sendNodeGroup;
   d.group.ep = ep;
   d.group.id = grpElt.ckGetGroupID();
   d.group.onPE = grpElt.ckGetGroupPe();
@@ -163,11 +163,11 @@ CkCallback::CkCallback(int ep, const CProxyElement_NodeGroup &grpElt, bool doInl
   d.group.refnum = 0;
 }
 
-CkCallback::CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,bool doInline) {
+CkCallback::CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,bool forceInline) {
 #if CMK_ERROR_CHECKING
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendArray:sendArray;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendArray : sendArray;
        d.array.ep=ep; 
        d.array.id=arrElt.ckGetArrayID(); 
        d.array.idx = arrElt.ckGetIndex();
@@ -175,11 +175,11 @@ CkCallback::CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,bool doInlin
         d.array.refnum = 0;
 }
 
-CkCallback::CkCallback(int ep,CProxySection_ArrayBase &sectElt,bool doInline) {
+CkCallback::CkCallback(int ep,CProxySection_ArrayBase &sectElt,bool forceInline) {
 #if CMK_ERROR_CHECKING
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=bcastSection;
+      type=bcastSection; // forceInline currently ignored
       d.section.ep=ep; 
       CkSectionID secID=sectElt.ckGetSectionID(0); 
       d.section.sinfo = secID._cookie.info;
@@ -206,11 +206,11 @@ CkCallback::CkCallback(int ep, CkSectionID &id) {
       d.section.refnum = 0;
 }
 
-CkCallback::CkCallback(ArrayElement *p, int ep,bool doInline) {
+CkCallback::CkCallback(ArrayElement *p, int ep,bool forceInline) {
 #if CMK_ERROR_CHECKING
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendArray:sendArray;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendArray : sendArray;
     d.array.ep=ep; 
        d.array.id=p->ckGetArrayID(); 
        d.array.idx = p->ckGetArrayIndex();
index 80405c43aab0193f307abe9212ef7e64282ee4e5..7a8443ce839d9c4526c1ea617085db23fe77d5da 100644 (file)
@@ -16,6 +16,7 @@ Initial version by Orion Sky Lawlor, olawlor@acm.org, 2/8/2002
 #include "conv-ccs.h" /*for CcsDelayedReply struct*/
 #include "charm.h"
 #include "ckarrayindex.h"
+#include "register.h"
 
 typedef void (*CkCallbackFn)(void *param,void *message);
 typedef void (*Ck1CallbackFn)(void *message);
@@ -250,11 +251,11 @@ public:
        }
 
     // Call a chare entry method
-       CkCallback(int ep,const CkChareID &id,bool doInline=false) {
+       CkCallback(int ep,const CkChareID &id,bool forceInline=false) {
 #if CMK_REPLAYSYSTEM
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendChare:sendChare;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendChare : sendChare;
          d.chare.ep=ep; d.chare.id=id;
           d.chare.hasRefnum = false;
           d.chare.refnum = 0;
@@ -275,24 +276,24 @@ public:
        }
 
     // Send to nodegroup element
-       CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,bool doInline=false);
+       CkCallback(int ep,int onPE,const CProxy_NodeGroup &ngp,bool forceInline=false);
 
     // Send to group/nodegroup element
-       CkCallback(int ep,int onPE,const CkGroupID &id,bool doInline=false, bool isNodeGroup=false) {
+       CkCallback(int ep,int onPE,const CkGroupID &id,bool forceInline=false, bool isNodeGroup=false) {
 #if CMK_REPLAYSYSTEM
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?(isNodeGroup?isendNodeGroup:isendGroup):(isNodeGroup?sendNodeGroup:sendGroup); 
+      type = (forceInline || _entryTable[ep]->isInline) ?  (isNodeGroup?isendNodeGroup:isendGroup) : (isNodeGroup?sendNodeGroup:sendGroup);
       d.group.ep=ep; d.group.id=id; d.group.onPE=onPE;
          d.group.hasRefnum = false;
           d.group.refnum = 0;
         }
 
     // Send to specified group element
-       CkCallback(int ep,const CProxyElement_Group &grpElt,bool doInline=false);
+       CkCallback(int ep,const CProxyElement_Group &grpElt,bool forceInline=false);
 
     // Send to specified nodegroup element
-       CkCallback(int ep,const CProxyElement_NodeGroup &grpElt,bool doInline=false);
+       CkCallback(int ep,const CProxyElement_NodeGroup &grpElt,bool forceInline=false);
 
     // Bcast to array
        CkCallback(int ep,const CkArrayID &id) {
@@ -306,34 +307,34 @@ public:
         }
 
     // Send to array element
-       CkCallback(int ep,const CkArrayIndex &idx,const CkArrayID &id,bool doInline=false) {
+       CkCallback(int ep,const CkArrayIndex &idx,const CkArrayID &id,bool forceInline=false) {
 #if CMK_REPLAYSYSTEM
       memset(this, 0, sizeof(CkCallback));
 #endif
-      type=doInline?isendArray:sendArray;
+      type = (forceInline || _entryTable[ep]->isInline) ? isendArray : sendArray;
          d.array.ep=ep; d.array.id=id; d.array.idx = idx;
          d.array.hasRefnum = false;
           d.array.refnum = 0;
         }
 
     // Bcast to array
-       CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,bool doInline=false);
+       CkCallback(int ep,const CProxyElement_ArrayBase &arrElt,bool forceInline=false);
        
        //Bcast to section
-       CkCallback(int ep,CProxySection_ArrayBase &sectElt,bool doInline=false);
+       CkCallback(int ep,CProxySection_ArrayBase &sectElt,bool forceInline=false);
        CkCallback(int ep, CkSectionID &sid);
        
        // Send to chare
-       CkCallback(Chare *p, int ep, bool doInline=false);
+       CkCallback(Chare *p, int ep, bool forceInline=false);
 
     // Send to group element on current PE
-       CkCallback(Group *p, int ep, bool doInline=false);
+       CkCallback(Group *p, int ep, bool forceInline=false);
 
     // Send to nodegroup element on current node
-       CkCallback(NodeGroup *p, int ep, bool doInline=false);
+       CkCallback(NodeGroup *p, int ep, bool forceInline=false);
 
     // Send to specified array element 
-       CkCallback(ArrayElement *p, int ep,bool doInline=false);
+       CkCallback(ArrayElement *p, int ep,bool forceInline=false);
 
        CkCallback(const CcsDelayedReply &reply) {
 #if CMK_REPLAYSYSTEM
index 7d81bb851acd1d80b5a86e82fc7b3ca1c29bfea7..9f6a466ef7fb5728743d7034122ce388a5753104 100644 (file)
@@ -58,6 +58,7 @@ int CkRegisterEpInternal(const char *name, CkCallFnPtr call, int msgIdx, int cha
   if (ck_ep_flags & CK_EP_TRACEDISABLE) e->traceEnabled=false;
   if (ck_ep_flags & CK_EP_APPWORK) e->appWork=true;
   if (ck_ep_flags & CK_EP_IMMEDIATE) e->isImmediate=true;
+  if (ck_ep_flags & CK_EP_INLINE) e->isInline=true;
 #if ADAPT_SCHED_MEM
   if (ck_ep_flags & CK_EP_MEMCRITICAL){
      e->isMemCritical=true;
index 5bb49635650f314251417aaf080cab074f158c99..5601f6c9fdc83e5529e95852435db7390d9eeb3d 100644 (file)
@@ -84,6 +84,8 @@ class EntryInfo {
     bool noKeep;
     /// Method is an immediate entry method and can bypass scheduler
     bool isImmediate;
+    /// Method is an inline entry method and can bypass scheduler and execute inline
+    bool isInline;
     /// true if this EP is charm internal functions
     bool inCharm;
     bool appWork;
@@ -102,7 +104,7 @@ class EntryInfo {
 #if CMK_CHARMDEBUG
       ,messagePup(0)
 #endif
-      ,traceEnabled(true), noKeep(false), isImmediate(false), inCharm(false), appWork(false),
+      ,traceEnabled(true), noKeep(false), isImmediate(false), isInline(false), inCharm(false), appWork(false),
       ownsName(ownsN), name(n)
     {
       if (ownsName) initName(n);
index 5c42a75199293e0a784be581f9b3d78034ab8072..3e741034ddb5be71d08c97c3a1d55f421eab480a 100644 (file)
@@ -2858,6 +2858,7 @@ XStr Entry::genRegEp(bool isForRedn) {
      str << "+CK_EP_TRACEDISABLE";
      str << "+CK_EP_IMMEDIATE";
   }
+  if (attribs & SINLINE) str << "+CK_EP_INLINE";
   if (attribs & SAPPWORK) str << "+CK_EP_APPWORK";
 
   /*MEICHAO*/