Papers/2015/kaito-lola: cfopm.tex comparison

comparison cfopm.tex @ 1:97e85476344e

fix typos

author	Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date	Tue, 02 Jun 2015 18:30:29 +0900
parents	c0d36568602d
children	771136eae970

comparison

equal deleted inserted replaced

-:c0d36568602d
+:97e85476344e
 Data segment is a set of typed data.
 Code segments are connected to data segments with a context, which is a meta data segment.
 After an execution of a code segment and its context, next code segments (Continuation) is executed.
 We had developed a programming language ``Continuation based C (CbC)'' \cite{DBLP:journals/corr/abs-1109-4048}.
-Hear after we call it CbC, which supports code segments.
+Hearafter we call it CbC, which supports code segments.
-CbC is compatible with C language and it has continuation as a goto statement.
+CbC is compatible with the C language and it has continuation as a goto statement.
 Code segments and data segments are low level enough to represent computation details,
 and it is architecture independent.
 It can be used as an architecture independent assembler.
 CbC has standalone compiler and GCC version. Here we report new partial implementation of CbC compiler based on LLVM and Clang 3.7.
-First we show CbC language overview.
+First we show the CbC language overview.
 \section{Continuation based C}
 CbC's basic programing unit is a code segment. It is not a subroutine, but it looks like a function, because it has input and output. These interfaces should be data segments and we are currently designing data segments part.
 \begin{table}[html]
 \begin{lstlisting}
 \end{lstlisting}
 \caption{CbC Example}
 \label{src:example}
 \end{table}
-In this example, a code segment {\bf f} has input datasegment {\bf allocate} (Allocate is a data segment identifier) and sends output it to a code segmnet {\bf g}. CbC compiler generates data segment definition automatically so we do not have to write it. There is no return from code segment {\bf g}, {\bf g} should call another continuation using {\bf goto}. Code segments has one input data segment and several output data segment, and their dependency is proved by data segments.
+In this example, a code segment {\bf f} has input datasegment {\bf allocate} (Allocate is a data segment identifier) and sends output it to a code segment {\bf g}. CbC compiler generates data segment definition automatically so we do not have to write it. There is no return from code segment {\bf g}, {\bf g} should call another continuation using {\bf goto}. Code segments has one input data segment and several output data segment, and their dependency is proved by data segments.
 \begin{figure}[htp]
 \begin{center}
 \scalebox{0.5}{\includegraphics{fig/csds.pdf}}
 \end{center}
-\caption{Code Segmnets and Data Segments on CbC}
+\caption{Code Segments and Data Segments on CbC}
 \label{fig:csds}
 \end{figure}
 In CbC, we can go to a code segment from a C function and we can call C functions in a code segment. So we don't have to shift completely from C to CbC. The later one is straight forward, but the former one needs further extensions.
 \item Transition is implemented by forced tail call.
 \item Goto with environment is implemented by setjmp and longjmp.
 \end{itemize}
 {\bf \_\_code} is implemented as a new type keyword in LLVM and Clang. You may think {\bf \_\_code} is an attribute of a function, which means that the function can call in tail call elimination only.
-Because of this implementation, we can actually call code segmnet as a C function call.
+Because of this implementation, we can actually call code segment as a C function call.
-Forcing tail call require many condisions. For example, there should be no statement after tail call, caller and callee's calling convention have to be the same and type is cc10, cc11 or fastcc, callee's return value type have to be the same as caller's it, add tail call elimination pass, and so on.
+Forcing tail call require many conditions. For example, there should be no statement after tail call, caller and callee's calling convention have to be the same and type is cc10, cc11 or fastcc, callee's return value type have to be the same as caller's it, add tail call elimination pass, and so on.
 All code segment has the void return type and we do not allow to write statement after continuation, so type problem and after statement problem is solved.
 Tail call elimination pass is enabled in {\bf BackendUtil.cpp}. In the clang, when optimize level is two or more, tail call elimination pass is enabled. We modify it to enable anytime and if optimize level is one or less, tail call elimination pass work for only code segment.
-Next, we solve a calling convention problem. We select fastcc for code segment's calling convention. In the clang, calling convention is managed by CGFunctionInfo class and its infomations are set in {\bf CGCall.cpp}. We modify here to set fastcc to code segmnets.
+Next, we solve a calling convention problem. We select fastcc for code segment's calling convention. In the clang, calling convention is managed by CGFunctionInfo class and its infomations are set in {\bf CGCall.cpp}. We modify here to set fastcc to code segments.
 Goto with environment is implemented by code rearranging. If the {\bf \_\_environment} or {\bf \_\_return} is declared, CbC compiler rearrange code for goto with environment. We use setjmp and longjmp for it. Setjmp save environment before continuation, and longjmp restore it.
 \section{Result}
-Here is our bench mark program.
+Here is our benchmark program.
 \begin{table}[html]
 \begin{lstlisting}
 int f0(int i) {
 int k,j;
 int h0(int i) {
 return i+4;
 }
 \end{lstlisting}
-\caption{bench mark program conv1}
+\caption{benchmark program conv1}
 \label{src:example}
 \end{table}
 It is written in C and CbC and there are several optimization is possible.
 When argument is 1, use CbC continuation. When argument is 2 or 3, optimization is enabled.
-Here we show bench mark result (TABLE \ref{result}).
+Here we show benchmark result (TABLE \ref{result}).
 \begin{table}[htpb]
 \centering
 \begin{tabular}{|l|r|r|r|} \hline
 & ./conv1 1 & ./conv1 2 & ./conv1 3 \\ \hline
 LLVM and clang compiler is faster than Micro-C when optimization is enabled. It mean LLVM's optimization is powerful and useful. LLVM and clang compiler is slower than GCC but GCC cannot compile safety without optimization. It means LLVM can compile more reliability than GCC.
 \section{Conclusion}
 We have designed and implemented Continuation based language for practical use. We have partial implementation of CbC using LLVM and Clang 3.7. CbC can use LLVM's optimization. We did not modify LLVM IR to implement CbC compiler.
-In future, we design and implement data segmnet and meta code segment, meta data segment for meta computation.
+In future, we design and implement data segment and meta code segment, meta data segment for meta computation.
 \nocite{opac-b1092711, LLVMIR, LLVM, clang}
 \bibliographystyle{IEEEtran}
 \bibliography{IEEEabrv,reference}

Mercurial > hg > Papers > 2015 > kaito-lola

comparison cfopm.tex @ 1:97e85476344e