Cleanup made possible by the new FEM:
authorOrion Lawlor <olawlor@acm.org>
Fri, 18 Jul 2003 03:17:38 +0000 (03:17 +0000)
committerOrion Lawlor <olawlor@acm.org>
Fri, 18 Jul 2003 03:17:38 +0000 (03:17 +0000)
  1.) Removed all "state" (init or driver) information,
      since it's error-prone, and init is now no more.
  2.) Remove TCHARM readonlies.  The intended semantics
      was never clear (when did they become valid?), and
      the same thing can now be done better with FEM_Mesh_pup.

src/libs/ck-libs/tcharm/tcharm.C
src/libs/ck-libs/tcharm/tcharm.ci
src/libs/ck-libs/tcharm/tcharm_impl.h
src/libs/ck-libs/tcharm/tcharmc.h

index 77fb99ce4233d684354759623a02e44eea69ed75..5197244087e68d7f2f1eba0820409cc0427fbcce 100644 (file)
@@ -18,7 +18,6 @@ Orion Sky Lawlor, olawlor@acm.org, 11/19/2001
 #endif
 
 CtvDeclare(TCharm *,_curTCharm);
-CkpvDeclare(inState,_stateTCharm);
 
 static int lastNumChunks=0;
 
@@ -61,8 +60,6 @@ void TCharm::nodeInit(void)
 {
   CtvInitialize(TCharm *,_curTCharm);
   CtvAccess(_curTCharm)=NULL;
-  CkpvInitialize(inState,_stateTCharm);
-  TCharm::setState(inInit);
 
   tcharm_initted=1;
 }
@@ -103,7 +100,7 @@ void TCHARM_Api_trace(const char *routineName,const char *libraryName)
 
 static void startTCharmThread(TCharmInitMsg *msg)
 {
-       TCharm::setState(inDriver);
+       DBGX("thread started");
        CtvAccess(_curTCharm)->activateHeap();
        typedef void (*threadFn_t)(void *);
        ((threadFn_t)msg->threadFn)(msg->data);
@@ -131,7 +128,6 @@ TCharm::TCharm(TCharmInitMsg *initMsg_)
 #endif
   }
   CtvAccessOther(tid,_curTCharm)=this;
-  TCharm::setState(inInit);
   isStopped=true;
   resumeAfterMigration=false;
   exitWhenDone=initMsg->opts.exitWhenDone;
@@ -188,13 +184,11 @@ void TCharm::pup(PUP::er &p) {
   }
 
   //Pack all user data
-  TCharm::setState(inPup);
   s.seek(0);
   p(nUd);
   for(int i=0;i<nUd;i++)
     ud[i].pup(p);
   p|sud;
