|
178
|
1 #include "context.h"
|
|
|
2 #include "stack.h"
|
|
|
3 #include "origin_cs.h"
|
|
|
4 #include <stdio.h>
|
|
|
5
|
|
|
6 union Data* createTaskManager(struct Context* context) {
|
|
|
7 struct TaskManager* taskManager = &ALLOCATE(context, TaskManager)->taskManager;
|
|
|
8 struct TaskManager* taskManagerImpl = &ALLOCATE(context, TaskManagerImpl)->taskManagerImpl;
|
|
|
9
|
|
|
10 taskManager->taskManager = (union Data*)taskManager;
|
|
|
11 taskManagerImpl->top = NULL;
|
|
|
12 taskManager->spawn = C_spawnTaskManager;
|
|
|
13 taskManager->shutdown = C_shutdownTaskManager;
|
|
|
14 return (union Data*)(taskManager);
|
|
|
15 }
|
|
|
16
|
|
|
17 void printStack1(union Data* data) {
|
|
|
18 struct Node* node = &data->element.data->node;
|
|
|
19 if (node == NULL) {
|
|
|
20 printf("NULL");
|
|
|
21 } else {
|
|
|
22 printf("key = %d ,", node->key);
|
|
|
23 printStack1((union Data*)data->element.next);
|
|
|
24 }
|
|
|
25 }
|
|
|
26
|
|
|
27 void printStack(union Data* data) {
|
|
|
28 printStack1(data);
|
|
|
29 printf("\n");
|
|
|
30 }
|
|
|
31
|
|
|
32 __code spawnTaskManager(struct Context* context, struct Task* task, struct Element* element, struct Queue* queue, struct Queue* activeQueue, struct Queue* waitQueue) {
|
|
|
33 if (task->idsCount == 0) {
|
|
|
34 // enqueue activeQueue
|
|
|
35 queue->queue = (union Data*)activeQueue;
|
|
|
36 } else {
|
|
|
37 // enqueue waitQueue
|
|
|
38 queue->queue = (union Data*)waitQueue;
|
|
|
39 }
|
|
|
40 queue->data = element->data;
|
|
|
41 queue->next = context->next;
|
|
|
42 goto meta(context, queue->queue->put);
|
|
|
43 }
|
|
|
44
|
|
|
45 __code spawnTaskManager_stub(struct Context* context) {
|
|
|
46 goto spawnTask(context,
|
|
|
47 context->data[D_Element]->element.data,
|
|
|
48 &context->data[D_Element]->element,
|
|
|
49 &context->data[D_ActiveQueue]->Queue,
|
|
|
50 &context->data[D_WaitQueue]->Queue);
|
|
|
51 }
|
|
|
52
|
|
|
53 __code taskManager(struct Context* context, struct LoopCounter* loopCounter, struct Worker* worker) {
|
|
|
54 int i = loopCounter->i;
|
|
|
55
|
|
|
56 if (i < worker->num) {
|
|
|
57 pthread_join(worker->contexts[i].thread, NULL);
|
|
|
58 loopCounter->i++;
|
|
|
59
|
|
|
60 goto meta(context, TaskManager);
|
|
|
61 }
|
|
|
62
|
|
|
63 loopCounter->i = 0;
|
|
|
64
|
|
|
65 Time *t = &context->data[D_Time]->Time;
|
|
|
66 t->next = C_code2;
|
|
|
67 goto meta(context, EndTime);
|
|
|
68 }
|
|
|
69
|
|
|
70 __code taskManager_stub(struct Context* context) {
|
|
|
71 goto taskManager(context, &context->data[D_LoopCounter]->loopCounter, &context->data[D_Worker]->worker);
|
|
|
72 }
|
|
|
73
|
|
|
74 __code clearTaskManager(struct Context* context, struct SingleLinkedStack* stack,enum Code next) {
|
|
|
75 stack->top = NULL;
|
|
|
76 goto meta(context, next);
|
|
|
77 }
|
|
|
78
|
|
|
79 __code clearTaskManager_stub(struct Context* context) {
|
|
|
80 goto clearTaskManager(context, (struct SingleLinkedStack *)context->data[D_Stack]->stack.stack->stack.stack, context->data[D_Stack]->stack.next);
|
|
|
81 }
|
|
|
82
|
|
|
83 __code pushTaskManager(struct Context* context, struct SingleLinkedStack* stack, struct Element* element, union Data* data, enum Code next) {
|
|
|
84 element->next = stack->top;
|
|
|
85 element->data = data;
|
|
|
86 stack->top = element;
|
|
|
87 goto meta(context, next);
|
|
|
88 }
|
|
|
89
|
|
|
90 __code pushTaskManager_stub(struct Context* context) {
|
|
|
91 struct Element* element = &ALLOCATE(context, Element)->element;
|
|
|
92 goto pushTaskManager(context,
|
|
|
93 (struct TaskManager *)context->data[D_Stack]->stack.stack->stack.stack,
|
|
|
94 element,
|
|
|
95 context->data[D_Stack]->stack.data,
|
|
|
96 context->data[D_Stack]->stack.next);
|
|
|
97 }
|
|
|
98
|
|
|
99 __code popTaskManager(struct Context* context, struct SingleLinkedStack* stack, union Data** data, enum Code next) {
|
|
|
100 if (stack->top) {
|
|
|
101 *data = stack->top->data;
|
|
|
102 stack->top = stack->top->next;
|
|
|
103 } else {
|
|
|
104 *data = NULL;
|
|
|
105 }
|
|
|
106 goto meta(context, next);
|
|
|
107 }
|
|
|
108
|
|
|
109 __code popTaskManager_stub(struct Context* context) {
|
|
|
110 goto popTaskManager(context,
|
|
|
111 (struct TaskManager *)context->data[D_Stack]->stack.stack->stack.stack,
|
|
|
112 &context->data[D_Stack]->stack.data,
|
|
|
113 context->data[D_Stack]->stack.next);
|
|
|
114 }
|
|
|
115
|
|
|
116 __code pop2TaskManager(struct Context* context, struct SingleLinkedStack* stack, union Data** data, union Data** data1, enum Code next) {
|
|
|
117 if (stack->top) {
|
|
|
118 *data = stack->top->data;
|
|
|
119 stack->top = stack->top->next;
|
|
|
120 } else {
|
|
|
121 *data = NULL;
|
|
|
122 }
|
|
|
123 if (stack->top) {
|
|
|
124 *data1 = stack->top->data;
|
|
|
125 stack->top = stack->top->next;
|
|
|
126 } else {
|
|
|
127 *data1 = NULL;
|
|
|
128 }
|
|
|
129 goto meta(context, next);
|
|
|
130 }
|
|
|
131
|
|
|
132 __code pop2TaskManager_stub(struct Context* context) {
|
|
|
133 goto pop2TaskManager(context,
|
|
|
134 (struct TaskManager *)context->data[D_Stack]->stack.stack->stack.stack,
|
|
|
135 &context->data[D_Stack]->stack.data,
|
|
|
136 &context->data[D_Stack]->stack.data1,
|
|
|
137 context->data[D_Stack]->stack.next);
|
|
|
138 }
|
|
|
139
|
|
|
140 __code getTaskManager(struct Context* context, struct SingleLinkedStack* stack, union Data** data, enum Code next) {
|
|
|
141 if (stack->top)
|
|
|
142 *data = stack->top->data;
|
|
|
143 else
|
|
|
144 *data = NULL;
|
|
|
145 goto meta(context, next);
|
|
|
146 }
|
|
|
147
|
|
|
148 __code getTaskManager_stub(struct Context* context) {
|
|
|
149 goto getTaskManager(context,
|
|
|
150 (struct TaskManager *)context->data[D_Stack]->stack.stack->stack.stack,
|
|
|
151 &context->data[D_Stack]->stack.data,
|
|
|
152 context->data[D_Stack]->stack.next);
|
|
|
153 }
|
|
|
154
|
|
|
155 __code get2TaskManager(struct Context* context, struct SingleLinkedStack* stack, union Data** data, union Data** data1, enum Code next) {
|
|
|
156 if (stack->top) {
|
|
|
157 *data = stack->top->data;
|
|
|
158 if (stack->top->next) {
|
|
|
159 *data1 = stack->top->next->data;
|
|
|
160 } else {
|
|
|
161 *data1 = NULL;
|
|
|
162 }
|
|
|
163 } else {
|
|
|
164 *data = NULL;
|
|
|
165 *data1 = NULL;
|
|
|
166 }
|
|
|
167 goto meta(context, next);
|
|
|
168 }
|
|
|
169
|
|
|
170 __code get2TaskManager_stub(struct Context* context) {
|
|
|
171 goto get2TaskManager(context,
|
|
|
172 (struct TaskManager *)context->data[D_Stack]->stack.stack->stack.stack,
|
|
|
173 &context->data[D_Stack]->stack.data,
|
|
|
174 &context->data[D_Stack]->stack.data1,
|
|
|
175 context->data[D_Stack]->stack.next);
|
|
|
176 }
|
|
|
177
|
|
|
178 __code isEmptyTaskManager(struct Context* context, struct SingleLinkedStack* stack, enum Code next,enum Code whenEmpty) {
|
|
|
179 if (stack->top)
|
|
|
180 goto meta(context, next);
|
|
|
181 else
|
|
|
182 goto meta(context, whenEmpty);
|
|
|
183 }
|
|
|
184
|
|
|
185 __code isEmptyTaskManager_stub(struct Context* context) {
|
|
|
186 goto isEmptyTaskManager(context,
|
|
|
187 (struct TaskManager *)context->data[D_Stack]->stack.stack->stack.stack,
|
|
|
188 context->data[D_Stack]->stack.next,
|
|
|
189 context->data[D_Stack]->stack.whenEmpty);
|
|
|
190 }
|
|
|
191
|
