commit f0b5f20f37e32299c5a477fcd43917e83d08ab60
parent 53ba4181703f28fa05f0b59a9b135e25994d8872
Author: Ivan Gankevich <igankevich@ya.ru>
Date: Sat, 18 Feb 2017 12:04:04 +0300
Emphasize act, react methods.
Diffstat:
3 files changed, 31 insertions(+), 26 deletions(-)
diff --git a/main.tex b/main.tex
@@ -8,6 +8,8 @@
%\hyphenation{op-tical net-works semi-conduc-tor}
+\input{preamble}
+
\begin{document}
\title{TITLE}
diff --git a/preamble.tex b/preamble.tex
@@ -0,0 +1,2 @@
+\newcommand{\Method}[1]{\texttt{#1}}
+
diff --git a/src/body.tex b/src/body.tex
@@ -10,40 +10,41 @@ on an arbitrary number of nodes. There are two kinds of tightly coupled
entities in the package~--- kernels and pipelines~--- which are used together
to compose a programme.
-Kernels implement control flow logic in theirs act and react methods and store
-the state of the current control flow branch. Both logic and state are
-implemented by a programmer. In act method some function is either sequentially
-computed or decomposed into subtasks (represented by another set of kernels)
-which are subsequently sent to a pipeline. In react method subordinate kernels
-that returned from the pipeline are processed by their parent. Calls to act and
-react methods are asynchronous and are made within threads spawned by a
-pipeline. For each kernel act is called only once, and for multiple kernels the
-calls are done in parallel to each other, whereas react method is called once
-for each subordinate kernel, and all the calls are made in the same thread to
+Kernels implement control flow logic in theirs \Method{act} and \Method{react}
+methods and store the state of the current control flow branch. Both logic and
+state are implemented by a programmer. In \Method{act} method some function is
+either sequentially computed or decomposed into subtasks (represented by
+another set of kernels) which are subsequently sent to a pipeline. In
+\Method{react} method subordinate kernels that returned from the pipeline are
+processed by their parent. Calls to \Method{act} and \Method{react} methods are
+asynchronous and are made within threads spawned by a pipeline. For each kernel
+\Method{act} is called only once, and for multiple kernels the calls are done
+in parallel to each other, whereas \Method{react} method is called once for
+each subordinate kernel, and all the calls are made in the same thread to
prevent race conditions (for different parent kernels different threads may be
used).
-Pipelines implement asynchronous calls to act and react, and try to make as
-many parallel calls as possible considering concurrency of the platform (no.~of
-cores per node and no. of nodes in a cluster). A pipeline consists of a kernel
-pool, which contains all the subordinate kernels sent by their parents, and a
-thread pool that processes kernels in accordance with rules outlined in the
-previous paragraph. A separate pipeline exists for each compute device: There
-are pipelines for parallel processing, schedule-based processing (periodic and
-delayed tasks), and a proxy pipeline for processing of kernels on other cluster
-nodes.
+Pipelines implement asynchronous calls to \Method{act} and \Method{react}, and
+try to make as many parallel calls as possible considering concurrency of the
+platform (no.~of cores per node and no. of nodes in a cluster). A pipeline
+consists of a kernel pool, which contains all the subordinate kernels sent by
+their parents, and a thread pool that processes kernels in accordance with
+rules outlined in the previous paragraph. A separate pipeline exists for each
+compute device: There are pipelines for parallel processing, schedule-based
+processing (periodic and delayed tasks), and a proxy pipeline for processing of
+kernels on other cluster nodes.
In principle, kernels and pipelines machinery reflect the one of procedures and
call stacks, with the advantage that kernel methods are called asynchronously
and in parallel to each other. The stack, which ordinarily stores local
variables, is modelled by fields of a kernel. The sequence of processor
-instructions before nested procedure calls is modelled by act method, and
-sequence of processor instructions after the calls is modelled by react method.
-The procedure calls themselves are modelled by constructing and sending
-subordinate kernels to the pipeline. Two methods are necessary because calls
-are asynchronous and one must wait before subordinate kernels complete their
-work. Pipelines allow circumventing active wait, and call correct kernel
-methods by analysing their internal state.
+instructions before nested procedure calls is modelled by \Method{act} method,
+and sequence of processor instructions after the calls is modelled by
+\Method{react} method. The procedure calls themselves are modelled by
+constructing and sending subordinate kernels to the pipeline. Two methods are
+necessary because calls are asynchronous and one must wait before subordinate
+kernels complete their work. Pipelines allow circumventing active wait, and
+call correct kernel methods by analysing their internal state.
\section{Cluster scheduler architecture}
