remove unused variables and other cleanup to get a clean compilation.
[charm.git] / src / conv-com / pipebroadcastconverse.h
1 /**
2    @addtogroup ComlibConverseStrategy
3    @{
4    @file
5    @brief Header for the PipeBroadcastConverse strategy
6 */
7
8 #ifndef PIPE_BROADCAST_CONVERSE
9 #define PIPE_BROADCAST_CONVERSE
10 #include "ckhashtable.h"
11 //#include "charm++.h"
12 //#include "envelope.h"
13 #include "convcomlibmanager.h"
14
15 #define DEFAULT_PIPE   8196
16
17 CkpvExtern(int, pipeline_handler);
18 extern void PipelineHandler(void *msg);
19 CkpvExtern(int, pipeline_frag_handler);
20 extern void PipelineFragmentHandler(void *msg);
21
22 /**
23  * Header used to split messages for the pipelining. Due to the usage of short
24  * types, this will not work in machines like BG/L.
25  */
26 struct PipeBcastInfo {
27   short bcastPe;     ///< pe who is doing the broadcast, used for the hash key
28   short seqNumber;   ///< timestamp of the message from processor bcastPe, the other part of the hash key
29   int chunkSize;     ///< it is the size of the data part of the message (without the converse header)
30   int chunkNumber;   ///< which chunk is this inside the whole message
31   int messageSize;   ///< the entire message size, all included
32   short srcPe;       ///< pe from whom I'm receiving the message
33 };
34
35 /**
36  * The hash key for indexing incoming fragmented messages while waiting to
37  * reassemble them. It is composed by the sourcePe and the timestamp it gave to
38  * the message (sequential number per processor)
39  */
40 class PipeBcastHashKey {
41  public:
42
43     int srcPe;
44     int seq;
45     PipeBcastHashKey(int _pe, int _seq):srcPe(_pe), seq(_seq){};
46
47     //These routines allow PipeBcastHashKey to be used in
48     //  a CkHashtableT
49     CkHashCode hash(void) const;
50     static CkHashCode staticHash(const void *a,size_t);
51     int compare(const PipeBcastHashKey &ind) const;
52     static int staticCompare(const void *a,const void *b,size_t);
53 };
54
55 /// sequential numbers must be below 2^16, so the number of processors must
56 inline CkHashCode PipeBcastHashKey::hash(void) const {
57     register int _seq = seq;
58     register int _pe = srcPe;
59     
60     register CkHashCode ret = (_seq << 16) + _pe;
61     return ret;
62 }
63
64 inline int PipeBcastHashKey::compare(const PipeBcastHashKey &k2) const {
65     if(seq == k2.seq && srcPe == k2.srcPe)
66         return 1;
67     
68     return 0;
69 }
70
71 /**
72  * The message in reassembling
73  */
74 class PipeBcastHashObj {
75  public:
76   char *message;
77   int dimension; ///< total size of the reassembled message
78   int remaining; ///< how many messages we are still waiting before reassembly is done
79   PipeBcastHashObj (int dim, int rem, char *msg) :dimension(dim),remaining(rem),message(msg) {};
80
81 };
82
83 //typedef const UInt  constUInt;
84 //typedef void (*setFunction)(char*, constUInt);
85
86 /**
87  * PipeBroadcastConverse streams broadcast messages to all processors, and
88  * delivers them using the "deliver" method. These messages are splitted into
89  * multiple packets and pipelined throughout the network. The typical routing
90  * algorithm is hypercube (linear array is also available) and the information
91  * of the next hops is computed at runtime without any overhead to store data in
92  * the memory.
93  */
94 class PipeBroadcastConverse : public Strategy {
95  protected:
96
97   int pipeSize; ///< this is the size of the splitted messages, including the converse header
98   short topology; ///< which topology to use: Hypercube vs. Linear
99   //double log_of_2_inv;
100   CmiUInt2 seqNumber; ///< the sequential numbering in this processor
101   //CkQ <MessageHolder*> *messageBuf;
102
103   /// All the messages which are currently fragmented and we are reassembling
104   CkHashtableT<PipeBcastHashKey, PipeBcastHashObj *> fragments;
105   //int propagateHandle;
106   //int propagateHandle_frag;
107
108   // WARNING: All pure converse messages need to insert a "CmiFragmentHeader"
109   // right after the ConverseHeader at the beginning of the user data.
110
111   /// return the pointer to where the structure CmiFragmentHeader is in the message
112   virtual CmiFragmentHeader *getFragmentHeader(char *msg);
113
114  public:
115   PipeBroadcastConverse(short top=USE_HYPERCUBE, int size=DEFAULT_PIPE);
116   PipeBroadcastConverse(CkMigrateMessage *m): Strategy(m) {};
117   int getPipeSize() { return pipeSize; };
118
119   //void commonInit();
120   // the deliver function deletes the message afterwards
121   virtual void deliver(char *msg, int dim);
122
123   void handleMessage(void*) {
124     CmiAbort("PipeBroadcastConverse::handleMessage, this should never be used!\n");
125   }
126
127   /** Store the fragment of the message into the hashtable, and deliver it when
128       the storing fragment is the last of the message */
129   void store(char *msg);
130
131   /** Forward the message to the next processors in the list */
132   void propagate(char *msg, int isFrag);//, int srcPeNumber, int totalSendingSize, setFunction setPeNumber);
133
134   //void conversePipeBcast(char *env, int size);
135   void insertMessage(MessageHolder *msg);
136   //void doneInserting();
137
138   virtual void pup(PUP::er &p);
139   PUPable_decl(PipeBroadcastConverse);
140 };
141
142 #endif
143
144 /*@}*/