Fixed instrument bug that was causing NaN start times. Renamed startTime to phaseStar...
[charm.git] / src / arch / cuda / hybridAPI / wr.h
1 /* 
2  * wr.h
3  *
4  * by Lukasz Wesolowski
5  * 06.02.2008
6  *
7  * header containing declarations needed by the user of the API
8  *
9  */
10
11 #ifndef __WR_H__
12 #define __WR_H__
13
14 /* struct pinnedMemReq
15  *
16  * a structure for submitting page-locked memory allocation requests;
17  * passed as input into pinnedMallocHost 
18  *
19  */
20 typedef struct pinnedMemReq {
21   void ***hostPtrs; 
22   size_t *sizes;
23   int nBuffers;
24   void *callbackFn; 
25 } pinnedMemReq;
26
27 void delayedFree(void *ptr);
28
29
30 /* pinnedMallocHost
31  *
32  * schedules a pinned memory allocation so that it does not impede
33  * concurrent asynchronous execution 
34  *
35  */
36 void pinnedMallocHost(pinnedMemReq *reqs);
37
38
39 /* struct bufferInfo
40  * 
41  * purpose: 
42  * structure to indicate which actions the runtime system should
43  * perform in relation to the buffer
44  *
45  * usage: 
46  *
47  * the user associates an array of dataInfo structures with each
48  * submitted work request; device memory will be allocated if there is
49  * no buffer in use for that index
50  * 
51  */
52 typedef struct dataInfo {
53
54   /* ID of buffer in the runtime system's buffer table*/
55   int bufferID; 
56
57   /* flags to indicate if the buffer should be transferred */
58   int transferToDevice; 
59   int transferFromDevice; 
60   
61   /* flag to indicate if the device buffer memory should be freed
62      after  execution of work request */
63   int freeBuffer; 
64
65   /* pointer to host data buffer */
66   void *hostBuffer; 
67
68   /* size of buffer in bytes */
69   size_t size; 
70
71 } dataInfo; 
72
73
74
75 /* struct workRequest
76  * 
77  * purpose:  
78  * structure for organizing work units for execution on the GPU
79  *
80  * usage model: 
81  * 1. declare a pointer to a workRequest 
82  * 2. allocate dynamic memory for the work request
83  * 3. define the data members for the work request
84  * 4. enqueue the work request
85  */
86
87
88 typedef struct workRequest {
89   /* The following parameters need to be set by the user */
90
91   /* parameters for kernel execution */
92   dim3 dimGrid; 
93   dim3 dimBlock; 
94   int smemSize;
95   
96   /* array of dataInfo structs containing buffer information for the
97      execution of the work request */ 
98   dataInfo *bufferInfo; 
99   
100   /* number of buffers used by the work request */ 
101   int nBuffers; 
102
103   /* a Charm++ callback function (cast to a void *) to be called after
104      the kernel finishes executing on the GPU */ 
105   void *callbackFn; 
106  
107   /* id to select the correct kernel in kernelSelect */
108   int id; 
109
110   /* The following flag is used for control by the system */
111
112   int state; 
113   /* user data, may be used to pass scalar values to kernel calls */
114   void *userData; 
115
116 #ifdef GPU_INSTRUMENT_WRS
117   double phaseStartTime;
118   int chareIndex;
119   char compType;
120   char compPhase;
121
122   workRequest(){
123     chareIndex = -1;
124   }
125 #endif
126
127 } workRequest; 
128
129
130 /* struct workRequestQueue 
131  *
132  * purpose: container for GPU work requests 
133  *
134  * usage model: 
135  * 1. declare a workRequestQueue
136  * 2. call init to allocate memory for the queue and initialize
137  *    bookkeeping variables
138  * 3. enqueue each work request which needs to be 
139  *    executed on the GPU
140  * 4. the runtime system will be invoked periodically to
141  *    handle the details of executing the work request on the GPU
142  *             
143  * implementation notes: 
144  * the queue is implemented using a circular array; if the array fills
145  * up, requests are transferred to a queue having additional
146  * QUEUE_EXPANSION_SIZE slots, and the memory for the old queue is freed
147  */
148 typedef struct {
149
150   /* array of requests */
151   workRequest* requests; 
152
153   /* array index for the logically first item in the queue */
154   int head; 
155
156   /* array index for the last item in the queue */ 
157   int tail; 
158
159   /* number of work requests in the queue */
160   int size; 
161
162   /* size of the array of work requests */ 
163   int capacity; 
164
165 } workRequestQueue; 
166
167 /* enqueue
168  *
169  * add a work request to the queue to be later executed on the GPU
170  *
171  */
172 void enqueue(workRequestQueue *q, workRequest *wr); 
173
174 #ifdef GPU_MEMPOOL
175 void hapi_poolFree(void *);
176 void *hapi_poolMalloc(int size);
177 #endif
178 /* external declarations needed by the user */
179
180 extern workRequestQueue *wrQueue; 
181 extern void **devBuffers; 
182 extern cudaStream_t kernel_stream; 
183
184 #ifdef GPU_INSTRUMENT_WRS
185 struct RequestTimeInfo {
186   double transferTime;
187   double kernelTime;
188   double cleanupTime;
189   int n;
190
191   RequestTimeInfo(){
192     transferTime = 0.0;
193     kernelTime = 0.0;
194     cleanupTime = 0.0;
195     n = 0;
196   }
197 };
198
199 void hapi_initInstrument(int nchares, char ntypes);
200 RequestTimeInfo *hapi_queryInstrument(int chare, char type, char phase);
201 #endif
202
203 #endif
204
205