root/implementation.hpp

#ifndef __TMTO__IMPLEMENTATION__HPP
#define __TMTO__IMPLEMENTATION__HPP

#include <tmto/condition/condition.hpp>
#include <tmto/round_function/round_function.hpp>

#include <tmto/utility/array.hpp>

#include <tmto/condition/condition.hpp>
#include <tmto/round_function/round_function.hpp>
//#include <tmto/round_function/generator/generator.hpp>

#include <tmto/threading/shared_forward.hpp>

#include <tmto/work_management/io_objects_fwd.hpp>

#include <tmto/device/working_set_host_side.hpp>

#include <tmto/origin/forward.hpp>
#include <tmto/table_access/table_access_fwd.hpp>

namespace boost {
  namespace program_options {
    class variables_map;
    class options_description;
  }
  namespace asio {
    class io_service;
  }
}

namespace tmto {
  template <typename T>
  struct static_initializer {
    static_initializer() {
      T::static_initialize();
    }
  };

  namespace configuration {
    class unused;
  }

  namespace work_generator {
    class implementation_base;
  }
  namespace work_consumer {
    class implementation_base;
  }
  namespace work_intermediate {
    class implementation_base;
  }

  namespace device {
    class device;
  }

  namespace implementation {
    template <typename Tag>
    struct host_part;

    template <typename Tag>
    struct combined_host_part;

    template <typename Tag>
    struct arguments_host_part;

    template <>
    struct arguments_host_part<configuration::unused> {
      static const bool has_options = false;
      static const char * name;
      static const int stepping = 1;
    };

    template <typename Impl>
    struct select_implementation_arguments {
    };

    template <typename HostPart>
    struct tag_of;
    template <typename Tag>
    struct tag_of<host_part<Tag> > {
      typedef Tag type;
    };

    template <typename HostPart>
    struct arguments_tag_of;
    template <typename Tag>
    struct arguments_tag_of<arguments_host_part<Tag> > {
      typedef Tag type;
    };

    class combined_implementation {
    public :
      virtual void dummy() { }
      virtual void initialize() { }

      template <typename T>
      device::working_set::working_set<T> * create_working_set(std::size_t size, int chunks, int num_roundfuncs) {
        return NULL;
      }

      int bitslice_width() {
        return 0;
      }
      //      bool apply_initial_roundfunc() { return false; }

      virtual const char * implementation_name() { return ""; }
      virtual const char * condition_name() { return ""; }
      virtual const char * round_function_name() { return ""; }
      virtual const char * data_type_name() { return ""; }
      virtual const char * chain_state_type_name() { return ""; }

      virtual origin::base * create_origin_management() {
        return NULL;
      }

      virtual table_access::master_base * create_io_scheduler(int stripewidth) {
        return NULL;
      }

      virtual void setup() { }

      virtual void setup
      (threading::shared & shared,
       work_management::io_objects_base * io_objects,
       boost::asio::io_service & io,
       device::device & device, bool master, int devno,
       int num_coop_threads,
       int abort_chain_threshold,
       const boost::program_options::variables_map & opt,
       origin::base *,
       table_access::master_base *
       ) { }

      virtual bool run(int run, int index, int devno, int dev_threadno, bool threaded,
                       bool firstrun, bool master) {
        return false;
      }
      virtual void synchronize(bool master) { }

      virtual void shutdown(bool master) { }

    };
  }

}

#endif