62350d89858e884cb368709b374f7d0fc4a65b7a
[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 /** Converse interface to handle all the Comlib strategies registered in the
34     Converse of Charm++ program. Being in Converse, this is a pure class
35     allocated into a global variable. */
36 class ConvComlibManager {
37
38   /// a table containing all the strategies in the system
39   StrategyTable strategyTable;
40   /// it is true after the system has been initialized at the program startup
41   CmiBool init_flag;
42   /// the number of strategies currently present in the system
43   int nstrats;
44
45   friend class Strategy;
46   int insertStrategy(Strategy *s);
47  public:
48   // a few variables used in the process of strategy synchronization
49   /// count how many acks have been received for the current synchronization
50   int acksReceived;
51   /// used when a doneCreating is called before the previous one is finished
52   CmiBool doneCreatingScheduled;
53   /// true when the manager is busy synchronizing the strategies
54   CmiBool busy;
55
56   ConvComlibManager();
57
58   void setInitialized() {init_flag = CmiTrue;}
59   CmiBool getInitialized() {return init_flag;}
60
61   // used only by ComlibManager.C to broadcast the strategies: DEPRECATED!
62   // the broadcast has to be done by converse
63   //void insertStrategy(Strategy *s, int loc);
64
65   /** Used to broadcast all strategies to all processors after inserting them */
66   void doneCreating();
67   /** Switch all the strategies in the "inSync" status to "ready" and deposit
68       into the strategies all pending messages */
69   void tableReady();
70   void enableStrategy(int loc);
71
72   // private:  //Why do we need private here?? XLC breaks with this private decl
73   inline void setStrategy(int loc, Strategy *s) {
74 #ifndef CMK_OPTIMIZE
75     if (loc == 0) CmiAbort("Trying to set strategy zero, not valid!\n");
76 #endif
77     strategyTable[loc].strategy = s;
78   }
79   friend void *comlibReceiveTableHandler(void *msg);
80  public:
81   inline int getNumStrats() {return nstrats;}
82   inline Strategy *getStrategy(int loc) {return strategyTable[loc].strategy;}
83   inline int isReady(int loc) {return strategyTable[loc].isReady;}
84   inline int isNew(int loc) {return strategyTable[loc].isNew;}
85   inline int isInSync(int loc) {return strategyTable[loc].isInSync;}
86   inline void inSync(int loc) {
87     strategyTable[loc].isNew = 0;
88     strategyTable[loc].isInSync = 1;
89   }
90   inline int getErrorMode(int loc) {return strategyTable[loc].errorMode;}
91   inline CkQ<MessageHolder*> *getTmpList(int loc) {return &strategyTable[loc].tmplist;}
92
93   
94   // TODO inline this function again
95   void insertMessage(MessageHolder* msg, int instid);
96   
97   inline void doneInserting(int loc) {
98           if (isReady(loc))
99                   strategyTable[loc].strategy->doneInserting();
100           else
101                   strategyTable[loc].call_doneInserting ++;
102   }
103
104   StrategyTableEntry *getStrategyTable(int loc) {return &strategyTable[loc];}
105   //StrategyTable *getStrategyTable() {return &strategyTable;}
106
107   void printDiagnostics();
108
109 };
110
111 /// This processor's converse Comlib manager
112 CkpvExtern(ConvComlibManager, conv_com_object);
113
114
115 void initConvComlibManager();
116
117
118 /***************************************************************************
119  * User section:
120  *
121  * Implementation of the functions used by the user
122  ***************************************************************************/
123
124 Strategy *ConvComlibGetStrategy(int loc);
125
126
127 /** Iterate over all the inserted strategies and broadcast all those that are
128     marked as new. This has some effect only on processor 0, for all the other
129     it is a NOP. */
130 inline void ComlibDoneCreating() {
131   if (CmiMyPe() != 0) return;
132   CkpvAccess(conv_com_object).doneCreating();
133 }
134
135 void ConvComlibScheduleDoneInserting(int loc);
136
137 /** Converse send utilities for comlib. For all of them the message passed will
138     be lost by the application. */
139 inline void ComlibSyncSendAndFree(unsigned int pe, unsigned int size, char *msg, ComlibInstanceHandle cinst) {
140   CkpvAccess(conv_com_object).insertMessage(new MessageHolder(msg, size, pe), cinst);
141 }
142
143 inline void ComlibSyncBroadcastAllAndFree(unsigned int size, char *msg, ComlibInstanceHandle cinst) {
144   CkpvAccess(conv_com_object).insertMessage(new MessageHolder(msg, size), cinst);
145 }
146
147 /// In this case the array "pes" is lost by the application together with "msg".
148 inline void ComlibSyncListSendAndFree(int npes, int *pes, unsigned int size, char *msg, ComlibInstanceHandle cinst) {
149   CkpvAccess(conv_com_object).insertMessage(new MessageHolder(msg, size, npes, pes), cinst);
150 }
151
152 inline void ComlibBegin(ComlibInstanceHandle cinst, int iteration) {
153   // Do nothing?
154 }
155
156 inline void ComlibEnd(ComlibInstanceHandle cinst, int iteration) {
157   // flush strategy???
158   CkpvAccess(conv_com_object).doneInserting(cinst);
159 }
160
161 CkpvExtern(int, comlib_handler);
162
163 /* DEPRECATED!!! gained the syntax above similar to Cmi
164 // Send a converse message to a remote strategy instance. On being
165 // received the handleMessage method will be invoked.
166 inline void ConvComlibSendMessage(int instance, int dest_pe, int size, char *msg) {
167   CmiSetHandler(msg, CkpvAccess(strategy_handlerid));
168   ((CmiMsgHeaderBasic *) msg)->stratid = instance;
169     
170   CmiSyncSendAndFree(dest_pe, size, msg);
171 }*/
172
173 /*@}*/
174
175 #endif