Merge cleanup fixes before static array optimizations
[charm.git] / src / conv-com / convcomlibmanager.h
1 #ifndef CONVCOMLIBMANAGER
2 #define CONVCOMLIBMANAGER
3
4
5 /**
6    @addtogroup ConvComlib
7    *@{
8    
9    @file
10    @brief Converse ComlibManager.
11    Declares the classes ConvComlibManager, plus
12    the interface provided to the user.
13    
14    * ConvComlibManager, responsible for the management of all the strategies in
15    the system, their initial broadcast and synchronization (at strategy
16    instantiation), as well as some runtime coordination. Mostly gives support
17    for the higher classes.
18     
19    The interface provided to the user es prefixed with "Comlib" except
20    ConvComlibRegister which has an extra prefix for compatibility with charm.
21
22    Sameer Kumar 28/03/04.
23    Heavily revised, Filippo Gioachin 01/06.
24 */
25
26 #include <convcomlibstrategy.h>
27 #include "ComlibStrategy.h"
28
29 // Are we crazy? Only 32 strategies allowed in the entire system?!?!?
30 #define MAX_NUM_STRATS 32
31
32
33 #define STARTUP_ITERATION -10000
34
35
36 /** Converse interface to handle all the Comlib strategies registered in the
37     Converse of Charm++ program. Being in Converse, this is a pure class
38     allocated into a global variable. */
39 class ConvComlibManager {
40
41   /// a table containing all the strategies in the system
42   StrategyTable strategyTable;
43   /// it is true after the system has been initialized at the program startup
44   CmiBool init_flag;
45   /// the number of strategies currently present in the system
46   int nstrats;
47
48   friend class Strategy;
49   int insertStrategy(Strategy *s);
50  public:
51   // a few variables used in the process of strategy synchronization
52   /// count how many acks have been received for the current synchronization
53   int acksReceived;
54   /// used when a doneCreating is called before the previous one is finished
55   CmiBool doneCreatingScheduled;
56   /// true when the manager is busy synchronizing the strategies
57   CmiBool busy;
58
59   ConvComlibManager();
60
61   void setInitialized() {init_flag = CmiTrue;}
62   CmiBool getInitialized() {return init_flag;}
63
64   // used only by ComlibManager.C to broadcast the strategies: DEPRECATED!
65   // the broadcast has to be done by converse
66   //void insertStrategy(Strategy *s, int loc);
67
68   /** Used to broadcast all strategies to all processors after inserting them */
69   void doneCreating();
70   /** Switch all the strategies in the "inSync" status to "ready" and deposit
71       into the strategies all pending messages */
72   void tableReady();
73   void enableStrategy(int loc);
74
75   // private:  //Why do we need private here?? XLC breaks with this private decl
76   inline void setStrategy(int loc, Strategy *s) {
77 #ifndef CMK_OPTIMIZE
78     if (loc == 0) CmiAbort("Trying to set strategy zero, not valid!\n");
79 #endif
80     strategyTable[loc].strategy = s;
81   }
82   friend void *comlibReceiveTableHandler(void *msg);
83  public:
84   inline int getNumStrats() {return nstrats;}
85   inline void incrementNumStrats() {nstrats++;}
86   inline void decrementNumStrats() {nstrats--;}
87   inline Strategy *getStrategy(int loc) {return strategyTable[loc].strategy;}
88   inline int isReady(int loc) {return strategyTable[loc].isReady;}
89   inline int isNew(int loc) {return strategyTable[loc].isNew;}
90   inline int isInSync(int loc) {return strategyTable[loc].isInSync;}
91   inline void inSync(int loc) {
92     strategyTable[loc].isNew = 0;
93     strategyTable[loc].isInSync = 1;
94   }
95 /*   inline int getErrorMode(int loc) {return strategyTable[loc].errorMode;} */
96   inline CkQ<MessageHolder*> *getTmpList(int loc) {return &strategyTable[loc].tmplist;}
97
98   
99   // TODO inline this function again
100   void insertMessage(MessageHolder* msg, int instid);
101   
102   inline void doneInserting(int loc) {
103           if (isReady(loc))
104                   strategyTable[loc].strategy->doneInserting();
105           else
106                   strategyTable[loc].call_doneInserting ++;
107   }
108
109   StrategyTableEntry *getStrategyTable(int loc) {return &strategyTable[loc];}
110   //StrategyTable *getStrategyTable() {return &strategyTable;}
111
112   void printDiagnostics();
113
114 };
115
116 /// This processor's converse Comlib manager
117 CkpvExtern(ConvComlibManager, conv_com_object);
118
119
120 void initConvComlibManager();
121
122
123 /***************************************************************************
124  * User section:
125  *
126  * Implementation of the functions used by the user
127  ***************************************************************************/
128
129 Strategy *ConvComlibGetStrategy(int loc);
130
131
132 /** Iterate over all the inserted strategies and broadcast all those that are
133     marked as new. This has some effect only on processor 0, for all the other
134     it is a NOP. */
135 inline void ComlibDoneCreating() {
136   if (CmiMyPe() != 0) return;
137   CkpvAccess(conv_com_object).doneCreating();
138 }
139
140 void ConvComlibScheduleDoneInserting(int loc);
141
142 /** Converse send utilities for comlib. For all of them the message passed will
143     be lost by the application. */
144 inline void ComlibSyncSendAndFree(unsigned int pe, unsigned int size, char *msg, ComlibInstanceHandle cinst) {
145   CkpvAccess(conv_com_object).insertMessage(new MessageHolder(msg, size, pe), cinst);
146 }
147
148 inline void ComlibSyncBroadcastAllAndFree(unsigned int size, char *msg, ComlibInstanceHandle cinst) {
149   CkpvAccess(conv_com_object).insertMessage(new MessageHolder(msg, size), cinst);
150 }
151
152 /// In this case the array "pes" is lost by the application together with "msg".
153 inline void ComlibSyncListSendAndFree(int npes, int *pes, unsigned int size, char *msg, ComlibInstanceHandle cinst) {
154   CkpvAccess(conv_com_object).insertMessage(new MessageHolder(msg, size, npes, pes), cinst);
155 }
156
157 inline void ComlibBegin(ComlibInstanceHandle cinst, int iteration) {
158   // Do nothing?
159 }
160
161 inline void ComlibEnd(ComlibInstanceHandle cinst, int iteration) {
162   // flush strategy???
163   CkpvAccess(conv_com_object).doneInserting(cinst);
164 }
165
166 CkpvExtern(int, comlib_handler);
167
168 /* DEPRECATED!!! gained the syntax above similar to Cmi
169 // Send a converse message to a remote strategy instance. On being
170 // received the handleMessage method will be invoked.
171 inline void ConvComlibSendMessage(int instance, int dest_pe, int size, char *msg) {
172   CmiSetHandler(msg, CkpvAccess(strategy_handlerid));
173   ((CmiMsgHeaderBasic *) msg)->stratid = instance;
174     
175   CmiSyncSendAndFree(dest_pe, size, msg);
176 }*/
177
178 /*@}*/
179
180 #endif