title: Gears OS
author: Tatsuki IHA
profile:
lang: Japanese
code-engine: coderay

## 研究目的
- 当研究室では  処理の単位を Code Gear、 データの単位を Data Gear を用いて 信頼性が高い並列処理を行う Gears OS を開発している
- Gears OS では Task を Code Gear と実行するときに必要な Input Data Gear と出力するための Output Data Gear の組で表現される。 Input Data Gear/Output Data Gear によって依存関係が決定し、それにそって並列実行を行う
- 現在の Gears では Stack や Queue の operatation の API が存在しなため, 記述が困難になっている. そのため, この研究では Gears OS における API の記述方法を設計し, 実装する

## 今週
- rb_tree をとりあえず error はとりました
    - 動いてない
- Jenkins の update をしました 2.17 -> 2.26
    - yum で jenkins を入れてたので yum update jenkins で update できました

## StackInterface
- ``struct Stack`` は 実際の Stack の実装(StackSelf)と push, pop, isEmpty を設定

``` c
struct Stack {
    union StackSelf* stack;
    union Data* data;
    enum Code push;
    enum Code pop;
    enum Code isEmpty;
    enum Code next;
} stack;
union StackSelf {
    struct SingleLinkedStack {
        struct Stack i;
        struct Element* top;
    } singleLinekedStack;
    struct ArrayStack {
        int size;
        int limit;
        struct Element* array;
    } arrayStack;
};
```

## push continuation
- push を継続する際は ``stack->data`` を入れて ``stack->push`` を呼び出す

``` c
__code put(struct Context* context, struct Stack* nodeStack,  struct Tree* tree, struct Node* node, struct Traverse* traverse, struct Node* root, struct Node* newNode) {
    ....
        traverse->current = root;
        // traverse->result = traverse->compare(traverse->current, node);
        traverse->result = compare(traverse->current, node);
        *traverse->newNode = *traverse->current;
        nodeStack->data = (union Data*)newNode; // set push data
        nodeStack->next = Replace1;
        goto meta(context, nodeStack->push);
        // goto traverse->nodeStack->push(newNode, replaceNode1, traverse, node);
}
```

## compare function
- compare は コメントに沿って node 2つを取って, return する形にしました

``` c
void compare(struct Context* context, struct Traverse* traverse, int key1, int key2) {
    if (key1 == key2) {
        traverse->result = EQ;
    } else if (key1 < key2) {
        traverse->result = GT;
    } else {
        traverse->result = LT;
    }
}
```

``` c
enum Relational compare(struct Node* node1, struct Node* node2) {
    int key1 = node1->key;
    int key2 = node2->key;
    if (key1 == key2) {
        return EQ;
    } else if (key1 < key2) {
        return GT;
    } else {
        return LT;
    }
}
```

## pop operation
- まだ例の部分を書いてない
- `stack->data` に pop した値を入れる感じになりそう

``` c
__code popSingleLinkedStack(struct Context* context, struct SingleLinkedStack* stack, union Data* data, enum Code next) {
    data = stack->top->data;
    stack->top = stack->top->next;
    goto meta(context, next);
}

__code popSingleLinkedStack_stub(struct Context* context) {
    goto popSingleLinkedStack(context,
                               &context->data[Stack]->stack.stack,
                               context->data[Stack]->stack.data,
                               context->data[Stack]->stack.next);
}
```

## わかってない
- Stack 等の初期化をどこでやるか？
- 今のところ initContext に書いている
- でも create~~stack はあるから多分これを呼ぶ

``` c
__code createSingleLinkedStack(struct Context* context, enum Code next) {
    struct SingleLinkedStack* stack = allocate(context, SignleLinkedStack);
    stack->top = NULL;
    stack->i.push = PushSingleLinkedStack;
    stack->i.pop = PopsingleLinkedStack;
    stack->i.isEmpty = _;
    goto meta(context, next);
}
```