ceph/src/boost/libs/numeric/ublas/benchmarks/opencl/benchmark.hpp

   1 //
   2 // Copyright (c) 2018 Stefan Seefeld
   3 //
   4 // Distributed under the Boost Software License, Version 1.0.
   5 // (See accompanying file LICENSE_1_0.txt or
   6 // copy at http://www.boost.org/LICENSE_1_0.txt)
   7
   8 #ifndef opencl_benchmark_hpp_
   9 #define opencl_benchmark_hpp_
  10 #define BOOST_UBLAS_ENABLE_OPENCL
  11
  12 #include <boost/numeric/ublas/opencl.hpp>
  13 #include "../benchmark.hpp"
  14 #include "init.hpp"
  15 #include <memory>
  16
  17 namespace boost { namespace numeric { namespace ublas { namespace benchmark {
  18 namespace opencl {
  19
  20 struct base
  21 {
  22   base(compute::device d = compute::system::default_device())
  23     : context(d),
  24       queue(context, d)
  25   {}
  26   compute::context context;
  27   compute::command_queue queue;
  28 };
  29
  30 template <typename T, bool C> struct data_factory;
  31 template <typename T>
  32 struct data_factory<T, true>
  33 {
  34   typedef T type;
  35   typedef std::unique_ptr<type> ptr_type;
  36   static ptr_type create(long) { return ptr_type(new T());}
  37 };
  38 template <typename T>
  39 struct data_factory<T, false>
  40 {
  41   typedef T type;
  42   typedef std::unique_ptr<type> ptr_type;
  43   static ptr_type create(long, compute::context) { return ptr_type(new T());}
  44 };
  45 template <>
  46 struct data_factory<void, true>
  47 {
  48   typedef void type;
  49   typedef void *ptr_type;
  50   static ptr_type create(long) { return 0;}
  51 };
  52 template <>
  53 struct data_factory<void, false>
  54 {
  55   typedef void type;
  56   typedef void *ptr_type;
  57   static ptr_type create(long, compute::context) { return 0;}
  58 };
  59 template <typename T>
  60 struct data_factory<ublas::vector<T>, true>
  61 {
  62   typedef ublas::vector<T> type;
  63   typedef std::unique_ptr<type> ptr_type;
  64   static ptr_type create(long l) { return ptr_type(new type(l));}
  65 };
  66 template <typename T>
  67 struct data_factory<ublas::vector<T>, false>
  68 {
  69   typedef ublas::vector<T, ublas::opencl::storage> type;
  70   typedef std::unique_ptr<type> ptr_type;
  71   static ptr_type create(long l, compute::context c)
  72   { return ptr_type(new type(l, c));}
  73 };
  74 template <typename T, typename L>
  75 struct data_factory<ublas::matrix<T, L>, true>
  76 {
  77   typedef ublas::matrix<T, L> type;
  78   typedef std::unique_ptr<type> ptr_type;
  79   static ptr_type create(long l)
  80   { return ptr_type(new type(l, l));}
  81 };
  82 template <typename T, typename L>
  83 struct data_factory<ublas::matrix<T, L>, false>
  84 {
  85   typedef ublas::matrix<T, L, ublas::opencl::storage> type;
  86   typedef std::unique_ptr<type> ptr_type;
  87   static ptr_type create(long l, compute::context c)
  88   { return ptr_type(new type(l, l, c));}
  89 };
  90
  91 template <typename S, bool> class benchmark;
  92
  93 template <typename R, typename O>
  94 class benchmark<R(O), true> : public base, public ublas::benchmark::benchmark
  95 {
  96 public:
  97   benchmark(std::string const &name)
  98     : base(),
  99       ublas::benchmark::benchmark(name + " with copy")
 100   {}
 101   virtual void setup(long l)
 102   {
 103     r = data_factory<R, true>::create(l);
 104     a = data_factory<O, true>::create(l);
 105     init(*a, l, 200);
 106   }
 107   typename data_factory<R, true>::ptr_type r;
 108   typename data_factory<O, true>::ptr_type a;
 109 };
 110
 111 template <typename R, typename O1, typename O2>
 112 class benchmark<R(O1, O2), true> : public base, public ublas::benchmark::benchmark
 113 {
 114 public:
 115   benchmark(std::string const &name)
 116     : base(),
 117       ublas::benchmark::benchmark(name + " with copy")
 118   {}
 119   virtual void setup(long l)
 120   {
 121     r = data_factory<R, true>::create(l);
 122     a = data_factory<O1, true>::create(l);
 123     init(*a, l, 200);
 124     b = data_factory<O2, true>::create(l);
 125     init(*b, l, 200);
 126   }
 127   typename data_factory<R, true>::ptr_type r;
 128   typename data_factory<O1, true>::ptr_type a;
 129   typename data_factory<O2, true>::ptr_type b;
 130 };
 131
 132 template <typename R, typename O1, typename O2, typename O3>
 133 class benchmark<R(O1, O2, O3), true> : public base, public ublas::benchmark::benchmark
 134 {
 135 public:
 136   benchmark(std::string const &name)
 137     : base(),
 138       ublas::benchmark::benchmark(name + " with copy")
 139   {}
 140   virtual void setup(long l)
 141   {
 142     r = data_factory<R, true>::create(l);
 143     a = data_factory<O1, true>::create(l);
 144     init(*a, l, 200);
 145     b = data_factory<O2, true>::create(l);
 146     init(*b, l, 200);
 147     c = data_factory<O3, true>::create(l);
 148     init(*c, l, 200);
 149   }
 150   typename data_factory<R, true>::ptr_type r;
 151   typename data_factory<O1, true>::ptr_type a;
 152   typename data_factory<O2, true>::ptr_type b;
 153   typename data_factory<O3, true>::ptr_type c;
 154 };
 155
 156 template <typename R, typename O>
 157 class benchmark<R(O), false> : public base, public ublas::benchmark::benchmark
 158 {
 159 public:
 160   benchmark(std::string const &name)
 161     : base(),
 162       ublas::benchmark::benchmark(name + " w/o copy")
 163   {}
 164   virtual void setup(long l)
 165   {
 166     r = data_factory<R, false>::create(l, context);
 167     a = data_factory<O, false>::create(l, context);
 168     init(*a, l, 200);
 169   }
 170   typename data_factory<R, false>::ptr_type r;
 171   typename data_factory<O, false>::ptr_type a;
 172 };
 173
 174 template <typename R, typename O1, typename O2>
 175 class benchmark<R(O1, O2), false> : public base, public ublas::benchmark::benchmark
 176 {
 177 public:
 178   benchmark(std::string const &name) : base(), ublas::benchmark::benchmark(name + " w/o copy") {}
 179   virtual void setup(long l)
 180   {
 181     r = data_factory<R, false>::create(l, context);
 182     a = data_factory<O1, false>::create(l, context);
 183     init(*a, l, 200);
 184     b = data_factory<O2, false>::create(l, context);
 185     init(*b, l, 200);
 186   }
 187   typename data_factory<R, false>::ptr_type r;
 188   typename data_factory<O1, false>::ptr_type a;
 189   typename data_factory<O2, false>::ptr_type b;
 190 };
 191
 192 template <typename R, typename O1, typename O2, typename O3>
 193 class benchmark<R(O1, O2, O3), false> : public base, public ublas::benchmark::benchmark
 194 {
 195 public:
 196   benchmark(std::string const &name) : base(), ublas::benchmark::benchmark(name + " w/o copy") {}
 197   virtual void setup(long l)
 198   {
 199     r = data_factory<R, false>::create(l, context);
 200     a = data_factory<O1, false>::create(l, context);
 201     init(*a, l, 200);
 202     b = data_factory<O2, false>::create(l, context);
 203     init(*b, l, 200);
 204     c = data_factory<O3, false>::create(l, context);
 205     init(*c, l, 200);
 206   }
 207   typename data_factory<R, false>::ptr_type r;
 208   typename data_factory<O1, false>::ptr_type a;
 209   typename data_factory<O2, false>::ptr_type b;
 210   typename data_factory<O3, false>::ptr_type c;
 211 };
 212 }}}}}
 213
 214 #endif