\chapter{Context、stub Code Segment の自動生成}

Gears OS では 3 章で述べたように通常の Computation の他に Context や stub などの Meta Computation を記述する必要がある。
Gears OS を現在の CbC の機能のみを用いて記述すると Context や stub Code Gear の記述を行わなくてはならず、これには多くの労力を要する。
そのため、この記述を助けるために Context を生成する generate\_context と stub Code Gear を生成する generate\_stub を perl スクリプトで作成した。

\section{stub Code Segment の生成}
stub Code Gear は Code Gear 間の継続に挟まれる Code Gear が必要な Data Gear を Context から取り出す処理を行うものである。
stub Code Gear は Code Gear 毎に記述する必要があり、そのCode Gear の引数を見て取り出す Data Gear を選択する。
stub Code Gear を 自動生成することによって Code Gear の記述量を約半分にすることができる。

stub を生成するために generate\_stub は指定された cbc ファイルの \_\_code型である Code Gear を取得し、引数から必要な Data Gear を選択する。
generate\_stub は引数と interface を照らし合わせ、Gearef または GearImpl を決定する。
この時既に stub Code Gear が記述されている Code Gear は無視される。

cbc ファイル(リスト\ref{stack_cbc}) から、生成した stub Code Gear を加えて c ファイル(\ref{stack_c})に変換を行う。

\begin{lstlisting}[frame=lrbt,label=stack_cbc,caption={\footnotesize cbcファイルの例}]
#include "../context.h"

Stack* createSingleLinkedStack(struct Context* context) {
    struct Stack* stack = new Stack();
    struct SingleLinkedStack* singleLinkedStack = new SingleLinkedStack();
    stack->stack = (union Data*)singleLinkedStack;
    singleLinkedStack->top = NULL;
    stack->push = C_pushSingleLinkedStack;
    stack->pop  = C_popSingleLinkedStack;
    stack->get  = C_getSingleLinkedStack;
    stack->isEmpty = C_isEmptySingleLinkedStack;
    stack->clear = C_clearSingleLinkedStack;
    return stack;
}

__code clearSingleLinkedStack(struct SingleLinkedStack* stack,__code next(...)) {
    stack->top = NULL;
    goto next(...);
}

__code pushSingleLinkedStack(struct SingleLinkedStack* stack,union Data* data, __code next(...)) {
    Element* element = new Element();
    element->next = stack->top;
    element->data = data;
    stack->top = element;
    goto next(...);
}

__code popSingleLinkedStack(struct SingleLinkedStack* stack, __code next(union Data* data, ...)) {
    if (stack->top) {
        data = stack->top->data;
        stack->top = stack->top->next;
    } else {
        data = NULL;
    }
    goto next(data, ...);
}

__code getSingleLinkedStack(struct SingleLinkedStack* stack, __code next(union Data* data, ...)) {
    if (stack->top)
        data = stack->top->data;
    else
        data = NULL;
    goto next(data, ...);
}

__code isEmptySingleLinkedStack(struct SingleLinkedStack* stack, __code next(...), __code whenEmpty(...)) {
    if (stack->top)
        goto next(...);
    else
        goto whenEmpty(...);
}
\end{lstlisting}

\begin{lstlisting}[frame=lrbt,label=stack_c,caption={\footnotesize 生成される stub}]
__code clearSingleLinkedStack(struct Context *context,struct SingleLinkedStack* stack,enum Code next) {
    stack->top = NULL;
    goto meta(context, next);
}

__code clearSingleLinkedStack_stub(struct Context* context) {
    SingleLinkedStack* stack = (SingleLinkedStack*)GearImpl(context, Stack, stack);
    enum Code next = Gearef(context, Stack)->next;
    goto clearSingleLinkedStack(context, stack, next);
} 
\end{lstlisting}

\section{Context の生成}
Context は Meta Data Gear に相当し、Code Gear や Data Gear を管理している。
Data Gear を取得するために generate\_context は context の定義 (リスト\ref{context}) を読み宣言されている Data Gear を取得する。
Code Gear は指定された cbc ファイルから stub を見て取得を行う。
取得した Code/Data Gear の enum の定義は enumCode.h、enumData.h に生成される。

Context では Code Gear の名前とポインタの対応は generate\_context によって生成される enum Code と関数ポインタによって表現される。
実際に Code Gear に接続する際は enum Code を指定することで接続を行う。

また、generate\_context は取得した Code/Data Gear から Context の生成を行うコード (リスト\ref{init_context}) も生成する。

Context には Allocation 等で生成した Data Gear へのポインタが格納されている。
Code Gear は Context を通して Data Gear へアクセスする。
Data Gear の Allocation を行うコードは dataGearInit.c に生成される。

