\chapter{Continuation based C (CbC)}
\label{chapter:CbC}
CbC では関数ではなく code segment を処理の単位とする. code segment は入力と出力を持ち, CbC では引数が入出力となっている. code segment は次の code segment への遷移で処理を終え, 引数として出力を与える. CbC は C との行き来に環境付き継続を使用する.

\section{CbC における Code Segment}
code segment は CbC における最も基本的な処理単位である. リスト \ref{code_simple} は最も基本的な CbC のコードの一例で, 図 \ref {fig:code_simple}はそれを図示したものである. 
code segment の宣言は C の関数の構文と同じように行い, 型に \_\_code を用いる. ただし, これは \_\_code 型の戻り値を返すという意味ではない. \_\_code はそれが関数ではなく code segment であることを示すフラグのようなものである. 

現在の code segment から次の code segment への処理の移動は goto の後に code segment 名と引数を並べて記述する リスト \ref{code_simple} の goto cs1(a+b); などがこれにたる. これを軽量継続と呼び, このときの a+b が次のコードセグメントへの出力と成る.

通常 Secheme の call/cc 等の継続はトップレベルから現在の位置までの位置を環境として保持する. ここで環境は現在のスタックの状態のことを指す.
CbC の軽量継続は呼び出し元の環境を持たない. つまりスタックの情報を破棄して処理を続けていくのである.

リスト \ref{code_simple} の場合, cs0 は cs1 に継続すると cs0 の環境は破棄されてしまうため, cs0 に戻ることは出来ない. 
\begin{lstlisting}[frame=lrbt,label=code_simple,caption={\footnotesize code segment の軽量継続}]
__code cs0(int a, int b){
  goto cs1(a+b);
}

__code cs1(int c){
  goto cs2(c);
}
\end{lstlisting}

\begin{figure}[htpb]
 \begin{center}
  \scalebox{0.55}{\includegraphics{fig/codesegment.pdf}}
 \end{center}
 \caption{code segment の軽量継続}
 \label{fig:code_simple}
\end{figure}


もう少し複雑な CbC のプログラムの例が以下のリスト \ref{factorial} である. これは与えられた数値の階乗を算出するプログラムである. このコードの factorial0 という code segment に注目すると, 条件判別を行い, その結果に応じて自分自身への再帰的な継続を行うか別の code segment への継続を行うかという処理を行っていることがわかる. CbC ではこのようにしてループ処理を制御する.

\begin{lstlisting}[frame=lrbt,label=factorial,caption={\footnotesize 階乗を求める CbC プログラムの例}]
__code print_factorial(int prod)
{
  printf("factorial = %d\n",prod);
  exit(0);
}

__code factorial0(int prod, int x)
{
  if ( x >= 1) {
    goto factorial0(prod*x, x-1);
  }else{
    goto print_factorial(prod);
  }
  
}

__code factorial(int x)
{
  goto factorial0(1, x);
}

int main(int argc, char **argv)
{
  int i;
  i = atoi(argv[1]);
  
  goto factorial(i);
}
\end{lstlisting}

\begin{figure}[htpb]
 \begin{center}
  \scalebox{0.55}{\includegraphics{fig/factorial.pdf}}
 \end{center}
 \caption{階乗を求める CbC プログラムの軽量継続図}
 \label{fig:factorial}
\end{figure}

\section{環境付き継続}
\label{sec:withEnv}
環境付き継続は C との互換性のために必要な機能である. CbC と C の記述を交える際, CbC の code segment から C の関数の呼び出しは問題なく行える. しかし, C の関数から CbC の code segment へと継続する場合, 呼び出し元の環境に戻るための特殊な継続が必要となる. これを環境付き継続と呼ぶ.

環境付き継続を用いる場合, C の関数から code segment へ継続する際に \_\_return, \_\_environment という変数を渡す. \_\_return は \_\_code (*)(return\_type, void*) 型の変数で環境付き継続先が元の環境に戻る際に利用する code segmentを表す. \_\_environment は void** 型の変数で元の関数の環境を表す. リスト\ref{gotoWithTheEnv}では関数 funcB から code segment cs に継続する際に環境付き継続を利用している. cs は funcB から渡された code segment へ継続することで元の C の環境に復帰することが可能となる. 但し復帰先は \_\_return を渡した関数が終了する位置である. このプログラムの例では, 関数 funcA は戻り値として funcB の終わりにある -1 ではなく, 環境付き継続によって渡される 1 を受け取る. 図\ref{fig:gotoWithTheEnv}にこの様子を表した.

\begin{lstlisting}[frame=lrbt,label=gotoWithTheEnv,caption={環境付き継続}]
__code cs(__code (*ret)(int, void*), void *env){
  /* C0 */
  goto ret(1, env);
}

int funcB(){
  /* B0 */
  goto cs(__return, __environment);
  /* B1 (never reached). */
  return -1;
}

int funcA(){
  /* A0 */
  int retval;
  retval = funcB();
  /* A1 */
  printf("retval = %d\n", retval);
  /* retval should not be -1 but be 1. */
  return 0;
}

\end{lstlisting}

\begin{figure}[htpb]
 \begin{center}
  \scalebox{0.55}{\includegraphics{fig/gotowithenv.pdf}}
 \end{center}
 \caption{環境付き継続}
 \label{fig:gotoWithTheEnv}
\end{figure}


このように, 環境付き継続を用いることで C, CbC 間の処理の移動が可能になる.

\section{Gears OS サポート}
\label{sec:Gears}
Gears OS は当研究室で開発している並列フレームワークで, CbC で記述している. Gears では通常の CbC には存在しない meta code segment, data segment, context 等を用いる. meta code segment は meta computation を行う code segment で, メモリの確保やネットワーク管理等が meta computation にあたる. data segment はデータの単位であり, code segment の入出力になる. context は meta data segment に相当し, code segment や data segment を管理している.

また meta computation を用いる場合, code segment から code segment への軽量継続の間に meta code segment によって meta computation が行われる. これを図示したのが図 \ref{fig:metaCS} である.

\begin{figure}[htpb]
 \begin{center}
  \scalebox{0.55}{\includegraphics{fig/metaCS.pdf}}
 \end{center}
 \caption{meta computation}
 \label{fig:metaCS}
\end{figure}

これらを現在の CbC の機能のみを用いて記述するとリスト\ref{gears}のようになり, 多くの労力を要する. そのためにこの記述を助ける機能を実装する必要があり, 本研究では以下の機能を提案した.

\begin{itemize}
\item code segment から meta code segment への自動接続
\item 継続時に context から必要な情報を取得する stub の自動生成
\item code segment 内での context の隠蔽
\end{itemize}

\begin{lstlisting}[frame=lrbt,label=gears,caption={Gears OS コード例}]
__code meta(struct Context* context, enum Code next) {
  goto (context->code[next])(context);
}

__code code1_stub(struct Context* context) {
  goto code1(context, &context->data[Allocate]->allocate);
}

__code code1(struct Context* context, struct Allocate* allocate) {
  allocate->size = sizeof(long);
  allocator(context);
  goto meta(context, Code2);
}


__code code2(struct Context* context, long* count) {
  *count = 0;
  goto meta(context, Code3);
}

__code code2_stub(struct Context* context) {
  goto code2(context, &context->data[Count]->count);
}
\end{lstlisting}