Mercurial > hg > GearsTemplate

changeset 326:f23f6d0aa4e9 examples_directory

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add examples/calc.cbc and build but not work
author Tatsuki IHA <e125716@ie.u-ryukyu.ac.jp>
date Tue, 18 Apr 2017 01:47:42 +0900
parents 7d664be4efa5
children 534601ed8c50
files src/parallel_execution/CMakeLists.txt src/parallel_execution/TaskManager.cbc src/parallel_execution/TaskManagerImpl.cbc src/parallel_execution/context.h src/parallel_execution/examples/calc.cbc
diffstat 5 files changed, 291 insertions(+), 6 deletions(-) [+]
line wrap: on
line diff
--- a/src/parallel_execution/CMakeLists.txt	Tue Apr 11 22:21:47 2017 +0900
+++ b/src/parallel_execution/CMakeLists.txt	Tue Apr 18 01:47:42 2017 +0900
@@ -63,6 +63,13 @@
       examples/twice.cbc RedBlackTree.cbc compare.c SingleLinkedStack.cbc CPUWorker.cbc time.cbc twice.cbc TaskManagerImpl.cbc SingleLinkedQueue.cbc SynchronizedQueue.cbc SemaphoreImpl.cbc
 )
 
+GearsCommand(
+  TARGET
+      calc
+  SOURCES 
+      examples/calc.cbc RedBlackTree.cbc compare.c SingleLinkedStack.cbc CPUWorker.cbc time.cbc twice.cbc TaskManagerImpl.cbc SingleLinkedQueue.cbc SynchronizedQueue.cbc SemaphoreImpl.cbc
+)
+
 if (${USE_CUDA})
     GearsCommand(
       TARGET
--- a/src/parallel_execution/TaskManager.cbc	Tue Apr 11 22:21:47 2017 +0900
+++ b/src/parallel_execution/TaskManager.cbc	Tue Apr 18 01:47:42 2017 +0900
@@ -2,6 +2,7 @@
     union Data* taskManager;
     __code createTask(struct TaskManager* taskManager);
     __code spawn(Impl* taskManager, struct Queue* queue, struct Context* task, __code next(...));
+    __code setWaitTask(struct Queue* queue, struct Context* task, __code next(...));
     __code shutdown(struct LoopCounter* loopCounter, struct TaskManager* taskManager, Impl* taskManagerImpl, struct Queue* queue, __code next(...));
     __code next(...);
     __code task(...);
--- a/src/parallel_execution/TaskManagerImpl.cbc	Tue Apr 11 22:21:47 2017 +0900
+++ b/src/parallel_execution/TaskManagerImpl.cbc	Tue Apr 18 01:47:42 2017 +0900
@@ -6,7 +6,7 @@
 
 TaskManager* createTaskManagerImpl(struct Context* context, int numCPU, int numGPU, int numIO) {
     struct TaskManager* taskManager = new TaskManager();
-    // 0...numIO-1 IOProcessor 
+    // 0...numIO-1 IOProcessor
     // numIO...numIO+numGPU-1 GPUProcessor
     // numIO+numGPU...numIO+numGPU+numCPU-1 CPUProcessor
     taskManager->io = 0;
@@ -15,6 +15,7 @@
     taskManager->maxCPU = numIO+numGPU+numCPU;
     taskManager->createTask = C_createTask;
     taskManager->spawn = C_spawnTaskManager;
+    taskManager->setWaitTask = C_setWaitTask;
     taskManager->shutdown  = C_shutdownTaskManager;
     struct TaskManagerImpl* taskManagerImpl = new TaskManagerImpl();
     taskManagerImpl -> activeQueue = createSingleLinkedQueue(context);
@@ -43,7 +44,7 @@
 #else
         Queue* queue = createSynchronizedQueue(context);
         taskManagerImpl->workers[i] = (Worker*)createCPUWorker(context, i, queue);
-#endif        
+#endif
     }
     for (;i<taskManager->maxCPU;i++) {
         Queue* queue = createSynchronizedQueue(context);
@@ -55,9 +56,25 @@
     taskManager->context = NEW(struct Context);
     initContext(taskManager->context);
     taskManager->context->taskManager = taskManager;
+    taskManager->context->idg = taskManager->context->dataNum;
     goto meta(context, C_setWorker);
 }
 
+__code setWaitTask(struct Queue* queue, struct Context* task, Data* data, __code next(...)) {
+    struct Meta *metaData = GET_META(data);
+    if (!metaData->wait) {
+        metaData->wait = createSynchronizedQueue(context);
+    }
+    queue->queue = (union Data*)metaData->wait;
+    queue->next = next;
+    queue->data = (Data *)task;
+    goto meta(context, queue->queue->Queue.put);
+}
+
+__code setWaitTask_stub(struct Context* context) {
+    goto setWaitTask(context, Gearef(context, Queue), Gearef(context, TaskManager)->context, Gearef(context, TaskManager)->data, Gearef(context, TaskManager)->next);
+}
+
 __code setWorker(struct TaskManagerImpl* taskManager, struct Context* task, __code next(...)) {
     task->workerId = taskManager->sendWorkerIndex;
     if(++taskManager->sendWorkerIndex >= taskManager->numWorker) {
--- a/src/parallel_execution/context.h	Tue Apr 11 22:21:47 2017 +0900
+++ b/src/parallel_execution/context.h	Tue Apr 18 01:47:42 2017 +0900
@@ -22,7 +22,7 @@
     struct Meta* meta = (struct Meta*)context->heap;\
     meta->type = D_##t;\
     meta->size = 1;\
-    context->heap += sizeof(struct Meta);                               \
+    context->heap += sizeof(struct Meta);\
     context->data[D_##dseg] = context->heap; context->heap += sizeof(struct t); (struct t *)context->data[D_##dseg]; })
 
 #define ALLOCATE(context, t) ({ \
@@ -76,6 +76,8 @@
     long heapLimit;
     int dataNum;
     int idgCount; //number of waiting dataGear
+    int idg;
+    int maxIdg;
     int odg;
     int maxOdg;
     int workerId;
@@ -108,11 +110,13 @@
         union Data* taskManager;
         enum Code createTask; // create NEW  contexts for execution & argument
         enum Code spawn;      // start NEW context on the worker
+        enum Code setWaitTask;
         enum Code shutdown;
 
         enum Code next;
         enum Code task;
         struct Context* context;
+        union Data* data;
         int worker;
         int cpu;
         int gpu;
@@ -274,9 +278,9 @@
         enum Code next;
         long size;
     } Allocate;
-    struct OutPutDataSegments {
-        union Data **data;
-    } Ods;
+    struct Integer {
+        int value;
+    } Integer;
 }; // union Data end       this is necessary for context generator
 
 typedef union Data Data;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/parallel_execution/examples/calc.cbc	Tue Apr 18 01:47:42 2017 +0900
@@ -0,0 +1,256 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "../../context.h"
+
+int cpu_num = 1;
+int length = 102400;
+int split = 8;
+int* array_ptr;
+int gpu_num = 0;
+int CPU_ANY = -1;
+int CPU_CUDA = -1;
+
+void print_queue(struct Element* element) {
+    while (element) {
+        printf("%p\n", ((struct Task *)(element->data)));
+        element = element->next;
+    }
+}
+
+void print_tree(struct Node* node) {
+    if (node != 0) {
+        printf("%d\n", node->value->Array.index);
+        print_tree(node->left);
+        print_tree(node->right);
+    }
+}
+
+void *start_taskManager(struct Context *context) {
+    goto initDataGears(context, Gearef(context, LoopCounter), Gearef(context, TaskManager));
+    return 0;
+}
+
+#ifdef USE_CUDAWorker
+#ifdef USE_CUDA_MAIN_THREAD
+extern volatile int cuda_initialized;
+#endif
+#endif
+
+__code initDataGears(struct LoopCounter* loopCounter, struct TaskManager* taskManager) {
+    // loopCounter->tree = createRedBlackTree(context);
+    loopCounter->i = 0;
+    taskManager->taskManager = (union Data*)createTaskManagerImpl(context, cpu_num, gpu_num, 0);
+#ifdef USE_CUDAWorker
+#ifdef USE_CUDA_MAIN_THREAD
+    while(! cuda_initialized) {};
+#endif
+#endif
+    goto meta(context, C_createTask1);
+}
+
+__code initDataGears_stub(struct Context* context) {
+    struct TaskManager* taskManager =  Gearef(context, TaskManager);
+    taskManager->taskManager = 0;
+#if (! defined(USE_CUDAWorker) || ! defined(USE_CUDA_MAIN_THREAD))
+    struct LoopCounter* loopCounter = Gearef(context, LoopCounter);
+    goto initDataGears(context, loopCounter, taskManager);
+#else
+    cuda_initialized = 0;
+    pthread_t thread;
+    pthread_create(&thread, NULL, (void*)&start_taskManager, context);
+    while (taskManager->taskManager == 0);
+    TaskManager *t = (TaskManager*)taskManager->taskManager;
+    TaskManagerImpl *im = (TaskManagerImpl*)t->taskManager;
+    struct Queue *q = (Queue *)im->workers[0];
+    createCUDAWorker(context,0,q, im);
+    pthread_join(thread,0);
+    exit(0);
+#endif
+}
+
+__code code1(struct Time* time) {
+    printf("cpus:\t\t%d\n", cpu_num);
+    printf("gpus:\t\t%d\n", gpu_num);
+    printf("length:\t\t%d\n", length);
+    printf("length/task:\t%d\n", length/split);
+    /* puts("queue"); */
+    /* print_queue(context->data[ActiveQueue]->queue.first); */
+    /* puts("tree"); */
+    /* print_tree(context->data[Tree]->tree.root); */
+    /* puts("result"); */
+
+    time->next = C_code2;
+    goto meta(context, C_code2);
+    //goto meta(context, C_exit_code);
+    //goto meta(context, C_start_time);
+}
+
+__code code1_stub(struct Context* context) {
+    goto code1(context, Gearef(context, Time));
+}
+
+__code code2(struct LoopCounter* loopCounter) {
+    int i = loopCounter->i;
+
+    if (i < length) {
+        //printf("%d\n", array_ptr[i]);
+        if (array_ptr[i] == (i*2)) {
+            loopCounter->i++;
+            goto meta(context, C_code2);
+        } else
+            puts("wrong result");
+
+    }
+
+    goto meta(context, C_exit_code);
+}
+
+__code createTask1(struct LoopCounter* loopCounter, struct TaskManager* taskManager) {
+    int i = loopCounter->i;
+
+    if ((length/split*i) < length) {
+        taskManager->next = C_createTask2;
+        goto meta(context, taskManager->taskManager->TaskManager.createTask);
+    }
+
+    loopCounter->i = 0;
+    taskManager->next = C_code1;
+    goto meta(context, taskManager->taskManager->TaskManager.shutdown);
+}
+
+__code createTask2(LoopCounter* loopCounter, TaskManager* taskManager, struct Context *task, Integer *integer1, Integer *integer2, Integer *integer3) {
+    int i = loopCounter->i;
+    loopCounter->i++;
+    task->idgCount = 0;
+    task->next = C_mult;
+    integer2->value = i+1;
+    task->data[task->idg] = (union Data*)integer1;
+    task->data[task->idg+1] = (union Data*)integer2;
+    task->maxIdg = task->idg + 2;
+    task->odg = task->maxIdg;
+    task->data[task->odg] = (union Data*)integer3;
+    task->maxOdg = task->odg + 1;
+    taskManager->next = C_createTask3;
+    taskManager->data = (union Data*)integer1;
+    goto meta(context, taskManager->taskManager->TaskManager.setWaitTask);
+}
+
+__code createTask2_stub(struct Context* context) {
+    Integer* integer1 = &ALLOCATE(context, Integer)->Integer;
+    Integer* integer2 = &ALLOCATE(context, Integer)->Integer;
+    Integer* integer3 = &ALLOCATE(context, Integer)->Integer;
+    goto createTask2(context,
+            Gearef(context, LoopCounter),
+            Gearef(context, TaskManager),
+            Gearef(context, TaskManager)->context,
+            integer1,
+            integer2,
+            integer3);
+}
+
+__code createTask3(TaskManager* taskManager) {
+    taskManager->next = C_createTask4;
+    goto meta(context, taskManager->taskManager->TaskManager.spawn);
+}
+
+__code createTask3_stub(struct Context* context) {
+    goto createTask3(context,
+            Gearef(context, TaskManager));
+}
+
+__code createTask4(struct TaskManager* taskManager) {
+    taskManager->next = C_createTask5;
+    goto meta(context, taskManager->taskManager->TaskManager.createTask);
+}
+
+__code createTask5(LoopCounter* loopCounter, TaskManager* taskManager, struct Context* task, Integer *integer1, Integer *integer2, Integer *integer3) {
+    int i = loopCounter->i;
+    task->next = C_add;
+    task->idgCount = 0;
+    integer1->value = i;
+    integer1->value = i+1;
+    task->data[task->idg] = (union Data*)integer1;
+    task->data[task->idg+1] = (union Data*)integer2;
+    task->maxIdg = task->idg + 2;
+    task->odg = task->maxIdg;
+    task->data[task->odg] = (union Data*)integer3;
+    task->maxOdg = task->odg + 1;
+    taskManager->next = C_createTask3;
+    taskManager->data = (union Data*)integer1;
+    goto meta(context, taskManager->taskManager->TaskManager.spawn);
+}
+
+__code createTask5_stub(struct Context* context) {
+    Integer* integer1 = &ALLOCATE(context, Integer)->Integer;
+    Integer* integer2 = &ALLOCATE(context, Integer)->Integer;
+    goto createTask5(context,
+            Gearef(context, LoopCounter),
+            Gearef(context, TaskManager),
+            Gearef(context, TaskManager)->context,
+            integer1,
+            integer2,
+            &Gearef(context, TaskManager)->data->Integer);
+}
+
+
+void init(int argc, char** argv) {
+    for (int i = 1; argv[i]; ++i) {
+        if (strcmp(argv[i], "-cpu") == 0)
+            cpu_num = (int)atoi(argv[i+1]);
+        else if (strcmp(argv[i], "-l") == 0)
+            length = (int)atoi(argv[i+1]);
+        else if (strcmp(argv[i], "-s") == 0)
+            split = (int)atoi(argv[i+1]);
+        else if (strcmp(argv[i], "-cuda") == 0) {
+            gpu_num = 1;
+            CPU_CUDA = 0;
+        }
+    }
+}
+
+
+int main(int argc, char** argv) {
+    init(argc, argv);
+
+    array_ptr = NEWN(length, int);
+
+    for(int i=0; i<length; i++)
+        array_ptr[i]=i;
+
+    struct Context* main_context = NEW(struct Context);
+    initContext(main_context);
+    main_context->next = C_initDataGears;
+
+    goto start_code(main_context);
+}
+
+__code add(struct Integer* input1, struct Integer* input2, struct Integer* output) { 
+    output->value = input1->value + input2->value; 
+    printf("%d + %d = %d\n", input1->value, input2->value, output->value); 
+    goto meta(context, context->next); 
+}
+
+__code add_stub(struct Context* context) { 
+    goto add(context, 
+            &context->data[context->idg]->Integer,
+            &context->data[context->idg + 1]->Integer,
+            &context->data[context->odg]->Integer);
+
+}
+
+__code mult(struct Integer* input1, struct Integer* input2, struct Integer* output) { 
+    output->value = input1->value * input2->value; 
+    printf("%d * %d = %d\n", input1->value, input2->value, output->value); 
+    goto meta(context, context->next);
+}
+
+__code mult_stub(struct Context* context) { 
+    goto add(context, 
+            &context->data[context->idg]->Integer,
+            &context->data[context->idg + 1]->Integer,
+            &context->data[context->odg]->Integer);
+
+}