|
41
|
1 /* Context definition for llrb example */
|
|
52
|
2 // #ifdef CBC_CONTEXT_H does not work well
|
|
|
3 #define CBC_CONTEXT_H
|
|
|
4 // #include <stdlib.h>
|
|
|
5 // #include <pthread.h>
|
|
41
|
6 #ifdef USE_CUDAWorker
|
|
|
7 #include <cuda.h>
|
|
|
8 #include <driver_types.h>
|
|
|
9 #include <cuda_runtime.h>
|
|
|
10 #include "helper_cuda.h"
|
|
|
11 #endif
|
|
|
12
|
|
53
|
13 #include "types.h"
|
|
|
14 #include "use_context_numbers.h"
|
|
|
15 #include "fs.h"
|
|
|
16 #include "defs.h"
|
|
|
17
|
|
|
18 #define calloc(a,b) kmalloc((a)*(b))
|
|
|
19 #define free(a) kfree(a)
|
|
51
|
20
|
|
41
|
21 #define ALLOCATE_SIZE 20000000
|
|
|
22 #define NEW(type) (type*)(calloc(1, sizeof(type)))
|
|
|
23 #define NEWN(n, type) (type*)(calloc(n, sizeof(type)))
|
|
|
24
|
|
52
|
25 #define ALLOC_DATA(cbc_context, dseg) ({\
|
|
|
26 Meta* meta = (Meta*)cbc_context->heap;\
|
|
41
|
27 meta->type = D_##dseg;\
|
|
|
28 meta->size = sizeof(dseg);\
|
|
|
29 meta->len = 1;\
|
|
52
|
30 cbc_context->heap += sizeof(Meta);\
|
|
|
31 cbc_context->data[D_##dseg] = cbc_context->heap; cbc_context->heap += sizeof(dseg); (dseg *)cbc_context->data[D_##dseg]; })
|
|
41
|
32
|
|
52
|
33 #define ALLOC_DATA_TYPE(cbc_context, dseg, t) ({\
|
|
|
34 Meta* meta = (Meta*)cbc_context->heap;\
|
|
41
|
35 meta->type = D_##t;\
|
|
|
36 meta->size = sizeof(t);\
|
|
|
37 meta->len = 1;\
|
|
52
|
38 cbc_context->heap += sizeof(Meta);\
|
|
|
39 cbc_context->data[D_##dseg] = cbc_context->heap; cbc_context->heap += sizeof(t); (t *)cbc_context->data[D_##dseg]; })
|
|
41
|
40
|
|
52
|
41 #define ALLOCATE(cbc_context, t) ({ \
|
|
|
42 Meta* meta = (Meta*)cbc_context->heap;\
|
|
|
43 cbc_context->heap += sizeof(Meta);\
|
|
|
44 union Data* data = cbc_context->heap; \
|
|
|
45 cbc_context->heap += sizeof(t); \
|
|
41
|
46 meta->type = D_##t; \
|
|
|
47 meta->size = sizeof(t); \
|
|
|
48 meta->len = 1;\
|
|
|
49 data; })
|
|
|
50
|
|
52
|
51 #define ALLOCATE_ARRAY(cbc_context, t, length) ({ \
|
|
|
52 Meta* meta = (Meta*)cbc_context->heap;\
|
|
|
53 cbc_context->heap += sizeof(Meta);\
|
|
|
54 union Data* data = cbc_context->heap; \
|
|
|
55 cbc_context->heap += sizeof(t)*length; \
|
|
41
|
56 meta->type = D_##t; \
|
|
|
57 meta->size = sizeof(t)*length; \
|
|
|
58 meta->len = length; \
|
|
|
59 data; })
|
|
|
60
|
|
52
|
61 #define ALLOCATE_PTR_ARRAY(cbc_context, dseg, length) ({\
|
|
|
62 Meta* meta = (Meta*)cbc_context->heap;\
|
|
|
63 cbc_context->heap += sizeof(Meta);\
|
|
|
64 union Data* data = cbc_context->heap; \
|
|
|
65 cbc_context->heap += sizeof(dseg *)*length; \
|
|
41
|
66 meta->type = D_##dseg; \
|
|
|
67 meta->size = sizeof(dseg *)*length; \
|
|
|
68 meta->len = length; \
|
|
|
69 data; })
|
|
|
70
|
|
52
|
71 #define ALLOCATE_DATA_GEAR(cbc_context, t) ({ \
|
|
|
72 union Data* data = ALLOCATE(cbc_context, t); \
|
|
41
|
73 Meta* meta = GET_META(data); \
|
|
52
|
74 meta->wait = createSynchronizedQueue(cbc_context); \
|
|
41
|
75 data; })
|
|
|
76
|
|
52
|
77 #define ALLOC(cbc_context, t) (&ALLOCATE(cbc_context, t)->t)
|
|
41
|
78
|
|
|
79 #define GET_META(dseg) ((Meta*)(((void*)dseg) - sizeof(Meta)))
|
|
|
80 #define GET_TYPE(dseg) (GET_META(dseg)->type)
|
|
|
81 #define GET_SIZE(dseg) (GET_META(dseg)->size)
|
|
|
82 #define GET_LEN(dseg) (GET_META(dseg)->len)
|
|
|
83 #define GET_WAIT_LIST(dseg) (GET_META(dseg)->wait)
|
|
|
84
|
|
52
|
85 #define Gearef(cbc_context, t) (&(cbc_context)->data[D_##t]->t)
|
|
41
|
86
|
|
52
|
87 // (SingleLinkedStack *)cbc_context->data[D_Stack]->Stack.stack->Stack.stack
|
|
41
|
88
|
|
52
|
89 #define GearImpl(cbc_context, intf, name) (Gearef(cbc_context, intf)->name->intf.name)
|
|
41
|
90
|
|
|
91 #include "c/enumCode.h"
|
|
|
92
|
|
|
93 enum Relational {
|
|
|
94 EQ,
|
|
|
95 GT,
|
|
|
96 LT,
|
|
|
97 };
|
|
|
98
|
|
|
99 #include "c/enumData.h"
|
|
51
|
100 #define NDIRECT 12 //fs.h
|
|
41
|
101
|
|
|
102 struct Context {
|
|
|
103 enum Code next;
|
|
|
104 struct Worker* worker;
|
|
|
105 struct TaskManager* taskManager;
|
|
|
106 int codeNum;
|
|
|
107 __code (**code) (struct Context*);
|
|
|
108 union Data **data;
|
|
|
109 void* heapStart;
|
|
|
110 void* heap;
|
|
|
111 long heapLimit;
|
|
|
112 int dataNum;
|
|
|
113
|
|
|
114 // task parameter
|
|
|
115 int idgCount; //number of waiting dataGear
|
|
|
116 int idg;
|
|
|
117 int maxIdg;
|
|
|
118 int odg;
|
|
|
119 int maxOdg;
|
|
|
120 int gpu; // GPU task
|
|
|
121 struct Context* task;
|
|
|
122 struct Element* taskList;
|
|
|
123 #ifdef USE_CUDAWorker
|
|
|
124 int num_exec;
|
|
|
125 CUmodule module;
|
|
|
126 CUfunction function;
|
|
|
127 #endif
|
|
|
128 /* multi dimension parameter */
|
|
|
129 int iterate;
|
|
|
130 struct Iterator* iterator;
|
|
|
131 enum Code before;
|
|
|
132 };
|
|
|
133
|
|
|
134 typedef int Int;
|
|
|
135 #ifndef USE_CUDAWorker
|
|
|
136 typedef unsigned long long CUdeviceptr;
|
|
|
137 #endif
|
|
|
138 union Data {
|
|
|
139 struct Meta {
|
|
|
140 enum DataType type;
|
|
|
141 long size;
|
|
|
142 long len;
|
|
|
143 struct Queue* wait; // tasks waiting this dataGear
|
|
|
144 } Meta;
|
|
|
145 struct Context Context;
|
|
|
146 struct Timer {
|
|
|
147 union Data* timer;
|
|
|
148 enum Code start;
|
|
|
149 enum Code end;
|
|
|
150 enum Code next;
|
|
|
151 } Timer;
|
|
|
152 struct TimerImpl {
|
|
|
153 double time;
|
|
|
154 } TimerImpl;
|
|
|
155 struct LoopCounter {
|
|
|
156 int i;
|
|
|
157 } LoopCounter;
|
|
|
158 struct TaskManager {
|
|
|
159 union Data* taskManager;
|
|
52
|
160 enum Code spawn; // start NEW cbc_context on the worker
|
|
41
|
161 enum Code spawnTasks; // start NEW tasks on the worker
|
|
|
162 enum Code shutdown;
|
|
|
163 enum Code incrementTaskCount;
|
|
|
164 enum Code decrementTaskCount;
|
|
|
165 enum Code next;
|
|
|
166 enum Code next1;
|
|
|
167 enum Code setWaitTask;
|
|
|
168 struct Context* task;
|
|
|
169 struct Element* taskList;
|
|
|
170 union Data* data;
|
|
|
171 } TaskManager;
|
|
|
172 struct TaskManagerImpl {
|
|
|
173 enum Code next;
|
|
|
174 int numWorker;
|
|
|
175 int sendCPUWorkerIndex;
|
|
|
176 int sendGPUWorkerIndex;
|
|
|
177 int taskCount;
|
|
52
|
178 // pthread_mutex_t mutex;
|
|
41
|
179 struct Queue* activeQueue;
|
|
|
180 struct Worker** workers;
|
|
|
181 struct Element* taskList;
|
|
|
182 int loopCounter;
|
|
|
183 int cpu;
|
|
|
184 int gpu;
|
|
|
185 int io;
|
|
|
186 int maxCPU;
|
|
|
187 } TaskManagerImpl;
|
|
|
188 struct Worker {
|
|
|
189 union Data* worker;
|
|
|
190 enum Code taskReceive;
|
|
|
191 enum Code shutdown;
|
|
|
192 enum Code next;
|
|
|
193 struct Queue* tasks;
|
|
52
|
194 // pthread_t thread;
|
|
41
|
195 struct TaskManager* taskManager;
|
|
|
196 struct Context* task;
|
|
|
197 } Worker;
|
|
|
198 struct CPUWorker {
|
|
52
|
199 // pthread_mutex_t mutex;
|
|
|
200 // pthread_cond_t cond;
|
|
|
201 struct Context* cbc_context;
|
|
41
|
202 int id;
|
|
|
203 int loopCounter;
|
|
|
204 } CPUWorker;
|
|
|
205 #ifdef USE_CUDAWorker
|
|
|
206 struct CUDAWorker {
|
|
|
207 CUdevice device;
|
|
52
|
208 CUcbc_context cuCtx;
|
|
|
209 struct Context* cbc_context;
|
|
41
|
210 int id;
|
|
|
211 int loopCounter;
|
|
|
212 int deviceNum;
|
|
|
213 struct Queue* tasks;
|
|
|
214 int runFlag;
|
|
|
215 enum Code next;
|
|
|
216 int numStream;
|
|
|
217 struct Executor* executor;
|
|
|
218 CUstream *stream;
|
|
|
219 } CUDAWorker;
|
|
|
220 #else
|
|
|
221 struct CUDAWorker {
|
|
|
222 } CUDAWorker;
|
|
|
223 #endif
|
|
|
224 struct Main {
|
|
|
225 enum Code code;
|
|
|
226 enum Code next;
|
|
|
227 struct Queue* args;
|
|
|
228 } Main;
|
|
|
229 // Queue Interface
|
|
|
230 struct Queue {
|
|
|
231 union Data* queue;
|
|
|
232 union Data* data;
|
|
|
233 enum Code whenEmpty;
|
|
|
234 enum Code clear;
|
|
|
235 enum Code put;
|
|
|
236 enum Code take;
|
|
|
237 enum Code isEmpty;
|
|
|
238 enum Code next;
|
|
|
239 } Queue;
|
|
|
240 struct SingleLinkedQueue {
|
|
|
241 struct Element* top;
|
|
|
242 struct Element* last;
|
|
|
243 } SingleLinkedQueue;
|
|
|
244 struct SynchronizedQueue {
|
|
|
245 struct Element* top;
|
|
|
246 struct Element* last;
|
|
|
247 struct Atomic* atomic;
|
|
|
248 } SynchronizedQueue;
|
|
|
249 // Stack Interface
|
|
|
250 struct Stack {
|
|
|
251 union Data* stack;
|
|
|
252 union Data* data;
|
|
|
253 union Data* data1;
|
|
|
254 enum Code whenEmpty;
|
|
|
255 enum Code clear;
|
|
|
256 enum Code push;
|
|
|
257 enum Code pop;
|
|
|
258 enum Code pop2;
|
|
|
259 enum Code isEmpty;
|
|
|
260 enum Code get;
|
|
|
261 enum Code get2;
|
|
|
262 enum Code next;
|
|
|
263 } Stack;
|
|
|
264 // Stack implementations
|
|
|
265 struct SingleLinkedStack {
|
|
|
266 struct Element* top;
|
|
|
267 } SingleLinkedStack;
|
|
|
268 struct ArrayStack {
|
|
|
269 int size;
|
|
|
270 int limit;
|
|
|
271 struct Element* array;
|
|
|
272 } ArrayStack;
|
|
|
273 // Stack implementation end
|
|
|
274 struct Element {
|
|
|
275 union Data* data;
|
|
|
276 struct Element* next;
|
|
|
277 } Element;
|
|
|
278 struct Array {
|
|
|
279 int prefix;
|
|
|
280 Int* array;
|
|
|
281 } Array;
|
|
|
282 struct Tree {
|
|
|
283 union Data* tree;
|
|
|
284 struct Node* node;
|
|
|
285 enum Code put;
|
|
|
286 enum Code get;
|
|
|
287 enum Code remove;
|
|
|
288 enum Code clear;
|
|
|
289 enum Code next;
|
|
|
290 } Tree;
|
|
|
291 struct RedBlackTree {
|
|
|
292 struct Node* root;
|
|
|
293 struct Node* current; // reading node of original tree
|
|
|
294 struct Node* previous; // parent of reading node of original tree
|
|
|
295 struct Node* newNode; // writing node of new tree
|
|
|
296 struct Node* parent;
|
|
|
297 struct Node* grandparent;
|
|
|
298 struct Stack* nodeStack;
|
|
|
299 enum Code findNodeNext;
|
|
|
300 int result;
|
|
|
301 } RedBlackTree;
|
|
|
302 struct RotateTree {
|
|
|
303 enum Code next;
|
|
|
304 struct RedBlackTree* traverse;
|
|
|
305 struct Tree* tree;
|
|
|
306 } RotateTree;
|
|
|
307 struct Node {
|
|
|
308 int key; // comparable data segment
|
|
|
309 union Data* value;
|
|
|
310 struct Node* left;
|
|
|
311 struct Node* right;
|
|
|
312 // need to balancing
|
|
|
313 enum Color {
|
|
|
314 Red,
|
|
|
315 Black,
|
|
|
316 // Red eq 0,Black eq 1. enum name convert intager.
|
|
|
317 } color;
|
|
|
318 } Node;
|
|
|
319 struct Atomic {
|
|
|
320 union Data* atomic;
|
|
|
321 union Data** ptr;
|
|
|
322 union Data* oldData;
|
|
|
323 union Data* newData;
|
|
|
324 enum Code checkAndSet;
|
|
|
325 enum Code next;
|
|
|
326 enum Code fail;
|
|
|
327 } Atomic;
|
|
|
328 struct AtomicReference {
|
|
|
329 } AtomicReference;
|
|
|
330 struct Semaphore {
|
|
|
331 union Data* semaphore;
|
|
|
332 enum Code p;
|
|
|
333 enum Code v;
|
|
|
334 enum Code next;
|
|
|
335 } Semaphore;
|
|
|
336 struct SemaphoreImpl {
|
|
|
337 int value;
|
|
|
338 struct Lock* lock;
|
|
|
339 struct Queue* waitThreadQueue;
|
|
|
340 } SemaphoreImpl;
|
|
|
341 struct Allocate {
|
|
|
342 enum Code next;
|
|
|
343 long size;
|
|
|
344 } Allocate;
|
|
|
345 struct Integer {
|
|
|
346 int value;
|
|
|
347 } Integer;
|
|
|
348 struct SortArray {
|
|
|
349 struct Integer *array; //Array arrayじゃできない？
|
|
|
350 int loopCounter;
|
|
|
351 int block;
|
|
|
352 int first;
|
|
|
353 int prefix;
|
|
|
354 } SortArray;
|
|
|
355 struct Iterator {
|
|
|
356 union Data* iterator;
|
|
|
357 struct Context* task;
|
|
|
358 int numGPU;
|
|
|
359 enum Code exec;
|
|
|
360 enum Code barrier;
|
|
|
361 enum Code whenWait;
|
|
|
362 enum Code next;
|
|
|
363 } Iterator;
|
|
|
364 struct MultiDimIterator {
|
|
|
365 int x;
|
|
|
366 int y;
|
|
|
367 int z;
|
|
|
368 int count;
|
|
|
369 int counterX;
|
|
|
370 int counterY;
|
|
|
371 int counterZ;
|
|
|
372 } MultiDimIterator;
|
|
|
373 struct MultiDim {
|
|
|
374 int x;
|
|
|
375 int y;
|
|
|
376 int z;
|
|
|
377 } MultiDim;
|
|
|
378 struct Executor {
|
|
|
379 union Data* executor;
|
|
|
380 struct Context* task;
|
|
|
381 enum Code read;
|
|
|
382 enum Code exec;
|
|
|
383 enum Code write;
|
|
|
384 enum Code next;
|
|
|
385 } Executor;
|
|
|
386 #ifdef USE_CUDAWorker
|
|
|
387 struct CUDAExecutor {
|
|
|
388 CUdeviceptr** kernelParams;
|
|
|
389 struct CUDABuffer* buffer;
|
|
|
390 int maxThreadPerBlock;
|
|
|
391 int maxThreadPerBlockX;
|
|
|
392 int maxThreadPerBlockY;
|
|
|
393 int maxThreadPerBlockZ;
|
|
|
394 struct Timer* timer;
|
|
|
395 } CUDAExecutor;
|
|
|
396 struct CUDABuffer {
|
|
|
397 int inputLen;
|
|
|
398 int outputLen;
|
|
|
399 union Data** inputData;
|
|
|
400 union Data** outputData;
|
|
|
401 } CUDABuffer;
|
|
|
402 CUdeviceptr CUdeviceptr;
|
|
|
403 #else
|
|
|
404 struct CUDAExecutor {
|
|
|
405 } CUDAExecutor;
|
|
|
406 struct CUDABuffer {
|
|
|
407 } CUDABuffer;
|
|
|
408 CUdeviceptr CUdeviceptr;
|
|
|
409 #endif
|
|
|
410 Int Int;
|
|
|
411 struct Memory {
|
|
|
412 union Data* adr;
|
|
|
413 int length;
|
|
|
414 union Data* body;
|
|
|
415 int hash;
|
|
|
416 } Memory;
|
|
|
417 struct Buffer {
|
|
|
418 union Data* buffer;
|
|
|
419 union Data* data;
|
|
|
420 enum Code put;
|
|
|
421 enum Code take;
|
|
|
422 enum Code next;
|
|
|
423 } Buffer;
|
|
|
424 struct BoundedBuffer {
|
|
|
425 struct Element* top;
|
|
|
426 struct Element* last;
|
|
|
427 struct Semaphore* fullCount;
|
|
|
428 struct Semaphore* emptyCount;
|
|
|
429 struct Semaphore* lock;
|
|
|
430 } BoundedBuffer;
|
|
|
431 struct Lock {
|
|
|
432 union Data* lock;
|
|
|
433 enum Code doLock;
|
|
|
434 enum Code doUnlock;
|
|
|
435 enum Code next;
|
|
|
436 } Lock;
|
|
|
437 struct LockImpl {
|
|
|
438 Int* lock;
|
|
|
439 struct Queue* waitThreadQueue;
|
|
|
440 struct Atomic* atomic;
|
|
|
441 struct Context* lockContext;
|
|
|
442 } LockImpl;
|
|
|
443 struct SpinLock {
|
|
|
444 volatile Int* lock;
|
|
|
445 struct Atomic* atomic;
|
|
|
446 struct Context* lockContext;
|
|
|
447 } SpinLock;
|
|
52
|
448 /* CbCxv6 cbc_context*/
|
|
51
|
449 struct Inode {
|
|
|
450 uint dev; // Device number
|
|
|
451 uint inum; // Inode number
|
|
|
452 int ref; // Reference count
|
|
|
453 int flags; // I_BUSY, I_VALID
|
|
|
454
|
|
|
455 short type; // copy of disk inode
|
|
|
456 short major;
|
|
|
457 short minor;
|
|
|
458 short nlink;
|
|
|
459 uint size;
|
|
|
460 uint addrs[NDIRECT+1];
|
|
|
461 } Inode;
|
|
|
462 struct Uinteger {
|
|
|
463 uint value;
|
|
|
464 } Uinteger;
|
|
|
465 struct Short {
|
|
|
466 short value;
|
|
|
467 } Short;
|
|
|
468 struct String {
|
|
|
469 char* string;
|
|
|
470 } String;
|
|
|
471 // fs.h ---
|
|
|
472 struct SuperBlock {
|
|
|
473 uint size; // Size of file system image (blocks)
|
|
|
474 uint nblocks; // Number of data blocks
|
|
|
475 uint ninodes; // Number of inodes.
|
|
|
476 uint nlog; // Number of log blocks
|
|
|
477 } SuperBlock;
|
|
|
478 struct Dinode {
|
|
|
479 short type; // copy of disk inode
|
|
|
480 short major;
|
|
|
481 short minor;
|
|
|
482 short nlink;
|
|
|
483 uint size;
|
|
|
484 uint addrs[NDIRECT+1];
|
|
|
485 } Dinode;
|
|
|
486 struct Dirent {
|
|
|
487 ushort inum;
|
|
|
488 char name[DIRSIZ];
|
|
|
489 } Dirent;
|
|
|
490 // --- fs.h
|
|
52
|
491 }; // union Data end this is necessary for cbc_context generator
|
|
51
|
492
|
|
41
|
493 typedef union Data Data;
|
|
|
494
|
|
|
495 #include "c/typedefData.h"
|
|
|
496
|
|
|
497 #include "c/extern.h"
|
|
|
498
|
|
52
|
499 extern __code start_code(struct Context* cbc_context);
|
|
|
500 extern __code exit_code(struct Context* cbc_context);
|
|
|
501 extern __code meta(struct Context* cbc_context, enum Code next);
|
|
|
502 //extern __code par_meta(struct Context* cbc_context, enum Code spawns, enum Code next);
|
|
|
503 extern __code parGotoMeta(struct Context* cbc_context, enum Code next);
|
|
|
504 extern void initContext(struct Context* cbc_context);
|
|
41
|
505
|
|
52
|
506 // #endif
|
