CPU: Add a skeleton CPU backend with an initially failing test

src/ngraph/CMakeLists.txt

@@ -92,6 +92,10 @@ if(LLVM_INCLUDE_DIR)
     # Add sources for the LLVM-based code generator
     set(SRC ${SRC}
         codegen/compiler.cpp
+        runtime/cpu/call_frame.cpp
+        runtime/cpu/cpu_manager.cpp
+        runtime/cpu/cpu_backend.cpp
+        runtime/cpu/external_function.cpp
         )
     set_source_files_properties(codegen/compiler.cpp PROPERTIES COMPILE_FLAGS "-fno-rtti")
 endif()

src/ngraph/codegen/compiler.cpp

@@ -61,7 +61,7 @@ static std::string GetExecutablePath(const char* Argv0)
 {
     // This just needs to be some symbol in the binary; C++ doesn't
     // allow taking the address of ::main however.
-    void* MainAddr = (void*)(intptr_t)GetExecutablePath;
+    void* MainAddr = reinterpret_cast<void*>(GetExecutablePath);
     return llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
 }
 
@@ -111,7 +111,7 @@ std::unique_ptr<llvm::Module> execution_state::compile(const string& source, con
     if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
         Clang->getHeaderSearchOpts().ResourceDir.empty())
     {
-        void* MainAddr = (void*)(intptr_t)GetExecutablePath;
+        void* MainAddr = reinterpret_cast<void*>(GetExecutablePath);
         auto path = CompilerInvocation::GetResourcesPath(args[0], MainAddr);
         Clang->getHeaderSearchOpts().ResourceDir = path;
     }
