ceph/src/boost/libs/compute/test/test_image2d.cpp

   1 //---------------------------------------------------------------------------//
   2 // Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com>
   3 //
   4 // Distributed under the Boost Software License, Version 1.0
   5 // See accompanying file LICENSE_1_0.txt or copy at
   6 // http://www.boost.org/LICENSE_1_0.txt
   7 //
   8 // See http://boostorg.github.com/compute for more information.
   9 //---------------------------------------------------------------------------//
  10
  11 #define BOOST_TEST_MODULE TestImage2D
  12 #include <boost/test/unit_test.hpp>
  13
  14 #include <iostream>
  15
  16 #include <boost/compute/system.hpp>
  17 #include <boost/compute/image/image2d.hpp>
  18 #include <boost/compute/utility/dim.hpp>
  19
  20 #include "quirks.hpp"
  21 #include "context_setup.hpp"
  22
  23 namespace compute = boost::compute;
  24
  25 BOOST_AUTO_TEST_CASE(image2d_get_supported_formats)
  26 {
  27     const std::vector<compute::image_format> formats =
  28         compute::image2d::get_supported_formats(context);
  29 }
  30
  31 BOOST_AUTO_TEST_CASE(create_image_doctest)
  32 {
  33     try {
  34 //! [create_image]
  35 // create 8-bit RGBA image format
  36 boost::compute::image_format rgba8(CL_RGBA, CL_UNSIGNED_INT8);
  37
  38 // create 640x480 image object
  39 boost::compute::image2d img(context, 640, 480, rgba8);
  40 //! [create_image]
  41
  42         // verify image has been created and format is correct
  43         BOOST_CHECK(img.get() != cl_mem());
  44         BOOST_CHECK(img.format() == rgba8);
  45         BOOST_CHECK_EQUAL(img.width(), size_t(640));
  46         BOOST_CHECK_EQUAL(img.height(), size_t(480));
  47     }
  48     catch(compute::opencl_error &e){
  49         if(e.error_code() == CL_IMAGE_FORMAT_NOT_SUPPORTED){
  50             // image format not supported by device
  51             return;
  52         }
  53
  54         // some other error, rethrow
  55         throw;
  56     }
  57 }
  58
  59 BOOST_AUTO_TEST_CASE(get_info)
  60 {
  61     compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8);
  62
  63     if(!compute::image2d::is_supported_format(format, context)){
  64         std::cerr << "skipping get_info test, image format not supported" << std::endl;
  65         return;
  66     }
  67
  68     compute::image2d image(
  69         context, 48, 64, format, compute::image2d::read_only
  70     );
  71
  72     BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_WIDTH), size_t(48));
  73     BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_HEIGHT), size_t(64));
  74     BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_DEPTH), size_t(0));
  75     BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_ROW_PITCH), size_t(48*4));
  76     BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_SLICE_PITCH), size_t(0));
  77     BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_ELEMENT_SIZE), size_t(4));
  78
  79     BOOST_CHECK(image.format() == format);
  80     BOOST_CHECK_EQUAL(image.width(), size_t(48));
  81     BOOST_CHECK_EQUAL(image.height(), size_t(64));
  82 }
  83
  84 BOOST_AUTO_TEST_CASE(clone_image)
  85 {
  86     compute::image_format format(CL_RGBA, CL_UNORM_INT8);
  87
  88     if(!compute::image2d::is_supported_format(format, context)){
  89         std::cerr << "skipping clone_image test, image format not supported" << std::endl;
  90         return;
  91     }
  92
  93     // image data
  94     unsigned int data[] = { 0x0000ffff, 0xff00ffff,
  95                             0x00ff00ff, 0xffffffff };
  96
  97     // create image on the device
  98     compute::image2d image(context, 2, 2, format);
  99
 100     // ensure we have a valid image object
 101     BOOST_REQUIRE(image.get() != cl_mem());
 102
 103     // copy image data to the device
 104     queue.enqueue_write_image(image, image.origin(), image.size(), data);
 105
 106     // clone image
 107     compute::image2d copy = image.clone(queue);
 108
 109     // ensure image format is the same
 110     BOOST_CHECK(copy.format() == image.format());
 111
 112     // read cloned image data back to the host
 113     unsigned int cloned_data[4];
 114     queue.enqueue_read_image(copy, image.origin(), image.size(), cloned_data);
 115
 116     // ensure original data and cloned data are the same
 117     BOOST_CHECK_EQUAL(cloned_data[0], data[0]);
 118     BOOST_CHECK_EQUAL(cloned_data[1], data[1]);
 119     BOOST_CHECK_EQUAL(cloned_data[2], data[2]);
 120     BOOST_CHECK_EQUAL(cloned_data[3], data[3]);
 121 }
 122
 123 #ifdef CL_VERSION_1_2
 124 BOOST_AUTO_TEST_CASE(fill_image)
 125 {
 126     REQUIRES_OPENCL_VERSION(1, 2); // device OpenCL version check
 127
 128     compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8);
 129
 130     if(!compute::image2d::is_supported_format(format, context)){
 131         std::cerr << "skipping fill_image test, image format not supported" << std::endl;
 132         return;
 133     }
 134
 135     compute::image2d img(context, 640, 480, format);
 136
 137     // fill image with black
 138     compute::uint4_ black(0, 0, 0, 255);
 139     queue.enqueue_fill_image(img, &black, img.origin(), img.size());
 140
 141     // read value of first pixel
 142     compute::uchar4_ first_pixel;
 143     queue.enqueue_read_image(img, compute::dim(0), compute::dim(1), &first_pixel);
 144     BOOST_CHECK_EQUAL(first_pixel, compute::uchar4_(0, 0, 0, 255));
 145
 146     // fill image with white
 147     compute::uint4_ white(255, 255, 255, 255);
 148     queue.enqueue_fill_image(img, &white, img.origin(), img.size());
 149
 150     // read value of first pixel
 151     queue.enqueue_read_image(img, compute::dim(0), compute::dim(1), &first_pixel);
 152     BOOST_CHECK_EQUAL(first_pixel, compute::uchar4_(255, 255, 255, 255));
 153 }
 154 #endif
 155
 156 // check type_name() for image2d
 157 BOOST_AUTO_TEST_CASE(image2d_type_name)
 158 {
 159     BOOST_CHECK(
 160         std::strcmp(
 161             boost::compute::type_name<boost::compute::image2d>(), "image2d_t"
 162         ) == 0
 163     );
 164 }
 165
 166 BOOST_AUTO_TEST_CASE(map_image)
 167 {
 168     compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8);
 169
 170     if(!compute::image2d::is_supported_format(format, context)){
 171         std::cerr << "skipping clone_image test, image format not supported" << std::endl;
 172         return;
 173     }
 174
 175     // create image on the device
 176     compute::image2d image(context, 2, 2, format);
 177
 178     // ensure we have a valid image object
 179     BOOST_REQUIRE(image.get() != cl_mem());
 180
 181     size_t row_pitch = 0;
 182     size_t slice_pitch = 0;
 183
 184     // write map image
 185     compute::uint_* ptr = static_cast<compute::uint_*>(
 186         queue.enqueue_map_image(image, CL_MAP_WRITE, image.origin(),
 187                                 image.size(), row_pitch, slice_pitch)
 188     );
 189
 190     BOOST_CHECK_EQUAL(row_pitch, size_t(2*4));
 191
 192     // image data
 193     compute::uint_ data[] = { 0x0000ffff, 0xff00ffff,
 194                               0x00ff00ff, 0xffffffff };
 195
 196     // copy data to image
 197     for(size_t i = 0; i < 4; i++){
 198         *(ptr+i) = data[i];
 199     }
 200
 201     // unmap
 202     queue.enqueue_unmap_image(image, static_cast<void*>(ptr));
 203
 204     // read map image
 205     compute::event map_event;
 206     ptr = static_cast<compute::uint_*>(
 207         queue.enqueue_map_image_async(image, CL_MAP_READ, image.origin(),
 208                                       image.size(), row_pitch, slice_pitch,
 209                                       map_event)
 210     );
 211
 212     map_event.wait();
 213
 214     BOOST_CHECK(map_event.get_status() == CL_COMPLETE);
 215     BOOST_CHECK_EQUAL(row_pitch, size_t(2*4));
 216
 217     // checking
 218     for(size_t i = 0; i < 4; i++){
 219         BOOST_CHECK_EQUAL(*(ptr+i), data[i]);
 220     }
 221
 222     // unmap
 223     queue.enqueue_unmap_image(image, static_cast<void*>(ptr));
 224 }
 225
 226 BOOST_AUTO_TEST_SUITE_END()