<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>design.md - +/pykokkos @ master</title>
<meta name="description" content="design.md in +/pykokkos at master.">
<meta property="og:title" content="design.md - +/pykokkos @ master">
<meta property="og:description" content="design.md in +/pykokkos at master.">
<meta property="og:type" content="website">
<meta property="og:site_name" content="git.julia.blue">
<link rel="stylesheet" href="/css/style.css?v=62">
<script type="module" src="/js/main.js?v=62"></script>
</head>
<body>
<main data-ref="master" data-tip="1a80dfe8f0fa1ab32b56ecb137124503be29b0bb">
<noscript>
  <div class="callout">
    <p>
      hey! this is a static git repo viewer. commit diffs, file history,
      older commits and other revisions won't load without javascript.
    </p>
    <p>
      you are still able to view source files on branch/tag tips,
      but the experience is degraded.
    </p>
  </div>
</noscript>
<header class="repo"><div>
<h1>+/pykokkos</h1>
</div>
<pre class="clone">git clone https://git.julia.blue/+/pykokkos</pre>
</header>
<p class="snapshot-commit"><span class="commit-author">Joseph Ryan</span><span class="commit-message" data-commit="1a80dfe8f0fa1ab32b56ecb137124503be29b0bb">Implement basic support for Debug ExecSpace</span><span class="snapshot-sha sha" data-commit="1a80dfe8f0fa1ab32b56ecb137124503be29b0bb">1a80dfe</span><time datetime="2020-03-06T11:02:48-06:00" title="2020-03-06 11:02:48 -0600">2020-03-06</time></p>
<header class="topbar"><details class="switcher"><summary>master</summary><div class="menu"><strong>branches</strong><a class="current" href="/%2B/pykokkos/ref/master/">master</a><a class="all" href="/%2B/pykokkos/refs">all refs →</a></div></details><nav class="crumbs"><a href="/%2B/pykokkos/">pykokkos</a> / <span class="cur">design.md</span></nav>
<span class="view-stats"><span>5.9 KiB</span><span>133 lines</span></span><span class="actions"><a class="raw" href="/%2B/pykokkos/raw/e8d081580f417007652b0d2caf246248b3b95f95/design.md">raw</a></span></header>
<div class="markdown-view"><input type="radio" name="markdown-view" id="markdown-rendered" checked><label for="markdown-rendered">rendered</label><input type="radio" name="markdown-view" id="markdown-code"><label for="markdown-code">code</label><section class="readme rendered"><h2>Design Decisions</h2>
<ul>
<li>Workloads are written completely in Python rather than kernels being written
in C++ or a DSL with Python used just for orchestration and configuration.
Supporting workloads with kernels written in C++ is a possible extension.</li>
<li>The C++ is generated through translation of the AST which means that no
Python code within work units is evaluated.</li>
<li>Data is passed back and forth between the Python code and the Kokkos
environment using "views" which are Kokkos' abstraction of multidimensional
arrays.</li>
<li>For now at least, scalar data types are neither explicitly annotated nor
inferred, everything is just cast to doubles with the exception of array
indices.</li>
</ul>
<h2>Components</h2>
<h3>KokkosWorkload class</h3>
<p>This is a base class that users must inherit from in their "workload" class. The
reason to have them define all Kokkos related code in a class rather than
wherever they want with top level declarations is that it makes it far simpler
to translate. For example when searching for functions or data that need to be
transfered to C++, the class's member variables can be searched rather than
having to look through the entire python environment. It also avoids issues with
defining multiple Kokkos workloads in the same python module because their
translation and execution are handled separately. The one drawback is that if a
user has many workloads that all use the same work units, they have to redefine
them for each class.</p>
<h3>View1D/2D/3D classes</h3>
<p>All data that's used by the Kokkos computations is stored in views, which are an
abstraction of multidimensional arrays. These are allocated and initialized in
python as members of the workload class and then serialized. Additional C++ code
is generated to load them from disk and store them back when the computation is
finished.</p>
<h3>work_unit annotation</h3>
<p>Any methods of the workload with this annotation are treated as kernels to be
translated to C++ lambdas. They either take an index (for <code>parallel_for</code>) or an
index and accumulator (for <code>parallel_reduce</code>) as arguments. The set of python
language constructs that can be translated is still growing, but the essential
ones like arithmetic, view access, and flow control are already working. In
addition it's possible to use data members of the python workload within work
units (read only), where they'll get translated to constants. The main features
currently missing are local variable declaration (which is tricky due to scoping
and typing) and function invocation, which will be handled by maintaining a
whitelist of functions that are legal to call from within work units.</p>
<h3>run_work_units</h3>
<p>This is a special method the user must define in their workload class. It
dictates how the work units are actually executed. Like the work units
themselves the method is translated to C++, but currently only a small subset of
language constructs are allowed. The only statements that the user can currently
write a are function invocations of <code>parallel_for</code> and <code>parallel_reduce</code>, and
assignments to store the result of said reductions. This limitation is primarily
used to make translation simpler, but if useful it would be possible to allow
the use of flow control or other constructs.</p>
<h3>use_results</h3>
<p>This is another special method the user can define. It is run after
<code>run_work_units</code> has completed and the updated data from C++ has been copied
back into python. Even if <code>run_work_units</code> executes many work units,
<code>use_results</code> is only invoked once at the very end to avoid continuously having
to copy large views back and forth between python and C++. This limits the
ability to write workloads that alter their execution based on the result of
previous steps such as fixed point numerical algorithms, so we're still
considering alternate approaches.</p>
<h3>execute</h3>
<p>This is a method from the base <code>KokkosWorkload</code> class, calling it triggers the
translation and execution of a workload. It will accept an argument to determine
which "Execution Space" (CUDA/OpenMP/Python/PThreads/Serial C++) to use. This
functionality is currently not implemented, but the Execution Space will change
the generated C++ code to handle specific issues with each one such as copying
data over to the GPU. See the next section for an in depth example of what steps
this method performs.</p>
<h2>Execution example</h2>
<p>Here is a simple example of a Kokkos workload which adds 1 to every element of
an array:</p>
<pre class="language-python"><a-k>class</a-k> <a-cr>AddOne</a-cr>(<a-cr>KokkosWorkload</a-cr>):
    <a-k>def</a-k> <a-f>__init__</a-f>(<a-v>self</a-v>, <a-v>n</a-v>):
        <a-v>self</a-v>.<a-pr>N</a-pr> <a-o>=</a-o> <a-v>n</a-v>
        <a-v>self</a-v>.<a-pr>a</a-pr> <a-o>=</a-o> <a-f>View1D</a-f>(<a-v>n</a-v>)

        <a-k>for</a-k> <a-v>i</a-v> <a-o>in</a-o> <a-f>range</a-f>(<a-v>self</a-v>.<a-pr>N</a-pr>):
            <a-v>self</a-v>.<a-pr>a</a-pr>[<a-v>i</a-v>] <a-o>=</a-o> <a-n>2</a-n>
        <a-f>print</a-f>(<a-s>&quot;Initialized view:&quot;</a-s>, )

    <a-k>def</a-k> <a-f>run_work_units</a-f>(<a-v>self</a-v>):
        <a-f>parallel_for</a-f>(<a-v>self</a-v>.<a-pr>N</a-pr>, <a-v>self</a-v>.<a-pr>add1</a-pr>)

    <a-k>def</a-k> <a-f>use_results</a-f>(<a-v>self</a-v>):
        <a-f>print</a-f>(<a-s>&quot;Modified view:&quot;</a-s>, <a-v>self</a-v>.<a-pr>a</a-pr>)

    <a-f>@work_unit</a-f>
    <a-k>def</a-k> <a-f>add1</a-f>(<a-v>self</a-v>, <a-v>i</a-v>):
        <a-v>self</a-v>.<a-pr>a</a-pr>[<a-v>i</a-v>] <a-o>+=</a-o> <a-n>1</a-n>