@@ -131,6 +131,12 @@ std::unique_ptr<llvm::Module> execution_state::compile(const string& source, con
     // Debian-like + GCC 5 libstdc++
     HSO.AddPath("/usr/include/x86_64-linux-gnu/c++/5", clang::frontend::System, false, false);
     HSO.AddPath("/usr/include/c++/5", clang::frontend::System, false, false);
+    // TODO: Hack in path to eigen headers for now
+    HSO.AddPath("/localdisk/menonjai/build/external/eigen/include/eigen3",
+                clang::frontend::System,
+                false,
+                false);
+    HSO.AddPath("/home/menonjai/ngraph-cpp/src", clang::frontend::System, false, false);
 
     // Map code filename to a memoryBuffer
     StringRef source_ref(source);

src/ngraph/codegen/compiler.hpp

@@ -65,7 +65,7 @@ private:
     template <typename signature>
     std::function<signature> f_cast(void* f)
     {
-        return static_cast<signature*>((signature*)f);
+        return static_cast<signature*>(reinterpret_cast<signature*>(f));
     }
 
     // class method_resolver : public llvm::RTDyldMemoryManager

src/ngraph/runtime/cpu/call_frame.cpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#include <algorithm>
+
+#include "ngraph/runtime/cpu/call_frame.hpp"
+#include "ngraph/runtime/cpu/instruction.hpp"
+
+using namespace std;
+using namespace ngraph::runtime::cpu;
+
+CallFrame::CallFrame(size_t n_inputs,
+                     size_t n_outputs,
+                     const TensorViewPtrs& temps)
+
+    : m_n_inputs(n_inputs)
+    , m_n_outputs(n_outputs)
+    , m_tensor_views(n_inputs + n_outputs + temps.size())
+{
+    copy(temps.begin(), temps.end(), m_tensor_views.begin() + m_n_inputs + m_n_outputs);
+}
+
+void CallFrame::tensor_call(
+    const std::vector<std::shared_ptr<ngraph::runtime::TensorView>>& inputs,
+    const std::vector<std::shared_ptr<ngraph::runtime::TensorView>>& outputs)
+{
+    copy(inputs.begin(), inputs.end(), m_tensor_views.begin());
+    copy(outputs.begin(), outputs.end(), m_tensor_views.begin() + m_n_inputs);
+
+    // TODO: Execute!
+
+    // Don't hold onto inputs/outputs
+    fill_n(m_tensor_views.begin(), m_n_inputs + m_n_outputs, nullptr);
+}
+
+void CallFrame::operator()(const std::vector<std::shared_ptr<ngraph::runtime::Value>>& arguments,
+                           const std::vector<std::shared_ptr<ngraph::runtime::Value>>& results)
+{
+    // TODO: Check types of args and result
+    std::vector<std::shared_ptr<ngraph::runtime::TensorView>> inputs;
+    for (auto argument : arguments)
+    {
+        argument->collect_tensor_views(inputs, argument);
+    }
+
+    std::vector<std::shared_ptr<ngraph::runtime::TensorView>> outputs;
+    for (auto result : results)
+    {
+        result->collect_tensor_views(outputs, result);
+    }
+
+    tensor_call(inputs, outputs);
+}

src/ngraph/runtime/cpu/call_frame.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "ngraph/function.hpp"
+#include "ngraph/runtime/call_frame.hpp"
+#include "ngraph/runtime/tensor_view.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        class PrimaryTensorView;
+
+        namespace cpu
+        {
+            class Instruction;
+
+            // Compile and execute graphs
+            class CallFrame : public ngraph::runtime::CallFrame
+            {
+            public:
+                CallFrame(
+                    size_t n_inputs,
+                    size_t n_outputs,
+                    const TensorViewPtrs& temps);
+
+                /// @brief Invoke the function with values matching the signature of the function.
+                ///
+                /// Tuples will be expanded into their tensor views to build the call frame.
+                void
+                    operator()(const std::vector<std::shared_ptr<ngraph::runtime::Value>>& inputs,
+                               const std::vector<std::shared_ptr<ngraph::runtime::Value>>& outputs);
+
+                /// @brief Invoke the function with tuples pre-expanded to their underlying tensor views.
+                void tensor_call(const TensorViewPtrs& inputs, const TensorViewPtrs& outputs);
+
+                void set_return() { m_return = true; }
+                std::shared_ptr<TensorView> get_tensor_view(size_t i) { return m_tensor_views[i]; }
+                template <typename ET>
+                ParameterizedTensorView<ET>* get_parameterized_tensor_view(size_t i)
+                {
+                    return m_tensor_views[i]->get_parameterized_tensor_view<ET>();
+                }
+
+                template <typename ET>
+                typename ET::type* get_tensor_view_data(size_t i)
+                {
+                    return &get_parameterized_tensor_view<ET>(i)->get_vector()[0];
+                }
+
+            protected:
+                size_t m_n_inputs;
+                size_t m_n_outputs;
+                TensorViewPtrs m_tensor_views;
+                bool m_return;
+            };
+        }
+    }
+}

src/ngraph/runtime/cpu/cpu_backend.cpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#include "ngraph/runtime/cpu/cpu_backend.hpp"
+#include "ngraph/runtime/external_function.hpp"
+
+using namespace ngraph::runtime::cpu;
+
+std::shared_ptr<ngraph::runtime::CallFrame>
+    CPUBackend::make_call_frame(const std::shared_ptr<ExternalFunction>& external_function)
+{
+    return external_function->make_call_frame();
+}

src/ngraph/runtime/cpu/cpu_backend.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include "ngraph/runtime/backend.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace cpu
+        {
+            class CPUBackend : public Backend
+            {
+            public:
+                virtual std::shared_ptr<ngraph::runtime::CallFrame> make_call_frame(
+                    const std::shared_ptr<ngraph::runtime::ExternalFunction>& external_function);
+            };
+        }
+    }
+}

src/ngraph/runtime/cpu/cpu_manager.cpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#include <memory>
+
+#include "ngraph/runtime/cpu/external_function.hpp"
+#include "ngraph/runtime/cpu/cpu_backend.hpp"
+#include "ngraph/runtime/cpu/cpu_manager.hpp"
+
+using namespace ngraph::runtime::cpu;
+
+std::shared_ptr<ngraph::runtime::Backend> CPUManager::allocate_backend()
+{
+    return std::make_shared<CPUBackend>();
+}
+
+std::shared_ptr<ngraph::runtime::ExternalFunction>
+    CPUManager::compile(const std::shared_ptr<ngraph::Function>& fun)
+{
+    return std::make_shared<ExternalFunction>(fun);
+}
+
+ngraph::runtime::Manager::Factory CPUManager::factory = ngraph::runtime::Manager::register_factory(
+    "CPU", [](const std::string& name) -> std::shared_ptr<ngraph::runtime::Manager> {
+        return std::make_shared<CPUManager>();
+    });

