|
5
|
1 \chapter{Context、stub Code Segment の自動生成}
|
|
|
2
|
|
|
3 Gears OS では 3 章で述べたように通常の Computation の他に Context や stub などの Meta Computation を記述する必要がある。
|
|
|
4 Gears OS を現在の CbC の機能のみを用いて記述すると Context や stub Code Gear の記述を行わなくてはならず、これには多くの労力を要する。
|
|
9
|
5 そのため、この記述を助けるために Context を生成する generate\_context と stub Code Gear を生成する generate\_stub を perl スクリプトで作成した。
|
|
5
|
6
|
|
|
7 \section{stub Code Segment の生成}
|
|
|
8 stub Code Gear は Code Gear 間の継続に挟まれる Code Gear が必要な Data Gear を Context から取り出す処理を行うものである。
|
|
|
9 stub Code Gear は Code Gear 毎に記述する必要があり、そのCode Gear の引数を見て取り出す Data Gear を選択する。
|
|
|
10 stub Code Gear を 自動生成することによって Code Gear の記述量を約半分にすることができる。
|
|
|
11
|
|
9
|
12 stub を生成するために generate\_stub は指定された cbc ファイルの \_\_code型である Code Gear を取得し、引数から必要な Data Gear を選択する。
|
|
|
13 generate\_stub は引数と interface を照らし合わせ、Gearef または GearImpl を決定する。
|
|
8
|
14 この時既に stub Code Gear が記述されている Code Gear は無視される。
|
|
5
|
15
|
|
9
|
16 cbc ファイル(リスト\ref{stack_cbc}) から、生成した stub Code Gear を加えて c ファイル(\ref{stack_c})に変換を行う。
|
|
6
|
17
|
|
9
|
18 \begin{lstlisting}[frame=lrbt,label=stack_cbc,caption={\footnotesize cbcファイルの例}]
|
|
5
|
19 #include "../context.h"
|
|
|
20
|
|
|
21 Stack* createSingleLinkedStack(struct Context* context) {
|
|
|
22 struct Stack* stack = new Stack();
|
|
|
23 struct SingleLinkedStack* singleLinkedStack = new SingleLinkedStack();
|
|
|
24 stack->stack = (union Data*)singleLinkedStack;
|
|
|
25 singleLinkedStack->top = NULL;
|
|
|
26 stack->push = C_pushSingleLinkedStack;
|
|
|
27 stack->pop = C_popSingleLinkedStack;
|
|
|
28 stack->get = C_getSingleLinkedStack;
|
|
|
29 stack->isEmpty = C_isEmptySingleLinkedStack;
|
|
|
30 stack->clear = C_clearSingleLinkedStack;
|
|
|
31 return stack;
|
|
|
32 }
|
|
|
33
|
|
|
34 __code clearSingleLinkedStack(struct SingleLinkedStack* stack,__code next(...)) {
|
|
|
35 stack->top = NULL;
|
|
|
36 goto next(...);
|
|
|
37 }
|
|
|
38
|
|
|
39 __code pushSingleLinkedStack(struct SingleLinkedStack* stack,union Data* data, __code next(...)) {
|
|
|
40 Element* element = new Element();
|
|
|
41 element->next = stack->top;
|
|
|
42 element->data = data;
|
|
|
43 stack->top = element;
|
|
|
44 goto next(...);
|
|
|
45 }
|
|
|
46
|
|
|
47 __code popSingleLinkedStack(struct SingleLinkedStack* stack, __code next(union Data* data, ...)) {
|
|
|
48 if (stack->top) {
|
|
|
49 data = stack->top->data;
|
|
|
50 stack->top = stack->top->next;
|
|
|
51 } else {
|
|
|
52 data = NULL;
|
|
|
53 }
|
|
|
54 goto next(data, ...);
|
|
|
55 }
|
|
|
56
|
|
|
57 __code getSingleLinkedStack(struct SingleLinkedStack* stack, __code next(union Data* data, ...)) {
|
|
|
58 if (stack->top)
|
|
|
59 data = stack->top->data;
|
|
|
60 else
|
|
|
61 data = NULL;
|
|
|
62 goto next(data, ...);
|
|
|
63 }
|
|
|
64
|
|
|
65 __code isEmptySingleLinkedStack(struct SingleLinkedStack* stack, __code next(...), __code whenEmpty(...)) {
|
|
|
66 if (stack->top)
|
|
|
67 goto next(...);
|
|
|
68 else
|
|
|
69 goto whenEmpty(...);
|
|
|
70 }
|
|
|
71 \end{lstlisting}
|
|
|
72
|
|
7
|
73 \begin{lstlisting}[frame=lrbt,label=stack_c,caption={\footnotesize 生成される stub}]
|
|
5
|
74 __code clearSingleLinkedStack(struct Context *context,struct SingleLinkedStack* stack,enum Code next) {
|
|
|
75 stack->top = NULL;
|
|
|
76 goto meta(context, next);
|
|
|
77 }
|
|
|
78
|
|
|
79 __code clearSingleLinkedStack_stub(struct Context* context) {
|
|
|
80 SingleLinkedStack* stack = (SingleLinkedStack*)GearImpl(context, Stack, stack);
|
|
|
81 enum Code next = Gearef(context, Stack)->next;
|
|
|
82 goto clearSingleLinkedStack(context, stack, next);
|
|
|
83 }
|
|
|
84 \end{lstlisting}
|
|
2
|
85
|
|
|
86 \section{Context の生成}
|
|
|
87 Context は Meta Data Gear に相当し、Code Gear や Data Gear を管理している。
|
|
9
|
88 Data Gear を取得するために generate\_context は context の定義 (リスト\ref{context}) を読み宣言されている Data Gear を取得する。
|
|
2
|
89 Code Gear は指定された cbc ファイルから stub を見て取得を行う。
|
|
9
|
90 取得した Code/Data Gear の enum の定義は enumCode.h、enumData.h に生成される。
|
|
2
|
91
|
|
9
|
92 Context では Code Gear の名前とポインタの対応は generate\_context によって生成される enum Code と関数ポインタによって表現される。
|
|
2
|
93 実際に Code Gear に接続する際は enum Code を指定することで接続を行う。
|
|
9
|
94
|
|
|
95 また、generate\_context は取得した Code/Data Gear から Context の生成を行うコード (リスト\ref{init_context}) も生成する。
|
|
2
|
96
|
|
4
|
97 Context には Allocation 等で生成した Data Gear へのポインタが格納されている。
|
|
|
98 Code Gear は Context を通して Data Gear へアクセスする。
|
|
|
99 Data Gear の Allocation を行うコードは dataGearInit.c に生成される。
|
|
2
|
100
|
|
4
|
101 Data Gear は union Data とその中の struct によって表現される。
|
|
|
102 Context には Data Gear の Data Type の情報が格納されている。
|
|
|
103 この情報から確保される Data Gear のサイズなどを決定する。
|
|
|
104
|
|
|
105 \begin{lstlisting}[frame=lrbt,label=context,caption={\footnotesize context の定義}]
|
|
|
106 #define ALLOCATE_SIZE 20000000
|
|
|
107 #define NEW(type) (type*)(calloc(1, sizeof(type)))
|
|
|
108 #define NEWN(n, type) (type*)(calloc(n, sizeof(type)))
|
|
|
109
|
|
|
110 #define ALLOC_DATA(context, dseg) ({\
|
|
|
111 struct Meta* meta = (struct Meta*)context->heap;\
|
|
|
112 meta->type = D_##dseg;\
|
|
|
113 meta->size = 1;\
|
|
|
114 context->heap += sizeof(struct Meta);\
|
|
|
115 context->data[D_##dseg] = context->heap; context->heap += sizeof(struct dseg); (struct dseg *)context->data[D_##dseg]; })
|
|
|
116
|
|
|
117 #define ALLOCATE(context, t) ({ \
|
|
|
118 struct Meta* meta = (struct Meta*)context->heap;\
|
|
|
119 context->heap += sizeof(struct Meta);\
|
|
|
120 union Data* data = context->heap; \
|
|
|
121 context->heap += sizeof(struct t); \
|
|
|
122 meta->type = D_##t; \
|
|
|
123 meta->size = 1; \
|
|
|
124 data; })
|
|
|
125
|
|
|
126 #define Gearef(context, t) (&(context)->data[D_##t]->t)
|
|
|
127 #define GearImpl(context, intf, name) (Gearef(context, intf)->name->intf.name)
|
|
|
128
|
|
|
129 #include "c/enumCode.h"
|
|
|
130
|
|
|
131 #include "c/enumData.h"
|
|
|
132
|
|
|
133 struct Context {
|
|
|
134 enum Code next;
|
|
|
135 struct Worker* worker;
|
|
|
136 struct TaskManager* taskManager;
|
|
|
137 int codeNum;
|
|
|
138 __code (**code) (struct Context*);
|
|
|
139 void* heapStart;
|
|
|
140 void* heap;
|
|
|
141 long heapLimit;
|
|
|
142 int dataNum;
|
|
|
143 int idgCount; //number of waiting dataGear
|
|
|
144 int odg;
|
|
|
145 int maxOdg;
|
|
|
146 int workerId;
|
|
|
147 union Data **data;
|
|
|
148 };
|
|
|
149
|
|
|
150 union Data {
|
|
|
151 struct Meta {
|
|
|
152 enum DataType type;
|
|
|
153 long size;
|
|
|
154 struct Queue* wait; // tasks waiting this dataGear
|
|
|
155 } meta;
|
|
|
156 struct Task {
|
|
|
157 enum Code code;
|
|
|
158 struct Queue* dataGears;
|
|
|
159 int idsCount;
|
|
|
160 } Task;
|
|
|
161 // Stack Interface
|
|
|
162 struct Stack {
|
|
|
163 union Data* stack;
|
|
|
164 union Data* data;
|
|
|
165 union Data* data1;
|
|
|
166 enum Code whenEmpty;
|
|
|
167 enum Code clear;
|
|
|
168 enum Code push;
|
|
|
169 enum Code pop;
|
|
|
170 enum Code isEmpty;
|
|
|
171 enum Code get;
|
|
|
172 enum Code next;
|
|
|
173 } Stack;
|
|
|
174 // Stack implementations
|
|
|
175 struct SingleLinkedStack {
|
|
|
176 struct Element* top;
|
|
|
177 } SingleLinkedStack;
|
|
|
178 struct Element {
|
|
|
179 union Data* data;
|
|
|
180 struct Element* next;
|
|
|
181 } Element;
|
|
|
182 struct Node {
|
|
|
183 int key; // comparable data segment
|
|
|
184 union Data* value;
|
|
|
185 struct Node* left;
|
|
|
186 struct Node* right;
|
|
|
187 // need to balancing
|
|
|
188 enum Color {
|
|
|
189 Red,
|
|
|
190 Black,
|
|
|
191 } color;
|
|
|
192 } Node;
|
|
|
193 }; // union Data end this is necessary for context generator
|
|
|
194
|
|
|
195 \end{lstlisting}
|
|
|
196
|
|
|
197 \begin{lstlisting}[frame=lrbt,label=init_context,caption={\footnotesize 生成された context}]
|
|
|
198
|
|
|
199 #include <stdlib.h>
|
|
|
200
|
|
|
201 #include "../context.h"
|
|
|
202
|
|
|
203 void initContext(struct Context* context) {
|
|
|
204 context->heapLimit = sizeof(union Data)*ALLOCATE_SIZE;
|
|
|
205 context->code = (__code(**) (struct Context*)) NEWN(ALLOCATE_SIZE, void*);
|
|
|
206 context->data = NEWN(ALLOCATE_SIZE, union Data*);
|
|
|
207 context->heapStart = NEWN(context->heapLimit, char);
|
|
|
208 context->heap = context->heapStart;
|
|
|
209
|
|
|
210 context->code[C_clearSingleLinkedStack] = clearSingleLinkedStack_stub;
|
|
|
211 context->code[C_exit_code] = exit_code_stub;
|
|
|
212 context->code[C_getSingleLinkedStack] = getSingleLinkedStack_stub;
|
|
|
213 context->code[C_isEmptySingleLinkedStack] = isEmptySingleLinkedStack_stub;
|
|
|
214 context->code[C_popSingleLinkedStack] = popSingleLinkedStack_stub;
|
|
|
215 context->code[C_pushSingleLinkedStack] = pushSingleLinkedStack_stub;
|
|
|
216 context->code[C_stack_test1] = stack_test1_stub;
|
|
|
217 context->code[C_stack_test2] = stack_test2_stub;
|
|
|
218 context->code[C_stack_test3] = stack_test3_stub;
|
|
|
219 context->code[C_stack_test4] = stack_test4_stub;
|
|
|
220 context->code[C_start_code] = start_code_stub;
|
|
|
221
|
|
|
222 #include "dataGearInit.c"
|
|
|
223
|
|
|
224 }
|
|
|
225
|
|
|
226 __code meta(struct Context* context, enum Code next) {
|
|
|
227 // printf("meta %d\n",next);
|
|
|
228 goto (context->code[next])(context);
|
|
|
229 }
|
|
|
230
|
|
|
231 __code start_code(struct Context* context) {
|
|
|
232 goto meta(context, context->next);
|
|
|
233 }
|
|
|
234
|
|
|
235 __code start_code_stub(struct Context* context) {
|
|
|
236 goto start_code(context);
|
|
|
237 }
|
|
|
238
|
|
|
239 __code exit_code(struct Context* context) {
|
|
|
240 free(context->code);
|
|
|
241 free(context->data);
|
|
|
242 free(context->heapStart);
|
|
|
243 goto exit(0);
|
|
|
244 }
|
|
|
245
|
|
|
246 __code exit_code_stub(struct Context* context) {
|
|
|
247 goto exit_code(context);
|
|
|
248 }
|
|
|
249
|
|
|
250 // end context_c
|
|
|
251 \end{lstlisting}
|
|
2
|
252 %enum で Code Gear と Data Gear
|
|
|
253 %Data Gear の typedef
|
|
|
254 %stub の extern
|
|
|
255 %Data Gear の init (ALLOCA)
|
|
|
256 %target 毎の init context
|
|
|
257
|
|
|
258
|
