Merge pull request #434 from kylelutz/parameter-cache

Add parameter_cache class

Author: kylelutz

.travis.yml

@@ -3,8 +3,9 @@ compiler:
     - gcc
     - clang
 before_install:
+    - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
     - sudo apt-get update -qq
-    - sudo apt-get install -qq fglrx=2:8.960-0ubuntu1 opencl-headers libboost-chrono1.48-dev libboost-date-time1.48-dev libboost-test1.48-dev libboost-system1.48-dev libboost-filesystem1.48-dev libboost-timer1.48-dev libboost-program-options1.48-dev libboost-thread1.48-dev python-yaml lcov libopencv-dev
+    - sudo apt-get install -qq fglrx=2:8.960-0ubuntu1 opencl-headers libboost-chrono1.48-dev libboost-date-time1.48-dev libboost-test1.48-dev libboost-system1.48-dev libboost-filesystem1.48-dev libboost-timer1.48-dev libboost-program-options1.48-dev libboost-thread1.48-dev python-yaml lcov libopencv-dev g++-4.8
     - gem install coveralls-lcov
 script:
     - mkdir -p build

include/boost/compute/algorithm/detail/binary_find.hpp

@@ -15,6 +15,7 @@
 #include <boost/compute/algorithm/find_if.hpp>
 #include <boost/compute/algorithm/transform.hpp>
 #include <boost/compute/command_queue.hpp>