-  TCharm::setState(inFramework);
 
   if (!p.isUnpacking())
   {//In this case, pack the thread & heap after the user data
@@ -279,25 +273,28 @@ void *TCharm::lookupUserData(int i) {
 void TCharm::run(void)
 {
   DBG("TCharm::run()");
-  start();
+  if (tcharm_nothreads) {/*Call user routine directly*/
+         startTCharmThread(initMsg);
+  } 
+  else /* start the thread as usual */
+         start();
 }
 
 //Block the thread until start()ed again.
 void TCharm::stop(void)
 {
-  if (isStopped) return; //Nothing to do
 #ifndef CMK_OPTIMIZE
-  DBG("suspending thread");
   if (tid != CthSelf())
     CkAbort("Called TCharm::stop from outside TCharm thread!\n");
   if (tcharm_nothreads)
     CkAbort("Cannot make blocking calls using +tcharm_nothreads!\n");
 #endif
-  isStopped=true;
   stopTiming();
-  TCharm::setState(inFramework);
+  isStopped=true;
+  DBG("thread suspended");
   CthSuspend();
-  TCharm::setState(inDriver);
+  DBG("thread resumed");
+  isStopped=false;
   /*We have to do the get() because "this" may have changed
     during a migration-suspend.*/
   TCharm::get()->startTiming();
@@ -306,14 +303,16 @@ void TCharm::stop(void)
 //Resume the waiting thread
 void TCharm::start(void)
 {
-  if (!isStopped) return; //Already started
   isStopped=false;
-  TCharm::setState(inDriver);
-  DBG("awakening thread");
-  if (tcharm_nothreads) /*Call user routine directly*/
-         startTCharmThread(initMsg);
-  else /*Jump to thread normally*/
-         CthAwaken(tid);
+  DBG("thread resuming soon");
+  CthAwaken(tid);
+}
+
+//Block our thread, schedule, and come back:
+void TCharm::schedule(void) {
+  DBG("thread schedule");
+  start(); // Calls CthAwaken
+  stop(); // Calls CthSuspend
 }
 
 //Go to sync, block, possibly migrate, and then resume
@@ -334,15 +333,6 @@ void TCharm::ResumeFromSync(void)
   start();
 }
 
-#ifndef CMK_OPTIMIZE
-//Make sure we're actually in driver
-void TCharm::check(void)
-{
-       if (getState()!=inDriver)
-               ::CkAbort("TCharm> Can only use that routine from within driver!\n");
-}
-#endif
-
 
 /****** TcharmClient ******/
 void TCharmClient1D::ckJustMigrated(void) {
@@ -358,120 +348,9 @@ void TCharmClient1D::pup(PUP::er &p) {
 
 CkArrayID TCHARM_Get_threads(void) {
        TCHARMAPI("TCHARM_Get_threads");
-       if (TCharm::getState()!=inDriver)
-               CkAbort("Can only call TCHARM_Get_threads from driver!\n");
        return TCharm::get()->getProxy();
 }
 
-/****** Readonlys *****/
-static int tcharm_readonlygroup_created=0;
-static TCharmReadonlys *initial_readonlies=NULL;
-TCharmReadonlys &getInitialReadonlies(void) {
-       if (!initial_readonlies) initial_readonlies=new TCharmReadonlys;
-       return *initial_readonlies;
-}
-CProxy_TCharmReadonlyGroup tcharm_readonlygroup;
-
-class TCharmReadonlyGroup : public CBase_TCharmReadonlyGroup {
-public:
-       TCharmReadonlys all;
-       
-       TCharmReadonlyGroup(CkMigrateMessage* m){ /* empty */ }
-       TCharmReadonlyGroup(TCharmReadonlys &r,int len,const char *data)
-       {
-               add(r,len,data);
-       }
-       
-       void add(TCharmReadonlys &r,int len,const char *data) {
-               // Unpack these readonlies:
-               PUP::fromMem p(data);
-               r.pupData(p);
-               // Add to our list:
-               all.add(r);
-       }
-       
-       void pup(PUP::er &p) {
-               all.pup(p);
-               all.pupData(p);
-       }
-};
-
-// Send out this set of readonlies to the readonly group:
-static void send_readonlies(TCharmReadonlys &r) {
-       int len; {PUP::sizer p; r.pupData(p); len=p.size();}
-       char *data=new char[len];
-       {PUP::toMem p(data); r.pupData(p);}
-       tcharm_readonlygroup.add(r,len,data);
-       delete[] data;
-}
-
-class TCharmReadonlyMain : public CBase_TCharmReadonlyMain {
-public:
-    TCharmReadonlyMain(void) {
-       TCharmReadonlys &r=getInitialReadonlies();
-       int len; {PUP::sizer p; r.pupData(p); len=p.size();}
-       char *data=new char[len];
-       {PUP::toMem p(data); r.pupData(p);}
-        tcharm_readonlygroup=CProxy_TCharmReadonlyGroup::ckNew(r,len,data);
-       delete[] data;
-       tcharm_readonlygroup_created=1;
-    }
-};
-
-void TCharmReadonlys::add(TCpupReadonlyGlobal fn)
-{
-       entries.push_back(fn);
-}
-void TCharmReadonlys::add(const TCharmReadonlys &r) {
-       for (unsigned int i=0;i<r.entries.size();i++)
-               entries.push_back(r.entries[i]);
-}
-
-//Pup the readonly *functions* (for shipping)
-void TCharmReadonlys::pup(PUP::er &p) {
-       p|entries;
-}
-
-//Pups the readonly *data*
-void TCharmReadonlys::pupData(PUP::er &p) {
-       for (unsigned int i=0;i<entries.size();i++)
-               (entries[i])((pup_er)&p);
-}
-
-//Pups all readonly data registered so far.
-void TCharmReadonlys::pupAll(PUP::er &p) {
-       if (!tcharm_readonlygroup_created)
-               CkAbort("TCharmReadonlys::pupAll can only be called after the TCHARM main");
-       TCharmReadonlys &all=tcharm_readonlygroup.ckLocalBranch()->all;
-       int n=all.size();
-       p|n;
-       if (n!=all.size())
-               CkAbort("TCharmReadonly list length mismatch!\n");
-       all.pupData(p);
-}
-
-CDECL void TCHARM_Readonly_globals(TCpupReadonlyGlobal fn)
-{
-       if (!tcharm_readonlygroup_created) 
-       { // Readonly message hasn't gone out yet: just add to list.
-         // Because this routine can be called from nodesetup,
-         //  TCHARMAPI isn't safe yet.
-               getInitialReadonlies().add(fn);
-       } 
-       else /* tcharm_readonlygroup_created */
-       { // Late addition: Broadcast our copy of the readonly data:
-               TCHARMAPI("TCHARM_Readonly_globals");
-               TCharmReadonlys r; r.add(fn);
-               send_readonlies(r);
-       }
-}
-FDECL void FTN_NAME(TCHARM_READONLY_GLOBALS,tcharm_readonly_globals)
-       (TCpupReadonlyGlobal fn)
-{
-       TCHARM_Readonly_globals(fn);
-}
-
-
 /************* Startup/Shutdown Coordination Support ************/
 
 // Useless values to reduce over:
@@ -489,7 +368,7 @@ void TCharm::barrier(void) {
 void TCharm::atBarrier(CkReductionMsg *m) {
        DBGX("clients all at barrier");
        delete m;
-       thisProxy.run(); //Just restart everybody
+       thisProxy.start(); //Just restart everybody
 }
 
 //Called when the thread is done running
@@ -588,8 +467,6 @@ CDECL void TCHARM_Create_data(int nThreads,
                  void *threadData,int threadDataLen)
 {
        TCHARMAPI("TCHARM_Create_data");
-       if (TCharm::getState()!=inInit)
-               CkAbort("TCharm> Can only create threads from in init!\n");
        TCharmInitMsg *msg=new (threadDataLen,0) TCharmInitMsg(
                (CthVoidFn)threadFn,g_tcharmOptions);
        msg->numElements=nThreads;
@@ -652,10 +529,7 @@ CDECL int TCHARM_Element(void)
 CDECL int TCHARM_Num_elements(void)
 { 
        TCHARMAPI("TCHARM_Num_elements");
-       if (TCharm::getState()==inDriver)
-               return TCharm::get()->getNumElements();
-       else
-               return lastNumChunks;
+       return TCharm::get()->getNumElements();
 }
 
 FDECL int FTN_NAME(TCHARM_ELEMENT,tcharm_element)(void) 
@@ -703,8 +577,7 @@ CDECL void TCHARM_Set_global(int globalID,void *new_value,TCHARM_Pup_global_fn p
        if (tc->sud.length()<=globalID)
        { //We don't have room for this ID yet: make room
                int newLen=2*globalID;
-               tc->sud.setSize(newLen);
-               tc->sud.length()=newLen;
+               tc->sud.resize(newLen);
        }
        tc->sud[globalID]=TCharm::UserData((TCHARM_Pup_fn) pup_or_NULL,new_value);
 }
@@ -749,8 +622,9 @@ FORTRAN_AS_C(TCHARM_BARRIER,TCHARM_Barrier,tcharm_barrier,(void),())
 CDECL void TCHARM_Done(void)
 {
        TCHARMAPI("TCHARM_Done");
-       if (TCharm::getState()!=inDriver) CkExit();
-       else TCharm::get()->done();
+       TCharm *c=TCharm::getNULL();
+       if (!c) CkExit();
+       else c->done();
 }
 FORTRAN_AS_C(TCHARM_DONE,TCHARM_Done,tcharm_done,(void),())
 
@@ -758,9 +632,10 @@ FORTRAN_AS_C(TCHARM_DONE,TCHARM_Done,tcharm_done,(void),())
 CDECL double TCHARM_Wall_timer(void)
 {
   TCHARMAPI("TCHARM_Wall_timer");
-  if(TCharm::getState()!=inDriver) return CkWallTimer();
+  TCharm *c=TCharm::getNULL();
+  if(!c) return CkWallTimer();
   else { //Have to apply current thread's time offset
-    return CkWallTimer()+TCharm::get()->getTimeOffset();
+    return CkWallTimer()+c->getTimeOffset();
   }
 }
 
index bd0ef22441b86f05b209a9ee08d8114bd2e0b621..a1e973f3a6504b1dccc763cf6349c27b000033aa 100644 (file)
@@ -4,20 +4,11 @@ module tcharm {
   };
   array [1D] TCharm {
     entry TCharm(TCharmInitMsg *initMsg);
-    entry void run(void);
     entry void atBarrier(CkReductionMsg *);
     entry void atExit(CkReductionMsg *);
     entry void migrateDelayed(int destPE);
+    entry void start(void);
     initproc void procInit(void);
     initnode void nodeInit(void);
   };
-  
-  readonly CProxy_TCharmReadonlyGroup tcharm_readonlygroup;
-  group [migratable] TCharmReadonlyGroup {
-    entry TCharmReadonlyGroup(TCharmReadonlys r,int len,char data[len]);
-    entry void add(TCharmReadonlys r,int len,char data[len]);
-  };
-  mainchare TCharmReadonlyMain {
-    entry TCharmReadonlyMain(void);
-  };
 };
index 5feecdde48fd5bbd7bc37ec0ab9871ce52cf5c72..3ee39bdcf98a1cb7777c2035fca0978b9c5ee6ea 100644 (file)
@@ -17,28 +17,6 @@ Orion Sky Lawlor, olawlor@acm.org, 11/19/2001
 #include "cklists.h"
 #include "memory-isomalloc.h"
 
-PUPbytes(TCpupReadonlyGlobal);
-
-//User's readonly global variables, set exactly once after initialization
-class TCharmReadonlys {
-       CkVec<TCpupReadonlyGlobal> entries;
- public:
-       void add(TCpupReadonlyGlobal fn);
-       void add(const TCharmReadonlys &r);
-       
-       inline int size(void) const {return entries.size();}
-       
-       //Pup the readonly *functions* (for shipping)
-       void pup(PUP::er &p);
-
-       //Pups the readonly *data*
-       void pupData(PUP::er &p);
-       
-       //Pups all registered readonlys 
-       static void pupAll(PUP::er &p);
-};
-PUPmarshall(TCharmReadonlys);
-
 class TCharmTraceLibList;
 
 #include "tcharm.decl.h"
@@ -72,12 +50,8 @@ class TCharmInitMsg : public CMessage_TCharmInitMsg {
                :threadFn(threadFn_), opts(opts_) {}
 };
 
-//Current computation location
-typedef enum {inNodeSetup,inInit,inDriver,inFramework,inPup} inState;
-
 //Thread-local variables:
 CtvExtern(TCharm *,_curTCharm);
-CkpvExtern(inState,_stateTCharm);
 
 CDECL {typedef void (*TCpupUserDataC)(pup_er p,void *data);};
 FDECL {typedef void (*TCpupUserDataF)(pup_er p,void *data);};
@@ -166,12 +140,6 @@ class TCharm: public CBase_TCharm
 
        void ResumeFromSync(void);
 
-#ifdef CMK_OPTIMIZE
-       static inline void check(void) {}
-#else
-       static void check(void);
-#endif
-
  public:
        TCharm(TCharmInitMsg *initMsg);
        TCharm(CkMigrateMessage *);
@@ -206,9 +174,14 @@ class TCharm: public CBase_TCharm
        int add(const UserData &d);
        void *lookupUserData(int ud);
        
-       inline static TCharm *get(void) {check(); return CtvAccess(_curTCharm);}
-       inline static inState getState(void) {return CkpvAccess(_stateTCharm);}
-       inline static void setState(inState to) {CkpvAccess(_stateTCharm)=to;}
+       inline static TCharm *get(void) {
+               TCharm *c=getNULL();
+#ifndef CMK_OPTIMIZE
+               if (!c) ::CkAbort("TCharm has not been initialized!\n");
+#endif
+               return c;
+       }
+       inline static TCharm *getNULL(void) {return CtvAccess(_curTCharm);}
        inline CthThread getThread(void) {return tid;}
        inline const CProxy_TCharm &getProxy(void) const {return threadInfo.tProxy;}
        inline int getElement(void) const {return threadInfo.thisElement;}
@@ -219,18 +192,14 @@ class TCharm: public CBase_TCharm
        inline void startTiming(void) {ckStartTiming();}
 
        //Block our thread, run the scheduler, and come back
-       inline void schedule(void) {
-               stopTiming();
-               CthYield();
-               startTiming();
-       }
+       void schedule(void);
 
        //As above, but start/stop the thread itself, too.
        void stop(void); //Blocks; will not return until "start" called.
        void start(void);
        //Aliases:
        inline void suspend(void) {stop();}
-       inline void resume(void) {start();}
+       inline void resume(void) { if (isStopped) start();}
 
        //Go to sync, block, possibly migrate, and then resume
        void migrate(void);
index e8e18d6baa98d7a9050fee143f8c17a9bbab67c9..35de6afea3324e79cfa6cfe3e6c763f5b32a3699 100644 (file)
@@ -18,14 +18,7 @@ void TCHARM_User_setup(void);
 
 void TCHARM_Call_fallback_setup(void);
 
-/**** Routines you can call from UserNodeSetup: ****/
-
-/*Register readonly global variables-- these will be broadcast
-after init and available in driver.*/
-typedef void (*TCpupReadonlyGlobal)(pup_er p);
-void TCHARM_Readonly_globals(TCpupReadonlyGlobal fn);
-
-/**** Routines you can call from UserSetup: ****/
+/**** Routines you can call to create threads: ****/
 
 /*Set the size of the thread stack*/
 void TCHARM_Set_stack_size(int newStackSize);
@@ -33,6 +26,9 @@ void TCHARM_Set_stack_size(int newStackSize);
 /*Exit the program when these threads are finished. */
 void TCHARM_Set_exit(void);
 
+/*Get the number of chunks we expect based on the command line*/
+int TCHARM_Get_num_chunks(void);
+
 /*Create a new array of threads, which will be bound to by subsequent libraries*/
 typedef void (*TCHARM_Thread_start_fn)(void);
 void TCHARM_Create(int nThreads,TCHARM_Thread_start_fn threadFn);
@@ -42,9 +38,6 @@ typedef void (*TCHARM_Thread_data_start_fn)(void *threadData);
 void TCHARM_Create_data(int nThreads,TCHARM_Thread_data_start_fn threadFn,
                  void *threadData,int threadDataLen);
 
-/*Get the number of chunks we expect based on the command line*/
-int TCHARM_Get_num_chunks(void);
-
 
 /**** Routines you can call from the thread (driver) ****/
 int TCHARM_Element(void);