Data Gear は union Data とその中の struct によって表現される。
Context には Data Gear の Data Type の情報が格納されている。
この情報から確保される Data Gear のサイズなどを決定する。

\begin{lstlisting}[frame=lrbt,label=context,caption={\footnotesize context の定義}]
#define ALLOCATE_SIZE 20000000
#define NEW(type) (type*)(calloc(1, sizeof(type)))
#define NEWN(n, type) (type*)(calloc(n, sizeof(type)))

#define ALLOC_DATA(context, dseg) ({\
    struct Meta* meta = (struct Meta*)context->heap;\
    meta->type = D_##dseg;\
    meta->size = 1;\
    context->heap += sizeof(struct Meta);\
    context->data[D_##dseg] = context->heap; context->heap += sizeof(struct dseg); (struct dseg *)context->data[D_##dseg]; })

#define ALLOCATE(context, t) ({ \
    struct Meta* meta = (struct Meta*)context->heap;\
    context->heap += sizeof(struct Meta);\
    union Data* data = context->heap; \
    context->heap += sizeof(struct t); \
    meta->type = D_##t; \
    meta->size = 1;     \
    data; })

#define Gearef(context, t) (&(context)->data[D_##t]->t)
#define GearImpl(context, intf, name) (Gearef(context, intf)->name->intf.name) 

#include "c/enumCode.h"

#include "c/enumData.h"

struct Context {
    enum Code next;
    struct Worker* worker;
    struct TaskManager* taskManager;
    int codeNum;
    __code (**code) (struct Context*);
    void* heapStart;
    void* heap;
    long heapLimit;
    int dataNum;
    int idgCount; //number of waiting dataGear
    int odg;
    int maxOdg;
    int workerId;
    union Data **data;
};

union Data {
    struct Meta {
        enum DataType type;
        long size;
        struct Queue* wait; // tasks waiting this dataGear
    } meta;
    struct Task {
        enum Code code;
        struct Queue* dataGears;
        int idsCount;
    } Task;
    // Stack Interface
    struct Stack {
        union Data* stack;
        union Data* data;
        union Data* data1;
        enum Code whenEmpty;
        enum Code clear;
        enum Code push;
        enum Code pop;
        enum Code isEmpty;
        enum Code get;
        enum Code next;
    } Stack;
    // Stack implementations
    struct SingleLinkedStack {
        struct Element* top;
    } SingleLinkedStack;
    struct Element {
        union Data* data;
        struct Element* next;
    } Element;
    struct Node {
        int key; // comparable data segment
        union Data* value;
        struct Node* left;
        struct Node* right;
        // need to balancing
        enum Color {
            Red,
            Black,
        } color;
    } Node;
}; // union Data end       this is necessary for context generator

\end{lstlisting}

\begin{lstlisting}[frame=lrbt,label=init_context,caption={\footnotesize 生成された context}]

#include <stdlib.h>

#include "../context.h"

void initContext(struct Context* context) {
    context->heapLimit = sizeof(union Data)*ALLOCATE_SIZE;
    context->code = (__code(**) (struct Context*)) NEWN(ALLOCATE_SIZE, void*);
    context->data = NEWN(ALLOCATE_SIZE, union Data*);
    context->heapStart = NEWN(context->heapLimit, char);
    context->heap = context->heapStart;

    context->code[C_clearSingleLinkedStack]    = clearSingleLinkedStack_stub;
    context->code[C_exit_code]    = exit_code_stub;
    context->code[C_getSingleLinkedStack]    = getSingleLinkedStack_stub;
    context->code[C_isEmptySingleLinkedStack]    = isEmptySingleLinkedStack_stub;
    context->code[C_popSingleLinkedStack]    = popSingleLinkedStack_stub;
    context->code[C_pushSingleLinkedStack]    = pushSingleLinkedStack_stub;
    context->code[C_stack_test1]    = stack_test1_stub;
    context->code[C_stack_test2]    = stack_test2_stub;
    context->code[C_stack_test3]    = stack_test3_stub;
    context->code[C_stack_test4]    = stack_test4_stub;
    context->code[C_start_code]    = start_code_stub;

#include "dataGearInit.c"

}

__code meta(struct Context* context, enum Code next) {
    // printf("meta %d\n",next);
    goto (context->code[next])(context);
}

__code start_code(struct Context* context) {
    goto meta(context, context->next);
}

__code start_code_stub(struct Context* context) {
    goto start_code(context);
}

__code exit_code(struct Context* context) {
    free(context->code);
    free(context->data);
    free(context->heapStart);
    goto exit(0);
}

__code exit_code_stub(struct Context* context) {
    goto exit_code(context);
}    

// end context_c
\end{lstlisting}
%enum で Code Gear と Data Gear
%Data Gear の typedef
%stub の extern
%Data Gear の init (ALLOCA)
%target 毎の init context