workflow.hpp

Go to the documentation of this file.

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
 
#ifndef workflow_h
#define workflow_h
 
#include "jit.hpp"
 
namespace workflow {
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class work_item {
    protected:
        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::shared_random_state<T, SAFE_MATH> state;
        std::function<void(void)> kernel;
 
    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::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), state(state),
        kernel_name(name), kernel_size(size) {
            context.add_kernel(name, in, out, maps, state, size);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void create_kernel_call(jit::context<T, SAFE_MATH> &context) {
            kernel = context.create_kernel_call(kernel_name, inputs, outputs,
                                                state, kernel_size);
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() {
            kernel();
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    template<jit::float_scalar T, bool SAFE_MATH=false>
    class loop_item final : public work_item<T, SAFE_MATH> {
        const size_t num_iterations;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        loop_item(graph::input_nodes<T, SAFE_MATH> inputs,
                  graph::output_nodes<T, SAFE_MATH> outputs,
                  graph::map_nodes<T, SAFE_MATH> maps,
                  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) :
        work_item<T, SAFE_MATH> (inputs, outputs, maps, state, name, size, context),
        num_iterations(iterations) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        virtual void run() {
            for (size_t i = 0; i < num_iterations; i++) {
                work_item<T, SAFE_MATH>::run();
            }
        }
    };
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
    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::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, 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<work_item<T, SAFE_MATH>>> preitems;
        std::vector<std::unique_ptr<work_item<T, SAFE_MATH>>> items;
        bool add_reduction;
 
    public:
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        manager(const size_t index) : context(index), add_reduction(false) {}
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void add_preitem(graph::input_nodes<T, SAFE_MATH> in,
                         graph::output_nodes<T, SAFE_MATH> out,
                         graph::map_nodes<T, SAFE_MATH> maps,
                         graph::shared_random_state<T, SAFE_MATH> state,
                         const std::string name, const size_t size) {
            preitems.push_back(std::make_unique<work_item<T, SAFE_MATH>> (in, out,
                                                                          maps, state,
                                                                          name, size,
                                                                          context));
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        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::shared_random_state<T, SAFE_MATH> state,
                      const std::string name, const size_t size) {
            items.push_back(std::make_unique<work_item<T, SAFE_MATH>> (in, out,
                                                                       maps, state,
                                                                       name, size,
                                                                       context));
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        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::shared_random_state<T, SAFE_MATH> state,
                           const std::string name, const size_t size,
                           const size_t iterations) {
            items.push_back(std::make_unique<loop_item<T, SAFE_MATH>> (in, out,
                                                                       maps, state,
                                                                       name, size,
                                                                       context,
                                                                       iterations));
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        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::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;
            items.push_back(std::make_unique<converge_item<T, SAFE_MATH>> (in, out,
                                                                           maps, 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);
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void pre_run() {
            for (auto &item : preitems) {
                item->run();
            }
        }
 
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
        void run() {
            for (auto &item : items) {
                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 */