workflow.hpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#ifndef workflow_h
#define workflow_h
 
#include "jit.hpp"
 
namespace workflow {
    enum order {
        pre_run_item,
        run_item,
        post_run_item
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class item {
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void create_kernel_call(jit::context<T, SAFE_MATH> &context) = 0;
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() = 0;
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class callback_item : public item<T, SAFE_MATH> {
    protected:
        std::function<void(void)> callback;
        std::function<void(void)> kernel;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        callback_item(std::function<void(void)> callback) :
        callback(callback) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void create_kernel_call(jit::context<T, SAFE_MATH> &context) {
            kernel = context.run_function(callback);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() {
            kernel();
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class zero_item : public item<T, SAFE_MATH> {
    protected:
        std::function<void(void)> kernel;
        graph::input_nodes<T, SAFE_MATH> inputs;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        zero_item(graph::input_nodes<T, SAFE_MATH> in) :
        inputs(in) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void create_kernel_call(jit::context<T, SAFE_MATH> &context) {
            kernel = context.create_zero_call(inputs);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() {
            kernel();
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class copy_item : public item<T, SAFE_MATH> {
    protected:
        std::function<void(void)> kernel;
        graph::copy_nodes<T, SAFE_MATH> maps;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        copy_item(graph::copy_nodes<T, SAFE_MATH> maps) :
        maps(maps) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void create_kernel_call(jit::context<T, SAFE_MATH> &context) {
            kernel = context.create_copy_call(maps);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() {
            kernel();
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class work_item : public item<T, SAFE_MATH> {
    protected:
        std::function<void(void)> kernel;
        const std::string kernel_name;
        const size_t kernel_size;
        graph::input_nodes<T, SAFE_MATH> inputs;
        graph::output_nodes<T, SAFE_MATH> outputs;
        graph::input_nodes<T, SAFE_MATH> atomics;
        graph::shared_random_state<T, SAFE_MATH> state;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        work_item(graph::input_nodes<T, SAFE_MATH> &in,
                  graph::output_nodes<T, SAFE_MATH> &out,
                  graph::map_nodes<T, SAFE_MATH> &maps,
                  graph::input_nodes<T, SAFE_MATH> &atomics,
                  graph::shared_random_state<T, SAFE_MATH> &state,
                  const std::string name, const size_t size,
                  jit::context<T, SAFE_MATH> &context) :
        inputs(in), outputs(out), atomics(atomics), state(state),
        kernel_name(name), kernel_size(size) {
            context.add_kernel(name, in, out, maps, atomics, state, size);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void create_kernel_call(jit::context<T, SAFE_MATH> &context) {
            kernel = context.create_kernel_call(kernel_name, inputs, outputs,
                                                atomics, state, kernel_size);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() {
            kernel();
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class loop_item final : public item<T, SAFE_MATH> {
    protected:
        std::function<void(void)> kernel;
        const std::string kernel_name;
        const size_t kernel_size;
        graph::input_nodes<T, SAFE_MATH> inputs;
        graph::output_nodes<T, SAFE_MATH> outputs;
        graph::input_nodes<T, SAFE_MATH> atomics;
        graph::shared_random_state<T, SAFE_MATH> state;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        loop_item(graph::input_nodes<T, SAFE_MATH> &in,
                  graph::output_nodes<T, SAFE_MATH> &out,
                  graph::map_nodes<T, SAFE_MATH> &maps,
                  graph::input_nodes<T, SAFE_MATH> &atomics,
                  graph::shared_random_state<T, SAFE_MATH> &state,
                  const std::string name, const size_t size,
                  jit::context<T, SAFE_MATH> &context,
                  const size_t iterations) :
        inputs(in), outputs(out), atomics(atomics),state(state),
        kernel_name(name), kernel_size(size) {
            context.add_kernel(name, in, out, maps, atomics,
                               state, size, iterations);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void create_kernel_call(jit::context<T, SAFE_MATH> &context) {
            kernel = context.create_kernel_call(kernel_name, inputs, outputs,
                                                atomics, state, kernel_size);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() {
            kernel();
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class converge_item final : public work_item<T, SAFE_MATH> {
    private:
        std::function<T(void)> max_kernel;
        const T tolerance;
        const size_t max_iterations;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        converge_item(graph::input_nodes<T, SAFE_MATH> &inputs,
                      graph::output_nodes<T, SAFE_MATH> &outputs,
                      graph::map_nodes<T, SAFE_MATH> &maps,
                      graph::input_nodes<T, SAFE_MATH> &atomics,
                      graph::shared_random_state<T, SAFE_MATH> &state,
                      const std::string name, const size_t size,
                      jit::context<T, SAFE_MATH> &context,
                      const T tol=1.0E-30,
                      const size_t max_iter=1000) :
        work_item<T, SAFE_MATH> (inputs, outputs, maps, atomics,
                                 state, name, size, context),
        tolerance(tol), max_iterations(max_iter) {
            context.add_max_reduction(size);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void create_kernel_call(jit::context<T, SAFE_MATH> &context) {
            work_item<T, SAFE_MATH>::create_kernel_call(context);
            max_kernel = context.create_max_call(this->outputs.back(),
                                                 this->kernel);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() {
            size_t iterations = 0;
            T max_residual = max_kernel();
            T last_max = std::numeric_limits<T>::max();
            T off_last_max = std::numeric_limits<T>::max();
            while (std::abs(max_residual) > std::abs(tolerance)                &&
                   std::abs(last_max - max_residual) > std::abs(tolerance)     &&
                   std::abs(off_last_max - max_residual) > std::abs(tolerance) &&
                   iterations++ < max_iterations) {
                last_max = max_residual;
                if (!(iterations%2)) {
                    off_last_max = max_residual;
                }
                max_residual = max_kernel();
            }
 
//  In release mode asserts are disables so write error to standard err. Need to
//  flip the comparison operator because we want to assert to trip if false.
            assert(iterations < max_iterations &&
                   "Workitem failed to converge.");
            if (iterations > max_iterations) {
                std::cerr << "Workitem failed to converge with in given iterations."
                          << std::endl;
                std::cerr << "Minimum residual reached: " << max_residual
                          << std::endl;
            }
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class manager {
    private:
        jit::context<T, SAFE_MATH> context;
        std::vector<std::unique_ptr<item<T, SAFE_MATH>>> preitems;
        std::vector<std::unique_ptr<item<T, SAFE_MATH>>> items;
        std::vector<std::unique_ptr<item<T, SAFE_MATH>>> postitems;
        bool add_reduction;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        manager(const size_t index) : context(index), add_reduction(false) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        template<order O=run_item>
        void add_callback_item(std::function<void(void)> callback) {
            if constexpr (O == pre_run_item) {
                preitems.push_back(std::make_unique<callback_item<T, SAFE_MATH>> (callback));
            } else if constexpr (O == run_item) {
                items.push_back(std::make_unique<callback_item<T, SAFE_MATH>> (callback));
            } else {
                postitems.push_back(std::make_unique<callback_item<T, SAFE_MATH>> (callback));
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        template<order O=run_item>
        void add_item(graph::input_nodes<T, SAFE_MATH> in,
                      graph::output_nodes<T, SAFE_MATH> out,
                      graph::map_nodes<T, SAFE_MATH> maps,
                      graph::input_nodes<T, SAFE_MATH> atomics,
                      graph::shared_random_state<T, SAFE_MATH> state,
                      const std::string name, const size_t size) {
            if constexpr (O == pre_run_item) {
                preitems.push_back(std::make_unique<work_item<T, SAFE_MATH>> (in, out,
                                                                              maps,
                                                                              atomics,
                                                                              state,
                                                                              name, size,
                                                                              context));
            } else if constexpr (O == run_item) {
                items.push_back(std::make_unique<work_item<T, SAFE_MATH>> (in, out,
                                                                           maps,
                                                                           atomics,
                                                                           state,
                                                                           name, size,
                                                                           context));
            } else {
                postitems.push_back(std::make_unique<work_item<T, SAFE_MATH>> (in, out,
                                                                               maps,
                                                                               atomics,
                                                                               state,
                                                                               name, size,
                                                                               context));
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        template<order O=run_item>
        void add_zero_item(graph::input_nodes<T, SAFE_MATH> in) {
            if constexpr (O == pre_run_item) {
                preitems.push_back(std::make_unique<zero_item<T, SAFE_MATH>> (in));
            } else if constexpr (O == run_item) {
                items.push_back(std::make_unique<zero_item<T, SAFE_MATH>> (in));
            } else {
                postitems.push_back(std::make_unique<zero_item<T, SAFE_MATH>> (in));
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        template<order O=run_item>
        void add_copy_item(graph::copy_nodes<T, SAFE_MATH> maps) {
            if constexpr (O == pre_run_item) {
                preitems.push_back(std::make_unique<copy_item<T, SAFE_MATH>> (maps));
            } else if constexpr (O == run_item) {
                items.push_back(std::make_unique<copy_item<T, SAFE_MATH>> (maps));
            } else {
                postitems.push_back(std::make_unique<copy_item<T, SAFE_MATH>> (maps));
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        template<order O=run_item>
        void add_loop_item(graph::input_nodes<T, SAFE_MATH> in,
                           graph::output_nodes<T, SAFE_MATH> out,
                           graph::map_nodes<T, SAFE_MATH> maps,
                           graph::input_nodes<T, SAFE_MATH> atomics,
                           graph::shared_random_state<T, SAFE_MATH> state,
                           const std::string name, const size_t size,
                           const size_t iterations) {
            if constexpr (O == pre_run_item) {
                preitems.push_back(std::make_unique<loop_item<T, SAFE_MATH>> (in, out,
                                                                              maps,
                                                                              atomics,
                                                                              state,
                                                                              name, size,
                                                                              context,
                                                                              iterations));
            } else if constexpr (O == run_item) {
                items.push_back(std::make_unique<loop_item<T, SAFE_MATH>> (in, out,
                                                                           maps,
                                                                           atomics,
                                                                           state,
                                                                           name, size,
                                                                           context,
                                                                           iterations));
            } else {
                postitems.push_back(std::make_unique<loop_item<T, SAFE_MATH>> (in, out,
                                                                               maps,
                                                                               atomics,
                                                                               state,
                                                                               name, size,
                                                                               context,
                                                                               iterations));
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        template<order O=run_item>
        void add_converge_item(graph::input_nodes<T, SAFE_MATH> in,
                               graph::output_nodes<T, SAFE_MATH> out,
                               graph::map_nodes<T, SAFE_MATH> maps,
                               graph::input_nodes<T, SAFE_MATH> atomics,
                               graph::shared_random_state<T, SAFE_MATH> state,
                               const std::string name, const size_t size,
                               const T tol=1.0E-30,
                               const size_t max_iter=1000) {
            add_reduction = true;
            if constexpr (O == pre_run_item) {
                items.push_back(std::make_unique<converge_item<T, SAFE_MATH>> (in, out,
                                                                               maps,
                                                                               atomics,
                                                                               state,
                                                                               name, size,
                                                                               context, tol,
                                                                               max_iter));
            } else if constexpr (O == run_item) {
                items.push_back(std::make_unique<converge_item<T, SAFE_MATH>> (in, out,
                                                                               maps,
                                                                               atomics,
                                                                               state,
                                                                               name, size,
                                                                               context, tol,
                                                                               max_iter));
            } else {
                postitems.push_back(std::make_unique<converge_item<T, SAFE_MATH>> (in, out,
                                                                                   maps,
                                                                                   atomics,
                                                                                   state,
                                                                                   name, size,
                                                                                   context, tol,
                                                                                   max_iter));
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void compile() {
            context.compile(add_reduction);
 
            for (auto &item : preitems) {
                item->create_kernel_call(context);
            }
            for (auto &item : items) {
                item->create_kernel_call(context);
            }
            for (auto &item : postitems) {
                item->create_kernel_call(context);
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        template<order O=run_item>
        void run() {
            if constexpr (O == pre_run_item) {
                for (auto &item : preitems) {
                    item->run();
                }
            } else if constexpr (O == run_item) {
                for (auto &item : items) {
                    item->run();
                }
            } else {
                for (auto &item : postitems) {
                    item->run();
                }
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void wait() {
            context.wait();
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void copy_to_device(graph::shared_leaf<T, SAFE_MATH> &node,
                            T *destination) {
            context.copy_to_device(node, destination);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void copy_to_host(graph::shared_leaf<T, SAFE_MATH> &node,
                          T *destination) {
            context.copy_to_host(node, destination);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void print(const size_t index,
                   const graph::output_nodes<T, SAFE_MATH> &nodes) {
            context.print(index, nodes);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        T check_value(const size_t index,
                      const graph::shared_leaf<T, SAFE_MATH> &node) {
            return context.check_value(index, node);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        jit::context<T, SAFE_MATH> &get_context() {
            return context;
        }
    };
}
 
#endif /* workflow_h */