+#include <boost/compute/detail/parameter_cache.hpp>
 
 namespace boost {
 namespace compute {
@@ -28,11 +29,9 @@ namespace detail{
 class binary_find_kernel : public meta_kernel
 {
 public:
-    size_t threads;
-
-    binary_find_kernel() : meta_kernel("binary_find")
+    binary_find_kernel(size_t threads) : meta_kernel("binary_find")
     {
-        threads = 128;
+        m_threads = threads;
     }
 
     template<class InputIterator, class UnaryPredicate>
@@ -41,7 +40,7 @@ class binary_find_kernel : public meta_kernel
                    UnaryPredicate predicate)
     {
         typedef typename std::iterator_traits<InputIterator>::value_type value_type;
-        int block = (iterator_range_size(first, last)-1)/(threads-1);
+        int block = (iterator_range_size(first, last)-1)/(m_threads-1);
 
         m_index_arg = add_arg<uint_ *>(memory_object::global_memory, "index");
 
@@ -60,10 +59,11 @@ class binary_find_kernel : public meta_kernel
     {
         set_arg(m_index_arg, index.get_buffer());
 
-        return exec_1d(queue, 0, threads);
+        return exec_1d(queue, 0, m_threads);
     }
 
 private:
+    size_t m_threads;
     size_t m_index_arg;
 };
 
@@ -84,16 +84,23 @@ inline InputIterator binary_find(InputIterator first,
                                  UnaryPredicate predicate,
                                  command_queue &queue = system::default_queue())
 {
+    const device &device = queue.get_device();
+
+    boost::shared_ptr<parameter_cache> parameters =
+        detail::parameter_cache::get_global_cache(device);
+
+    const std::string cache_key = "__boost_binary_find";
+
     size_t find_if_limit = 128;
-    size_t threads = 128;
+    size_t threads = parameters->get(cache_key, "tpb", 128);
     size_t count = iterator_range_size(first, last);
 
     while(count > find_if_limit) {
 
         scalar<uint_> index(queue.get_context());
         index.write(static_cast<uint_>(count), queue);
 
-        binary_find_kernel kernel;
+        binary_find_kernel kernel(threads);
         kernel.set_range(first, last, predicate);
         kernel.exec(queue, index);
 

include/boost/compute/algorithm/detail/copy_on_device.hpp

@@ -20,6 +20,7 @@
 #include <boost/compute/memory/svm_ptr.hpp>
 #include <boost/compute/detail/iterator_range_size.hpp>
 #include <boost/compute/detail/meta_kernel.hpp>
+#include <boost/compute/detail/parameter_cache.hpp>
 #include <boost/compute/detail/work_size.hpp>
 
 namespace boost {
@@ -42,12 +43,21 @@ template<class InputIterator, class OutputIterator>
 class copy_kernel : public meta_kernel
 {
 public:
-    copy_kernel()
+    copy_kernel(const device &device)
         : meta_kernel("copy")
     {
         m_count = 0;
-        m_vpt = 4;
-        m_tpb = 128;
+
+        typedef typename std::iterator_traits<InputIterator>::value_type input_type;
+
+        boost::shared_ptr<parameter_cache> parameters =
+            detail::parameter_cache::get_global_cache(device);
+
+        std::string cache_key =
+            "__boost_copy_kernel_" + boost::lexical_cast<std::string>(sizeof(input_type));
+
+        m_vpt = parameters->get(cache_key, "vpt", 4);
+        m_tpb = parameters->get(cache_key, "tpb", 128);
     }
 
     void set_range(InputIterator first,
@@ -97,7 +107,9 @@ inline OutputIterator copy_on_device(InputIterator first,
                                      OutputIterator result,
                                      command_queue &queue)
 {
-    copy_kernel<InputIterator, OutputIterator> kernel;
+    const device &device = queue.get_device();
+
+    copy_kernel<InputIterator, OutputIterator> kernel(device);
 
     kernel.set_range(first, last, result);
     kernel.exec(queue);
@@ -122,7 +134,9 @@ inline future<OutputIterator> copy_on_device_async(InputIterator first,
                                                    OutputIterator result,
                                                    command_queue &queue)
 {
-    copy_kernel<InputIterator, OutputIterator> kernel;
+    const device &device = queue.get_device();
+
+    copy_kernel<InputIterator, OutputIterator> kernel(device);
 
     kernel.set_range(first, last, result);
     event event_ = kernel.exec(queue);

include/boost/compute/algorithm/detail/inplace_reduce.hpp

@@ -13,6 +13,8 @@
 
 #include <iterator>
 
+#include <boost/utility/result_of.hpp>
+
 #include <boost/compute/command_queue.hpp>
 #include <boost/compute/container/vector.hpp>
 #include <boost/compute/detail/iterator_range_size.hpp>

include/boost/compute/algorithm/detail/radix_sort.hpp

@@ -23,9 +23,10 @@
 #include <boost/compute/algorithm/exclusive_scan.hpp>
 #include <boost/compute/container/vector.hpp>
 #include <boost/compute/detail/iterator_range_size.hpp>
+#include <boost/compute/detail/parameter_cache.hpp>
+#include <boost/compute/type_traits/type_name.hpp>
 #include <boost/compute/type_traits/is_fundamental.hpp>
 #include <boost/compute/type_traits/is_vector_type.hpp>
-#include <boost/compute/type_traits/type_name.hpp>
 #include <boost/compute/utility/program_cache.hpp>
 
 namespace boost {
@@ -232,19 +233,9 @@ inline void radix_sort_impl(const buffer_iterator<T> first,
     typedef T value_type;
     typedef typename radix_sort_value_type<sizeof(T)>::type sort_type;
 
+    const device &device = queue.get_device();
     const context &context = queue.get_context();
 
-    size_t count = detail::iterator_range_size(first, last);
-
-    // sort parameters
-    const uint_ k = 4;
-    const uint_ k2 = 1 << k;
-    const uint_ block_size = 128;
-
-    uint_ block_count = static_cast<uint_>(count / block_size);
-    if(block_count * block_size != count){
-        block_count++;
-    }
 
     // if we have a valid values iterator then we are doing a
     // sort by key and have to set up the values buffer
@@ -258,6 +249,17 @@ inline void radix_sort_impl(const buffer_iterator<T> first,
         cache_key += std::string("_with_") + type_name<T2>();
     }
 
+    boost::shared_ptr<program_cache> cache =
+        program_cache::get_global_cache(context);
+    boost::shared_ptr<parameter_cache> parameters =
+        detail::parameter_cache::get_global_cache(device);
+
+    // sort parameters
+    const uint_ k = parameters->get(cache_key, "k", 4);
+    const uint_ k2 = 1 << k;
+    const uint_ block_size = parameters->get(cache_key, "tpb", 128);
+
+    // sort program compiler options
     std::stringstream options;
     options << "-DK_BITS=" << k;
     options << " -DT=" << type_name<sort_type>();
@@ -277,17 +279,22 @@ inline void radix_sort_impl(const buffer_iterator<T> first,
         options << enable_double<T2>();
     }
 
-    // load (or create) radix sort program
-    boost::shared_ptr<program_cache> cache =
-        program_cache::get_global_cache(context);
-
-    program radix_sort_program =
-        cache->get_or_build(cache_key, options.str(), radix_sort_source, context);
+    // load radix sort program
+    program radix_sort_program = cache->get_or_build(
+        cache_key, options.str(), radix_sort_source, context
+    );
 
     kernel count_kernel(radix_sort_program, "count");
     kernel scan_kernel(radix_sort_program, "scan");
     kernel scatter_kernel(radix_sort_program, "scatter");
 
+    size_t count = detail::iterator_range_size(first, last);
+
+    uint_ block_count = static_cast<uint_>(count / block_size);
+    if(block_count * block_size != count){
+        block_count++;
+    }
+
     // setup temporary buffers
     vector<value_type> output(count, context);
     vector<T2> values_output(sort_by_key ? count : 0, context);

include/boost/compute/algorithm/detail/reduce_on_gpu.hpp

@@ -13,15 +13,15 @@
 
 #include <iterator>
 
+#include <boost/compute/utility/source.hpp>
 #include <boost/compute/program.hpp>
 #include <boost/compute/command_queue.hpp>
 #include <boost/compute/detail/vendor.hpp>
+#include <boost/compute/detail/parameter_cache.hpp>
 #include <boost/compute/detail/work_size.hpp>
 #include <boost/compute/detail/meta_kernel.hpp>
-#include <boost/compute/type_traits/result_of.hpp>
 #include <boost/compute/type_traits/type_name.hpp>
 #include <boost/compute/utility/program_cache.hpp>
-#include <boost/compute/utility/source.hpp>
 
 namespace boost {
 namespace compute {
@@ -99,7 +99,7 @@ inline void initial_reduce(InputIterator first,
     (void) reduce_kernel;
 
     typedef typename std::iterator_traits<InputIterator>::value_type Arg;
-    typedef typename ::boost::compute::result_of<Function(Arg, Arg)>::type T;
+    typedef typename boost::tr1_result_of<Function(Arg, Arg)>::type T;
 
     size_t count = std::distance(first, last);
     detail::meta_kernel k("initial_reduce");
@@ -174,6 +174,7 @@ inline void reduce_on_gpu(InputIterator first,
                           command_queue &queue)
 {
     const device &device = queue.get_device();
+    const context &context = queue.get_context();
 
     detail::meta_kernel k("reduce");
     k.add_arg<const T*>(memory_object::global_memory, "input");
@@ -210,28 +211,34 @@ inline void reduce_on_gpu(InputIterator first,
          "    output[output_offset + get_group_id(0)] = scratch[0];\n" <<
          "}\n";
 
-    uint_ vpt = 8;
-    uint_ tpb = 128;
+    std::string cache_key = std::string("__boost_reduce_on_gpu_") + type_name<T>();
 
-    size_t count = std::distance(first, last);
+    // load parameters
+    boost::shared_ptr<parameter_cache> parameters =
+        detail::parameter_cache::get_global_cache(device);
 
-    const context &context = queue.get_context();
+    uint_ vpt = parameters->get(cache_key, "vpt", 8);
+    uint_ tpb = parameters->get(cache_key, "tpb", 128);
+
+    // reduce program compiler flags
+    std::stringstream options;
+    options << "-DT=" << type_name<T>()
+            << " -DVPT=" << vpt
+            << " -DTPB=" << tpb;
 
-    // load (or create) reduce program
+    // load program
     boost::shared_ptr<program_cache> cache =
         program_cache::get_global_cache(context);
 
-    std::string cache_key = std::string("__boost_reduce_on_gpu_") + type_name<T>();
-
-    std::stringstream options;
-    options << "-DT=" << type_name<T>() << " -DVPT=" << vpt << " -DTPB=" << tpb;
-
-    program reduce_program =
-        cache->get_or_build(cache_key, options.str(), k.source(), context);
+    program reduce_program = cache->get_or_build(
+        cache_key, options.str(), k.source(), context
+    );
 
     // create reduce kernel
     kernel reduce_kernel(reduce_program, "reduce");
 
+    size_t count = std::distance(first, last);
+
     // first pass, reduce from input to ping
     buffer ping(context, std::ceil(float(count) / vpt / tpb) * sizeof(T));
     initial_reduce(first, last, ping, function, reduce_kernel, vpt, tpb, queue);