src/ngraph/runtime/cpu/cpu_manager.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <memory>
+
+#include "ngraph/runtime/manager.hpp"
+#include "ngraph/codegen/compiler.hpp"
+
+namespace ngraph
+{
+    class Function;
+
+    namespace runtime
+    {
+        class ExternalFunction;
+
+        namespace cpu
+        {
+            /// @brief Transformer for the interpreted backend
+            class CPUManager : public Manager
+            {
+            protected:
+                nervana::cpu::execution_state exec_state;
+            public:
+                virtual std::shared_ptr<Backend> allocate_backend() override;
+
+                virtual std::shared_ptr<ngraph::runtime::ExternalFunction>
+                    compile(const std::shared_ptr<ngraph::Function>& fun) override;
+
+                static Factory factory;
+            };
+        };
+    }
+}

src/ngraph/runtime/cpu/external_function.cpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#include <memory>
+#include <tuple>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+
+#include "ngraph/codegen/compiler.hpp"
+#include "ngraph/descriptor/input.hpp"
+#include "ngraph/descriptor/layout/dense_tensor_view_layout.hpp"
+#include "ngraph/descriptor/output.hpp"
+#include "ngraph/function.hpp"
+#include "ngraph/node.hpp"
+#include "ngraph/ops/abs.hpp"
+#include "ngraph/ops/add.hpp"
+#include "ngraph/ops/broadcast.hpp"
+#include "ngraph/ops/concatenate.hpp"
+#include "ngraph/ops/constant.hpp"
+#include "ngraph/ops/convert.hpp"
+#include "ngraph/ops/divide.hpp"
+#include "ngraph/ops/dot.hpp"
+#include "ngraph/ops/equal.hpp"
+#include "ngraph/ops/function_call.hpp"
+#include "ngraph/ops/get_tuple_element.hpp"
+#include "ngraph/ops/greater.hpp"
+#include "ngraph/ops/greater_eq.hpp"
+#include "ngraph/ops/less.hpp"
+#include "ngraph/ops/less_eq.hpp"
+#include "ngraph/ops/log.hpp"
+#include "ngraph/ops/maximum.hpp"
+#include "ngraph/ops/multiply.hpp"
+#include "ngraph/ops/negative.hpp"
+#include "ngraph/ops/not_equal.hpp"
+#include "ngraph/ops/reduce.hpp"
+#include "ngraph/ops/select.hpp"
+#include "ngraph/ops/subtract.hpp"
+#include "ngraph/ops/tuple.hpp"
+#include "ngraph/pass/assign_tensors.hpp"
+#include "ngraph/pass/manager.hpp"
+#include "ngraph/pass/propagate_types.hpp"
+#include "ngraph/pass/topological_sort.hpp"
+#include "ngraph/runtime/cpu/call_frame.hpp"
+#include "ngraph/runtime/cpu/external_function.hpp"
+#include "ngraph/runtime/utils.hpp"
+
+using namespace std;
+using namespace ngraph::runtime::cpu;
+
+using ngraph::descriptor::layout::DenseTensorViewLayout;
+
+ExternalFunction::ExternalFunction(const std::shared_ptr<ngraph::Function>& function,
+                                   bool release_function)
+    : ngraph::runtime::ExternalFunction(function, release_function)
+    , m_instructions(make_shared<std::vector<std::shared_ptr<Instruction>>>())
+{
+}
+
+void ExternalFunction::compile()
+{
+    if (m_is_compiled)
+    {
+        return;
+    }
+
+    // This will be replaced with the pass manager
+    // Get the ordered list of ops in execution order
+    pass::Manager pass_manager;
+    pass_manager.register_pass<pass::TopologicalSort>();
+    pass_manager.register_pass<pass::PropagateTypes>();
+    pass_manager.register_pass<pass::AssignTensors>();
+    pass_manager.run_passes(m_function);
+
+    // Turn this into a pass
+    // Assign layouts
+    // For now, just make everyone row-major.
+    for (shared_ptr<Node> node : m_function->get_ordered_ops())
+    {
+        for (const descriptor::Output& output : node->get_outputs())
+        {
+            auto tv = output.get_tensor_view();
+            if (nullptr == tv->get_tensor_view_layout())
+            {
+                auto layout = std::make_shared<DenseTensorViewLayout>(*tv);
+                tv->set_tensor_view_layout(layout);
+            }
+        }
+    }
+
+    // Determine tensor requirements for the call frame
+    unordered_map<shared_ptr<ngraph::descriptor::TensorView>, size_t> tensor_index;
+    // First come the function inputs
+    for (auto param : m_function->get_parameters())
+    {
+        for (const descriptor::Output& output : param->get_outputs())
+        {
+            auto tv = output.get_tensor_view();
+            size_t index = tensor_index.size();
+            tensor_index[tv] = index;
+        }
+    }
+    m_n_inputs = tensor_index.size();
+
+    // Next are the function outputs
+    for (const descriptor::Output& output : m_function->get_result()->get_outputs())
+    {
+        auto tv = output.get_tensor_view();
+        size_t index = tensor_index.size();
+        tensor_index[tv] = index;
+    }
+    m_n_outputs = tensor_index.size() - m_n_inputs;
+
+    // All remaining tensor views
+    for (shared_ptr<Node> node : m_function->get_ordered_ops())
+    {
+        for (const descriptor::Output& output : node->get_outputs())
+        {
+            auto tv = output.get_tensor_view();
+            if (0 == tensor_index.count(tv))
+            {
+                size_t index = tensor_index.size();
+                tensor_index[tv] = index;
+                m_temp_views.push_back(tv);
+            }
+        }
+    }
+
+    // Now we build the TU
+    for (shared_ptr<Node> node : m_function->get_ordered_ops())
+    {
+        
+    }
+
+    m_is_compiled = true;
+    if (m_release_function)
+    {
+        release_function();
+    }
+}
+
+// Suppress Clang's complaints about the ,##__VA_ARGS__ token-pasting hack, which is a GNU extension
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-zero-variadic-macro-arguments"
+
+#define DO_ON_ELEMENT_TYPE(et, err_msg, macro, ...)                                                \
+    {                                                                                              \
+        if (et == element::Bool::element_type())                                                   \
+        {                                                                                          \
+            macro(element::Bool, ##__VA_ARGS__);                                                   \
+        }                                                                                          \
+        else if (et == element::Float32::element_type())                                           \
+        {                                                                                          \
+            macro(element::Float32, ##__VA_ARGS__);                                                \
+        }                                                                                          \
+        else if (et == element::Int8::element_type())                                              \
+        {                                                                                          \
+            macro(element::Int8, ##__VA_ARGS__);                                                   \
+        }                                                                                          \
+        else if (et == element::Int32::element_type())                                             \
+        {                                                                                          \
+            macro(element::Int32, ##__VA_ARGS__);                                                  \
+        }                                                                                          \
+        else if (et == element::Int64::element_type())                                             \
+        {                                                                                          \
+            macro(element::Int64, ##__VA_ARGS__);                                                  \
+        }                                                                                          \
+        else if (et == element::UInt8::element_type())                                             \
+        {                                                                                          \
+            macro(element::UInt8, ##__VA_ARGS__);                                                  \
+        }                                                                                          \
+        else if (et == element::UInt32::element_type())                                            \
+        {                                                                                          \
+            macro(element::UInt32, ##__VA_ARGS__);                                                 \
+        }                                                                                          \
+        else if (et == element::UInt64::element_type())                                            \
+        {                                                                                          \
+            macro(element::UInt64, ##__VA_ARGS__);                                                 \
+        }                                                                                          \
+        else                                                                                       \
+        {                                                                                          \
+            throw ngraph_error(err_msg);                                                           \
+        }                                                                                          \
+    }
+
+// Turn off complaint suppression (see above)
+#pragma clang diagnostic pop
+
+shared_ptr<ngraph::runtime::CallFrame> ExternalFunction::make_call_frame()
+{
+    if (!m_is_compiled)
+    {
+        compile();
+    }
+    std::vector<std::shared_ptr<ngraph::runtime::TensorView>> temps;
+    for (auto tv : m_temp_views)
+    {
+        auto& et = tv->get_tensor_view_type()->get_element_type();
+        auto shape = tv->get_tensor_view_type()->get_shape();
+
+#define M(T) temps.push_back(ngraph::runtime::make_tensor<T>(shape));
+        DO_ON_ELEMENT_TYPE(
+            et, "Internal error: tried to create temporary for unhandled element type", M);
+#undef M
+    }
+    return make_shared<ngraph::runtime::cpu::CallFrame>(
+        m_n_inputs, m_n_outputs, temps);
+
+    //return shared_ptr<ngraph::runtime::CallFrame>();
+}

src/ngraph/runtime/cpu/external_function.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <memory>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+
+#include "ngraph/function.hpp"
+#include "ngraph/codegen/compiler.hpp"
+#include "ngraph/runtime/external_function.hpp"
+#include "ngraph/runtime/tensor_view_info.hpp"
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace cpu
+        {
+            class Instruction;
+
+            class ExternalFunction : public ngraph::runtime::ExternalFunction
+            {
+                using FunctionMap = std::unordered_map<std::shared_ptr<Function>,
+                                                       std::shared_ptr<ExternalFunction>>;
+
+                using OpFunction = std::function<void(const ngraph::Node*,
+                                                      ExternalFunction*,
+                                                      FunctionMap&,
+                                                      const std::vector<TensorViewInfo>& inputs,
+                                                      const std::vector<TensorViewInfo>& outputs)>;
+                using OpMap = std::unordered_map<std::type_index, OpFunction>;
+
+            public:
+                ExternalFunction(const std::shared_ptr<ngraph::Function>& function,
+                                 bool release_function = true);
+                std::shared_ptr<ngraph::runtime::CallFrame> make_call_frame();
+            protected:
+                void compile();
+                void compile(FunctionMap& function_map);
+
+                size_t m_n_inputs;
+                size_t m_n_outputs;
+                std::shared_ptr<std::vector<std::shared_ptr<Instruction>>> m_instructions;
+                ngraph::descriptor::TensorViewPtrs m_temp_views;
+            };
+        }
+    }
+}

src/ngraph/runtime/cpu/instruction.hpp

+// ----------------------------------------------------------------------------
+// Copyright 2017 Nervana Systems Inc.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// ----------------------------------------------------------------------------
+
+#pragma once
+
+#include <memory>
+
+namespace ngraph
+{
+    namespace runtime
+    {
+        namespace cpu
+        {
+            class CallFrame;
+
+            /// @brief An interpreter for an Op
+            ///
+            /// The call_frame has a vector of instructions and calls execute on each instruction, passing it the call_frame.
+            /// Instructions get argument, result, and intermediate tensor views from the call frame. Instructions may also
+            /// set a flag in the call_frame to end execution, or adjust execution by modifying the position in the instruction vector.
+            class Instruction
+            {
+            public:
+                virtual ~Instruction() {}
+                virtual void execute(CallFrame& call_frame) const = 0;
+            };
+        }
+    }
+}

test/CMakeLists.txt

@@ -49,7 +49,7 @@ endif()
 
 if(LLVM_INCLUDE_DIR)
     include_directories(SYSTEM ${LLVM_INCLUDE_DIR})
-    set(SRC ${SRC} codegen.cpp)
+    set(SRC ${SRC} codegen.cpp cpu.cpp)
 endif()
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")