More unused variable cleanup
[charm.git] / src / ck-core / qd.h
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8 #ifndef _QD_H
9 #define _QD_H
10
11 class QdMsg {
12   private:
13     int phase; // 0..2
14     union {
15       struct { /* none */ } p1;
16       struct { int created; int processed; } p2;
17       struct { /* none */ } p3;
18       struct { int dirty; } p4;
19     } u;
20     CkCallback cb;
21   public:
22     int getPhase(void) { return phase; }
23     void setPhase(int p) { phase = p; }
24     CkCallback getCb(void) { CkAssert(phase==0); return cb; }
25     void setCb(CkCallback cb_) { CkAssert(phase==0); cb = cb_; }
26     int getCreated(void) { CkAssert(phase==1); return u.p2.created; }
27     void setCreated(int c) { CkAssert(phase==1); u.p2.created = c; }
28     int getProcessed(void) { CkAssert(phase==1); return u.p2.processed; }
29     void setProcessed(int p) { CkAssert(phase==1); u.p2.processed = p; }
30     int getDirty(void) { CkAssert(phase==2); return u.p4.dirty; }
31     void setDirty(int d) { CkAssert(phase==2); u.p4.dirty = d; }
32 };
33
34 class QdCommMsg {
35   public:
36     int flag;     //  0: create   1: process
37     int count;
38 };
39
40 class QdCallback {
41   public:
42         CkCallback cb;
43   public:
44     QdCallback(int e, CkChareID c) : cb(e, c) {}
45         QdCallback(CkCallback cb_) : cb(cb_) {}
46 //    void send(void) { CkSendMsg(ep,CkAllocMsg(0,0,0),&cid); }
47     void send(void) {
48       // pretending pe 0 in blue gene mode, switch back after the call.
49 #if CMK_CONDS_USE_SPECIAL_CODE
50       int old = CmiSwitchToPE(0);
51 #endif
52       cb.send(NULL);
53 #if CMK_CONDS_USE_SPECIAL_CODE
54       CmiSwitchToPE(old);
55 #endif
56     }
57 };
58
59 class QdState {
60   private:
61     int stage; // 0..2
62     int oProcessed;
63     int mCreated, mProcessed;
64     int cCreated, cProcessed;
65     int cDirty;
66     int nReported;
67     PtrQ *callbacks;
68     int nChildren;
69     int parent;
70     int *children;
71   public:
72     QdState():stage(0),mCreated(0),mProcessed(0),nReported(0) {
73       cCreated = 0; cProcessed = 0; cDirty = 0;
74       oProcessed = 0;
75       callbacks = new PtrQ();
76       _MEMCHECK(callbacks);
77       nChildren = CmiNumSpanTreeChildren(CmiMyPe());
78       parent = CmiSpanTreeParent(CmiMyPe());
79       if (nChildren != 0) {
80         children = new int[nChildren];
81         _MEMCHECK(children);
82         CmiSpanTreeChildren(CmiMyPe(), children);
83       }
84       /* CmiPrintf("[%d] n:%d parent:%d - %d %d %d %d %d %d.\n", CmiMyPe(), nChildren, parent, nChildren?children[0]:-1, nChildren?children[1]:-1, nChildren?children[2]:-1, nChildren?children[3]:-1, nChildren?children[4]:-1, nChildren?children[5]:-1); */
85     }
86     void propagate(QdMsg *msg) {
87       envelope *env = UsrToEnv((void *)msg);
88       CmiSetHandler(env, _qdHandlerIdx);
89       for(int i=0; i<nChildren; i++) {
90 #if CMK_BLUEGENE_CHARM
91         CmiSyncSendFn(children[i], env->getTotalsize(), (char *)env);
92 #else
93         CmiSyncSend(children[i], env->getTotalsize(), (char *)env);
94 #endif
95       }
96     }
97     int getParent(void) { return parent; }
98     QdCallback *deq(void) { return (QdCallback*) callbacks->deq(); }
99     void enq(QdCallback *c) { callbacks->enq((void *) c); }
100     void create(int n=1) { 
101         mCreated += n; 
102 #if CK_MSG_IMMEDIATE
103         sendCount(0, n);
104 #endif
105     }
106     void sendCount(int flag, int count);     // send msg to rank 0 for counting
107     void process(int n=1) { 
108          mProcessed += n; 
109     }
110     int getCreated(void) { return mCreated; }
111     int getProcessed(void) { return mProcessed; }
112     int getCCreated(void) { return cCreated; }
113     int getCProcessed(void) { return cProcessed; }
114     void subtreeCreate(int c) { cCreated += c; }
115     void subtreeProcess(int p) { cProcessed += p; }
116     int getStage(void) { return stage; }
117     void setStage(int p) { stage = p; }
118     void reported(void) { nReported++; }
119     int allReported(void) {return nReported==(nChildren+1);}
120     void reset(void) { nReported=0; cCreated=0; cProcessed=0; cDirty=0; }
121     void markProcessed(void) { oProcessed = mProcessed; }
122     int isDirty(void) { return ((mProcessed > oProcessed) || cDirty); }
123     void subtreeSetDirty(int d) { cDirty = cDirty || d; }
124     void flushStates() {
125       stage = mCreated = mProcessed = nReported = 0;
126       cCreated = 0; cProcessed = 0; cDirty = 0;
127       oProcessed = 0;
128     }
129 };
130
131 extern void _qdHandler(envelope *);
132 extern void _qdCommHandler(envelope *);
133 CpvExtern(QdState*, _qd);
134
135 #endif