<a-v>my_workload</a-v> <a-o>=</a-o> <a-f>AddOne</a-f>(<a-n>1000</a-n>)
<a-v>my_workload</a-v>.<a-pr>execute</a-pr>()</pre>
<p>When <code>my_workload = AddOne(1000)</code> is run, the workload's constructor executes
which initializes its view. Then when <code>my_workload.execute()</code> is run the
following steps happen in order:</p>
<ol>
<li>A build directory is created and essential files like protobufs and the
Makefile for the C++ code are copied in.</li>
<li>The members of <code>AddOne</code> are inspected and the view <code>self.a</code> is serialized
into the build directory.</li>
<li>Boilerplate C++ is generated to initialize the Kokkos runtime and load in the
view that has been serialized.</li>
<li>The workload <code>add1</code> is detected because of its <code>@work_unit</code> decorator and
translated to a C++ lambda.</li>
<li><code>run_work_units</code> is translated to C++ (this is a simple case because no
reductions occur).</li>
<li>More C++ is generated to write the modified views back out to disk and shut
down the Kokkos runtime.</li>
<li>The finished C++ file is compiled and run. Any errors are passed back to the
user.</li>
<li>If the C++ code compiled and executed successfully, the views are read back
into python.</li>
<li><code>use_results</code> is run and the updated view gets printed.</li>
</ol>
</section><div class="code-panel"><pre class="code src language-markdown"><span class="code-line"><a class="ln" id="L1" href="#L1">1</a><span class="code-text"><a-p>##</a-p> <a-tt>Design Decisions</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L2" href="#L2">2</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L3" href="#L3">3</a><span class="code-text"><a-p>-   </a-p>Workloads are written completely in Python rather than kernels being written</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L4" href="#L4">4</a><span class="code-text"><a-p>    </a-p>in C++ or a DSL with Python used just for orchestration and configuration.</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L5" href="#L5">5</a><span class="code-text"><a-p>    </a-p>Supporting workloads with kernels written in C++ is a possible extension.</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L6" href="#L6">6</a><span class="code-text"><a-p>-   </a-p>The C++ is generated through translation of the AST which means that no</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L7" href="#L7">7</a><span class="code-text"><a-p>    </a-p>Python code within work units is evaluated.</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L8" href="#L8">8</a><span class="code-text"><a-p>-   </a-p>Data is passed back and forth between the Python code and the Kokkos</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L9" href="#L9">9</a><span class="code-text"><a-p>    </a-p>environment using &quot;views&quot; which are Kokkos&#39; abstraction of multidimensional</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L10" href="#L10">10</a><span class="code-text"><a-p>    </a-p>arrays.</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L11" href="#L11">11</a><span class="code-text"><a-p>-   </a-p>For now at least, scalar data types are neither explicitly annotated nor</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L12" href="#L12">12</a><span class="code-text"><a-p>    </a-p>inferred, everything is just cast to doubles with the exception of array</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L13" href="#L13">13</a><span class="code-text"><a-p>    </a-p>indices.</span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L14" href="#L14">14</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L15" href="#L15">15</a><span class="code-text"><a-p>## </a-p><a-tt>Components</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L16" href="#L16">16</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L17" href="#L17">17</a><span class="code-text"><a-p>### </a-p><a-tt>KokkosWorkload class</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L18" href="#L18">18</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L19" href="#L19">19</a><span class="code-text"><a-p>This is a base class that users must inherit from in their &quot;workload&quot; class. The</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L20" href="#L20">20</a><span class="code-text"><a-p>reason to have them define all Kokkos related code in a class rather than</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L21" href="#L21">21</a><span class="code-text"><a-p>wherever they want with top level declarations is that it makes it far simpler</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L22" href="#L22">22</a><span class="code-text"><a-p>to translate. For example when searching for functions or data that need to be</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L23" href="#L23">23</a><span class="code-text"><a-p>transfered to C++, the class&#39;s member variables can be searched rather than</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L24" href="#L24">24</a><span class="code-text"><a-p>having to look through the entire python environment. It also avoids issues with</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L25" href="#L25">25</a><span class="code-text"><a-p>defining multiple Kokkos workloads in the same python module because their</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L26" href="#L26">26</a><span class="code-text"><a-p>translation and execution are handled separately. The one drawback is that if a</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L27" href="#L27">27</a><span class="code-text"><a-p>user has many workloads that all use the same work units, they have to redefine</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L28" href="#L28">28</a><span class="code-text"><a-p>them for each class.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L29" href="#L29">29</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L30" href="#L30">30</a><span class="code-text"><a-p>### </a-p><a-tt>View1D/2D/3D classes</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L31" href="#L31">31</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L32" href="#L32">32</a><span class="code-text"><a-p>All data that&#39;s used by the Kokkos computations is stored in views, which are an</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L33" href="#L33">33</a><span class="code-text"><a-p>abstraction of multidimensional arrays. These are allocated and initialized in</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L34" href="#L34">34</a><span class="code-text"><a-p>python as members of the workload class and then serialized. Additional C++ code</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L35" href="#L35">35</a><span class="code-text"><a-p>is generated to load them from disk and store them back when the computation is</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L36" href="#L36">36</a><span class="code-text"><a-p>finished.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L37" href="#L37">37</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L38" href="#L38">38</a><span class="code-text"><a-p>### </a-p><a-tt>work_unit annotation</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L39" href="#L39">39</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L40" href="#L40">40</a><span class="code-text"><a-p>Any methods of the workload with this annotation are treated as kernels to be</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L41" href="#L41">41</a><span class="code-text"><a-p>translated to C++ lambdas. They either take an index (for `parallel_for`) or an</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L42" href="#L42">42</a><span class="code-text"><a-p>index and accumulator (for `parallel_reduce`) as arguments. The set of python</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L43" href="#L43">43</a><span class="code-text"><a-p>language constructs that can be translated is still growing, but the essential</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L44" href="#L44">44</a><span class="code-text"><a-p>ones like arithmetic, view access, and flow control are already working. In</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L45" href="#L45">45</a><span class="code-text"><a-p>addition it&#39;s possible to use data members of the python workload within work</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L46" href="#L46">46</a><span class="code-text"><a-p>units (read only), where they&#39;ll get translated to constants. The main features</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L47" href="#L47">47</a><span class="code-text"><a-p>currently missing are local variable declaration (which is tricky due to scoping</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L48" href="#L48">48</a><span class="code-text"><a-p>and typing) and function invocation, which will be handled by maintaining a</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L49" href="#L49">49</a><span class="code-text"><a-p>whitelist of functions that are legal to call from within work units.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L50" href="#L50">50</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L51" href="#L51">51</a><span class="code-text"><a-p>### </a-p><a-tt>run_work_units</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L52" href="#L52">52</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L53" href="#L53">53</a><span class="code-text"><a-p>This is a special method the user must define in their workload class. It</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L54" href="#L54">54</a><span class="code-text"><a-p>dictates how the work units are actually executed. Like the work units</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L55" href="#L55">55</a><span class="code-text"><a-p>themselves the method is translated to C++, but currently only a small subset of</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L56" href="#L56">56</a><span class="code-text"><a-p>language constructs are allowed. The only statements that the user can currently</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L57" href="#L57">57</a><span class="code-text"><a-p>write a are function invocations of `parallel_for` and `parallel_reduce`, and</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L58" href="#L58">58</a><span class="code-text"><a-p>assignments to store the result of said reductions. This limitation is primarily</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L59" href="#L59">59</a><span class="code-text"><a-p>used to make translation simpler, but if useful it would be possible to allow</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L60" href="#L60">60</a><span class="code-text"><a-p>the use of flow control or other constructs.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L61" href="#L61">61</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L62" href="#L62">62</a><span class="code-text"><a-p>### </a-p><a-tt>use_results</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L63" href="#L63">63</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L64" href="#L64">64</a><span class="code-text"><a-p>This is another special method the user can define. It is run after</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L65" href="#L65">65</a><span class="code-text"><a-p>`run_work_units` has completed and the updated data from C++ has been copied</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L66" href="#L66">66</a><span class="code-text"><a-p>back into python. Even if `run_work_units` executes many work units,</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L67" href="#L67">67</a><span class="code-text"><a-p>`use_results` is only invoked once at the very end to avoid continuously having</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L68" href="#L68">68</a><span class="code-text"><a-p>to copy large views back and forth between python and C++. This limits the</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L69" href="#L69">69</a><span class="code-text"><a-p>ability to write workloads that alter their execution based on the result of</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L70" href="#L70">70</a><span class="code-text"><a-p>previous steps such as fixed point numerical algorithms, so we&#39;re still</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L71" href="#L71">71</a><span class="code-text"><a-p>considering alternate approaches.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L72" href="#L72">72</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L73" href="#L73">73</a><span class="code-text"><a-p>### </a-p><a-tt>execute</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L74" href="#L74">74</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L75" href="#L75">75</a><span class="code-text"><a-p>This is a method from the base `KokkosWorkload` class, calling it triggers the</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L76" href="#L76">76</a><span class="code-text"><a-p>translation and execution of a workload. It will accept an argument to determine</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L77" href="#L77">77</a><span class="code-text"><a-p>which &quot;Execution Space&quot; (CUDA/OpenMP/Python/PThreads/Serial C++) to use. This</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L78" href="#L78">78</a><span class="code-text"><a-p>functionality is currently not implemented, but the Execution Space will change</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L79" href="#L79">79</a><span class="code-text"><a-p>the generated C++ code to handle specific issues with each one such as copying</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L80" href="#L80">80</a><span class="code-text"><a-p>data over to the GPU. See the next section for an in depth example of what steps</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L81" href="#L81">81</a><span class="code-text"><a-p>this method performs.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L82" href="#L82">82</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L83" href="#L83">83</a><span class="code-text"><a-p>## </a-p><a-tt>Execution example</a-tt></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L84" href="#L84">84</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L85" href="#L85">85</a><span class="code-text"><a-p>Here is a simple example of a Kokkos workload which adds 1 to every element of</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L86" href="#L86">86</a><span class="code-text"><a-p>an array:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L87" href="#L87">87</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L88" href="#L88">88</a><span class="code-text"><a-p>```</a-p><a-tl>python</a-tl></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L89" href="#L89">89</a><span class="code-text"><a-p>class </a-p><a-cr>AddOne</a-cr><a-p>(</a-p><a-cr>KokkosWorkload</a-cr><a-p>):</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L90" href="#L90">90</a><span class="code-text"><a-p>    </a-p><a-k>def</a-k><a-p> </a-p><a-f>__init__</a-f><a-p>(</a-p><a-v>self</a-v><a-p>, </a-p><a-v>n</a-v><a-p>):</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L91" href="#L91">91</a><span class="code-text"><a-p>        </a-p><a-v>self</a-v><a-p>.</a-p><a-pr>N</a-pr><a-p> </a-p><a-o>=</a-o><a-p> </a-p><a-v>n</a-v></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L92" href="#L92">92</a><span class="code-text"><a-p>        </a-p><a-v>self</a-v><a-p>.</a-p><a-pr>a</a-pr><a-p> </a-p><a-o>=</a-o><a-p> </a-p><a-f>View1D</a-f><a-p>(</a-p><a-v>n</a-v><a-p>)</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L93" href="#L93">93</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L94" href="#L94">94</a><span class="code-text"><a-p>        </a-p><a-k>for</a-k><a-p> </a-p><a-v>i</a-v><a-p> </a-p><a-o>in</a-o><a-p> </a-p><a-f>range</a-f><a-p>(</a-p><a-v>self</a-v><a-p>.</a-p><a-pr>N</a-pr><a-p>):</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L95" href="#L95">95</a><span class="code-text"><a-p>            </a-p><a-v>self</a-v><a-p>.</a-p><a-pr>a</a-pr><a-p>[</a-p><a-v>i</a-v><a-p>] </a-p><a-o>=</a-o><a-p> </a-p><a-n>2</a-n></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L96" href="#L96">96</a><span class="code-text"><a-p>        </a-p><a-f>print</a-f><a-p>(</a-p><a-s>&quot;Initialized view:&quot;</a-s><a-p>, )</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L97" href="#L97">97</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L98" href="#L98">98</a><span class="code-text"><a-p>    </a-p><a-k>def</a-k><a-p> </a-p><a-f>run_work_units</a-f><a-p>(</a-p><a-v>self</a-v><a-p>):</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L99" href="#L99">99</a><span class="code-text"><a-p>        </a-p><a-f>parallel_for</a-f><a-p>(</a-p><a-v>self</a-v><a-p>.</a-p><a-pr>N</a-pr><a-p>, </a-p><a-v>self</a-v><a-p>.</a-p><a-pr>add1</a-pr><a-p>)</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L100" href="#L100">100</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L101" href="#L101">101</a><span class="code-text"><a-p>    </a-p><a-k>def</a-k><a-p> </a-p><a-f>use_results</a-f><a-p>(</a-p><a-v>self</a-v><a-p>):</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L102" href="#L102">102</a><span class="code-text"><a-p>        </a-p><a-f>print</a-f><a-p>(</a-p><a-s>&quot;Modified view:&quot;</a-s><a-p>, </a-p><a-v>self</a-v><a-p>.</a-p><a-pr>a</a-pr><a-p>)</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L103" href="#L103">103</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L104" href="#L104">104</a><span class="code-text"><a-p>    </a-p><a-f>@work_unit</a-f></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L105" href="#L105">105</a><span class="code-text"><a-p>    </a-p><a-k>def</a-k><a-p> </a-p><a-f>add1</a-f><a-p>(</a-p><a-v>self</a-v><a-p>, </a-p><a-v>i</a-v><a-p>):</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L106" href="#L106">106</a><span class="code-text"><a-p>        </a-p><a-v>self</a-v><a-p>.</a-p><a-pr>a</a-pr><a-p>[</a-p><a-v>i</a-v><a-p>] </a-p><a-o>+=</a-o><a-p> </a-p><a-n>1</a-n></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L107" href="#L107">107</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L108" href="#L108">108</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L109" href="#L109">109</a><span class="code-text"><a-p>my_workload </a-p><a-o>=</a-o><a-p> </a-p><a-f>AddOne</a-f><a-p>(</a-p><a-n>1000</a-n><a-p>)</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L110" href="#L110">110</a><span class="code-text"><a-p>my_workload.</a-p><a-pr>execute</a-pr><a-p>()</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L111" href="#L111">111</a><span class="code-text"><a-p>```</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L112" href="#L112">112</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L113" href="#L113">113</a><span class="code-text"><a-p>When `my_workload = AddOne(1000)` is run, the workload&#39;s constructor executes</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L114" href="#L114">114</a><span class="code-text"><a-p>which initializes its view. Then when `my_workload.execute()` is run the</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L115" href="#L115">115</a><span class="code-text"><a-p>following steps happen in order:</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L116" href="#L116">116</a><span class="code-text"></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L117" href="#L117">117</a><span class="code-text"><a-p>1. A build directory is created and essential files like protobufs and the</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L118" href="#L118">118</a><span class="code-text"><a-p>   Makefile for the C++ code are copied in.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L119" href="#L119">119</a><span class="code-text"><a-p>2. The members of `AddOne` are inspected and the view `self.a` is serialized</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L120" href="#L120">120</a><span class="code-text"><a-p>   into the build directory.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L121" href="#L121">121</a><span class="code-text"><a-p>3. Boilerplate C++ is generated to initialize the Kokkos runtime and load in the</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L122" href="#L122">122</a><span class="code-text"><a-p>   view that has been serialized.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L123" href="#L123">123</a><span class="code-text"><a-p>4. The workload `add1` is detected because of its `@work_unit` decorator and</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L124" href="#L124">124</a><span class="code-text"><a-p>   translated to a C++ lambda.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L125" href="#L125">125</a><span class="code-text"><a-p>5. `run_work_units` is translated to C++ (this is a simple case because no</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L126" href="#L126">126</a><span class="code-text"><a-p>   reductions occur).</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L127" href="#L127">127</a><span class="code-text"><a-p>6. More C++ is generated to write the modified views back out to disk and shut</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L128" href="#L128">128</a><span class="code-text"><a-p>   down the Kokkos runtime.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L129" href="#L129">129</a><span class="code-text"><a-p>7. The finished C++ file is compiled and run. Any errors are passed back to the</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L130" href="#L130">130</a><span class="code-text"><a-p>   user.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L131" href="#L131">131</a><span class="code-text"><a-p>8. If the C++ code compiled and executed successfully, the views are read back</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L132" href="#L132">132</a><span class="code-text"><a-p>   into python.</a-p></span><span class="code-break">
</span></span><span class="code-line"><a class="ln" id="L133" href="#L133">133</a><span class="code-text"><a-p>9. </a-p>`use_results` is run and the updated view gets printed.</span></span></pre></div></div>
</main>
</body>
</html>
