diff options
Diffstat (limited to 'src/boost/libs/compute')
324 files changed, 34564 insertions, 0 deletions
diff --git a/src/boost/libs/compute/CMakeLists.txt b/src/boost/libs/compute/CMakeLists.txt new file mode 100644 index 00000000..71e7722e --- /dev/null +++ b/src/boost/libs/compute/CMakeLists.txt @@ -0,0 +1,129 @@ +# --------------------------------------------------------------------------- +# Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +# +# Distributed under the Boost Software License, Version 1.0 +# See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt +# +# --------------------------------------------------------------------------- + +cmake_minimum_required(VERSION 2.8) + +project(BoostCompute) + +set(CMAKE_MODULE_PATH ${BoostCompute_SOURCE_DIR}/cmake) +if (CMAKE_VERSION VERSION_LESS "3.1.0") + list(APPEND CMAKE_MODULE_PATH "${BoostCompute_SOURCE_DIR}/cmake/opencl") +endif() + +# find OpenCL +find_package(OpenCL REQUIRED) +include_directories(SYSTEM ${OpenCL_INCLUDE_DIRS}) + +# find Boost +find_package(Boost 1.54 REQUIRED) +include_directories(SYSTEM ${Boost_INCLUDE_DIRS}) + +# optional support for c++11 +option(BOOST_COMPUTE_USE_CPP11 "Use C++11 features" OFF) +if(NOT MSVC) + if(${BOOST_COMPUTE_USE_CPP11}) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") + endif() +endif() + +# optional support for offline-caching +option(BOOST_COMPUTE_USE_OFFLINE_CACHE "Use offline cache for OpenCL program binaries" OFF) +if(${BOOST_COMPUTE_USE_OFFLINE_CACHE}) + add_definitions(-DBOOST_COMPUTE_USE_OFFLINE_CACHE) +endif() + +# thread-safety options +option(BOOST_COMPUTE_THREAD_SAFE "Compile with BOOST_COMPUTE_THREAD_SAFE defined" OFF) +if(${BOOST_COMPUTE_THREAD_SAFE}) + add_definitions(-DBOOST_COMPUTE_THREAD_SAFE) + if(${BOOST_COMPUTE_USE_CPP11}) + if(MSVC) + if (MSVC_VERSION GREATER 1800) + add_definitions(-DBOOST_COMPUTE_HAVE_THREAD_LOCAL) + endif() + else() + add_definitions(-DBOOST_COMPUTE_HAVE_THREAD_LOCAL) + endif() + endif() +endif() + +# optional third-party libraries +option(BOOST_COMPUTE_HAVE_EIGEN "Have Eigen" OFF) +option(BOOST_COMPUTE_HAVE_OPENCV "Have OpenCV" OFF) +option(BOOST_COMPUTE_HAVE_QT "Have Qt" OFF) +option(BOOST_COMPUTE_HAVE_VTK "Have VTK" OFF) +option(BOOST_COMPUTE_HAVE_CUDA "Have CUDA" OFF) +option(BOOST_COMPUTE_HAVE_TBB "Have TBB" OFF) +option(BOOST_COMPUTE_HAVE_BOLT "Have BOLT" OFF) + +include_directories(include) + +if(${OpenCL_HEADER_CL_EXT_FOUND}) + add_definitions(-DBOOST_COMPUTE_HAVE_HDR_CL_EXT) +endif() + +if(WIN32) + # optional support for boost dynamic libraries + option(BOOST_COMPUTE_BOOST_ALL_DYN_LINK "Use boost dynamic link libraries" OFF) + if(${BOOST_COMPUTE_BOOST_ALL_DYN_LINK}) + add_definitions(-DBOOST_ALL_DYN_LINK) + else() + # for default use statis libs + set(Boost_USE_STATIC_LIBS ON) + endif() + link_directories(${Boost_LIBRARY_DIRS}) +endif() + +# compiler options +option(BOOST_COMPUTE_ENABLE_COVERAGE "Enable code coverage generation" OFF) + +# Visual Studio C++ +if(MSVC) + add_definitions(-D_CRT_SECURE_NO_WARNINGS) + add_definitions(-D_SCL_SECURE_NO_WARNINGS) + add_definitions(-DNOMINMAX) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4003") # Not enough actual parameters for a BOOST_PP macro + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4244") # Warning C4244: 'initializing': conversion from 'double' to 'int', possible loss of data + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4305") # Warning C4305: 'initializing': truncation from 'double' to 'float' + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4800") # Warning C4800: 'uint32_t' : forcing value to bool 'true' or 'false' (performance warning) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4838") # Warning C4838: conversion from 'double' to 'float' requires a narrowing conversion +endif() + +option(BOOST_COMPUTE_BUILD_TESTS "Build the Boost.Compute tests" OFF) +if(${BOOST_COMPUTE_BUILD_TESTS}) + enable_testing() + add_subdirectory(test) +endif() + +option(BOOST_COMPUTE_BUILD_BENCHMARKS "Build the Boost.Compute benchmarks" OFF) +if(${BOOST_COMPUTE_BUILD_BENCHMARKS}) + add_subdirectory(perf) +endif() + +option(BOOST_COMPUTE_BUILD_EXAMPLES "Build the Boost.Compute examples" OFF) +if(${BOOST_COMPUTE_BUILD_EXAMPLES}) + add_subdirectory(example) +endif() + +# configure cmake config file +configure_file( + cmake/BoostComputeConfig.cmake.in + ${BoostCompute_BINARY_DIR}/BoostComputeConfig.cmake + @ONLY +) + +# install cmake config file +install( + FILES ${BoostCompute_BINARY_DIR}/BoostComputeConfig.cmake + DESTINATION lib/cmake/BoostCompute +) + +# install header files +install(DIRECTORY include/boost DESTINATION include/compute) diff --git a/src/boost/libs/compute/CONTRIBUTING.md b/src/boost/libs/compute/CONTRIBUTING.md new file mode 100644 index 00000000..d8b5fa23 --- /dev/null +++ b/src/boost/libs/compute/CONTRIBUTING.md @@ -0,0 +1,46 @@ +# Contributing to Boost.Compute # + +## Reporting Issues ## + +We value your feedback about issues you encounter. The more information you +provide the easier it is for developers to resolve the problem. + +Issues should be reported to the [issue tracker]( +https://github.com/boostorg/compute/issues?state=open). + +Issues can also be used to submit feature requests. + +## Submitting Pull Requests ## + +Base your changes on `master` but submit your pull-request to `develop`. This +can be changed by clicking the "Edit" button on the pull-request page. The +develop branch is used for integration and testing of changes before merging +into the stable `master` branch. + +Please try to rebase your changes on the current master branch before +submitting. This keeps the git history cleaner and easier to understand. + +## Coding Style ## + +* Indentation is four-spaces (not tabs) +* Try to keep line-length under 80 characters +* Follow the STL/Boost naming conventions (e.g. lower case with underscores) +* When in doubt, match the style of existing code +* Otherwise, do whatever you want + +Also see the [Boost Library Requirements] +(http://www.boost.org/development/requirements.html)). + +## Running Tests ## + +To build the tests you must enable the `BOOST_COMPUTE_BUILD_TESTS` option in +`cmake`. The tests can be run by executing the `ctest` command from the build +directory. + +Please report any tests failures to the issue tracker along with the test +output and information on your system and compute device. + +## Support ## + +Feel free to send an email to kyle.r.lutz@gmail.com with any problems or +questions. diff --git a/src/boost/libs/compute/LICENSE_1_0.txt b/src/boost/libs/compute/LICENSE_1_0.txt new file mode 100644 index 00000000..36b7cd93 --- /dev/null +++ b/src/boost/libs/compute/LICENSE_1_0.txt @@ -0,0 +1,23 @@ +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by +this license (the "Software") to use, reproduce, display, distribute, +execute, and transmit the Software, and to prepare derivative works of the +Software, and to permit third-parties to whom the Software is furnished to +do so, all subject to the following: + +The copyright notices in the Software and this entire statement, including +the above license grant, this restriction and the following disclaimer, +must be included in all copies of the Software, in whole or in part, and +all derivative works of the Software, unless such copies or derivative +works are solely in the form of machine-executable object code generated by +a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT +SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE +FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. diff --git a/src/boost/libs/compute/README.md b/src/boost/libs/compute/README.md new file mode 100644 index 00000000..f8556116 --- /dev/null +++ b/src/boost/libs/compute/README.md @@ -0,0 +1,90 @@ +# Boost.Compute # + +[](https://travis-ci.org/boostorg/compute) +[](https://ci.appveyor.com/project/jszuppe/compute/branch/master) +[](https://coveralls.io/r/boostorg/compute) +[](https://gitter.im/boostorg/compute?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) + +Boost.Compute is a GPU/parallel-computing library for C++ based on OpenCL. + +The core library is a thin C++ wrapper over the OpenCL API and provides +access to compute devices, contexts, command queues and memory buffers. + +On top of the core library is a generic, STL-like interface providing common +algorithms (e.g. `transform()`, `accumulate()`, `sort()`) along with common +containers (e.g. `vector<T>`, `flat_set<T>`). It also features a number of +extensions including parallel-computing algorithms (e.g. `exclusive_scan()`, +`scatter()`, `reduce()`) and a number of fancy iterators (e.g. +`transform_iterator<>`, `permutation_iterator<>`, `zip_iterator<>`). + +The full documentation is available at http://boostorg.github.io/compute/. + +## Example ## + +The following example shows how to sort a vector of floats on the GPU: + +```c++ +#include <vector> +#include <algorithm> +#include <boost/compute.hpp> + +namespace compute = boost::compute; + +int main() +{ + // get the default compute device + compute::device gpu = compute::system::default_device(); + + // create a compute context and command queue + compute::context ctx(gpu); + compute::command_queue queue(ctx, gpu); + + // generate random numbers on the host + std::vector<float> host_vector(1000000); + std::generate(host_vector.begin(), host_vector.end(), rand); + + // create vector on the device + compute::vector<float> device_vector(1000000, ctx); + + // copy data to the device + compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + // sort data on the device + compute::sort( + device_vector.begin(), device_vector.end(), queue + ); + + // copy data back to the host + compute::copy( + device_vector.begin(), device_vector.end(), host_vector.begin(), queue + ); + + return 0; +} +``` + +Boost.Compute is a header-only library, so no linking is required. The example +above can be compiled with: + +`g++ -I/path/to/compute/include sort.cpp -lOpenCL` + +More examples can be found in the [tutorial]( +http://boostorg.github.io/compute/boost_compute/tutorial.html) and under the +[examples](https://github.com/boostorg/compute/tree/master/example) directory. + +## Support ## +Questions about the library (both usage and development) can be posted to the +[mailing list](https://groups.google.com/forum/#!forum/boost-compute). + +Bugs and feature requests can be reported through the [issue tracker]( +https://github.com/boostorg/compute/issues?state=open). + +Also feel free to send me an email with any problems, questions, or feedback. + +## Help Wanted ## +The Boost.Compute project is currently looking for additional developers with +interest in parallel computing. + +Please send an email to Kyle Lutz (kyle.r.lutz@gmail.com) for more information. diff --git a/src/boost/libs/compute/cmake/BoostComputeConfig.cmake.in b/src/boost/libs/compute/cmake/BoostComputeConfig.cmake.in new file mode 100644 index 00000000..5f03d0db --- /dev/null +++ b/src/boost/libs/compute/cmake/BoostComputeConfig.cmake.in @@ -0,0 +1,6 @@ +# Config file for Boost.Compute (https://github.com/boostorg/compute) +# +# Sets the following variables: +# BoostCompute_INCLUDE_DIRS - include directories for Boost.Compute + +set(BoostCompute_INCLUDE_DIRS "@CMAKE_INSTALL_PREFIX@/include/compute") diff --git a/src/boost/libs/compute/cmake/FindBolt.cmake b/src/boost/libs/compute/cmake/FindBolt.cmake new file mode 100644 index 00000000..0820de0d --- /dev/null +++ b/src/boost/libs/compute/cmake/FindBolt.cmake @@ -0,0 +1,149 @@ +############################################################################ +# © 2012,2014 Advanced Micro Devices, Inc. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +############################################################################ + +# Locate an BOLT implementation. +# +# Defines the following variables: +# +# BOLT_FOUND - Found an Bolt imlementation +# +# Also defines the library variables below as normal +# variables. +# +# BOLT_LIBRARIES - These contain debug/optimized keywords when a debugging library is found +# BOLT_INCLUDE_DIRS - All relevant Bolt include directories +# +# Accepts the following variables as input: +# +# BOLT_ROOT - (as a CMake or environment variable) +# The root directory of an BOLT installation +# +# FIND_LIBRARY_USE_LIB64_PATHS - Global property that controls whether FindBOLT should search for +# 64bit or 32bit libs +# +#----------------------- +# Example Usage: +# +# find_package(BOLT REQUIRED) +# include_directories(${BOLT_INCLUDE_DIRS}) +# +# add_executable(foo foo.cc) +# target_link_libraries(foo ${BOLT_LIBRARIES}) +# +#----------------------- + +# This module helps to use BOLT_FIND_COMPONENTS, BOLT_FIND_REQUIRED, BOLT_FIND_QUIETLY +include( FindPackageHandleStandardArgs ) + +# Search for 64bit libs if FIND_LIBRARY_USE_LIB64_PATHS is set to true in the global environment, 32bit libs else +get_property( LIB64 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS ) + +# Debug print statements +#message( "BOLT_LIBRARY_PATH_SUFFIXES: ${BOLT_LIBRARY_PATH_SUFFIXES}" ) +#message( "ENV{BOLT_ROOT}: $ENV{BOLT_ROOT}" ) +#message( "BOLT_FIND_COMPONENTS: ${BOLT_FIND_COMPONENTS}" ) +#message( "BOLT_FIND_REQUIRED: ${BOLT_FIND_REQUIRED}" ) + +# Set the component to find if the user does not specify explicitely +if( NOT BOLT_FIND_COMPONENTS ) + set( BOLT_FIND_COMPONENTS CL ) +endif( ) +if(WIN32) +if( MSVC_VERSION VERSION_LESS 1600 ) + set( myMSVCVer "vc90" ) +elseif( MSVC_VERSION VERSION_LESS 1700 ) + set( myMSVCVer "vc100" ) +elseif( MSVC_VERSION VERSION_LESS 1800 ) + set( myMSVCVer "vc110" ) +else() + set( myMSVCVer "vc120" ) +endif( ) +else() + set( myMSVCVer "gcc" ) +endif() + +if(WIN32) + set( BoltLibName "clBolt.runtime.${myMSVCVer}") + set( LIB_EXT "lib") +else() + set( BoltLibName "libclBolt.runtime.${myMSVCVer}") + set( LIB_EXT "a") +endif() + +# Eventually, Bolt may support multiple backends, but for now it only supports CL +list( FIND BOLT_FIND_COMPONENTS CL find_CL ) +if( NOT find_CL EQUAL -1 ) + set( BOLT_LIBNAME_BASE ${BoltLibName} ) +endif( ) + +if( NOT find_CL EQUAL -1 ) + # Find and set the location of main BOLT static lib file + find_library( BOLT_LIBRARY_STATIC_RELEASE + NAMES ${BOLT_LIBNAME_BASE}.${LIB_EXT} + HINTS + ${BOLT_ROOT} + ENV BOLT_ROOT + DOC "BOLT static library path" + PATH_SUFFIXES lib + ) + mark_as_advanced( BOLT_LIBRARY_STATIC_RELEASE ) + + # Find and set the location of main BOLT static lib file + find_library( BOLT_LIBRARY_STATIC_DEBUG + NAMES ${BOLT_LIBNAME_BASE}.debug.${LIB_EXT} + HINTS + ${BOLT_ROOT} + ENV BOLT_ROOT + DOC "BOLT static library path" + PATH_SUFFIXES lib + ) + mark_as_advanced( BOLT_LIBRARY_STATIC_DEBUG ) + + if( BOLT_LIBRARY_STATIC_RELEASE ) + set( BOLT_LIBRARY_STATIC optimized ${BOLT_LIBRARY_STATIC_RELEASE} ) + else( ) + set( BOLT_LIBRARY_STATIC "" ) + message( "${BOLT_LIBNAME_BASE}.${LIB_EXT}: Release static bolt library not found" ) + endif( ) + + if( BOLT_LIBRARY_STATIC_DEBUG ) + set( BOLT_LIBRARY_STATIC ${BOLT_LIBRARY_STATIC} debug ${BOLT_LIBRARY_STATIC_DEBUG} ) + else( ) + message( "${BOLT_LIBNAME_BASE}.debug.${LIB_EXT}: Debug static bolt library not found" ) + endif( ) + + find_path( BOLT_INCLUDE_DIRS + NAMES bolt/cl/bolt.h + HINTS + ${BOLT_ROOT} + ENV BOLT_ROOT + DOC "BOLT header file path" + PATH_SUFFIXES include + ) + mark_as_advanced( BOLT_INCLUDE_DIRS ) + + FIND_PACKAGE_HANDLE_STANDARD_ARGS( BOLT DEFAULT_MSG BOLT_LIBRARY_STATIC BOLT_INCLUDE_DIRS ) +endif( ) + +if( BOLT_FOUND ) + list( APPEND BOLT_LIBRARIES ${BOLT_LIBRARY_STATIC} ) +else( ) + if( NOT BOLT_FIND_QUIETLY ) + message( WARNING "FindBOLT could not find the BOLT library" ) + message( STATUS "Did you remember to set the BOLT_ROOT environment variable?" ) + endif( ) +endif() diff --git a/src/boost/libs/compute/cmake/FindEigen.cmake b/src/boost/libs/compute/cmake/FindEigen.cmake new file mode 100644 index 00000000..2cd3e12c --- /dev/null +++ b/src/boost/libs/compute/cmake/FindEigen.cmake @@ -0,0 +1,160 @@ +# Ceres Solver - A fast non-linear least squares minimizer +# Copyright 2013 Google Inc. All rights reserved. +# http://code.google.com/p/ceres-solver/ +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# * Neither the name of Google Inc. nor the names of its contributors may be +# used to endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +# +# Author: alexs.mac@gmail.com (Alex Stewart) +# + +# FindEigen.cmake - Find Eigen library, version >= 3. +# +# This module defines the following variables: +# +# EIGEN_FOUND: TRUE iff Eigen is found. +# EIGEN_INCLUDE_DIRS: Include directories for Eigen. +# +# EIGEN_VERSION: Extracted from Eigen/src/Core/util/Macros.h +# EIGEN_WORLD_VERSION: Equal to 3 if EIGEN_VERSION = 3.2.0 +# EIGEN_MAJOR_VERSION: Equal to 2 if EIGEN_VERSION = 3.2.0 +# EIGEN_MINOR_VERSION: Equal to 0 if EIGEN_VERSION = 3.2.0 +# +# The following variables control the behaviour of this module: +# +# EIGEN_INCLUDE_DIR_HINTS: List of additional directories in which to +# search for eigen includes, e.g: /timbuktu/eigen3. +# +# The following variables are also defined by this module, but in line with +# CMake recommended FindPackage() module style should NOT be referenced directly +# by callers (use the plural variables detailed above instead). These variables +# do however affect the behaviour of the module via FIND_[PATH/LIBRARY]() which +# are NOT re-called (i.e. search for library is not repeated) if these variables +# are set with valid values _in the CMake cache_. This means that if these +# variables are set directly in the cache, either by the user in the CMake GUI, +# or by the user passing -DVAR=VALUE directives to CMake when called (which +# explicitly defines a cache variable), then they will be used verbatim, +# bypassing the HINTS variables and other hard-coded search locations. +# +# EIGEN_INCLUDE_DIR: Include directory for CXSparse, not including the +# include directory of any dependencies. + +# Called if we failed to find Eigen or any of it's required dependencies, +# unsets all public (designed to be used externally) variables and reports +# error message at priority depending upon [REQUIRED/QUIET/<NONE>] argument. +MACRO(EIGEN_REPORT_NOT_FOUND REASON_MSG) + UNSET(EIGEN_FOUND) + UNSET(EIGEN_INCLUDE_DIRS) + # Make results of search visible in the CMake GUI if Eigen has not + # been found so that user does not have to toggle to advanced view. + MARK_AS_ADVANCED(CLEAR EIGEN_INCLUDE_DIR) + # Note <package>_FIND_[REQUIRED/QUIETLY] variables defined by FindPackage() + # use the camelcase library name, not uppercase. + IF (Eigen_FIND_QUIETLY) + MESSAGE(STATUS "Failed to find Eigen - " ${REASON_MSG} ${ARGN}) + ELSEIF (Eigen_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "Failed to find Eigen - " ${REASON_MSG} ${ARGN}) + ELSE() + # Neither QUIETLY nor REQUIRED, use no priority which emits a message + # but continues configuration and allows generation. + MESSAGE("-- Failed to find Eigen - " ${REASON_MSG} ${ARGN}) + ENDIF () +ENDMACRO(EIGEN_REPORT_NOT_FOUND) + +# Search user-installed locations first, so that we prefer user installs +# to system installs where both exist. +# +# TODO: Add standard Windows search locations for Eigen. +LIST(APPEND EIGEN_CHECK_INCLUDE_DIRS + /usr/local/include/eigen3 + /usr/local/homebrew/include/eigen3 # Mac OS X + /opt/local/var/macports/software/eigen3 # Mac OS X. + /opt/local/include/eigen3 + /usr/include/eigen3) + +# Search supplied hint directories first if supplied. +FIND_PATH(EIGEN_INCLUDE_DIR + NAMES Eigen/Core + PATHS ${EIGEN_INCLUDE_DIR_HINTS} + ${EIGEN_CHECK_INCLUDE_DIRS}) +IF (NOT EIGEN_INCLUDE_DIR OR + NOT EXISTS ${EIGEN_INCLUDE_DIR}) + EIGEN_REPORT_NOT_FOUND( + "Could not find eigen3 include directory, set EIGEN_INCLUDE_DIR to " + "path to eigen3 include directory, e.g. /usr/local/include/eigen3.") +ENDIF (NOT EIGEN_INCLUDE_DIR OR + NOT EXISTS ${EIGEN_INCLUDE_DIR}) + +# Mark internally as found, then verify. EIGEN_REPORT_NOT_FOUND() unsets +# if called. +SET(EIGEN_FOUND TRUE) + +# Extract Eigen version from Eigen/src/Core/util/Macros.h +IF (EIGEN_INCLUDE_DIR) + SET(EIGEN_VERSION_FILE ${EIGEN_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h) + IF (NOT EXISTS ${EIGEN_VERSION_FILE}) + EIGEN_REPORT_NOT_FOUND( + "Could not find file: ${EIGEN_VERSION_FILE} " + "containing version information in Eigen install located at: " + "${EIGEN_INCLUDE_DIR}.") + ELSE (NOT EXISTS ${EIGEN_VERSION_FILE}) + FILE(READ ${EIGEN_VERSION_FILE} EIGEN_VERSION_FILE_CONTENTS) + + STRING(REGEX MATCH "#define EIGEN_WORLD_VERSION [0-9]+" + EIGEN_WORLD_VERSION "${EIGEN_VERSION_FILE_CONTENTS}") + STRING(REGEX REPLACE "#define EIGEN_WORLD_VERSION ([0-9]+)" "\\1" + EIGEN_WORLD_VERSION "${EIGEN_WORLD_VERSION}") + + STRING(REGEX MATCH "#define EIGEN_MAJOR_VERSION [0-9]+" + EIGEN_MAJOR_VERSION "${EIGEN_VERSION_FILE_CONTENTS}") + STRING(REGEX REPLACE "#define EIGEN_MAJOR_VERSION ([0-9]+)" "\\1" + EIGEN_MAJOR_VERSION "${EIGEN_MAJOR_VERSION}") + + STRING(REGEX MATCH "#define EIGEN_MINOR_VERSION [0-9]+" + EIGEN_MINOR_VERSION "${EIGEN_VERSION_FILE_CONTENTS}") + STRING(REGEX REPLACE "#define EIGEN_MINOR_VERSION ([0-9]+)" "\\1" + EIGEN_MINOR_VERSION "${EIGEN_MINOR_VERSION}") + + # This is on a single line s/t CMake does not interpret it as a list of + # elements and insert ';' separators which would result in 3.;2.;0 nonsense. + SET(EIGEN_VERSION "${EIGEN_WORLD_VERSION}.${EIGEN_MAJOR_VERSION}.${EIGEN_MINOR_VERSION}") + ENDIF (NOT EXISTS ${EIGEN_VERSION_FILE}) +ENDIF (EIGEN_INCLUDE_DIR) + +# Set standard CMake FindPackage variables if found. +IF (EIGEN_FOUND) + SET(EIGEN_INCLUDE_DIRS ${EIGEN_INCLUDE_DIR}) +ENDIF (EIGEN_FOUND) + +# Handle REQUIRED / QUIET optional arguments and version. +INCLUDE(FindPackageHandleStandardArgs) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(Eigen + REQUIRED_VARS EIGEN_INCLUDE_DIRS + VERSION_VAR EIGEN_VERSION) + +# Only mark internal variables as advanced if we found Eigen, otherwise +# leave it visible in the standard GUI for the user to set manually. +IF (EIGEN_FOUND) + MARK_AS_ADVANCED(FORCE EIGEN_INCLUDE_DIR) +ENDIF (EIGEN_FOUND) diff --git a/src/boost/libs/compute/cmake/FindTBB.cmake b/src/boost/libs/compute/cmake/FindTBB.cmake new file mode 100644 index 00000000..d299fd14 --- /dev/null +++ b/src/boost/libs/compute/cmake/FindTBB.cmake @@ -0,0 +1,286 @@ +# Locate Intel Threading Building Blocks include paths and libraries +# FindTBB.cmake can be found at https://code.google.com/p/findtbb/ +# Written by Hannes Hofmann <hannes.hofmann _at_ informatik.uni-erlangen.de> +# Improvements by Gino van den Bergen <gino _at_ dtecta.com>, +# Florian Uhlig <F.Uhlig _at_ gsi.de>, +# Jiri Marsik <jiri.marsik89 _at_ gmail.com> + +# The MIT License +# +# Copyright (c) 2011 Hannes Hofmann +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in +# all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +# THE SOFTWARE. + +# GvdB: This module uses the environment variable TBB_ARCH_PLATFORM which defines architecture and compiler. +# e.g. "ia32/vc8" or "em64t/cc4.1.0_libc2.4_kernel2.6.16.21" +# TBB_ARCH_PLATFORM is set by the build script `tbbvars[.bat|.sh|.csh], which can be found +# in the TBB installation directory (TBB_INSTALL_DIR). +# +# GvdB: Mac OS X distribution places libraries directly in lib directory. +# +# For backwards compatibility, you may explicitely set the CMake variables TBB_ARCHITECTURE and TBB_COMPILER. +# TBB_ARCHITECTURE [ ia32 | em64t | itanium ] +# which architecture to use +# TBB_COMPILER e.g. vc9 or cc3.2.3_libc2.3.2_kernel2.4.21 or cc4.0.1_os10.4.9 +# which compiler to use (detected automatically on Windows) + +# This module respects +# TBB_INSTALL_DIR or $ENV{TBB21_INSTALL_DIR} or $ENV{TBB_INSTALL_DIR} + +# This module defines +# TBB_INCLUDE_DIRS, where to find task_scheduler_init.h, etc. +# TBB_LIBRARY_DIRS, where to find libtbb, libtbbmalloc +# TBB_DEBUG_LIBRARY_DIRS, where to find libtbb_debug, libtbbmalloc_debug +# TBB_INSTALL_DIR, the base TBB install directory +# TBB_LIBRARIES, the libraries to link against to use TBB. +# TBB_DEBUG_LIBRARIES, the libraries to link against to use TBB with debug symbols. +# TBB_FOUND, If false, don't try to use TBB. +# TBB_INTERFACE_VERSION, as defined in tbb/tbb_stddef.h + + +if (WIN32) + # has em64t/vc8 em64t/vc9 + # has ia32/vc7.1 ia32/vc8 ia32/vc9 + set(_TBB_DEFAULT_INSTALL_DIR "C:/Program Files/Intel/TBB" "C:/Program Files (x86)/Intel/TBB") + set(_TBB_LIB_NAME "tbb") + set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc") + set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug") + set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug") + if (MSVC71) + set (_TBB_COMPILER "vc7.1") + endif(MSVC71) + if (MSVC80) + set(_TBB_COMPILER "vc8") + endif(MSVC80) + if (MSVC90) + set(_TBB_COMPILER "vc9") + endif(MSVC90) + if(MSVC10) + set(_TBB_COMPILER "vc10") + endif(MSVC10) + # Todo: add other Windows compilers such as ICL. + set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE}) +endif (WIN32) + +if (UNIX) + if (APPLE) + # MAC + set(_TBB_DEFAULT_INSTALL_DIR "/Library/Frameworks/Intel_TBB.framework/Versions") + # libs: libtbb.dylib, libtbbmalloc.dylib, *_debug + set(_TBB_LIB_NAME "tbb") + set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc") + set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug") + set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug") + # default flavor on apple: ia32/cc4.0.1_os10.4.9 + # Jiri: There is no reason to presume there is only one flavor and + # that user's setting of variables should be ignored. + if(NOT TBB_COMPILER) + set(_TBB_COMPILER "cc4.0.1_os10.4.9") + elseif (NOT TBB_COMPILER) + set(_TBB_COMPILER ${TBB_COMPILER}) + endif(NOT TBB_COMPILER) + if(NOT TBB_ARCHITECTURE) + set(_TBB_ARCHITECTURE "ia32") + elseif(NOT TBB_ARCHITECTURE) + set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE}) + endif(NOT TBB_ARCHITECTURE) + else (APPLE) + # LINUX + set(_TBB_DEFAULT_INSTALL_DIR "/opt/intel/tbb" "/usr/local/include" "/usr/include") + set(_TBB_LIB_NAME "tbb") + set(_TBB_LIB_MALLOC_NAME "${_TBB_LIB_NAME}malloc") + set(_TBB_LIB_DEBUG_NAME "${_TBB_LIB_NAME}_debug") + set(_TBB_LIB_MALLOC_DEBUG_NAME "${_TBB_LIB_MALLOC_NAME}_debug") + # has em64t/cc3.2.3_libc2.3.2_kernel2.4.21 em64t/cc3.3.3_libc2.3.3_kernel2.6.5 em64t/cc3.4.3_libc2.3.4_kernel2.6.9 em64t/cc4.1.0_libc2.4_kernel2.6.16.21 + # has ia32/* + # has itanium/* + set(_TBB_COMPILER ${TBB_COMPILER}) + set(_TBB_ARCHITECTURE ${TBB_ARCHITECTURE}) + endif (APPLE) +endif (UNIX) + +if (CMAKE_SYSTEM MATCHES "SunOS.*") +# SUN +# not yet supported +# has em64t/cc3.4.3_kernel5.10 +# has ia32/* +endif (CMAKE_SYSTEM MATCHES "SunOS.*") + + +#-- Clear the public variables +set (TBB_FOUND "NO") + + +#-- Find TBB install dir and set ${_TBB_INSTALL_DIR} and cached ${TBB_INSTALL_DIR} +# first: use CMake variable TBB_INSTALL_DIR +if (TBB_INSTALL_DIR) + set (_TBB_INSTALL_DIR ${TBB_INSTALL_DIR}) +endif (TBB_INSTALL_DIR) +# second: use environment variable +if (NOT _TBB_INSTALL_DIR) + if (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "") + set (_TBB_INSTALL_DIR $ENV{TBB_INSTALL_DIR}) + endif (NOT "$ENV{TBB_INSTALL_DIR}" STREQUAL "") + # Intel recommends setting TBB21_INSTALL_DIR + if (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "") + set (_TBB_INSTALL_DIR $ENV{TBB21_INSTALL_DIR}) + endif (NOT "$ENV{TBB21_INSTALL_DIR}" STREQUAL "") + if (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "") + set (_TBB_INSTALL_DIR $ENV{TBB22_INSTALL_DIR}) + endif (NOT "$ENV{TBB22_INSTALL_DIR}" STREQUAL "") + if (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "") + set (_TBB_INSTALL_DIR $ENV{TBB30_INSTALL_DIR}) + endif (NOT "$ENV{TBB30_INSTALL_DIR}" STREQUAL "") +endif (NOT _TBB_INSTALL_DIR) +# third: try to find path automatically +if (NOT _TBB_INSTALL_DIR) + if (_TBB_DEFAULT_INSTALL_DIR) + set (_TBB_INSTALL_DIR ${_TBB_DEFAULT_INSTALL_DIR}) + endif (_TBB_DEFAULT_INSTALL_DIR) +endif (NOT _TBB_INSTALL_DIR) +# sanity check +if (NOT _TBB_INSTALL_DIR) + message ("ERROR: Unable to find Intel TBB install directory. ${_TBB_INSTALL_DIR}") +else (NOT _TBB_INSTALL_DIR) +# finally: set the cached CMake variable TBB_INSTALL_DIR +if (NOT TBB_INSTALL_DIR) + set (TBB_INSTALL_DIR ${_TBB_INSTALL_DIR} CACHE PATH "Intel TBB install directory") + mark_as_advanced(TBB_INSTALL_DIR) +endif (NOT TBB_INSTALL_DIR) + + +#-- A macro to rewrite the paths of the library. This is necessary, because +# find_library() always found the em64t/vc9 version of the TBB libs +macro(TBB_CORRECT_LIB_DIR var_name) +# if (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t") + string(REPLACE em64t "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}}) +# endif (NOT "${_TBB_ARCHITECTURE}" STREQUAL "em64t") + string(REPLACE ia32 "${_TBB_ARCHITECTURE}" ${var_name} ${${var_name}}) + string(REPLACE vc7.1 "${_TBB_COMPILER}" ${var_name} ${${var_name}}) + string(REPLACE vc8 "${_TBB_COMPILER}" ${var_name} ${${var_name}}) + string(REPLACE vc9 "${_TBB_COMPILER}" ${var_name} ${${var_name}}) + string(REPLACE vc10 "${_TBB_COMPILER}" ${var_name} ${${var_name}}) +endmacro(TBB_CORRECT_LIB_DIR var_content) + + +#-- Look for include directory and set ${TBB_INCLUDE_DIR} +set (TBB_INC_SEARCH_DIR ${_TBB_INSTALL_DIR}/include) +# Jiri: tbbvars now sets the CPATH environment variable to the directory +# containing the headers. +find_path(TBB_INCLUDE_DIR + tbb/task_scheduler_init.h + PATHS ${TBB_INC_SEARCH_DIR} ENV CPATH +) +mark_as_advanced(TBB_INCLUDE_DIR) + + +#-- Look for libraries +# GvdB: $ENV{TBB_ARCH_PLATFORM} is set by the build script tbbvars[.bat|.sh|.csh] +if (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "") + set (_TBB_LIBRARY_DIR + ${_TBB_INSTALL_DIR}/lib/$ENV{TBB_ARCH_PLATFORM} + ${_TBB_INSTALL_DIR}/$ENV{TBB_ARCH_PLATFORM}/lib + ) +endif (NOT $ENV{TBB_ARCH_PLATFORM} STREQUAL "") +# Jiri: This block isn't mutually exclusive with the previous one +# (hence no else), instead I test if the user really specified +# the variables in question. +if ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL "")) + # HH: deprecated + message(STATUS "[Warning] FindTBB.cmake: The use of TBB_ARCHITECTURE and TBB_COMPILER is deprecated and may not be supported in future versions. Please set \$ENV{TBB_ARCH_PLATFORM} (using tbbvars.[bat|csh|sh]).") + # Jiri: It doesn't hurt to look in more places, so I store the hints from + # ENV{TBB_ARCH_PLATFORM} and the TBB_ARCHITECTURE and TBB_COMPILER + # variables and search them both. + set (_TBB_LIBRARY_DIR "${_TBB_INSTALL_DIR}/${_TBB_ARCHITECTURE}/${_TBB_COMPILER}/lib" ${_TBB_LIBRARY_DIR}) +endif ((NOT ${TBB_ARCHITECTURE} STREQUAL "") AND (NOT ${TBB_COMPILER} STREQUAL "")) + +# GvdB: Mac OS X distribution places libraries directly in lib directory. +list(APPEND _TBB_LIBRARY_DIR ${_TBB_INSTALL_DIR}/lib) + +# Jiri: No reason not to check the default paths. From recent versions, +# tbbvars has started exporting the LIBRARY_PATH and LD_LIBRARY_PATH +# variables, which now point to the directories of the lib files. +# It all makes more sense to use the ${_TBB_LIBRARY_DIR} as a HINTS +# argument instead of the implicit PATHS as it isn't hard-coded +# but computed by system introspection. Searching the LIBRARY_PATH +# and LD_LIBRARY_PATH environment variables is now even more important +# that tbbvars doesn't export TBB_ARCH_PLATFORM and it facilitates +# the use of TBB built from sources. +find_library(TBB_LIBRARY ${_TBB_LIB_NAME} HINTS ${_TBB_LIBRARY_DIR} + PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH) +find_library(TBB_MALLOC_LIBRARY ${_TBB_LIB_MALLOC_NAME} HINTS ${_TBB_LIBRARY_DIR} + PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH) + +#Extract path from TBB_LIBRARY name +get_filename_component(TBB_LIBRARY_DIR ${TBB_LIBRARY} PATH) + +#TBB_CORRECT_LIB_DIR(TBB_LIBRARY) +#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY) +mark_as_advanced(TBB_LIBRARY TBB_MALLOC_LIBRARY) + +#-- Look for debug libraries +# Jiri: Changed the same way as for the release libraries. +find_library(TBB_LIBRARY_DEBUG ${_TBB_LIB_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR} + PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH) +find_library(TBB_MALLOC_LIBRARY_DEBUG ${_TBB_LIB_MALLOC_DEBUG_NAME} HINTS ${_TBB_LIBRARY_DIR} + PATHS ENV LIBRARY_PATH ENV LD_LIBRARY_PATH) + +# Jiri: Self-built TBB stores the debug libraries in a separate directory. +# Extract path from TBB_LIBRARY_DEBUG name +get_filename_component(TBB_LIBRARY_DEBUG_DIR ${TBB_LIBRARY_DEBUG} PATH) + +#TBB_CORRECT_LIB_DIR(TBB_LIBRARY_DEBUG) +#TBB_CORRECT_LIB_DIR(TBB_MALLOC_LIBRARY_DEBUG) +mark_as_advanced(TBB_LIBRARY_DEBUG TBB_MALLOC_LIBRARY_DEBUG) + + +if (TBB_INCLUDE_DIR) + if (TBB_LIBRARY) + set (TBB_FOUND "YES") + set (TBB_LIBRARIES ${TBB_LIBRARY} ${TBB_MALLOC_LIBRARY} ${TBB_LIBRARIES}) + set (TBB_DEBUG_LIBRARIES ${TBB_LIBRARY_DEBUG} ${TBB_MALLOC_LIBRARY_DEBUG} ${TBB_DEBUG_LIBRARIES}) + set (TBB_INCLUDE_DIRS ${TBB_INCLUDE_DIR} CACHE PATH "TBB include directory" FORCE) + set (TBB_LIBRARY_DIRS ${TBB_LIBRARY_DIR} CACHE PATH "TBB library directory" FORCE) + # Jiri: Self-built TBB stores the debug libraries in a separate directory. + set (TBB_DEBUG_LIBRARY_DIRS ${TBB_LIBRARY_DEBUG_DIR} CACHE PATH "TBB debug library directory" FORCE) + mark_as_advanced(TBB_INCLUDE_DIRS TBB_LIBRARY_DIRS TBB_DEBUG_LIBRARY_DIRS TBB_LIBRARIES TBB_DEBUG_LIBRARIES) + message(STATUS "Found Intel TBB") + endif (TBB_LIBRARY) +endif (TBB_INCLUDE_DIR) + +if (NOT TBB_FOUND) + message("ERROR: Intel TBB NOT found!") + message(STATUS "Looked for Threading Building Blocks in ${_TBB_INSTALL_DIR}") + # do only throw fatal, if this pkg is REQUIRED + if (TBB_FIND_REQUIRED) + message(FATAL_ERROR "Could NOT find TBB library. + On ubuntu try + apt-get install libtbb-dev +") + endif (TBB_FIND_REQUIRED) +endif (NOT TBB_FOUND) + +endif (NOT _TBB_INSTALL_DIR) + +if (TBB_FOUND) + set(TBB_INTERFACE_VERSION 0) + FILE(READ "${TBB_INCLUDE_DIRS}/tbb/tbb_stddef.h" _TBB_VERSION_CONTENTS) + STRING(REGEX REPLACE ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1" TBB_INTERFACE_VERSION "${_TBB_VERSION_CONTENTS}") + set(TBB_INTERFACE_VERSION "${TBB_INTERFACE_VERSION}") +endif (TBB_FOUND) diff --git a/src/boost/libs/compute/cmake/opencl/FindOpenCL.cmake b/src/boost/libs/compute/cmake/opencl/FindOpenCL.cmake new file mode 100644 index 00000000..0a60e8d1 --- /dev/null +++ b/src/boost/libs/compute/cmake/opencl/FindOpenCL.cmake @@ -0,0 +1,84 @@ +# - Try to find OpenCL +# This module tries to find an OpenCL implementation on your system. It supports +# AMD / ATI, Apple and NVIDIA implementations. +# +# To set the paths manually, define these environment variables: +# OpenCL_INCPATH - Include path (e.g. OpenCL_INCPATH=/opt/cuda/4.0/cuda/include) +# OpenCL_LIBPATH - Library path (e.h. OpenCL_LIBPATH=/usr/lib64/nvidia) +# +# Once done this will define +# OpenCL_FOUND - system has OpenCL +# OpenCL_INCLUDE_DIRS - the OpenCL include directory +# OpenCL_LIBRARIES - link these to use OpenCL + +FIND_PACKAGE(PackageHandleStandardArgs) + +SET (OpenCL_VERSION_STRING "0.1.0") +SET (OpenCL_VERSION_MAJOR 0) +SET (OpenCL_VERSION_MINOR 1) +SET (OpenCL_VERSION_PATCH 0) + +IF (APPLE) + + FIND_LIBRARY(OpenCL_LIBRARIES OpenCL DOC "OpenCL lib for OSX") + FIND_PATH(OpenCL_INCLUDE_DIRS OpenCL/cl.h DOC "Include for OpenCL on OSX") + FIND_PATH(_OpenCL_CPP_INCLUDE_DIRS OpenCL/cl.hpp DOC "Include for OpenCL CPP bindings on OSX") + +ELSE (APPLE) + + IF (WIN32) + # The AMD SDK currently installs both x86 and x86_64 libraries + # This is only a hack to find out architecture + IF( CMAKE_SIZEOF_VOID_P EQUAL 8 ) + SET(OpenCL_LIB_DIR "$ENV{AMDAPPSDKROOT}/lib/x86_64") + ELSE( CMAKE_SIZEOF_VOID_P EQUAL 8 ) + SET(OpenCL_LIB_DIR "$ENV{AMDAPPSDKROOT}/lib/x86") + ENDIF( CMAKE_SIZEOF_VOID_P EQUAL 8 ) + + FIND_LIBRARY(OpenCL_LIBRARIES OpenCL.lib PATHS + ${OpenCL_LIB_DIR} $ENV{OpenCL_LIBPATH} $ENV{CUDA_LIB_PATH}) + + GET_FILENAME_COMPONENT(_OpenCL_INC_CAND ${OpenCL_LIB_DIR}/../../include ABSOLUTE) + + # On Win32 search relative to the library + FIND_PATH(OpenCL_INCLUDE_DIRS CL/cl.h PATHS + ${_OpenCL_INC_CAND} $ENV{OpenCL_INCPATH} $ENV{CUDA_INC_PATH}) + FIND_PATH(_OpenCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS + ${_OpenCL_INC_CAND} $ENV{OpenCL_INCPATH} $ENV{CUDA_INC_PATH}) + + ELSE (WIN32) + + # Unix style platforms + FIND_LIBRARY(OpenCL_LIBRARIES OpenCL + PATHS ENV LD_LIBRARY_PATH ENV OpenCL_LIBPATH + ) + + GET_FILENAME_COMPONENT(OpenCL_LIB_DIR ${OpenCL_LIBRARIES} PATH) + GET_FILENAME_COMPONENT(_OpenCL_INC_CAND ${OpenCL_LIB_DIR}/../../include ABSOLUTE) + + # The AMD SDK currently does not place its headers + # in /usr/include, therefore also search relative + # to the library + FIND_PATH(OpenCL_INCLUDE_DIRS CL/cl.h PATHS "$ENV{CUDADIR}/include" ${_OpenCL_INC_CAND} "/usr/local/cuda/include" "/opt/cuda/include" "/opt/AMDAPP/include" ENV OpenCL_INCPATH) + FIND_PATH(_OpenCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS "$ENV{CUDADIR}/include" ${_OpenCL_INC_CAND} "/usr/local/cuda/include" "/opt/cuda/include" "/opt/AMDAPP/include" ENV OpenCL_INCPATH) + # for Mali GPUs, libmali must be linked + FIND_LIBRARY(OpenCL_LIBRARIES_MALI mali + PATHS ENV LD_LIBRARY_PATH ENV OpenCL_LIBPATH "/usr/lib64" "$ENV{CUDADIR}/lib64" + ) + IF (OpenCL_LIBRARIES_MALI) + SET(OpenCL_LIBRARIES ${OpenCL_LIBRARIES} ${OpenCL_LIBRARIES_MALI}) + ENDIF (OpenCL_LIBRARIES_MALI) + ENDIF (WIN32) + +ENDIF (APPLE) + +FIND_PACKAGE_HANDLE_STANDARD_ARGS(OpenCL DEFAULT_MSG OpenCL_LIBRARIES OpenCL_INCLUDE_DIRS) + +IF(_OpenCL_CPP_INCLUDE_DIRS) + SET( OpenCL_HAS_CPP_BINDINGS TRUE ) + LIST( APPEND OpenCL_INCLUDE_DIRS ${_OpenCL_CPP_INCLUDE_DIRS} ) + # This is often the same, so clean up + LIST( REMOVE_DUPLICATES OpenCL_INCLUDE_DIRS ) +ENDIF(_OpenCL_CPP_INCLUDE_DIRS) + +MARK_AS_ADVANCED( OpenCL_INCLUDE_DIRS ) diff --git a/src/boost/libs/compute/example/CMakeLists.txt b/src/boost/libs/compute/example/CMakeLists.txt new file mode 100644 index 00000000..a5708cb0 --- /dev/null +++ b/src/boost/libs/compute/example/CMakeLists.txt @@ -0,0 +1,166 @@ +# --------------------------------------------------------------------------- +# Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +# +# Distributed under the Boost Software License, Version 1.0 +# See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt +# +# --------------------------------------------------------------------------- + +include_directories(../include) + +set(EXAMPLES + amd_cpp_kernel + black_scholes + copy_data + fizz_buzz + hello_world + host_sort + inline_ptx + longest_vector + list_devices + mapped_view + memory_limits + monte_carlo + point_centroid + price_cross + print_vector + sort_vector + simple_kernel + time_copy + transform_sqrt + vector_addition + simple_moving_average + matrix_transpose +) + +# boost library link dependencies +set(EXAMPLE_BOOST_COMPONENTS program_options) + +if (${BOOST_COMPUTE_USE_OFFLINE_CACHE}) + set(EXAMPLE_BOOST_COMPONENTS ${EXAMPLE_BOOST_COMPONENTS} system filesystem) +endif() + +if(${BOOST_COMPUTE_THREAD_SAFE} AND NOT ${BOOST_COMPUTE_USE_CPP11}) + set(EXAMPLE_BOOST_COMPONENTS ${EXAMPLE_BOOST_COMPONENTS} system thread) +endif() + +if(MSVC AND EXAMPLE_BOOST_COMPONENTS) + set(EXAMPLE_BOOST_COMPONENTS ${EXAMPLE_BOOST_COMPONENTS} chrono) +endif() + +if(EXAMPLE_BOOST_COMPONENTS) + list(REMOVE_DUPLICATES EXAMPLE_BOOST_COMPONENTS) +endif() +find_package(Boost 1.54 REQUIRED COMPONENTS ${EXAMPLE_BOOST_COMPONENTS}) +include_directories(SYSTEM ${Boost_INCLUDE_DIRS}) + +foreach(EXAMPLE ${EXAMPLES}) + add_executable(${EXAMPLE} ${EXAMPLE}.cpp) + target_link_libraries(${EXAMPLE} ${OpenCL_LIBRARIES} ${Boost_LIBRARIES}) + + # add example program to list of tests (if testing is enabled) + if(${BOOST_COMPUTE_BUILD_TESTS}) + add_test("example.${EXAMPLE}" ${EXAMPLE}) + endif() +endforeach() + +# opencl test example +add_executable(opencl_test opencl_test.cpp) +target_link_libraries(opencl_test ${OpenCL_LIBRARIES}) + +# eigen examples +if(${BOOST_COMPUTE_HAVE_EIGEN}) + find_package(Eigen REQUIRED) + include_directories(SYSTEM ${EIGEN_INCLUDE_DIRS}) + add_executable(batched_determinant batched_determinant.cpp) + target_link_libraries(batched_determinant ${OpenCL_LIBRARIES} ${Boost_LIBRARIES}) +endif() + +# opencv examples +if(${BOOST_COMPUTE_HAVE_OPENCV}) + find_package(OpenCV REQUIRED) + include_directories(SYSTEM ${OpenCV_INCLUDE_DIRS}) + + set(OPENCV_EXAMPLES + k_means + opencv_flip + random_walk + opencv_optical_flow + opencv_convolution + opencv_sobel_filter + opencv_histogram + ) + + foreach(EXAMPLE ${OPENCV_EXAMPLES}) + add_executable(${EXAMPLE} ${EXAMPLE}.cpp) + target_link_libraries(${EXAMPLE} ${OpenCL_LIBRARIES} ${Boost_LIBRARIES} ${OpenCV_LIBS}) + endforeach() +endif() + +# opengl/vtk examples +if(${BOOST_COMPUTE_HAVE_VTK}) + find_package(VTK REQUIRED) + include(${VTK_USE_FILE}) + add_executable(opengl_sphere opengl_sphere.cpp) + target_link_libraries(opengl_sphere ${OpenCL_LIBRARIES} ${Boost_LIBRARIES} ${VTK_LIBRARIES}) + if(APPLE) + target_link_libraries(opengl_sphere "-framework OpenGL") + elseif(UNIX) + target_link_libraries(opengl_sphere GL) + endif() +endif() + +# qt examples +if(${BOOST_COMPUTE_HAVE_QT}) + + # look for Qt4 in the first place + find_package(Qt4 QUIET) + + if(${QT4_FOUND}) + # build with Qt4 + find_package(Qt4 REQUIRED COMPONENTS QtCore QtGui QtOpenGL) + set(QT_USE_QTOPENGL TRUE) + include(${QT_USE_FILE}) + else() + + # look for Qt5 + find_package(Qt5Widgets QUIET) + + if(${Qt5Widgets_FOUND}) + # build with Qt5 + find_package(Qt5Core REQUIRED) + find_package(Qt5Widgets REQUIRED) + find_package(Qt5OpenGL REQUIRED) + include_directories(${Qt5OpenGL_INCLUDE_DIRS}) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5OpenGL_EXECUTABLE_COMPILE_FLAGS}") + set(QT_LIBRARIES ${Qt5OpenGL_LIBRARIES}) + else() + # no valid Qt framework found + message(FATAL_ERROR "Error: Did not find Qt4 or Qt5") + endif() + endif() + + # required by both versions + set(CMAKE_AUTOMOC TRUE) + include_directories(${CMAKE_CURRENT_BINARY_DIR}) + + # add examples + add_executable(qimage_blur qimage_blur.cpp) + target_link_libraries(qimage_blur ${OpenCL_LIBRARIES} ${Boost_LIBRARIES} ${QT_LIBRARIES}) + + set(QT_OPENGL_EXAMPLES + mandelbrot + nbody + resize_image + ) + foreach(EXAMPLE ${QT_OPENGL_EXAMPLES}) + add_executable(${EXAMPLE} ${EXAMPLE}.cpp) + target_link_libraries(${EXAMPLE} ${OpenCL_LIBRARIES} ${Boost_LIBRARIES} ${QT_LIBRARIES}) + if(APPLE) + target_link_libraries(${EXAMPLE} "-framework OpenGL") + elseif(UNIX) + target_link_libraries(${EXAMPLE} GL) + endif() + endforeach() +endif() diff --git a/src/boost/libs/compute/example/amd_cpp_kernel.cpp b/src/boost/libs/compute/example/amd_cpp_kernel.cpp new file mode 100644 index 00000000..0207312f --- /dev/null +++ b/src/boost/libs/compute/example/amd_cpp_kernel.cpp @@ -0,0 +1,116 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/kernel.hpp> +#include <boost/compute/program.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +// this example shows how to use the static c++ kernel language +// extension (currently only supported by AMD) to compile and +// execute a templated c++ kernel. +// Using platform vendor info to decide if this is AMD platform +int main() +{ + // get default device and setup context + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + + // check the platform vendor string + if(device.platform().vendor() != "Advanced Micro Devices, Inc."){ + std::cerr << "error: static C++ kernel language is only " + << "supported on AMD devices." + << std::endl; + return 0; + } + + // create input int values and copy them to the device + int int_data[] = { 1, 2, 3, 4}; + compute::vector<int> int_vector(int_data, int_data + 4, queue); + + // create input float values and copy them to the device + float float_data[] = { 2.0f, 4.0f, 6.0f, 8.0f }; + compute::vector<float> float_vector(float_data, float_data + 4, queue); + + // create kernel source with a templated function and templated kernel + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + // define our templated function which returns the square of its input + template<typename T> + inline T square(const T x) + { + return x * x; + } + + // define our templated kernel which calls square on each value in data + template<typename T> + __kernel void square_kernel(__global T *data) + { + const uint i = get_global_id(0); + data[i] = square(data[i]); + } + + // explicitly instantiate the square kernel for int's. this allows + // for it to be called from the host with the given mangled name. + template __attribute__((mangled_name(square_kernel_int))) + __kernel void square_kernel(__global int *data); + + // also instantiate the square kernel for float's. + template __attribute__((mangled_name(square_kernel_float))) + __kernel void square_kernel(__global float *data); + ); + + // build the program. must enable the c++ static kernel language + // by passing the "-x clc++" compile option. + compute::program square_program = + compute::program::build_with_source(source, context, "-x clc++"); + + // create the square kernel for int's by using its mangled name declared + // in the explicit template instantiation. + compute::kernel square_int_kernel(square_program, "square_kernel_int"); + square_int_kernel.set_arg(0, int_vector); + + // execute the square int kernel + queue.enqueue_1d_range_kernel(square_int_kernel, 0, int_vector.size(), 4); + + // print out the squared int values + std::cout << "int's: "; + compute::copy( + int_vector.begin(), int_vector.end(), + std::ostream_iterator<int>(std::cout, " "), + queue + ); + std::cout << std::endl; + + // now create the square kernel for float's + compute::kernel square_float_kernel(square_program, "square_kernel_float"); + square_float_kernel.set_arg(0, float_vector); + + // execute the square int kernel + queue.enqueue_1d_range_kernel(square_float_kernel, 0, float_vector.size(), 4); + + // print out the squared float values + std::cout << "float's: "; + compute::copy( + float_vector.begin(), float_vector.end(), + std::ostream_iterator<float>(std::cout, " "), + queue + ); + std::cout << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/batched_determinant.cpp b/src/boost/libs/compute/example/batched_determinant.cpp new file mode 100644 index 00000000..0029151e --- /dev/null +++ b/src/boost/libs/compute/example/batched_determinant.cpp @@ -0,0 +1,96 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <Eigen/Core> +#include <Eigen/LU> + +#include <boost/compute/function.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +namespace compute = boost::compute; + +// this example shows how to compute the determinant of many 4x4 matrices +// using a determinant function and the transform() algorithm. in OpenCL the +// float16 type can be used to store a 4x4 matrix and the components are laid +// out in the following order: +// +// M = [ s0 s4 s8 sc ] +// [ s1 s5 s9 sd ] +// [ s2 s6 sa se ] +// [ s3 s7 sb sf ] +// +// the input matrices are created using eigen's random matrix and then +// used again at the end to verify the results of the determinant function. +int main() +{ + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + std::cout << "device: " << gpu.name() << std::endl; + + size_t n = 1000; + + // create random 4x4 matrices on the host + std::vector<Eigen::Matrix4f> matrices(n); + for(size_t i = 0; i < n; i++){ + matrices[i] = Eigen::Matrix4f::Random(); + } + + // copy matrices to the device + using compute::float16_; + compute::vector<float16_> input(n, context); + compute::copy( + matrices.begin(), matrices.end(), input.begin(), queue + ); + + // function returning the determinant of a 4x4 matrix. + BOOST_COMPUTE_FUNCTION(float, determinant4x4, (const float16_ m), + { + return m.s0*m.s5*m.sa*m.sf + m.s0*m.s6*m.sb*m.sd + m.s0*m.s7*m.s9*m.se + + m.s1*m.s4*m.sb*m.se + m.s1*m.s6*m.s8*m.sf + m.s1*m.s7*m.sa*m.sc + + m.s2*m.s4*m.s9*m.sf + m.s2*m.s5*m.sb*m.sc + m.s2*m.s7*m.s8*m.sd + + m.s3*m.s4*m.sa*m.sd + m.s3*m.s5*m.s8*m.se + m.s3*m.s6*m.s9*m.sc - + m.s0*m.s5*m.sb*m.se - m.s0*m.s6*m.s9*m.sf - m.s0*m.s7*m.sa*m.sd - + m.s1*m.s4*m.sa*m.sf - m.s1*m.s6*m.sb*m.sc - m.s1*m.s7*m.s8*m.se - + m.s2*m.s4*m.sb*m.sd - m.s2*m.s5*m.s8*m.sf - m.s2*m.s7*m.s9*m.sc - + m.s3*m.s4*m.s9*m.se - m.s3*m.s5*m.sa*m.sc - m.s3*m.s6*m.s8*m.sd; + }); + + // calculate determinants on the gpu + compute::vector<float> determinants(n, context); + compute::transform( + input.begin(), input.end(), determinants.begin(), determinant4x4, queue + ); + + // check determinants + std::vector<float> host_determinants(n); + compute::copy( + determinants.begin(), determinants.end(), host_determinants.begin(), queue + ); + + for(size_t i = 0; i < n; i++){ + float det = matrices[i].determinant(); + + if(std::abs(det - host_determinants[i]) > 1e-6){ + std::cerr << "error: wrong determinant at " << i << " (" + << host_determinants[i] << " != " << det << ")" + << std::endl; + return -1; + } + } + + return 0; +} diff --git a/src/boost/libs/compute/example/black_scholes.cpp b/src/boost/libs/compute/example/black_scholes.cpp new file mode 100644 index 00000000..13a0e097 --- /dev/null +++ b/src/boost/libs/compute/example/black_scholes.cpp @@ -0,0 +1,168 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <cstdlib> +#include <iostream> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +// return a random float between lo and hi +float rand_float(float lo, float hi) +{ + float x = (float) std::rand() / (float) RAND_MAX; + + return (1.0f - x) * lo + x * hi; +} + +// this example demostrates a black-scholes option pricing kernel. +int main() +{ + // number of options + const int N = 4000000; + + // black-scholes parameters + const float risk_free_rate = 0.02f; + const float volatility = 0.30f; + + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + std::cout << "device: " << gpu.name() << std::endl; + + // initialize option data on host + std::vector<float> stock_price_data(N); + std::vector<float> option_strike_data(N); + std::vector<float> option_years_data(N); + + std::srand(5347); + for(int i = 0; i < N; i++){ + stock_price_data[i] = rand_float(5.0f, 30.0f); + option_strike_data[i] = rand_float(1.0f, 100.0f); + option_years_data[i] = rand_float(0.25f, 10.0f); + } + + // create memory buffers on the device + compute::vector<float> call_result(N, context); + compute::vector<float> put_result(N, context); + compute::vector<float> stock_price(N, context); + compute::vector<float> option_strike(N, context); + compute::vector<float> option_years(N, context); + + // copy initial values to the device + compute::copy_n(stock_price_data.begin(), N, stock_price.begin(), queue); + compute::copy_n(option_strike_data.begin(), N, option_strike.begin(), queue); + compute::copy_n(option_years_data.begin(), N, option_years.begin(), queue); + + // source code for black-scholes program + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + // approximation of the cumulative normal distribution function + static float cnd(float d) + { + const float A1 = 0.319381530f; + const float A2 = -0.356563782f; + const float A3 = 1.781477937f; + const float A4 = -1.821255978f; + const float A5 = 1.330274429f; + const float RSQRT2PI = 0.39894228040143267793994605993438f; + + float K = 1.0f / (1.0f + 0.2316419f * fabs(d)); + float cnd = + RSQRT2PI * exp(-0.5f * d * d) * + (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))); + + if(d > 0){ + cnd = 1.0f - cnd; + } + + return cnd; + } + + // black-scholes option pricing kernel + __kernel void black_scholes(__global float *call_result, + __global float *put_result, + __global const float *stock_price, + __global const float *option_strike, + __global const float *option_years, + float risk_free_rate, + float volatility) + { + const uint opt = get_global_id(0); + + float S = stock_price[opt]; + float X = option_strike[opt]; + float T = option_years[opt]; + float R = risk_free_rate; + float V = volatility; + + float sqrtT = sqrt(T); + float d1 = (log(S / X) + (R + 0.5f * V * V) * T) / (V * sqrtT); + float d2 = d1 - V * sqrtT; + float CNDD1 = cnd(d1); + float CNDD2 = cnd(d2); + + float expRT = exp(-R * T); + call_result[opt] = S * CNDD1 - X * expRT * CNDD2; + put_result[opt] = X * expRT * (1.0f - CNDD2) - S * (1.0f - CNDD1); + } + ); + + // build black-scholes program + compute::program program = compute::program::create_with_source(source, context); + program.build(); + + // setup black-scholes kernel + compute::kernel kernel(program, "black_scholes"); + kernel.set_arg(0, call_result); + kernel.set_arg(1, put_result); + kernel.set_arg(2, stock_price); + kernel.set_arg(3, option_strike); + kernel.set_arg(4, option_years); + kernel.set_arg(5, risk_free_rate); + kernel.set_arg(6, volatility); + + // execute black-scholes kernel + queue.enqueue_1d_range_kernel(kernel, 0, N, 0); + + // print out the first option's put and call prices + float call0, put0; + compute::copy_n(put_result.begin(), 1, &put0, queue); + compute::copy_n(call_result.begin(), 1, &call0, queue); + + std::cout << "option 0 call price: " << call0 << std::endl; + std::cout << "option 0 put price: " << put0 << std::endl; + + // due to the differences in the random-number generators between Operating Systems + // and/or compilers, we will get different "expected" results for this example +#ifdef __APPLE__ + double expected_call0 = 0.000249461; + double expected_put0 = 26.2798; +#elif _MSC_VER + double expected_call0 = 8.21412; + double expected_put0 = 2.25904; +#else + double expected_call0 = 0.0999f; + double expected_put0 = 43.0524f; +#endif + + // check option prices + if(std::abs(call0 - expected_call0) > 1e-4 || std::abs(put0 - expected_put0) > 1e-4){ + std::cerr << "error: option prices are wrong" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/example/copy_data.cpp b/src/boost/libs/compute/example/copy_data.cpp new file mode 100644 index 00000000..0550287f --- /dev/null +++ b/src/boost/libs/compute/example/copy_data.cpp @@ -0,0 +1,49 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +//[copy_data_example + +#include <vector> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> + +namespace compute = boost::compute; + +int main() +{ + // get default device and setup context + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + + // create data array on host + int host_data[] = { 1, 3, 5, 7, 9 }; + + // create vector on device + compute::vector<int> device_vector(5, context); + + // copy from host to device + compute::copy( + host_data, host_data + 5, device_vector.begin(), queue + ); + + // create vector on host + std::vector<int> host_vector(5); + + // copy data back to host + compute::copy( + device_vector.begin(), device_vector.end(), host_vector.begin(), queue + ); + + return 0; +} + +//] diff --git a/src/boost/libs/compute/example/fizz_buzz.cpp b/src/boost/libs/compute/example/fizz_buzz.cpp new file mode 100644 index 00000000..2c69995f --- /dev/null +++ b/src/boost/libs/compute/example/fizz_buzz.cpp @@ -0,0 +1,160 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/accumulate.hpp> +#include <boost/compute/algorithm/exclusive_scan.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/utility/dim.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +const char fizz_buzz_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + // returns the length of the string for the number 'n'. This is used + // during the first pass when we calculate the amount of space needed + // for each string in the fizz-buzz sequence. + inline uint fizz_buzz_string_length(uint n) + { + if((n % 5 == 0) && (n % 3 == 0)){ + return sizeof("fizzbuzz"); + } + else if(n % 5 == 0){ + return sizeof("fizz"); + } + else if(n % 3 == 0){ + return sizeof("buzz"); + } + else { + uint digits = 0; + while(n){ + n /= 10; + digits++; + } + return digits + 1; + } + } + + // first-pass kernel which calculates the string length for each number + // and writes it to the string_lengths array. these will then be passed + // to exclusive_scan() to calculate the output offsets for each string. + __kernel void fizz_buzz_allocate_strings(__global uint *string_lengths) + { + const uint i = get_global_id(0); + const uint n = i + 1; + + string_lengths[i] = fizz_buzz_string_length(n); + } + + // copy the string 's' with length 'n' to 'result' (just like strncpy()) + inline void copy_string(__constant const char *s, uint n, __global char *result) + { + while(n--){ + result[n] = s[n]; + } + } + + // reverse the string [start, end). + inline void reverse_string(__global char *start, __global char *end) + { + while(start < end){ + char tmp = *end; + *end = *start; + *start = tmp; + start++; + end--; + } + } + + // second-pass kernel which copies the fizz-buzz string for each number to + // buffer using the previously calculated offsets. + __kernel void fizz_buzz_copy_strings(__global const uint *offsets, __global char *buffer) + { + const uint i = get_global_id(0); + const uint n = i + 1; + const uint offset = offsets[i]; + + if((n % 5 == 0) && (n % 3 == 0)){ + copy_string("fizzbuzz\n", 9, buffer + offset); + } + else if(n % 5 == 0){ + copy_string("fizz\n", 5, buffer + offset); + } + else if(n % 3 == 0){ + copy_string("buzz\n", 5, buffer + offset); + } + else { + // convert number to string and write it to the output + __global char *number = buffer + offset; + uint n_ = n; + while(n_){ + *number++ = (n_%10) + '0'; + n_ /= 10; + } + reverse_string(buffer + offset, number - 1); + *number = '\n'; + } + } +); + +int main() +{ + using compute::dim; + using compute::uint_; + + // fizz-buzz up to 100 + size_t n = 100; + + // get the default device + compute::device device = compute::system::default_device(); + compute::context ctx(device); + compute::command_queue queue(ctx, device); + + // compile the fizz-buzz program + compute::program fizz_buzz_program = + compute::program::create_with_source(fizz_buzz_source, ctx); + fizz_buzz_program.build(); + + // create a vector for the output string and computing offsets + compute::vector<char> output(ctx); + compute::vector<uint_> offsets(n, ctx); + + // run the allocate kernel to calculate string lengths + compute::kernel allocate_kernel(fizz_buzz_program, "fizz_buzz_allocate_strings"); + allocate_kernel.set_arg(0, offsets); + queue.enqueue_nd_range_kernel(allocate_kernel, dim(0), dim(n), dim(1)); + + // allocate space for the output string + output.resize( + compute::accumulate(offsets.begin(), offsets.end(), 0, queue) + ); + + // scan string lengths for each number to calculate the output offsets + compute::exclusive_scan( + offsets.begin(), offsets.end(), offsets.begin(), queue + ); + + // run the copy kernel to fill the output buffer + compute::kernel copy_kernel(fizz_buzz_program, "fizz_buzz_copy_strings"); + copy_kernel.set_arg(0, offsets); + copy_kernel.set_arg(1, output); + queue.enqueue_nd_range_kernel(copy_kernel, dim(0), dim(n), dim(1)); + + // copy the string to the host and print it to stdout + std::string str; + str.resize(output.size()); + compute::copy(output.begin(), output.end(), str.begin(), queue); + std::cout << str; + + return 0; +} diff --git a/src/boost/libs/compute/example/hello_world.cpp b/src/boost/libs/compute/example/hello_world.cpp new file mode 100644 index 00000000..ef45fdd6 --- /dev/null +++ b/src/boost/libs/compute/example/hello_world.cpp @@ -0,0 +1,30 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +//[hello_world_example + +#include <iostream> + +#include <boost/compute/core.hpp> + +namespace compute = boost::compute; + +int main() +{ + // get the default device + compute::device device = compute::system::default_device(); + + // print the device's name and platform + std::cout << "hello from " << device.name(); + std::cout << " (platform: " << device.platform().name() << ")" << std::endl; + + return 0; +} +//] diff --git a/src/boost/libs/compute/example/host_sort.cpp b/src/boost/libs/compute/example/host_sort.cpp new file mode 100644 index 00000000..b5ff52cf --- /dev/null +++ b/src/boost/libs/compute/example/host_sort.cpp @@ -0,0 +1,56 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <vector> + +#include <boost/spirit/include/karma.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/sort.hpp> + +namespace compute = boost::compute; +namespace karma = boost::spirit::karma; + +int rand_int() +{ + return rand() % 100; +} + +// this example demonstrates how to sort a std::vector of ints on the GPU +int main() +{ + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + std::cout << "device: " << gpu.name() << std::endl; + + // create vector of random values on the host + std::vector<int> vector(8); + std::generate(vector.begin(), vector.end(), rand_int); + + // print input vector + std::cout << "input: [ " + << karma::format(karma::int_ % ", ", vector) + << " ]" + << std::endl; + + // sort vector + compute::sort(vector.begin(), vector.end(), queue); + + // print sorted vector + std::cout << "output: [ " + << karma::format(karma::int_ % ", ", vector) + << " ]" + << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/inline_ptx.cpp b/src/boost/libs/compute/example/inline_ptx.cpp new file mode 100644 index 00000000..fe4e32f0 --- /dev/null +++ b/src/boost/libs/compute/example/inline_ptx.cpp @@ -0,0 +1,72 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> + +namespace compute = boost::compute; + +// this example shows how to embed PTX assembly instructions +// directly into boost.compute functions and use them with the +// transform() algorithm. +int main() +{ + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + std::cout << "device: " << gpu.name() << std::endl; + + // check to ensure we have an nvidia device + if(gpu.vendor() != "NVIDIA Corporation"){ + std::cerr << "error: inline PTX assembly is only supported " + << "on NVIDIA devices." + << std::endl; + return 0; + } + + // create input values and copy them to the device + using compute::uint_; + uint_ data[] = { 0x00, 0x01, 0x11, 0xFF }; + compute::vector<uint_> input(data, data + 4, queue); + + // function returning the number of bits set (aka population count or + // popcount) using the "popc" inline ptx assembly instruction. + BOOST_COMPUTE_FUNCTION(uint_, nvidia_popc, (uint_ x), + { + uint count; + asm("popc.b32 %0, %1;" : "=r"(count) : "r"(x)); + return count; + }); + + // calculate the popcount for each input value + compute::vector<uint_> output(input.size(), context); + compute::transform( + input.begin(), input.end(), output.begin(), nvidia_popc, queue + ); + + // copy results back to the host and print them out + std::vector<uint_> counts(output.size()); + compute::copy(output.begin(), output.end(), counts.begin(), queue); + + for(size_t i = 0; i < counts.size(); i++){ + std::cout << "0x" << std::hex << data[i] + << " has " << counts[i] + << " bits set" << std::endl; + } + + return 0; +} diff --git a/src/boost/libs/compute/example/k_means.cpp b/src/boost/libs/compute/example/k_means.cpp new file mode 100644 index 00000000..cd291a9b --- /dev/null +++ b/src/boost/libs/compute/example/k_means.cpp @@ -0,0 +1,229 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <opencv2/core/core.hpp> +#include <opencv2/highgui/highgui.hpp> +#include <opencv2/imgproc/imgproc.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/image/image2d.hpp> +#include <boost/compute/interop/opencv/core.hpp> +#include <boost/compute/interop/opencv/highgui.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/uniform_real_distribution.hpp> +#include <boost/compute/utility/dim.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +using compute::dim; +using compute::int_; +using compute::float_; +using compute::float2_; + +// the k-means example implements the k-means clustering algorithm +int main() +{ + // number of clusters + size_t k = 6; + + // number of points + size_t n_points = 4500; + + // height and width of image + size_t height = 800; + size_t width = 800; + + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + + // generate random, uniformily-distributed points + compute::default_random_engine random_engine(queue); + compute::uniform_real_distribution<float_> uniform_distribution(0, 800); + + compute::vector<float2_> points(n_points, context); + uniform_distribution.generate( + compute::make_buffer_iterator<float_>(points.get_buffer(), 0), + compute::make_buffer_iterator<float_>(points.get_buffer(), n_points * 2), + random_engine, + queue + ); + + // initialize all points to cluster 0 + compute::vector<int_> clusters(n_points, context); + compute::fill(clusters.begin(), clusters.end(), 0, queue); + + // create initial means with the first k points + compute::vector<float2_> means(k, context); + compute::copy_n(points.begin(), k, means.begin(), queue); + + // k-means clustering program source + const char k_means_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void assign_clusters(__global const float2 *points, + __global const float2 *means, + const int k, + __global int *clusters) + { + const uint gid = get_global_id(0); + + const float2 point = points[gid]; + + // find the closest cluster + float current_distance = 0; + int closest_cluster = -1; + + // find closest cluster mean to the point + for(int i = 0; i < k; i++){ + const float2 mean = means[i]; + + int distance_to_mean = distance(point, mean); + if(closest_cluster == -1 || distance_to_mean < current_distance){ + current_distance = distance_to_mean; + closest_cluster = i; + } + } + + // write new cluster + clusters[gid] = closest_cluster; + } + + __kernel void update_means(__global const float2 *points, + const uint n_points, + __global float2 *means, + __global const int *clusters) + { + const uint k = get_global_id(0); + + float2 sum = { 0, 0 }; + float count = 0; + for(uint i = 0; i < n_points; i++){ + if(clusters[i] == k){ + sum += points[i]; + count += 1; + } + } + + means[k] = sum / count; + } + ); + + // build the k-means program + compute::program k_means_program = + compute::program::build_with_source(k_means_source, context); + + // setup the k-means kernels + compute::kernel assign_clusters_kernel(k_means_program, "assign_clusters"); + assign_clusters_kernel.set_arg(0, points); + assign_clusters_kernel.set_arg(1, means); + assign_clusters_kernel.set_arg(2, int_(k)); + assign_clusters_kernel.set_arg(3, clusters); + + compute::kernel update_means_kernel(k_means_program, "update_means"); + update_means_kernel.set_arg(0, points); + update_means_kernel.set_arg(1, int_(n_points)); + update_means_kernel.set_arg(2, means); + update_means_kernel.set_arg(3, clusters); + + // run the k-means algorithm + for(int iteration = 0; iteration < 25; iteration++){ + queue.enqueue_1d_range_kernel(assign_clusters_kernel, 0, n_points, 0); + queue.enqueue_1d_range_kernel(update_means_kernel, 0, k, 0); + } + + // create output image + compute::image2d image( + context, width, height, compute::image_format(CL_RGBA, CL_UNSIGNED_INT8) + ); + + // program with two kernels, one to fill the image with white, and then + // one the draw to points calculated in coordinates on the image + const char draw_walk_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void draw_points(__global const float2 *points, + __global const int *clusters, + __write_only image2d_t image) + { + const uint i = get_global_id(0); + const float2 coord = points[i]; + + // map cluster number to color + uint4 color = { 0, 0, 0, 0 }; + switch(clusters[i]){ + case 0: + color = (uint4)(255, 0, 0, 255); + break; + case 1: + color = (uint4)(0, 255, 0, 255); + break; + case 2: + color = (uint4)(0, 0, 255, 255); + break; + case 3: + color = (uint4)(255, 255, 0, 255); + break; + case 4: + color = (uint4)(255, 0, 255, 255); + break; + case 5: + color = (uint4)(0, 255, 255, 255); + break; + } + + // draw a 3x3 pixel point + for(int x = -1; x <= 1; x++){ + for(int y = -1; y <= 1; y++){ + if(coord.x + x > 0 && coord.x + x < get_image_width(image) && + coord.y + y > 0 && coord.y + y < get_image_height(image)){ + write_imageui(image, (int2)(coord.x, coord.y) + (int2)(x, y), color); + } + } + } + } + + __kernel void fill_gray(__write_only image2d_t image) + { + const int2 coord = { get_global_id(0), get_global_id(1) }; + + if(coord.x < get_image_width(image) && coord.y < get_image_height(image)){ + uint4 gray = { 15, 15, 15, 15 }; + write_imageui(image, coord, gray); + } + } + ); + + // build the program + compute::program draw_program = + compute::program::build_with_source(draw_walk_source, context); + + // fill image with dark gray + compute::kernel fill_kernel(draw_program, "fill_gray"); + fill_kernel.set_arg(0, image); + + queue.enqueue_nd_range_kernel( + fill_kernel, dim(0, 0), dim(width, height), dim(1, 1) + ); + + // draw points colored according to cluster + compute::kernel draw_kernel(draw_program, "draw_points"); + draw_kernel.set_arg(0, points); + draw_kernel.set_arg(1, clusters); + draw_kernel.set_arg(2, image); + queue.enqueue_1d_range_kernel(draw_kernel, 0, n_points, 0); + + // show image + compute::opencv_imshow("k-means", image, queue); + + // wait and return + cv::waitKey(0); + + return 0; +} diff --git a/src/boost/libs/compute/example/list_devices.cpp b/src/boost/libs/compute/example/list_devices.cpp new file mode 100644 index 00000000..b7bdbc94 --- /dev/null +++ b/src/boost/libs/compute/example/list_devices.cpp @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/core.hpp> + +namespace compute = boost::compute; + +int main() +{ + std::vector<compute::platform> platforms = compute::system::platforms(); + + for(size_t i = 0; i < platforms.size(); i++){ + const compute::platform &platform = platforms[i]; + + std::cout << "Platform '" << platform.name() << "'" << std::endl; + + std::vector<compute::device> devices = platform.devices(); + for(size_t j = 0; j < devices.size(); j++){ + const compute::device &device = devices[j]; + + std::string type; + if(device.type() & compute::device::gpu) + type = "GPU Device"; + else if(device.type() & compute::device::cpu) + type = "CPU Device"; + else if(device.type() & compute::device::accelerator) + type = "Accelerator Device"; + else + type = "Unknown Device"; + + std::cout << " " << type << ": " << device.name() << std::endl; + } + } + + return 0; +} diff --git a/src/boost/libs/compute/example/longest_vector.cpp b/src/boost/libs/compute/example/longest_vector.cpp new file mode 100644 index 00000000..faada332 --- /dev/null +++ b/src/boost/libs/compute/example/longest_vector.cpp @@ -0,0 +1,58 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <iterator> + +#include <boost/compute/algorithm/max_element.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/geometry.hpp> +#include <boost/compute/iterator/transform_iterator.hpp> +#include <boost/compute/types/fundamental.hpp> + +namespace compute = boost::compute; + +// this example shows how to use the max_element() algorithm along with +// a transform_iterator and the length() function to find the longest +// 4-component vector in an array of vectors +int main() +{ + using compute::float4_; + + // vectors data + float data[] = { 1.0f, 2.0f, 3.0f, 0.0f, + 4.0f, 5.0f, 6.0f, 0.0f, + 7.0f, 8.0f, 9.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f }; + + // create device vector with the vector data + compute::vector<float4_> vector( + reinterpret_cast<float4_ *>(data), + reinterpret_cast<float4_ *>(data) + 4 + ); + + // find the longest vector + compute::vector<float4_>::const_iterator iter = + compute::max_element( + compute::make_transform_iterator( + vector.begin(), compute::length<float4_>() + ), + compute::make_transform_iterator( + vector.end(), compute::length<float4_>() + ) + ).base(); + + // print the index of the longest vector + std::cout << "longest vector index: " + << std::distance(vector.begin(), iter) + << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/mandelbrot.cpp b/src/boost/libs/compute/example/mandelbrot.cpp new file mode 100644 index 00000000..5ddb3687 --- /dev/null +++ b/src/boost/libs/compute/example/mandelbrot.cpp @@ -0,0 +1,224 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> + +#include <QtGlobal> +#if QT_VERSION >= 0x050000 +#include <QtWidgets> +#else +#include <QtGui> +#endif +#include <QtOpenGL> + +#ifndef Q_MOC_RUN +#include <boost/compute/command_queue.hpp> +#include <boost/compute/kernel.hpp> +#include <boost/compute/program.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/interop/opengl.hpp> +#include <boost/compute/utility/dim.hpp> +#include <boost/compute/utility/source.hpp> +#endif // Q_MOC_RUN + +namespace compute = boost::compute; + +// opencl source code +const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + // map value to color + float4 color(uint i) + { + uchar c = i; + uchar x = 35; + uchar y = 25; + uchar z = 15; + uchar max = 255; + + if(i == 256) + return (float4)(0, 0, 0, 255); + else + return (float4)(max-x*i, max-y*i, max-z*i, max) / 255.f; + } + + __kernel void mandelbrot(__write_only image2d_t image) + { + const uint x_coord = get_global_id(0); + const uint y_coord = get_global_id(1); + const uint width = get_global_size(0); + const uint height = get_global_size(1); + + float x_origin = ((float) x_coord / width) * 3.25f - 2.0f; + float y_origin = ((float) y_coord / height) * 2.5f - 1.25f; + + float x = 0.0f; + float y = 0.0f; + + uint i = 0; + while(x*x + y*y <= 4.f && i < 256){ + float tmp = x*x - y*y + x_origin; + y = 2*x*y + y_origin; + x = tmp; + i++; + } + + int2 coord = { x_coord, y_coord }; + write_imagef(image, coord, color(i)); + }; +); + +class MandelbrotWidget : public QGLWidget +{ + Q_OBJECT + +public: + MandelbrotWidget(QWidget *parent = 0); + ~MandelbrotWidget(); + + void initializeGL(); + void resizeGL(int width, int height); + void paintGL(); + void keyPressEvent(QKeyEvent* event); + +private: + compute::context context_; + compute::command_queue queue_; + compute::program program_; + GLuint gl_texture_; + compute::opengl_texture cl_texture_; +}; + +MandelbrotWidget::MandelbrotWidget(QWidget *parent) + : QGLWidget(parent) +{ + gl_texture_ = 0; +} + +MandelbrotWidget::~MandelbrotWidget() +{ +} + +void MandelbrotWidget::initializeGL() +{ + // setup opengl + glDisable(GL_LIGHTING); + + // create the OpenGL/OpenCL shared context + context_ = compute::opengl_create_shared_context(); + + // get gpu device + compute::device gpu = context_.get_device(); + std::cout << "device: " << gpu.name() << std::endl; + + // setup command queue + queue_ = compute::command_queue(context_, gpu); + + // build mandelbrot program + program_ = compute::program::create_with_source(source, context_); + program_.build(); +} + +void MandelbrotWidget::resizeGL(int width, int height) +{ +#if QT_VERSION >= 0x050000 + // scale height/width based on device pixel ratio + width /= windowHandle()->devicePixelRatio(); + height /= windowHandle()->devicePixelRatio(); +#endif + + // resize viewport + glViewport(0, 0, width, height); + + // delete old texture + if(gl_texture_){ + glDeleteTextures(1, &gl_texture_); + gl_texture_ = 0; + } + + // generate new texture + glGenTextures(1, &gl_texture_); + glBindTexture(GL_TEXTURE_2D, gl_texture_); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexImage2D( + GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0 + ); + + // create opencl object for the texture + cl_texture_ = compute::opengl_texture( + context_, GL_TEXTURE_2D, 0, gl_texture_, CL_MEM_WRITE_ONLY + ); +} + +void MandelbrotWidget::paintGL() +{ + using compute::dim; + + float w = width(); + float h = height(); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0.0, w, 0.0, h, -1.0, 1.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + // setup the mandelbrot kernel + compute::kernel kernel(program_, "mandelbrot"); + kernel.set_arg(0, cl_texture_); + + // acquire the opengl texture so it can be used in opencl + compute::opengl_enqueue_acquire_gl_objects(1, &cl_texture_.get(), queue_); + + // execute the mandelbrot kernel + queue_.enqueue_nd_range_kernel( + kernel, dim(0, 0), dim(width(), height()), dim(1, 1) + ); + + // release the opengl texture so it can be used by opengl + compute::opengl_enqueue_release_gl_objects(1, &cl_texture_.get(), queue_); + + // ensure opencl is finished before rendering in opengl + queue_.finish(); + + // draw a single quad with the mandelbrot image texture + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, gl_texture_); + + glBegin(GL_QUADS); + glTexCoord2f(0, 0); glVertex2f(0, 0); + glTexCoord2f(0, 1); glVertex2f(0, h); + glTexCoord2f(1, 1); glVertex2f(w, h); + glTexCoord2f(1, 0); glVertex2f(w, 0); + glEnd(); +} + +void MandelbrotWidget::keyPressEvent(QKeyEvent* event) +{ + if(event->key() == Qt::Key_Escape) { + this->close(); + } +} + +// the mandelbrot example shows how to create a mandelbrot image in +// OpenCL and render the image as a texture in OpenGL +int main(int argc, char *argv[]) +{ + QApplication app(argc, argv); + + MandelbrotWidget widget; + widget.show(); + + return app.exec(); +} + +#include "mandelbrot.moc" diff --git a/src/boost/libs/compute/example/mapped_view.cpp b/src/boost/libs/compute/example/mapped_view.cpp new file mode 100644 index 00000000..1e05107a --- /dev/null +++ b/src/boost/libs/compute/example/mapped_view.cpp @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/reduce.hpp> +#include <boost/compute/container/mapped_view.hpp> + +namespace compute = boost::compute; + +// this example demonstrates how to use the mapped_view class to map +// an array of numbers to device memory and use the reduce() algorithm +// to calculate the sum. +int main() +{ + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + std::cout << "device: " << gpu.name() << std::endl; + + // create data on host + int data[] = { 4, 2, 3, 7, 8, 9, 1, 6 }; + + // create mapped view on device + compute::mapped_view<int> view(data, 8, context); + + // use reduce() to calculate sum on the device + int sum = 0; + compute::reduce(view.begin(), view.end(), &sum, queue); + + // print the sum on the host + std::cout << "sum: " << sum << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/matrix_transpose.cpp b/src/boost/libs/compute/example/matrix_transpose.cpp new file mode 100644 index 00000000..ee9b1e9d --- /dev/null +++ b/src/boost/libs/compute/example/matrix_transpose.cpp @@ -0,0 +1,355 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Benoit Dequidt <benoit.dequidt@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <cstdlib> + +#include <boost/program_options.hpp> + +#include <boost/compute/core.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/type_traits/type_name.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; +namespace po = boost::program_options; + +using compute::uint_; + +const uint_ TILE_DIM = 32; +const uint_ BLOCK_ROWS = 8; + +// generate a copy kernel program +compute::kernel make_copy_kernel(const compute::context& context) +{ + // source for the copy_kernel program + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void copy_kernel(__global const float *src, __global float *dst) + { + uint x = get_group_id(0) * TILE_DIM + get_local_id(0); + uint y = get_group_id(1) * TILE_DIM + get_local_id(1); + + uint width = get_num_groups(0) * TILE_DIM; + + for(uint i = 0 ; i < TILE_DIM ; i+= BLOCK_ROWS){ + dst[(y+i)*width +x] = src[(y+i)*width + x]; + } + } + ); + + // setup compilation flags for the copy program + std::stringstream options; + options << "-DTILE_DIM=" << TILE_DIM << " -DBLOCK_ROWS=" << BLOCK_ROWS; + + // create and build the copy program + compute::program program = + compute::program::build_with_source(source, context, options.str()); + + // create and return the copy kernel + return program.create_kernel("copy_kernel"); +} + +// generate a naive transpose kernel +compute::kernel make_naive_transpose_kernel(const compute::context& context) +{ + // source for the naive_transpose kernel + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void naive_transpose(__global const float *src, __global float *dst) + { + uint x = get_group_id(0) * TILE_DIM + get_local_id(0); + uint y = get_group_id(1) * TILE_DIM + get_local_id(1); + + uint width = get_num_groups(0) * TILE_DIM; + + for(uint i = 0 ; i < TILE_DIM; i+= BLOCK_ROWS){ + dst[x*width + y+i] = src[(y+i)*width + x]; + } + } + ); + + // setup compilation flags for the naive_transpose program + std::stringstream options; + options << "-DTILE_DIM=" << TILE_DIM << " -DBLOCK_ROWS=" << BLOCK_ROWS; + + // create and build the naive_transpose program + compute::program program = + compute::program::build_with_source(source, context, options.str()); + + // create and return the naive_transpose kernel + return program.create_kernel("naive_transpose"); +} + +// generates a coalesced transpose kernel +compute::kernel make_coalesced_transpose_kernel(const compute::context& context) +{ + // source for the coalesced_transpose kernel + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void coalesced_transpose(__global const float *src, __global float *dst) + { + __local float tile[TILE_DIM][TILE_DIM]; + + // compute indexes + uint x = get_group_id(0) * TILE_DIM + get_local_id(0); + uint y = get_group_id(1) * TILE_DIM + get_local_id(1); + + uint width = get_num_groups(0) * TILE_DIM; + + // load inside local memory + for(uint i = 0 ; i < TILE_DIM; i+= BLOCK_ROWS){ + tile[get_local_id(1)+i][get_local_id(0)] = src[(y+i)*width + x]; + } + + barrier(CLK_LOCAL_MEM_FENCE); + + // transpose indexes + x = get_group_id(1) * TILE_DIM + get_local_id(0); + y = get_group_id(0) * TILE_DIM + get_local_id(1); + + // write output from local memory + for(uint i = 0 ; i < TILE_DIM ; i+=BLOCK_ROWS){ + dst[(y+i)*width + x] = tile[get_local_id(0)][get_local_id(1)+i]; + } + } + ); + + // setup compilation flags for the coalesced_transpose program + std::stringstream options; + options << "-DTILE_DIM=" << TILE_DIM << " -DBLOCK_ROWS=" << BLOCK_ROWS; + + // create and build the coalesced_transpose program + compute::program program = + compute::program::build_with_source(source, context, options.str()); + + // create and return coalesced_transpose kernel + return program.create_kernel("coalesced_transpose"); +} + +// generate a coalesced withtout bank conflicts kernel +compute::kernel make_coalesced_no_bank_conflicts_kernel(const compute::context& context) +{ + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void coalesced_no_bank_conflicts(__global const float *src, __global float *dst) + { + // TILE_DIM+1 is here to avoid bank conflicts in local memory + __local float tile[TILE_DIM][TILE_DIM+1]; + + // compute indexes + uint x = get_group_id(0) * TILE_DIM + get_local_id(0); + uint y = get_group_id(1) * TILE_DIM + get_local_id(1); + + uint width = get_num_groups(0) * TILE_DIM; + + // load inside local memory + for(uint i = 0 ; i < TILE_DIM; i+= BLOCK_ROWS){ + tile[get_local_id(1)+i][get_local_id(0)] = src[(y+i)*width + x]; + } + + barrier(CLK_LOCAL_MEM_FENCE); + + // transpose indexes + x = get_group_id(1) * TILE_DIM + get_local_id(0); + y = get_group_id(0) * TILE_DIM + get_local_id(1); + + // write output from local memory + for(uint i = 0 ; i < TILE_DIM ; i+=BLOCK_ROWS){ + dst[(y+i)*width + x] = tile[get_local_id(0)][get_local_id(1)+i]; + } + } + ); + + // setup compilation flags for the coalesced_no_bank_conflicts program + std::stringstream options; + options << "-DTILE_DIM=" << TILE_DIM << " -DBLOCK_ROWS=" << BLOCK_ROWS; + + // create and build the coalesced_no_bank_conflicts program + compute::program program = + compute::program::build_with_source(source, context, options.str()); + + // create and return the coalesced_no_bank_conflicts kernel + return program.create_kernel("coalesced_no_bank_conflicts"); +} + +// compare 'expectedResult' to 'transposedMatrix'. prints an error message if not equal. +bool check_transposition(const std::vector<float>& expectedResult, + uint_ size, + const std::vector<float>& transposedMatrix) +{ + for(uint_ i = 0 ; i < size ; ++i){ + if(expectedResult[i] != transposedMatrix[i]){ + std::cout << "idx = " << i << " , expected " << expectedResult[i] + << " , got " << transposedMatrix[i] << std::endl; + std::cout << "FAILED" << std::endl; + return false; + } + } + return true; +} + +// generate a matrix inside 'in' and do the tranposition inside 'out' +void generate_matrix(std::vector<float>& in, std::vector<float>& out, uint_ rows, uint_ cols) +{ + // generate a matrix + for(uint_ i = 0 ; i < rows ; ++i){ + for(uint_ j = 0 ; j < cols ; ++j){ + in[i*cols + j] = i*cols + j; + } + } + + // store transposed result + for(uint_ j = 0; j < cols ; ++j){ + for(uint_ i = 0 ; i < rows ; ++i){ + out[j*rows + i] = in[i*cols + j]; + } + } +} + +// neccessary for 64-bit integer on win32 +#ifdef _WIN32 +#define uint64_t unsigned __int64 +#endif + +int main(int argc, char *argv[]) +{ + // setup command line arguments + po::options_description options("options"); + options.add_options() + ("help", "show usage instructions") + ("rows", po::value<uint_>()->default_value(4096), "number of matrix rows") + ("cols", po::value<uint_>()->default_value(4096), "number of matrix columns") + ; + + // parse command line + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, options), vm); + po::notify(vm); + + // check command line arguments + if(vm.count("help")){ + std::cout << options << std::endl; + return 0; + } + + // get number rows and columns for the matrix + const uint_ rows = vm["rows"].as<uint_>(); + const uint_ cols = vm["cols"].as<uint_>(); + + // get the default device + compute::device device = compute::system::default_device(); + + // print out device name and matrix information + std::cout << "Device: " << device.name() << std::endl; + std::cout << "Matrix Size: " << rows << "x" << cols << std::endl; + std::cout << "Grid Size: " << rows/TILE_DIM << "x" << cols/TILE_DIM << " blocks" << std::endl; + std::cout << "Local Size: " << TILE_DIM << "x" << BLOCK_ROWS << " threads" << std::endl; + std::cout << std::endl; + + // On OSX this example does not work on CPU devices + #if defined(__APPLE__) + if(device.type() & compute::device::cpu) { + std::cout << "On OSX this example does not work on CPU devices" << std::endl; + return 0; + } + #endif + + const size_t global_work_size[2] = {rows, cols*BLOCK_ROWS/TILE_DIM}; + const size_t local_work_size[2] = {TILE_DIM, BLOCK_ROWS}; + + // setup input data on the host + const uint_ size = rows * cols; + std::vector<float> h_input(size); + std::vector<float> h_output(size); + std::vector<float> expectedResult(size); + generate_matrix(h_input, expectedResult, rows, cols); + + // create a context for the device + compute::context context(device); + + // device vectors + compute::vector<float> d_input(size, context); + compute::vector<float> d_output(size, context); + + // command_queue with profiling + compute::command_queue queue(context, device, compute::command_queue::enable_profiling); + + // copy input data + compute::copy(h_input.begin(), h_input.end(), d_input.begin(), queue); + + // simple copy kernel + std::cout << "Testing copy_kernel:" << std::endl; + compute::kernel kernel = make_copy_kernel(context); + kernel.set_arg(0, d_input); + kernel.set_arg(1, d_output); + + compute::event start; + start = queue.enqueue_nd_range_kernel(kernel, 2, 0, global_work_size, local_work_size); + queue.finish(); + uint64_t elapsed = start.duration<boost::chrono::nanoseconds>().count(); + + std::cout << " Elapsed: " << elapsed << " ns" << std::endl; + std::cout << " BandWidth: " << 2*rows*cols*sizeof(float) / elapsed << " GB/s" << std::endl; + compute::copy(d_output.begin(), d_output.end(), h_output.begin(), queue); + + check_transposition(h_input, rows*cols, h_output); + std::cout << std::endl; + + // naive_transpose kernel + std::cout << "Testing naive_transpose:" << std::endl; + kernel = make_naive_transpose_kernel(context); + kernel.set_arg(0, d_input); + kernel.set_arg(1, d_output); + + start = queue.enqueue_nd_range_kernel(kernel, 2, 0, global_work_size, local_work_size); + queue.finish(); + elapsed = start.duration<boost::chrono::nanoseconds>().count(); + std::cout << " Elapsed: " << elapsed << " ns" << std::endl; + std::cout << " BandWidth: " << 2*rows*cols*sizeof(float) / elapsed << " GB/s" << std::endl; + compute::copy(d_output.begin(), d_output.end(), h_output.begin(), queue); + + check_transposition(expectedResult, rows*cols, h_output); + std::cout << std::endl; + + // coalesced_transpose kernel + std::cout << "Testing coalesced_transpose:" << std::endl; + kernel = make_coalesced_transpose_kernel(context); + kernel.set_arg(0, d_input); + kernel.set_arg(1, d_output); + + start = queue.enqueue_nd_range_kernel(kernel, 2, 0, global_work_size, local_work_size); + queue.finish(); + elapsed = start.duration<boost::chrono::nanoseconds>().count(); + std::cout << " Elapsed: " << elapsed << " ns" << std::endl; + std::cout << " BandWidth: " << 2*rows*cols*sizeof(float) / elapsed << " GB/s" << std::endl; + + compute::copy(d_output.begin(), d_output.end(), h_output.begin(), queue); + + check_transposition(expectedResult, rows*cols, h_output); + std::cout << std::endl; + + // coalesced_no_bank_conflicts kernel + std::cout << "Testing coalesced_no_bank_conflicts:" << std::endl; + + kernel = make_coalesced_no_bank_conflicts_kernel(context); + kernel.set_arg(0, d_input); + kernel.set_arg(1, d_output); + + start = queue.enqueue_nd_range_kernel(kernel, 2, 0, global_work_size, local_work_size); + queue.finish(); + elapsed = start.duration<boost::chrono::nanoseconds>().count(); + std::cout << " Elapsed: " << elapsed << " ns" << std::endl; + std::cout << " BandWidth: " << 2*rows*cols*sizeof(float) / elapsed << " GB/s" << std::endl; + + compute::copy(d_output.begin(), d_output.end(), h_output.begin(), queue); + + check_transposition(expectedResult, rows*cols, h_output); + std::cout << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/memory_limits.cpp b/src/boost/libs/compute/example/memory_limits.cpp new file mode 100644 index 00000000..8d0e4a7a --- /dev/null +++ b/src/boost/libs/compute/example/memory_limits.cpp @@ -0,0 +1,37 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/core.hpp> + +namespace compute = boost::compute; + +int main() +{ + // get the default device + compute::device device = compute::system::default_device(); + + std::cout << "device: " << device.name() << std::endl; + std::cout << " global memory size: " + << device.get_info<cl_ulong>(CL_DEVICE_GLOBAL_MEM_SIZE) / 1024 / 1024 + << " MB" + << std::endl; + std::cout << " local memory size: " + << device.get_info<cl_ulong>(CL_DEVICE_LOCAL_MEM_SIZE) / 1024 + << " KB" + << std::endl; + std::cout << " constant memory size: " + << device.get_info<cl_ulong>(CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE) / 1024 + << " KB" + << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/monte_carlo.cpp b/src/boost/libs/compute/example/monte_carlo.cpp new file mode 100644 index 00000000..8ae26209 --- /dev/null +++ b/src/boost/libs/compute/example/monte_carlo.cpp @@ -0,0 +1,73 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/function.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/count_if.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/buffer_iterator.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/types/fundamental.hpp> + +namespace compute = boost::compute; + +int main() +{ + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + + std::cout << "device: " << gpu.name() << std::endl; + + using compute::uint_; + using compute::uint2_; + + +#ifdef CI_BUILD // lower number of points for CI builds + size_t n = 2000; +#else + // ten million random points + size_t n = 10000000; +#endif + + // generate random numbers + compute::default_random_engine rng(queue); + compute::vector<uint_> vector(n * 2, context); + rng.generate(vector.begin(), vector.end(), queue); + + // function returing true if the point is within the unit circle + BOOST_COMPUTE_FUNCTION(bool, is_in_unit_circle, (const uint2_ point), + { + const float x = point.x / (float) UINT_MAX - 1; + const float y = point.y / (float) UINT_MAX - 1; + + return (x*x + y*y) < 1.0f; + }); + + // iterate over vector<uint> as vector<uint2> + compute::buffer_iterator<uint2_> start = + compute::make_buffer_iterator<uint2_>(vector.get_buffer(), 0); + compute::buffer_iterator<uint2_> end = + compute::make_buffer_iterator<uint2_>(vector.get_buffer(), vector.size() / 2); + + // count number of random points within the unit circle + size_t count = compute::count_if(start, end, is_in_unit_circle, queue); + + // print out values + float count_f = static_cast<float>(count); + std::cout << "count: " << count << " / " << n << std::endl; + std::cout << "ratio: " << count_f / float(n) << std::endl; + std::cout << "pi = " << (count_f / float(n)) * 4.0f << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/nbody.cpp b/src/boost/libs/compute/example/nbody.cpp new file mode 100644 index 00000000..9379c63b --- /dev/null +++ b/src/boost/libs/compute/example/nbody.cpp @@ -0,0 +1,236 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Fabian Köhler <fabian2804@googlemail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#define GL_GLEXT_PROTOTYPES +#ifdef __APPLE__ +#include <OpenGL/gl.h> +#include <OpenGL/glext.h> +#else +#include <GL/gl.h> +#include <GL/glext.h> +#endif + +#include <QtGlobal> +#if QT_VERSION >= 0x050000 +#include <QtWidgets> +#else +#include <QtGui> +#endif +#include <QtOpenGL> +#include <QTimer> + +#include <boost/program_options.hpp> +#include <boost/random/uniform_real_distribution.hpp> +#include <boost/random/mersenne_twister.hpp> + +#ifndef Q_MOC_RUN +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/interop/opengl.hpp> +#include <boost/compute/utility/source.hpp> +#endif // Q_MOC_RUN + +namespace compute = boost::compute; +namespace po = boost::program_options; + +using compute::uint_; +using compute::float4_; + +const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void updateVelocity(__global const float4* position, __global float4* velocity, float dt, uint N) + { + uint gid = get_global_id(0); + + float4 r = { 0.0f, 0.0f, 0.0f, 0.0f }; + float f = 0.0f; + for(uint i = 0; i != gid; i++) { + if(i != gid) { + r = position[i]-position[gid]; + f = length(r)+0.001f; + f *= f*f; + f = dt/f; + velocity[gid] += f*r; + } + } + } + __kernel void updatePosition(__global float4* position, __global const float4* velocity, float dt) + { + uint gid = get_global_id(0); + + position[gid].xyz += dt*velocity[gid].xyz; + } +); + +class NBodyWidget : public QGLWidget +{ + Q_OBJECT + +public: + NBodyWidget(std::size_t particles, float dt, QWidget* parent = 0); + ~NBodyWidget(); + + void initializeGL(); + void resizeGL(int width, int height); + void paintGL(); + void updateParticles(); + void keyPressEvent(QKeyEvent* event); + +private: + QTimer* timer; + + compute::context m_context; + compute::command_queue m_queue; + compute::program m_program; + compute::opengl_buffer m_position; + compute::vector<float4_>* m_velocity; + compute::kernel m_velocity_kernel; + compute::kernel m_position_kernel; + + bool m_initial_draw; + + const uint_ m_particles; + const float m_dt; +}; + +NBodyWidget::NBodyWidget(std::size_t particles, float dt, QWidget* parent) + : QGLWidget(parent), m_initial_draw(true), m_particles(particles), m_dt(dt) +{ + // create a timer to redraw as fast as possible + timer = new QTimer(this); + connect(timer, SIGNAL(timeout()), this, SLOT(updateGL())); + timer->start(1); +} + +NBodyWidget::~NBodyWidget() +{ + delete m_velocity; + + // delete the opengl buffer + GLuint vbo = m_position.get_opengl_object(); + glDeleteBuffers(1, &vbo); +} + +void NBodyWidget::initializeGL() +{ + // create context, command queue and program + m_context = compute::opengl_create_shared_context(); + m_queue = compute::command_queue(m_context, m_context.get_device()); + m_program = compute::program::create_with_source(source, m_context); + m_program.build(); + + // prepare random particle positions that will be transferred to the vbo + float4_* temp = new float4_[m_particles]; + boost::random::uniform_real_distribution<float> dist(-0.5f, 0.5f); + boost::random::mt19937_64 gen; + for(size_t i = 0; i < m_particles; i++) { + temp[i][0] = dist(gen); + temp[i][1] = dist(gen); + temp[i][2] = dist(gen); + temp[i][3] = 1.0f; + } + + // create an OpenGL vbo + GLuint vbo = 0; + glGenBuffers(1, &vbo); + glBindBuffer(GL_ARRAY_BUFFER, vbo); + glBufferData(GL_ARRAY_BUFFER, m_particles*sizeof(float4_), temp, GL_DYNAMIC_DRAW); + + // create a OpenCL buffer from the vbo + m_position = compute::opengl_buffer(m_context, vbo); + delete[] temp; + + // create buffer for velocities + m_velocity = new compute::vector<float4_>(m_particles, m_context); + compute::fill(m_velocity->begin(), m_velocity->end(), float4_(0.0f, 0.0f, 0.0f, 0.0f), m_queue); + + // create compute kernels + m_velocity_kernel = m_program.create_kernel("updateVelocity"); + m_velocity_kernel.set_arg(0, m_position); + m_velocity_kernel.set_arg(1, m_velocity->get_buffer()); + m_velocity_kernel.set_arg(2, m_dt); + m_velocity_kernel.set_arg(3, m_particles); + m_position_kernel = m_program.create_kernel("updatePosition"); + m_position_kernel.set_arg(0, m_position); + m_position_kernel.set_arg(1, m_velocity->get_buffer()); + m_position_kernel.set_arg(2, m_dt); +} +void NBodyWidget::resizeGL(int width, int height) +{ + // update viewport + glViewport(0, 0, width, height); +} +void NBodyWidget::paintGL() +{ + // clear buffer + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + // check if this is the first draw + if(m_initial_draw) { + // do not update particles + m_initial_draw = false; + } else { + // update particles + updateParticles(); + } + + // draw + glVertexPointer(4, GL_FLOAT, 0, 0); + glEnableClientState(GL_VERTEX_ARRAY); + glDrawArrays(GL_POINTS, 0, m_particles); + glFinish(); +} +void NBodyWidget::updateParticles() +{ + // enqueue kernels to update particles and make sure that the command queue is finished + compute::opengl_enqueue_acquire_buffer(m_position, m_queue); + m_queue.enqueue_1d_range_kernel(m_velocity_kernel, 0, m_particles, 0).wait(); + m_queue.enqueue_1d_range_kernel(m_position_kernel, 0, m_particles, 0).wait(); + m_queue.finish(); + compute::opengl_enqueue_release_buffer(m_position, m_queue); +} +void NBodyWidget::keyPressEvent(QKeyEvent* event) +{ + if(event->key() == Qt::Key_Escape) { + this->close(); + } +} + +int main(int argc, char** argv) +{ + // parse command line arguments + po::options_description options("options"); + options.add_options() + ("help", "show usage") + ("particles", po::value<uint_>()->default_value(1000), "number of particles") + ("dt", po::value<float>()->default_value(0.00001f), "width of each integration step"); + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, options), vm); + po::notify(vm); + + if(vm.count("help") > 0) { + std::cout << options << std::endl; + return 0; + } + + const uint_ particles = vm["particles"].as<uint_>(); + const float dt = vm["dt"].as<float>(); + + QApplication app(argc, argv); + NBodyWidget nbody(particles, dt); + + nbody.show(); + + return app.exec(); +} + +#include "nbody.moc" diff --git a/src/boost/libs/compute/example/opencl_test.cpp b/src/boost/libs/compute/example/opencl_test.cpp new file mode 100644 index 00000000..15b85202 --- /dev/null +++ b/src/boost/libs/compute/example/opencl_test.cpp @@ -0,0 +1,165 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +// See boost/compute/detail/diagnostic.hpp +// GCC +#if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 402 +#define BOOST_COMPUTE_GCC_DIAG_STR(s) #s +#define BOOST_COMPUTE_GCC_DIAG_JOINSTR(x,y) BOOST_COMPUTE_GCC_DIAG_STR(x ## y) +# define BOOST_COMPUTE_GCC_DIAG_DO_PRAGMA(x) _Pragma (#x) +# define BOOST_COMPUTE_GCC_DIAG_PRAGMA(x) BOOST_COMPUTE_GCC_DIAG_DO_PRAGMA(GCC diagnostic x) +# if ((__GNUC__ * 100) + __GNUC_MINOR__) >= 406 +# define BOOST_COMPUTE_GCC_DIAG_OFF(x) BOOST_COMPUTE_GCC_DIAG_PRAGMA(push) \ + BOOST_COMPUTE_GCC_DIAG_PRAGMA(ignored BOOST_COMPUTE_GCC_DIAG_JOINSTR(-W,x)) +# define BOOST_COMPUTE_GCC_DIAG_ON(x) BOOST_COMPUTE_GCC_DIAG_PRAGMA(pop) +# else +# define BOOST_COMPUTE_GCC_DIAG_OFF(x) \ + BOOST_COMPUTE_GCC_DIAG_PRAGMA(ignored BOOST_COMPUTE_GCC_DIAG_JOINSTR(-W,x)) +# define BOOST_COMPUTE_GCC_DIAG_ON(x) \ + BOOST_COMPUTE_GCC_DIAG_PRAGMA(warning BOOST_COMPUTE_GCC_DIAG_JOINSTR(-W,x)) +# endif +#else // Ensure these macros do nothing for other compilers. +# define BOOST_COMPUTE_GCC_DIAG_OFF(x) +# define BOOST_COMPUTE_GCC_DIAG_ON(x) +#endif + +// Clang +#ifdef __clang__ +# define BOOST_COMPUTE_CLANG_DIAG_STR(s) # s +// stringize s to "no-sign-compare" +# define BOOST_COMPUTE_CLANG_DIAG_JOINSTR(x,y) BOOST_COMPUTE_CLANG_DIAG_STR(x ## y) +// join -W with no-unused-variable to "-Wno-sign-compare" +# define BOOST_COMPUTE_CLANG_DIAG_DO_PRAGMA(x) _Pragma (#x) +// _Pragma is unary operator #pragma ("") +# define BOOST_COMPUTE_CLANG_DIAG_PRAGMA(x) \ + BOOST_COMPUTE_CLANG_DIAG_DO_PRAGMA(clang diagnostic x) +# define BOOST_COMPUTE_CLANG_DIAG_OFF(x) BOOST_COMPUTE_CLANG_DIAG_PRAGMA(push) \ + BOOST_COMPUTE_CLANG_DIAG_PRAGMA(ignored BOOST_COMPUTE_CLANG_DIAG_JOINSTR(-W,x)) +// For example: #pragma clang diagnostic ignored "-Wno-sign-compare" +# define BOOST_COMPUTE_CLANG_DIAG_ON(x) BOOST_COMPUTE_CLANG_DIAG_PRAGMA(pop) +// For example: #pragma clang diagnostic warning "-Wno-sign-compare" +#else // Ensure these macros do nothing for other compilers. +# define BOOST_COMPUTE_CLANG_DIAG_OFF(x) +# define BOOST_COMPUTE_CLANG_DIAG_ON(x) +# define BOOST_COMPUTE_CLANG_DIAG_PRAGMA(x) +#endif + +// MSVC +#if defined(_MSC_VER) +# define BOOST_COMPUTE_MSVC_DIAG_DO_PRAGMA(x) __pragma(x) +# define BOOST_COMPUTE_MSVC_DIAG_PRAGMA(x) \ + BOOST_COMPUTE_MSVC_DIAG_DO_PRAGMA(warning(x)) +# define BOOST_COMPUTE_MSVC_DIAG_OFF(x) BOOST_COMPUTE_MSVC_DIAG_PRAGMA(push) \ + BOOST_COMPUTE_MSVC_DIAG_PRAGMA(disable: x) +# define BOOST_COMPUTE_MSVC_DIAG_ON(x) BOOST_COMPUTE_MSVC_DIAG_PRAGMA(pop) +#else // Ensure these macros do nothing for other compilers. +# define BOOST_COMPUTE_MSVC_DIAG_OFF(x) +# define BOOST_COMPUTE_MSVC_DIAG_ON(x) +#endif + +#include <iostream> + +// include the proper opencl header for the system +#if defined(__APPLE__) +#include <OpenCL/cl.h> +#else +#include <CL/cl.h> +#endif + +// the opencl_test example displays the opencl platforms and devices found +// on the system using the opencl api directly. if this test fails to compile +// and/or run, there is a problem with the opencl implementation found on the +// system. users should ensure this test runs successfuly before using any of +// the boost.compute apis (which depend on a working opencl implementation). +int main() +{ + // Suppress deprecated declarations warning + BOOST_COMPUTE_MSVC_DIAG_OFF(4996); // MSVC + BOOST_COMPUTE_GCC_DIAG_OFF(deprecated-declarations); // GCC + BOOST_COMPUTE_CLANG_DIAG_OFF(deprecated-declarations); // Clang + + // query number of opencl platforms + cl_uint num_platforms = 0; + cl_int ret = clGetPlatformIDs(0, NULL, &num_platforms); + if(ret != CL_SUCCESS){ + std::cerr << "failed to query platforms: " << ret << std::endl; + return -1; + } + + // check that at least one platform was found + if(num_platforms == 0){ + std::cerr << "found 0 platforms" << std::endl; + return 0; + } + + // get platform ids + cl_platform_id *platforms = new cl_platform_id[num_platforms]; + clGetPlatformIDs(num_platforms, platforms, NULL); + + // iterate through each platform and query its devices + for(cl_uint i = 0; i < num_platforms; i++){ + cl_platform_id platform = platforms[i]; + + // query number of opencl devices + cl_uint num_devices = 0; + ret = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices); + if(ret != CL_SUCCESS){ + std::cerr << "failed to lookup devices for platform " << i << std::endl; + continue; + } + + // print number of devices found + std::cout << "platform " << i << " has " << num_devices << " devices:" << std::endl; + + // get device ids for the platform + cl_device_id *devices = new cl_device_id[num_devices]; + ret = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, num_devices, devices, NULL); + if(ret != CL_SUCCESS){ + std::cerr << "failed to query platform devices" << std::endl; + delete[] devices; + continue; + } + + // iterate through each device on the platform and print its name + for(cl_uint j = 0; j < num_devices; j++){ + cl_device_id device = devices[j]; + + // get length of the device name string + size_t name_length = 0; + ret = clGetDeviceInfo(device, CL_DEVICE_NAME, 0, NULL, &name_length); + if(ret != CL_SUCCESS){ + std::cerr << "failed to query device name length for device " << j << std::endl; + continue; + } + + // get the device name string + char *name = new char[name_length]; + ret = clGetDeviceInfo(device, CL_DEVICE_NAME, name_length, name, NULL); + if(ret != CL_SUCCESS){ + std::cerr << "failed to query device name string for device " << j << std::endl; + delete[] name; + continue; + } + + // print out the device name + std::cout << " device: " << name << std::endl; + + delete[] name; + } + delete[] devices; + } + delete[] platforms; + + BOOST_COMPUTE_CLANG_DIAG_ON(deprecated-declarations); // Clang + BOOST_COMPUTE_GCC_DIAG_ON(deprecated-declarations); // GCC + BOOST_COMPUTE_MSVC_DIAG_OFF(4996); // MSVC + + return 0; +} diff --git a/src/boost/libs/compute/example/opencv_convolution.cpp b/src/boost/libs/compute/example/opencv_convolution.cpp new file mode 100644 index 00000000..7ba53436 --- /dev/null +++ b/src/boost/libs/compute/example/opencv_convolution.cpp @@ -0,0 +1,265 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Mageswaran.D <mageswaran1989@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <string> + +#include <opencv2/core/core.hpp> +#include <opencv2/highgui/highgui.hpp> +#include <opencv2/imgproc/imgproc.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/interop/opencv/core.hpp> +#include <boost/compute/interop/opencv/highgui.hpp> +#include <boost/compute/utility/source.hpp> + +#include <boost/program_options.hpp> + +namespace compute = boost::compute; +namespace po = boost::program_options; + +// Create convolution program +const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE ( + __kernel void convolution(__read_only image2d_t sourceImage, + __write_only image2d_t outputImage, + __constant float* filter, + int filterWidth) + { + const sampler_t sampler = CLK_NORMALIZED_COORDS_FALSE | + CLK_ADDRESS_CLAMP_TO_EDGE | + CLK_FILTER_NEAREST; + + // Store each work-item's unique row and column + int x = get_global_id(0); + int y = get_global_id(1); + + // Half the width of the filter is needed for indexing + // memory later + int halfWidth = (int)(filterWidth/2); + + // All accesses to images return data as four-element vector + // (i.e., float4). + float4 sum = {0.0f, 0.0f, 0.0f, 0.0f}; + + // Iterator for the filter + int filterIdx = 0; + + // Each work-item iterates around its local area based on the + // size of the filter + int2 coords; // Coordinates for accessing the image + + // Iterate the filter rows + for(int i = -halfWidth; i <= halfWidth; i++) + { + coords.y = y + i; + + // Iterate over the filter columns + for(int j = -halfWidth; j <= halfWidth; j++) + { + coords.x = x + j; + + float4 pixel; + + // Read a pixel from the image. + // Work on a channel + pixel = read_imagef(sourceImage, sampler, coords); + sum.x += pixel.x * filter[filterIdx++]; + //sum.y += pixel.y * filter[filterIdx++]; + //sum.z += pixel.z * filter[filterIdx++]; + } + } + + barrier(CLK_GLOBAL_MEM_FENCE); + // Copy the data to the output image if the + // work-item is in bounds + if(y < get_image_height(sourceImage) && + x < get_image_width(sourceImage)) + { + coords.x = x; + coords.y = y; + + //Same channel is copied in all three channels + //write_imagef(outputImage, coords, + // (float4)(sum.x,sum.x,sum.x,1.0f)); + + write_imagef(outputImage, coords, sum); + } + } +); + +// This example shows how to read two images or use camera +// with OpenCV, transfer the frames to the GPU, +// and apply a convolution written in OpenCL +int main(int argc, char *argv[]) +{ + /////////////////////////////////////////////////////////////////////////// + + // setup the command line arguments + po::options_description desc; + desc.add_options() + ("help", "show available options") + ("camera", po::value<int>()->default_value(-1), + "if not default camera, specify a camera id") + ("image", po::value<std::string>(), "path to image file"); + + // Parse the command lines + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, desc), vm); + po::notify(vm); + + //check the command line arguments + if(vm.count("help")) + { + std::cout << desc << std::endl; + return 0; + } + + /////////////////////////////////////////////////////////////////////////// + + //OpenCV variables + cv::Mat cv_mat; + cv::VideoCapture cap; //OpenCV camera handle. + + //Filter Variables + float filter[9] = { + -1.0, 0.0, 1.0, + -2.0, 0.0, 2.0, + -1.0, 0.0, 1.0, + }; + + // The convolution filter is 3x3 + int filterWidth = 3; + + //OpenCL variables + // Get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + compute::buffer dev_filter(context, sizeof(filter), + compute::memory_object::read_only | + compute::memory_object::copy_host_ptr, + filter); + + compute::program filter_program = + compute::program::create_with_source(source, context); + + try + { + filter_program.build(); + } + catch(compute::opencl_error e) + { + std::cout<<"Build Error: "<<std::endl + <<filter_program.build_log(); + return -1; + } + + // create fliter kernel and set arguments + compute::kernel filter_kernel(filter_program, "convolution"); + + /////////////////////////////////////////////////////////////////////////// + + //check for image paths + if(vm.count("image")) + { + // Read image with OpenCV + cv_mat = cv::imread(vm["image"].as<std::string>(), + CV_LOAD_IMAGE_COLOR); + if(!cv_mat.data){ + std::cerr << "Failed to load image" << std::endl; + return -1; + } + } + else //by default use camera + { + //open camera + cap.open(vm["camera"].as<int>()); + // read first frame + cap >> cv_mat; + if(!cv_mat.data){ + std::cerr << "failed to capture frame" << std::endl; + return -1; + } + } + + // Convert image to BGRA (OpenCL requires 16-byte aligned data) + cv::cvtColor(cv_mat, cv_mat, CV_BGR2BGRA); + + // Transfer image/frame data to gpu + compute::image2d dev_input_image = + compute::opencv_create_image2d_with_mat( + cv_mat, compute::image2d::read_write, queue + ); + + // Create output image + // Be sure what will be your ouput image/frame size + compute::image2d dev_output_image( + context, + dev_input_image.width(), + dev_input_image.height(), + dev_input_image.format(), + compute::image2d::write_only + ); + + filter_kernel.set_arg(0, dev_input_image); + filter_kernel.set_arg(1, dev_output_image); + filter_kernel.set_arg(2, dev_filter); + filter_kernel.set_arg(3, filterWidth); + + // run flip kernel + size_t origin[2] = { 0, 0 }; + size_t region[2] = { dev_input_image.width(), + dev_input_image.height() }; + + /////////////////////////////////////////////////////////////////////////// + + queue.enqueue_nd_range_kernel(filter_kernel, 2, origin, region, 0); + + //check for image paths + if(vm.count("image")) + { + // show host image + cv::imshow("Original Image", cv_mat); + + // show gpu image + compute::opencv_imshow("Convoluted Image", dev_output_image, queue); + + // wait and return + cv::waitKey(0); + } + else + { + char key = '\0'; + while(key != 27) //check for escape key + { + cap >> cv_mat; + + // Convert image to BGRA (OpenCL requires 16-byte aligned data) + cv::cvtColor(cv_mat, cv_mat, CV_BGR2BGRA); + + // Update the device image memory with current frame data + compute::opencv_copy_mat_to_image(cv_mat, + dev_input_image,queue); + + // Run the kernel on the device + queue.enqueue_nd_range_kernel(filter_kernel, 2, origin, region, 0); + + // Show host image + cv::imshow("Camera Frame", cv_mat); + + // Show GPU image + compute::opencv_imshow("Convoluted Frame", dev_output_image, queue); + + // wait + key = cv::waitKey(10); + } + } + return 0; +} diff --git a/src/boost/libs/compute/example/opencv_flip.cpp b/src/boost/libs/compute/example/opencv_flip.cpp new file mode 100644 index 00000000..8cc26ef2 --- /dev/null +++ b/src/boost/libs/compute/example/opencv_flip.cpp @@ -0,0 +1,101 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <opencv2/core/core.hpp> +#include <opencv2/highgui/highgui.hpp> +#include <opencv2/imgproc/imgproc.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/interop/opencv/core.hpp> +#include <boost/compute/interop/opencv/highgui.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +// this example shows how to read an image with OpenCV, transfer the +// image to the GPU, and apply a simple flip filter written in OpenCL +int main(int argc, char *argv[]) +{ + // check command line + if(argc < 2){ + std::cerr << "usage: " << argv[0] << " FILENAME" << std::endl; + return -1; + } + + // read image with opencv + cv::Mat cv_image = cv::imread(argv[1], CV_LOAD_IMAGE_COLOR); + if(!cv_image.data){ + std::cerr << "failed to load image" << std::endl; + return -1; + } + + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + + // convert image to BGRA (OpenCL requires 16-byte aligned data) + cv::cvtColor(cv_image, cv_image, CV_BGR2BGRA); + + // transfer image to gpu + compute::image2d input_image = + compute::opencv_create_image2d_with_mat( + cv_image, compute::image2d::read_write, queue + ); + + // create output image + compute::image2d output_image( + context, + input_image.width(), + input_image.height(), + input_image.format(), + compute::image2d::write_only + ); + + // create flip program + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void flip_kernel(__read_only image2d_t input, + __write_only image2d_t output) + { + const sampler_t sampler = CLK_ADDRESS_NONE | CLK_FILTER_NEAREST; + int height = get_image_height(input); + int2 input_coord = { get_global_id(0), get_global_id(1) }; + int2 output_coord = { input_coord.x, height - input_coord.y - 1 }; + float4 value = read_imagef(input, sampler, input_coord); + write_imagef(output, output_coord, value); + } + ); + + compute::program flip_program = + compute::program::create_with_source(source, context); + flip_program.build(); + + // create flip kernel and set arguments + compute::kernel flip_kernel(flip_program, "flip_kernel"); + flip_kernel.set_arg(0, input_image); + flip_kernel.set_arg(1, output_image); + + // run flip kernel + size_t origin[2] = { 0, 0 }; + size_t region[2] = { input_image.width(), input_image.height() }; + queue.enqueue_nd_range_kernel(flip_kernel, 2, origin, region, 0); + + // show host image + cv::imshow("opencv image", cv_image); + + // show gpu image + compute::opencv_imshow("filtered image", output_image, queue); + + // wait and return + cv::waitKey(0); + return 0; +} diff --git a/src/boost/libs/compute/example/opencv_histogram.cpp b/src/boost/libs/compute/example/opencv_histogram.cpp new file mode 100644 index 00000000..e339030b --- /dev/null +++ b/src/boost/libs/compute/example/opencv_histogram.cpp @@ -0,0 +1,228 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Mageswaran.D <mageswaran1989@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +//Code sample for calculating histogram using OpenCL and +//displaying image histogram in OpenCV. + +#include <iostream> +#include <string> + +#include <opencv2/imgproc/imgproc.hpp> +#include <opencv2/highgui/highgui.hpp> + +#include <boost/compute/source.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/interop/opencv/core.hpp> +#include <boost/compute/interop/opencv/highgui.hpp> +#include <boost/program_options.hpp> + +namespace compute = boost::compute; +namespace po = boost::program_options; + +// number of bins +int histSize = 256; + +// Set the ranges ( for B,G,R) ) +// TryOut: consider the range in kernel calculation +float range[] = { 0, 256 } ; +const float* histRange = { range }; + +// Create naive histogram program +// Needs "cl_khr_local_int32_base_atomics" extension +const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE ( + __kernel void histogram(read_only image2d_t src_image, + __global int* b_hist, + __global int* g_hist, + __global int* r_hist) + { + sampler_t sampler =( CLK_NORMALIZED_COORDS_FALSE | + CLK_FILTER_NEAREST | + CLK_ADDRESS_CLAMP_TO_EDGE); + + int image_width = get_image_width(src_image); + int image_height = get_image_height(src_image); + + int2 coords = (int2)(get_global_id(0), get_global_id(1)); + float4 pixel = read_imagef(src_image,sampler, coords); + + //boundary condition + if ((coords.x < image_width) && (coords.y < image_height)) + { + uchar indx_x, indx_y, indx_z; + indx_x = convert_uchar_sat(pixel.x * 255.0f); + indx_y = convert_uchar_sat(pixel.y * 255.0f); + indx_z = convert_uchar_sat(pixel.z * 255.0f); + + atomic_inc(&b_hist[(uint)indx_z]); + atomic_inc(&g_hist[(uint)indx_y]); + atomic_inc(&r_hist[(uint)indx_x]); + } + } +); + +inline void showHistogramWindow(cv::Mat &b_hist, cv::Mat &g_hist, cv::Mat &r_hist, + std::string window_name) +{ + // Draw the histograms for B, G and R + int hist_w = 1024; + int hist_h = 768; + int bin_w = cvRound((double)hist_w/histSize); + + cv::Mat histImage(hist_h, hist_w, CV_8UC3, cv::Scalar(0,0,0)); + + // Normalize the result to [ 0, histImage.rows ] + cv::normalize(b_hist, b_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat()); + cv::normalize(g_hist, g_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat()); + cv::normalize(r_hist, r_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat()); + + // Draw for each channel + for (int i = 1; i < histSize; i++ ) + { + cv::line(histImage, + cv::Point(bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1))), + cv::Point(bin_w*(i), hist_h - cvRound(b_hist.at<float>(i))), + cv::Scalar(255, 0, 0), + 2, + 8, + 0); + + cv::line(histImage, + cv::Point(bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1))), + cv::Point(bin_w*(i), hist_h - cvRound(g_hist.at<float>(i))), + cv::Scalar(0, 255, 0), + 2, + 8, + 0); + + cv::line(histImage, + cv::Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1))), + cv::Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ), + cv::Scalar( 0, 0, 255), + 2, + 8, + 0); + } + + // Display + cv::namedWindow(window_name, CV_WINDOW_AUTOSIZE ); + cv::imshow(window_name, histImage ); +} + +//Get the device context +//Create GPU array/vector +//Copy the image & set up the kernel +//Execute the kernel +//Copy GPU data back to CPU cv::Mat data pointer +//OpenCV conversion for convienient display +void calculateHistogramUsingCL(cv::Mat src, compute::command_queue &queue) +{ + compute::context context = queue.get_context(); + + // Convert image to BGRA (OpenCL requires 16-byte aligned data) + cv::cvtColor(src, src, CV_BGR2BGRA); + + //3 channels & 256 bins : alpha channel is ignored + compute::vector<int> gpu_b_hist(histSize, context); + compute::vector<int> gpu_g_hist(histSize, context); + compute::vector<int> gpu_r_hist(histSize, context); + + // Transfer image to gpu + compute::image2d gpu_src = + compute::opencv_create_image2d_with_mat( + src, compute::image2d::read_only, + queue + ); + + compute::program histogram_program = + compute::program::create_with_source(source, context); + histogram_program.build(); + + // create histogram kernel and set arguments + compute::kernel histogram_kernel(histogram_program, "histogram"); + histogram_kernel.set_arg(0, gpu_src); + histogram_kernel.set_arg(1, gpu_b_hist.get_buffer()); + histogram_kernel.set_arg(2, gpu_g_hist.get_buffer()); + histogram_kernel.set_arg(3, gpu_r_hist.get_buffer()); + + // run histogram kernel + // each kernel thread updating red, green & blue bins + size_t origin[2] = { 0, 0 }; + size_t region[2] = { gpu_src.width(), + gpu_src.height() }; + + queue.enqueue_nd_range_kernel(histogram_kernel, 2, origin, region, 0); + + //Make sure kernel get executed and data copied back + queue.finish(); + + //create Mat and copy GPU bins to CPU memory + cv::Mat b_hist(256, 1, CV_32SC1); + compute::copy(gpu_b_hist.begin(), gpu_b_hist.end(), b_hist.data, queue); + cv::Mat g_hist(256, 1, CV_32SC1); + compute::copy(gpu_g_hist.begin(), gpu_g_hist.end(), g_hist.data, queue); + cv::Mat r_hist(256, 1, CV_32SC1); + compute::copy(gpu_r_hist.begin(), gpu_r_hist.end(), r_hist.data, queue); + + b_hist.convertTo(b_hist, CV_32FC1); //converted for displaying + g_hist.convertTo(g_hist, CV_32FC1); + r_hist.convertTo(r_hist, CV_32FC1); + + showHistogramWindow(b_hist, g_hist, r_hist, "Histogram"); +} + +int main( int argc, char** argv ) +{ + // Get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + + cv::Mat src; + + // setup the command line arguments + po::options_description desc; + desc.add_options() + ("help", "show available options") + ("image", po::value<std::string>(), "path to image file"); + + // Parse the command lines + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, desc), vm); + po::notify(vm); + + //check the command line arguments + if(vm.count("help")) + { + std::cout << desc << std::endl; + return 0; + } + + //check for image paths + if(vm.count("image")) + { + // Read image with OpenCV + src = cv::imread(vm["image"].as<std::string>(), + CV_LOAD_IMAGE_COLOR); + if(!src.data){ + std::cerr << "Failed to load image" << std::endl; + return -1; + } + calculateHistogramUsingCL(src, queue); + cv::imshow("Image", src); + cv::waitKey(0); + } + else + { + std::cout << desc << std::endl; + return 0; + } + return 0; +} diff --git a/src/boost/libs/compute/example/opencv_optical_flow.cpp b/src/boost/libs/compute/example/opencv_optical_flow.cpp new file mode 100644 index 00000000..87f330ae --- /dev/null +++ b/src/boost/libs/compute/example/opencv_optical_flow.cpp @@ -0,0 +1,289 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Mageswaran.D <mageswaran1989@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <string> + +#include <opencv2/core/core.hpp> +#include <opencv2/highgui/highgui.hpp> +#include <opencv2/imgproc/imgproc.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/interop/opencv/core.hpp> +#include <boost/compute/interop/opencv/highgui.hpp> +#include <boost/compute/utility/source.hpp> + +#include <boost/program_options.hpp> + +namespace compute = boost::compute; +namespace po = boost::program_options; + +// Create naive optical flow program +const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE ( + const sampler_t sampler = CLK_ADDRESS_CLAMP_TO_EDGE; + + __kernel void optical_flow ( + read_only + image2d_t current_image, + read_only image2d_t previous_image, + write_only image2d_t optical_flow, + const float scale, + const float offset, + const float lambda, + const float threshold ) + { + int2 coords = (int2)(get_global_id(0), get_global_id(1)); + float4 current_pixel = read_imagef(current_image, + sampler, + coords); + float4 previous_pixel = read_imagef(previous_image, + sampler, + coords); + int2 x1 = (int2)(offset, 0.f); + int2 y1 = (int2)(0.f, offset); + + //get the difference + float4 curdif = previous_pixel - current_pixel; + + //calculate the gradient + //Image 2 first + float4 gradx = read_imagef(previous_image, + sampler, + coords+x1) - + read_imagef(previous_image, + sampler, + coords-x1); + //Image 1 + gradx += read_imagef(current_image, + sampler, + coords+x1) - + read_imagef(current_image, + sampler, + coords-x1); + //Image 2 first + float4 grady = read_imagef(previous_image, + sampler, + coords+y1) - + read_imagef(previous_image, + sampler, + coords-y1); + //Image 1 + grady += read_imagef(current_image, + sampler, + coords+y1) - + read_imagef(current_image, + sampler, + coords-y1); + + float4 sqr = (gradx*gradx) + (grady*grady) + + (float4)(lambda,lambda, lambda, lambda); + float4 gradmag = sqrt(sqr); + + /////////////////////////////////////////////////// + float4 vx = curdif * (gradx / gradmag); + float vxd = vx.x;//assumes greyscale + + //format output for flowrepos, out(-x,+x,-y,+y) + float2 xout = (float2)(fmax(vxd,0.f),fabs(fmin(vxd,0.f))); + xout *= scale; + /////////////////////////////////////////////////// + float4 vy = curdif*(grady/gradmag); + float vyd = vy.x;//assumes greyscale + + //format output for flowrepos, out(-x,+x,-y,+y) + float2 yout = (float2)(fmax(vyd,0.f),fabs(fmin(vyd,0.f))); + yout *= scale; + /////////////////////////////////////////////////// + + float4 out = (float4)(xout, yout); + float cond = (float)isgreaterequal(length(out), threshold); + out *= cond; + + write_imagef(optical_flow, coords, out); + } +); + +// This example shows how to read two images or use camera +// with OpenCV, transfer the frames to the GPU, +// and apply a naive optical flow algorithm +// written in OpenCL +int main(int argc, char *argv[]) +{ + // setup the command line arguments + po::options_description desc; + desc.add_options() + ("help", "show available options") + ("camera", po::value<int>()->default_value(-1), + "if not default camera, specify a camera id") + ("image1", po::value<std::string>(), "path to image file 1") + ("image2", po::value<std::string>(), "path to image file 2"); + + // Parse the command lines + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, desc), vm); + po::notify(vm); + + //check the command line arguments + if(vm.count("help")) + { + std::cout << desc << std::endl; + return 0; + } + + //OpenCV variables + cv::Mat previous_cv_image; + cv::Mat current_cv_image; + cv::VideoCapture cap; //OpenCV camera handle + + //check for image paths + if(vm.count("image1") && vm.count("image2")) + { + // Read image 1 with OpenCV + previous_cv_image = cv::imread(vm["image1"].as<std::string>(), + CV_LOAD_IMAGE_COLOR); + if(!previous_cv_image.data){ + std::cerr << "Failed to load image" << std::endl; + return -1; + } + + // Read image 2 with opencv + current_cv_image = cv::imread(vm["image2"].as<std::string>(), + CV_LOAD_IMAGE_COLOR); + if(!current_cv_image.data){ + std::cerr << "Failed to load image" << std::endl; + return -1; + } + } + else //by default use camera + { + //open camera + cap.open(vm["camera"].as<int>()); + // read first frame + cap >> previous_cv_image; + if(!previous_cv_image.data){ + std::cerr << "failed to capture frame" << std::endl; + return -1; + } + + // read second frame + cap >> current_cv_image; + if(!current_cv_image.data){ + std::cerr << "failed to capture frame" << std::endl; + return -1; + } + + } + + // Get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + + // Convert image to BGRA (OpenCL requires 16-byte aligned data) + cv::cvtColor(previous_cv_image, previous_cv_image, CV_BGR2BGRA); + cv::cvtColor(current_cv_image, current_cv_image, CV_BGR2BGRA); + + // Transfer image to gpu + compute::image2d dev_previous_image = + compute::opencv_create_image2d_with_mat( + previous_cv_image, compute::image2d::read_write, queue + ); + // Transfer image to gpu + compute::image2d dev_current_image = + compute::opencv_create_image2d_with_mat( + current_cv_image, compute::image2d::read_write, queue + ); + + // Create output image + compute::image2d dev_output_image( + context, + dev_previous_image.width(), + dev_previous_image.height(), + dev_previous_image.format(), + compute::image2d::write_only + ); + + compute::program optical_program = + compute::program::create_with_source(source, context); + optical_program.build(); + + // create flip kernel and set arguments + compute::kernel optical_kernel(optical_program, "optical_flow"); + float scale = 10; + float offset = 1; + float lambda = 0.0025; + float threshold = 1.0; + + optical_kernel.set_arg(0, dev_previous_image); + optical_kernel.set_arg(1, dev_current_image); + optical_kernel.set_arg(2, dev_output_image); + optical_kernel.set_arg(3, scale); + optical_kernel.set_arg(4, offset); + optical_kernel.set_arg(5, lambda); + optical_kernel.set_arg(6, threshold); + + // run flip kernel + size_t origin[2] = { 0, 0 }; + size_t region[2] = { dev_previous_image.width(), + dev_previous_image.height() }; + queue.enqueue_nd_range_kernel(optical_kernel, 2, origin, region, 0); + + //check for image paths + if(vm.count("image1") && vm.count("image2")) + { + // show host image + cv::imshow("Previous Frame", previous_cv_image); + cv::imshow("Current Frame", current_cv_image); + + // show gpu image + compute::opencv_imshow("filtered image", dev_output_image, queue); + + // wait and return + cv::waitKey(0); + } + else + { + char key = '\0'; + while(key != 27) //check for escape key + { + cap >> current_cv_image; + + // Convert image to BGRA (OpenCL requires 16-byte aligned data) + cv::cvtColor(current_cv_image, current_cv_image, CV_BGR2BGRA); + + // Update the device image memory with current frame data + compute::opencv_copy_mat_to_image(previous_cv_image, + dev_previous_image, + queue); + compute::opencv_copy_mat_to_image(current_cv_image, + dev_current_image, + queue); + + // Run the kernel on the device + queue.enqueue_nd_range_kernel(optical_kernel, 2, origin, region, 0); + + // Show host image + cv::imshow("Previous Frame", previous_cv_image); + cv::imshow("Current Frame", current_cv_image); + + // Show GPU image + compute::opencv_imshow("filtered image", dev_output_image, queue); + + // Copy current frame container to previous frame container + current_cv_image.copyTo(previous_cv_image); + + // wait + key = cv::waitKey(10); + } + + } + return 0; +} + diff --git a/src/boost/libs/compute/example/opencv_sobel_filter.cpp b/src/boost/libs/compute/example/opencv_sobel_filter.cpp new file mode 100644 index 00000000..4fcfa206 --- /dev/null +++ b/src/boost/libs/compute/example/opencv_sobel_filter.cpp @@ -0,0 +1,254 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Mageswaran.D <mageswaran1989@gmail.com> +// +// Book Refered: OpenCL Programming Guide +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +//---------------------------------------------------------------------------// +// About Sobel Filter: +// * Edge Filter - distinguishes the differrent color region +// * Finds the gradient in x and y-axes +// * Three step process +// -> Find x-axis gradient with kernel/matrix +// Gx = [-1 0 +1] +// [-2 0 +2] +// [-1 0 +1] +// -> Find y-axis gradient with kernel/matrix +// Gy = [-1 -2 -1] +// [ 0 0 0] +// [+1 +2 +1] +// * Gradient magnitude G = sqrt(Gx^2 + Gy^2) +//---------------------------------------------------------------------------// + +#include <iostream> +#include <string> + +#include <opencv2/core/core.hpp> +#include <opencv2/highgui/highgui.hpp> +#include <opencv2/imgproc/imgproc.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/interop/opencv/core.hpp> +#include <boost/compute/interop/opencv/highgui.hpp> +#include <boost/compute/utility/source.hpp> + +#include <boost/program_options.hpp> + +namespace compute = boost::compute; +namespace po = boost::program_options; + +// Create sobel filter program +const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE ( + //For out of boundary pixels, edge pixel + // value is returned + const sampler_t sampler = CLK_ADDRESS_CLAMP_TO_EDGE | + CLK_FILTER_NEAREST; + kernel void sobel_rgb(read_only image2d_t src, write_only image2d_t dst) + { + int x = (int)get_global_id(0); + int y = (int)get_global_id(1); + + if (x >= get_image_width(src) || y >= get_image_height(src)) + return; + + // [(x-1, y+1), (x, y+1), (x+1, y+1)] + // [(x-1, y ), (x, y ), (x+1, y )] + // [(x-1, y-1), (x, y-1), (x+1, y-1)] + + // [p02, p12, p22] + // [p01, pixel, p21] + // [p00, p10, p20] + + //Basically finding influence of neighbour pixels on current pixel + float4 p00 = read_imagef(src, sampler, (int2)(x - 1, y - 1)); + float4 p10 = read_imagef(src, sampler, (int2)(x, y - 1)); + float4 p20 = read_imagef(src, sampler, (int2)(x + 1, y - 1)); + + float4 p01 = read_imagef(src, sampler, (int2)(x - 1, y)); + //pixel that we are working on + float4 p21 = read_imagef(src, sampler, (int2)(x + 1, y)); + + float4 p02 = read_imagef(src, sampler, (int2)(x - 1, y + 1)); + float4 p12 = read_imagef(src, sampler, (int2)(x, y + 1)); + float4 p22 = read_imagef(src, sampler, (int2)(x + 1, y + 1)); + + //Find Gx = kernel + 3x3 around current pixel + // Gx = [-1 0 +1] [p02, p12, p22] + // [-2 0 +2] + [p01, pixel, p21] + // [-1 0 +1] [p00, p10, p20] + float3 gx = -p00.xyz + p20.xyz + + 2.0f * (p21.xyz - p01.xyz) + -p02.xyz + p22.xyz; + + //Find Gy = kernel + 3x3 around current pixel + // Gy = [-1 -2 -1] [p02, p12, p22] + // [ 0 0 0] + [p01, pixel, p21] + // [+1 +2 +1] [p00, p10, p20] + float3 gy = p00.xyz + p20.xyz + + 2.0f * (- p12.xyz + p10.xyz) - + p02.xyz - p22.xyz; + //Find G + float3 g = native_sqrt(gx * gx + gy * gy); + + // we could also approximate this as g = fabs(gx) + fabs(gy) + write_imagef(dst, (int2)(x, y), (float4)(g.x, g.y, g.z, 1.0f)); + } +); + +// This example shows how to apply sobel filter on images or on camera frames +// with OpenCV, transfer the frames to the GPU, and apply a sobel filter +// written in OpenCL +int main(int argc, char *argv[]) +{ + /////////////////////////////////////////////////////////////////////////// + + // setup the command line arguments + po::options_description desc; + desc.add_options() + ("help", "show available options") + ("camera", po::value<int>()->default_value(-1), + "if not default camera, specify a camera id") + ("image", po::value<std::string>(), "path to image file"); + + // Parse the command lines + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, desc), vm); + po::notify(vm); + + //check the command line arguments + if(vm.count("help")) + { + std::cout << desc << std::endl; + return 0; + } + + /////////////////////////////////////////////////////////////////////////// + + //OpenCV variables + cv::Mat cv_mat; + cv::VideoCapture cap; //OpenCV camera handle. + + //OpenCL variables + // Get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + compute::program filter_program = + compute::program::create_with_source(source, context); + + try + { + filter_program.build(); + } + catch(compute::opencl_error e) + { + std::cout<<"Build Error: "<<std::endl + <<filter_program.build_log(); + } + + // create fliter kernel and set arguments + compute::kernel filter_kernel(filter_program, "sobel_rgb"); + + /////////////////////////////////////////////////////////////////////////// + + //check for image paths + if(vm.count("image")) + { + // Read image with OpenCV + cv_mat = cv::imread(vm["image"].as<std::string>(), + CV_LOAD_IMAGE_COLOR); + if(!cv_mat.data){ + std::cerr << "Failed to load image" << std::endl; + return -1; + } + } + else //by default use camera + { + //open camera + cap.open(vm["camera"].as<int>()); + // read first frame + cap >> cv_mat; + if(!cv_mat.data){ + std::cerr << "failed to capture frame" << std::endl; + return -1; + } + } + + // Convert image to BGRA (OpenCL requires 16-byte aligned data) + cv::cvtColor(cv_mat, cv_mat, CV_BGR2BGRA); + + // Transfer image/frame data to gpu + compute::image2d dev_input_image = + compute::opencv_create_image2d_with_mat( + cv_mat, compute::image2d::read_write, queue + ); + + // Create output image + // Be sure what will be your ouput image/frame size + compute::image2d dev_output_image( + context, + dev_input_image.width(), + dev_input_image.height(), + dev_input_image.format(), + compute::image2d::write_only + ); + + filter_kernel.set_arg(0, dev_input_image); + filter_kernel.set_arg(1, dev_output_image); + + + // run flip kernel + size_t origin[2] = { 0, 0 }; + size_t region[2] = { dev_input_image.width(), + dev_input_image.height() }; + + /////////////////////////////////////////////////////////////////////////// + + queue.enqueue_nd_range_kernel(filter_kernel, 2, origin, region, 0); + + //check for image paths + if(vm.count("image")) + { + // show host image + cv::imshow("Original Image", cv_mat); + + // show gpu image + compute::opencv_imshow("Filtered Image", dev_output_image, queue); + + // wait and return + cv::waitKey(0); + } + else + { + char key = '\0'; + while(key != 27) //check for escape key + { + cap >> cv_mat; + + // Convert image to BGRA (OpenCL requires 16-byte aligned data) + cv::cvtColor(cv_mat, cv_mat, CV_BGR2BGRA); + + // Update the device image memory with current frame data + compute::opencv_copy_mat_to_image(cv_mat, + dev_input_image,queue); + + // Run the kernel on the device + queue.enqueue_nd_range_kernel(filter_kernel, 2, origin, region, 0); + + // Show host image + cv::imshow("Camera Frame", cv_mat); + + // Show GPU image + compute::opencv_imshow("Filtered RGB Frame", dev_output_image, queue); + + // wait + key = cv::waitKey(10); + } + } + return 0; +} diff --git a/src/boost/libs/compute/example/opengl_sphere.cpp b/src/boost/libs/compute/example/opengl_sphere.cpp new file mode 100644 index 00000000..38999f34 --- /dev/null +++ b/src/boost/libs/compute/example/opengl_sphere.cpp @@ -0,0 +1,242 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> + +#include <GL/gl.h> + +#include <vtkActor.h> +#include <vtkCamera.h> +#include <vtkgl.h> +#include <vtkInteractorStyleSwitch.h> +#include <vtkMapper.h> +#include <vtkObjectFactory.h> +#include <vtkOpenGLExtensionManager.h> +#include <vtkOpenGLRenderWindow.h> +#include <vtkProperty.h> +#include <vtkRenderer.h> +#include <vtkRenderWindow.h> +#include <vtkRenderWindowInteractor.h> +#include <vtkSmartPointer.h> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/interop/opengl.hpp> +#include <boost/compute/interop/vtk.hpp> +#include <boost/compute/utility/dim.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +// tesselates a sphere with radius, phi_slices, and theta_slices. returns +// a shared opencl/opengl buffer containing the vertex data. +compute::opengl_buffer tesselate_sphere(float radius, + size_t phi_slices, + size_t theta_slices, + compute::command_queue &queue) +{ + using compute::dim; + + const compute::context &context = queue.get_context(); + + const size_t vertex_count = phi_slices * theta_slices; + + // create opengl buffer + GLuint vbo; + vtkgl::GenBuffersARB(1, &vbo); + vtkgl::BindBufferARB(vtkgl::ARRAY_BUFFER, vbo); + vtkgl::BufferDataARB(vtkgl::ARRAY_BUFFER, + sizeof(float) * 4 * vertex_count, + NULL, + vtkgl::STREAM_DRAW); + vtkgl::BindBufferARB(vtkgl::ARRAY_BUFFER, 0); + + // create shared opengl/opencl buffer + compute::opengl_buffer vertex_buffer(context, vbo); + + // tesselate_sphere kernel source + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void tesselate_sphere(float radius, + uint phi_slices, + uint theta_slices, + __global float4 *vertex_buffer) + { + const uint phi_i = get_global_id(0); + const uint theta_i = get_global_id(1); + + const float phi = phi_i * 2.f * M_PI_F / phi_slices; + const float theta = theta_i * 2.f * M_PI_F / theta_slices; + + float4 v; + v.x = radius * cos(theta) * cos(phi); + v.y = radius * cos(theta) * sin(phi); + v.z = radius * sin(theta); + v.w = 1.f; + + vertex_buffer[phi_i*phi_slices+theta_i] = v; + } + ); + + // build tesselate_sphere program + compute::program program = + compute::program::create_with_source(source, context); + program.build(); + + // setup tesselate_sphere kernel + compute::kernel kernel(program, "tesselate_sphere"); + kernel.set_arg<compute::float_>(0, radius); + kernel.set_arg<compute::uint_>(1, phi_slices); + kernel.set_arg<compute::uint_>(2, theta_slices); + kernel.set_arg(3, vertex_buffer); + + // acqurire buffer so that it is accessible to OpenCL + compute::opengl_enqueue_acquire_buffer(vertex_buffer, queue); + + // execute tesselate_sphere kernel + queue.enqueue_nd_range_kernel( + kernel, dim(0, 0), dim(phi_slices, theta_slices), dim(1, 1) + ); + + // release buffer so that it is accessible to OpenGL + compute::opengl_enqueue_release_buffer(vertex_buffer, queue); + + return vertex_buffer; +} + +// simple vtkMapper subclass to render the tesselated sphere on the gpu. +class gpu_sphere_mapper : public vtkMapper +{ +public: + vtkTypeMacro(gpu_sphere_mapper, vtkMapper) + + static gpu_sphere_mapper* New() + { + return new gpu_sphere_mapper; + } + + void Render(vtkRenderer *renderer, vtkActor *actor) + { + if(!m_initialized){ + Initialize(renderer, actor); + m_initialized = true; + } + + if(!m_tesselated){ + m_vertex_count = m_phi_slices * m_theta_slices; + + // tesselate sphere + m_vertex_buffer = tesselate_sphere( + m_radius, m_phi_slices, m_theta_slices, m_command_queue + ); + + // ensure tesselation is finished (seems to be required on AMD) + m_command_queue.finish(); + + // set tesselated flag to true + m_tesselated = true; + } + + // draw sphere + glEnableClientState(GL_VERTEX_ARRAY); + vtkgl::BindBufferARB(vtkgl::ARRAY_BUFFER, m_vertex_buffer.get_opengl_object()); + glVertexPointer(4, GL_FLOAT, sizeof(float)*4, 0); + glDrawArrays(GL_POINTS, 0, m_vertex_count); + } + + void Initialize(vtkRenderer *renderer, vtkActor *actor) + { + // initialize opengl extensions + vtkOpenGLExtensionManager *extensions = + static_cast<vtkOpenGLRenderWindow *>(renderer->GetRenderWindow()) + ->GetExtensionManager(); + extensions->LoadExtension("GL_ARB_vertex_buffer_object"); + + // initialize opencl/opengl shared context + m_context = compute::opengl_create_shared_context(); + compute::device device = m_context.get_device(); + std::cout << "device: " << device.name() << std::endl; + + // create command queue for the gpu device + m_command_queue = compute::command_queue(m_context, device); + } + + double* GetBounds() + { + static double bounds[6]; + bounds[0] = -m_radius; bounds[1] = m_radius; + bounds[2] = -m_radius; bounds[3] = m_radius; + bounds[4] = -m_radius; bounds[5] = m_radius; + return bounds; + } + +protected: + gpu_sphere_mapper() + { + m_radius = 5.0f; + m_phi_slices = 100; + m_theta_slices = 100; + m_initialized = false; + m_tesselated = false; + } + +private: + float m_radius; + int m_phi_slices; + int m_theta_slices; + int m_vertex_count; + bool m_initialized; + bool m_tesselated; + compute::context m_context; + compute::command_queue m_command_queue; + compute::opengl_buffer m_vertex_buffer; +}; + +int main(int argc, char *argv[]) +{ + // create gpu sphere mapper + vtkSmartPointer<gpu_sphere_mapper> mapper = + vtkSmartPointer<gpu_sphere_mapper>::New(); + + // create actor for gpu sphere mapper + vtkSmartPointer<vtkActor> actor = + vtkSmartPointer<vtkActor>::New(); + actor->GetProperty()->LightingOff(); + actor->GetProperty()->SetInterpolationToFlat(); + actor->SetMapper(mapper); + + // create render window + vtkSmartPointer<vtkRenderer> renderer = + vtkSmartPointer<vtkRenderer>::New(); + renderer->SetBackground(.1, .2, .31); + vtkSmartPointer<vtkRenderWindow> renderWindow = + vtkSmartPointer<vtkRenderWindow>::New(); + renderWindow->SetSize(800, 600); + renderWindow->AddRenderer(renderer); + vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor = + vtkSmartPointer<vtkRenderWindowInteractor>::New(); + vtkInteractorStyleSwitch *interactorStyle = + vtkInteractorStyleSwitch::SafeDownCast( + renderWindowInteractor->GetInteractorStyle() + ); + interactorStyle->SetCurrentStyleToTrackballCamera(); + renderWindowInteractor->SetRenderWindow(renderWindow); + renderer->AddActor(actor); + + // render + renderer->ResetCamera(); + vtkCamera *camera = renderer->GetActiveCamera(); + camera->Elevation(-90.0); + renderWindowInteractor->Initialize(); + renderWindow->Render(); + renderWindowInteractor->Start(); + + return 0; +} diff --git a/src/boost/libs/compute/example/point_centroid.cpp b/src/boost/libs/compute/example/point_centroid.cpp new file mode 100644 index 00000000..e5691f7c --- /dev/null +++ b/src/boost/libs/compute/example/point_centroid.cpp @@ -0,0 +1,68 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +//[point_centroid_example + +#include <iostream> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/accumulate.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +namespace compute = boost::compute; + +// the point centroid example calculates and displays the +// centroid of a set of 3D points stored as float4's +int main() +{ + using compute::float4_; + + // get default device and setup context + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + + // point coordinates + float points[] = { 1.0f, 2.0f, 3.0f, 0.0f, + -2.0f, -3.0f, 4.0f, 0.0f, + 1.0f, -2.0f, 2.5f, 0.0f, + -7.0f, -3.0f, -2.0f, 0.0f, + 3.0f, 4.0f, -5.0f, 0.0f }; + + // create vector for five points + compute::vector<float4_> vector(5, context); + + // copy point data to the device + compute::copy( + reinterpret_cast<float4_ *>(points), + reinterpret_cast<float4_ *>(points) + 5, + vector.begin(), + queue + ); + + // calculate sum + float4_ sum = compute::accumulate( + vector.begin(), vector.end(), float4_(0, 0, 0, 0), queue + ); + + // calculate centroid + float4_ centroid; + for(size_t i = 0; i < 3; i++){ + centroid[i] = sum[i] / 5.0f; + } + + // print centroid + std::cout << "centroid: " << centroid << std::endl; + + return 0; +} + +//] diff --git a/src/boost/libs/compute/example/price_cross.cpp b/src/boost/libs/compute/example/price_cross.cpp new file mode 100644 index 00000000..95196494 --- /dev/null +++ b/src/boost/libs/compute/example/price_cross.cpp @@ -0,0 +1,87 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/find_if.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/zip_iterator.hpp> + +namespace compute = boost::compute; + +// this example shows how to use the find_if() algorithm to detect the +// point at which two vectors of prices (such as stock prices) cross. +int main() +{ + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + + // prices #1 (from 10.0 to 11.0) + std::vector<float> prices1; + for(float i = 10.0; i <= 11.0; i += 0.1){ + prices1.push_back(i); + } + + // prices #2 (from 11.0 to 10.0) + std::vector<float> prices2; + for(float i = 11.0; i >= 10.0; i -= 0.1){ + prices2.push_back(i); + } + + // create gpu vectors + compute::vector<float> gpu_prices1(prices1.size(), context); + compute::vector<float> gpu_prices2(prices2.size(), context); + + // copy prices to gpu + compute::copy(prices1.begin(), prices1.end(), gpu_prices1.begin(), queue); + compute::copy(prices2.begin(), prices2.end(), gpu_prices2.begin(), queue); + + // function returning true if the second price is less than the first price + BOOST_COMPUTE_FUNCTION(bool, check_price_cross, (boost::tuple<float, float> prices), + { + // first price + const float first = boost_tuple_get(prices, 0); + + // second price + const float second = boost_tuple_get(prices, 1); + + // return true if second price is less than first + return second < first; + }); + + // find cross point (should be 10.5) + compute::vector<float>::iterator iter = boost::get<0>( + compute::find_if( + compute::make_zip_iterator( + boost::make_tuple(gpu_prices1.begin(), gpu_prices2.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(gpu_prices1.end(), gpu_prices2.end()) + ), + check_price_cross, + queue + ).get_iterator_tuple() + ); + + // print out result + int index = std::distance(gpu_prices1.begin(), iter); + std::cout << "price cross at index: " << index << std::endl; + + float value; + compute::copy_n(iter, 1, &value, queue); + std::cout << "value: " << value << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/print_vector.cpp b/src/boost/libs/compute/example/print_vector.cpp new file mode 100644 index 00000000..9ec5c6c7 --- /dev/null +++ b/src/boost/libs/compute/example/print_vector.cpp @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/container/vector.hpp> + +namespace compute = boost::compute; + +// this example demonstrates how to print the values in a vector +int main() +{ + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + std::cout << "device: " << gpu.name() << std::endl; + + // create vector on the device and fill with the sequence 1..10 + compute::vector<int> vector(10, context); + compute::iota(vector.begin(), vector.end(), 1, queue); + +//[print_vector_example + std::cout << "vector: [ "; + boost::compute::copy( + vector.begin(), vector.end(), + std::ostream_iterator<int>(std::cout, ", "), + queue + ); + std::cout << "]" << std::endl; +//] + + return 0; +} diff --git a/src/boost/libs/compute/example/qimage_blur.cpp b/src/boost/libs/compute/example/qimage_blur.cpp new file mode 100644 index 00000000..cbfa3145 --- /dev/null +++ b/src/boost/libs/compute/example/qimage_blur.cpp @@ -0,0 +1,145 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> + +#include <QtGlobal> +#if QT_VERSION >= 0x050000 +#include <QtWidgets> +#else +#include <QtGui> +#endif + +#ifndef Q_MOC_RUN +#include <boost/compute/system.hpp> +#include <boost/compute/image/image2d.hpp> +#include <boost/compute/interop/qt.hpp> +#include <boost/compute/utility/dim.hpp> +#include <boost/compute/utility/source.hpp> +#endif // Q_MOC_RUN + +namespace compute = boost::compute; + +inline void box_filter_image(const compute::image2d &input, + compute::image2d &output, + compute::uint_ box_height, + compute::uint_ box_width, + compute::command_queue &queue) +{ + using compute::dim; + + const compute::context &context = queue.get_context(); + + // simple box filter kernel source + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void box_filter(__read_only image2d_t input, + __write_only image2d_t output, + uint box_height, + uint box_width) + { + int x = get_global_id(0); + int y = get_global_id(1); + int h = get_image_height(input); + int w = get_image_width(input); + int k = box_width; + int l = box_height; + + if(x < k/2 || y < l/2 || x >= w-(k/2) || y >= h-(l/2)){ + write_imagef(output, (int2)(x, y), (float4)(0, 0, 0, 1)); + } + else { + const sampler_t sampler = CLK_ADDRESS_NONE | CLK_FILTER_NEAREST; + + float4 sum = { 0, 0, 0, 0 }; + for(int i = 0; i < k; i++){ + for(int j = 0; j < l; j++){ + sum += read_imagef(input, sampler, (int2)(x+i-k, y+j-l)); + } + } + sum /= (float) k * l; + float4 value = (float4)( sum.x, sum.y, sum.z, 1.f ); + write_imagef(output, (int2)(x, y), value); + } + } + ); + + // build box filter program + compute::program program = + compute::program::create_with_source(source, context); + program.build(); + + // setup box filter kernel + compute::kernel kernel(program, "box_filter"); + kernel.set_arg(0, input); + kernel.set_arg(1, output); + kernel.set_arg(2, box_height); + kernel.set_arg(3, box_width); + + // execute the box filter kernel + queue.enqueue_nd_range_kernel(kernel, dim(0, 0), input.size(), dim(1, 1)); +} + +// this example shows how to load an image using Qt, apply a simple +// box blur filter, and then display it in a Qt window. +int main(int argc, char *argv[]) +{ + QApplication app(argc, argv); + + // check command line + if(argc < 2){ + std::cout << "usage: qimage_blur [FILENAME]" << std::endl; + return -1; + } + + // load image using Qt + QString fileName = argv[1]; + QImage qimage(fileName); + + size_t height = qimage.height(); + size_t width = qimage.width(); + size_t bytes_per_line = qimage.bytesPerLine(); + + qDebug() << "height:" << height + << "width:" << width + << "bytes per line:" << bytes_per_line + << "depth:" << qimage.depth() + << "format:" << qimage.format(); + + // create compute context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + std::cout << "device: " << gpu.name() << std::endl; + + // get the opencl image format for the qimage + compute::image_format format = + compute::qt_qimage_format_to_image_format(qimage.format()); + + // create input and output images on the gpu + compute::image2d input_image(context, width, height, format); + compute::image2d output_image(context, width, height, format); + + // copy host qimage to gpu image + compute::qt_copy_qimage_to_image2d(qimage, input_image, queue); + + // apply box filter + box_filter_image(input_image, output_image, 7, 7, queue); + + // copy gpu blurred image from to host qimage + compute::qt_copy_image2d_to_qimage(output_image, qimage, queue); + + // show image as a pixmap + QLabel label; + label.setPixmap(QPixmap::fromImage(qimage)); + label.show(); + + return app.exec(); +} diff --git a/src/boost/libs/compute/example/random_walk.cpp b/src/boost/libs/compute/example/random_walk.cpp new file mode 100644 index 00000000..13106d96 --- /dev/null +++ b/src/boost/libs/compute/example/random_walk.cpp @@ -0,0 +1,153 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <opencv2/core/core.hpp> +#include <opencv2/highgui/highgui.hpp> +#include <opencv2/imgproc/imgproc.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/inclusive_scan.hpp> +#include <boost/compute/algorithm/inclusive_scan.hpp> +#include <boost/compute/interop/opencv/core.hpp> +#include <boost/compute/interop/opencv/highgui.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/uniform_real_distribution.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +// this example uses the random-number generation functions in Boost.Compute +// to calculate a large number of random "steps" and then plots the final +// random "walk" in a 2D image on the GPU and displays it with OpenCV +int main() +{ + // number of random steps to take + size_t steps = 250000; + + // height and width of image + size_t height = 800; + size_t width = 800; + + // get default device and setup context + compute::device gpu = compute::system::default_device(); + compute::context context(gpu); + compute::command_queue queue(context, gpu); + + using compute::int2_; + + // calaculate random values for each step + compute::vector<float> random_values(steps, context); + compute::default_random_engine random_engine(queue); + compute::uniform_real_distribution<float> random_distribution(0.f, 4.f); + + random_distribution.generate( + random_values.begin(), random_values.end(), random_engine, queue + ); + + // calaculate coordinates for each step + compute::vector<int2_> coordinates(steps, context); + + // function to convert random values to random directions (in 2D) + BOOST_COMPUTE_FUNCTION(int2_, take_step, (const float x), + { + if(x < 1.f){ + // move right + return (int2)(1, 0); + } + if(x < 2.f){ + // move up + return (int2)(0, 1); + } + if(x < 3.f){ + // move left + return (int2)(-1, 0); + } + else { + // move down + return (int2)(0, -1); + } + }); + + // transform the random values into random steps + compute::transform( + random_values.begin(), random_values.end(), coordinates.begin(), take_step, queue + ); + + // set staring position + int2_ starting_position(width / 2, height / 2); + compute::copy_n(&starting_position, 1, coordinates.begin(), queue); + + // scan steps to calculate position after each step + compute::inclusive_scan( + coordinates.begin(), coordinates.end(), coordinates.begin(), queue + ); + + // create output image + compute::image2d image( + context, width, height, compute::image_format(CL_RGBA, CL_UNSIGNED_INT8) + ); + + // program with two kernels, one to fill the image with white, and then + // one the draw to points calculated in coordinates on the image + const char draw_walk_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void draw_walk(__global const int2 *coordinates, + __write_only image2d_t image) + { + const uint i = get_global_id(0); + const int2 coord = coordinates[i]; + + if(coord.x > 0 && coord.x < get_image_width(image) && + coord.y > 0 && coord.y < get_image_height(image)){ + uint4 black = { 0, 0, 0, 0 }; + write_imageui(image, coord, black); + } + } + + __kernel void fill_white(__write_only image2d_t image) + { + const int2 coord = { get_global_id(0), get_global_id(1) }; + + if(coord.x < get_image_width(image) && + coord.y < get_image_height(image)){ + uint4 white = { 255, 255, 255, 255 }; + write_imageui(image, coord, white); + } + } + ); + + // build the program + compute::program draw_program = + compute::program::build_with_source(draw_walk_source, context); + + // fill image with white + compute::kernel fill_kernel(draw_program, "fill_white"); + fill_kernel.set_arg(0, image); + + const size_t offset[] = { 0, 0 }; + const size_t bounds[] = { width, height }; + + queue.enqueue_nd_range_kernel(fill_kernel, 2, offset, bounds, 0); + + // draw random walk + compute::kernel draw_kernel(draw_program, "draw_walk"); + draw_kernel.set_arg(0, coordinates); + draw_kernel.set_arg(1, image); + queue.enqueue_1d_range_kernel(draw_kernel, 0, coordinates.size(), 0); + + // show image + compute::opencv_imshow("random walk", image, queue); + + // wait and return + cv::waitKey(0); + + return 0; +} diff --git a/src/boost/libs/compute/example/resize_image.cpp b/src/boost/libs/compute/example/resize_image.cpp new file mode 100644 index 00000000..d9e29edd --- /dev/null +++ b/src/boost/libs/compute/example/resize_image.cpp @@ -0,0 +1,253 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> + +#include <QtGlobal> +#if QT_VERSION >= 0x050000 +#include <QtWidgets> +#else +#include <QtGui> +#endif +#include <QtOpenGL> + +#include <boost/program_options.hpp> + +#ifndef Q_MOC_RUN +#include <boost/compute/command_queue.hpp> +#include <boost/compute/kernel.hpp> +#include <boost/compute/program.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/image/image2d.hpp> +#include <boost/compute/image/image_sampler.hpp> +#include <boost/compute/interop/qt.hpp> +#include <boost/compute/interop/opengl.hpp> +#include <boost/compute/utility/source.hpp> +#endif // Q_MOC_RUN + +namespace compute = boost::compute; +namespace po = boost::program_options; + +// opencl source code +const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void resize_image(__read_only image2d_t input, + const sampler_t sampler, + __write_only image2d_t output) + { + const uint x = get_global_id(0); + const uint y = get_global_id(1); + + const float w = get_image_width(output); + const float h = get_image_height(output); + + float2 coord = { ((float) x / w) * get_image_width(input), + ((float) y / h) * get_image_height(input) }; + + float4 pixel = read_imagef(input, sampler, coord); + write_imagef(output, (int2)(x, h - y - 1), pixel); + }; +); + +class ImageWidget : public QGLWidget +{ + Q_OBJECT + +public: + ImageWidget(QString fileName, QWidget *parent = 0); + ~ImageWidget(); + + void initializeGL(); + void resizeGL(int width, int height); + void paintGL(); + +private: + QImage qt_image_; + compute::context context_; + compute::command_queue queue_; + compute::program program_; + compute::image2d image_; + compute::image_sampler sampler_; + GLuint gl_texture_; + compute::opengl_texture cl_texture_; +}; + +ImageWidget::ImageWidget(QString fileName, QWidget *parent) + : QGLWidget(parent), + qt_image_(fileName) +{ + gl_texture_ = 0; +} + +ImageWidget::~ImageWidget() +{ +} + +void ImageWidget::initializeGL() +{ + // setup opengl + glDisable(GL_LIGHTING); + + // create the OpenGL/OpenCL shared context + context_ = compute::opengl_create_shared_context(); + + // get gpu device + compute::device gpu = context_.get_device(); + std::cout << "device: " << gpu.name() << std::endl; + + // setup command queue + queue_ = compute::command_queue(context_, gpu); + + // allocate image on the device + compute::image_format format = + compute::qt_qimage_format_to_image_format(qt_image_.format()); + + image_ = compute::image2d( + context_, qt_image_.width(), qt_image_.height(), format, CL_MEM_READ_ONLY + ); + + // transfer image to the device + compute::qt_copy_qimage_to_image2d(qt_image_, image_, queue_); + + // setup image sampler (use CL_FILTER_NEAREST to disable linear interpolation) + sampler_ = compute::image_sampler( + context_, false, CL_ADDRESS_NONE, CL_FILTER_LINEAR + ); + + // build resize program + program_ = compute::program::build_with_source(source, context_); +} + +void ImageWidget::resizeGL(int width, int height) +{ +#if QT_VERSION >= 0x050000 + // scale height/width based on device pixel ratio + width /= windowHandle()->devicePixelRatio(); + height /= windowHandle()->devicePixelRatio(); +#endif + + // resize viewport + glViewport(0, 0, width, height); + + // delete old texture + if(gl_texture_){ + glDeleteTextures(1, &gl_texture_); + gl_texture_ = 0; + } + + // generate new texture + glGenTextures(1, &gl_texture_); + glBindTexture(GL_TEXTURE_2D, gl_texture_); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + glTexImage2D( + GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0 + ); + + // create opencl object for the texture + cl_texture_ = compute::opengl_texture( + context_, GL_TEXTURE_2D, 0, gl_texture_, CL_MEM_WRITE_ONLY + ); +} + +void ImageWidget::paintGL() +{ + float w = width(); + float h = height(); + + glMatrixMode(GL_PROJECTION); + glLoadIdentity(); + glOrtho(0.0, w, 0.0, h, -1.0, 1.0); + glMatrixMode(GL_MODELVIEW); + glLoadIdentity(); + + // setup the resize kernel + compute::kernel kernel(program_, "resize_image"); + kernel.set_arg(0, image_); + kernel.set_arg(1, sampler_); + kernel.set_arg(2, cl_texture_); + + // acquire the opengl texture so it can be used in opencl + compute::opengl_enqueue_acquire_gl_objects(1, &cl_texture_.get(), queue_); + + // execute the resize kernel + const size_t global_work_offset[] = { 0, 0 }; + const size_t global_work_size[] = { size_t(width()), size_t(height()) }; + + queue_.enqueue_nd_range_kernel( + kernel, 2, global_work_offset, global_work_size, 0 + ); + + // release the opengl texture so it can be used by opengl + compute::opengl_enqueue_release_gl_objects(1, &cl_texture_.get(), queue_); + + // ensure opencl is finished before rendering in opengl + queue_.finish(); + + // draw a single quad with the resized image texture + glEnable(GL_TEXTURE_2D); + glBindTexture(GL_TEXTURE_2D, gl_texture_); + + glBegin(GL_QUADS); + glTexCoord2f(0, 0); glVertex2f(0, 0); + glTexCoord2f(0, 1); glVertex2f(0, h); + glTexCoord2f(1, 1); glVertex2f(w, h); + glTexCoord2f(1, 0); glVertex2f(w, 0); + glEnd(); +} + +// the resize image example demonstrates how to interactively resize a +// 2D image and display it using OpenGL. a image sampler is used to perform +// hardware-accelerated linear interpolation for the resized image. +int main(int argc, char *argv[]) +{ + // setup command line arguments + po::options_description options("options"); + options.add_options() + ("help", "show usage instructions") + ("file", po::value<std::string>(), "image file name (e.g. /path/to/image.png)") + ; + po::positional_options_description positional_options; + positional_options.add("file", 1); + + // parse command line + po::variables_map vm; + po::store( + po::command_line_parser(argc, argv) + .options(options) + .positional(positional_options) + .run(), + vm + ); + po::notify(vm); + + // check for file argument + if(vm.count("help") || !vm.count("file")){ + std::cout << options << std::endl; + return -1; + } + + // get file name + std::string file_name = vm["file"].as<std::string>(); + + // setup qt application + QApplication app(argc, argv); + + // setup image widget + ImageWidget widget(QString::fromStdString(file_name)); + widget.show(); + + // run qt application + return app.exec(); +} + +#include "resize_image.moc" diff --git a/src/boost/libs/compute/example/simple_kernel.cpp b/src/boost/libs/compute/example/simple_kernel.cpp new file mode 100644 index 00000000..4aa1872f --- /dev/null +++ b/src/boost/libs/compute/example/simple_kernel.cpp @@ -0,0 +1,84 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/core.hpp> + +namespace compute = boost::compute; + +// this example demonstrates how to use the Boost.Compute classes to +// setup and run a simple vector addition kernel on the GPU +int main() +{ + // get the default device + compute::device device = compute::system::default_device(); + + // create a context for the device + compute::context context(device); + + // setup input arrays + float a[] = { 1, 2, 3, 4 }; + float b[] = { 5, 6, 7, 8 }; + + // make space for the output + float c[] = { 0, 0, 0, 0 }; + + // create memory buffers for the input and output + compute::buffer buffer_a(context, 4 * sizeof(float)); + compute::buffer buffer_b(context, 4 * sizeof(float)); + compute::buffer buffer_c(context, 4 * sizeof(float)); + + // source code for the add kernel + const char source[] = + "__kernel void add(__global const float *a," + " __global const float *b," + " __global float *c)" + "{" + " const uint i = get_global_id(0);" + " c[i] = a[i] + b[i];" + "}"; + + // create the program with the source + compute::program program = + compute::program::create_with_source(source, context); + + // compile the program + program.build(); + + // create the kernel + compute::kernel kernel(program, "add"); + + // set the kernel arguments + kernel.set_arg(0, buffer_a); + kernel.set_arg(1, buffer_b); + kernel.set_arg(2, buffer_c); + + // create a command queue + compute::command_queue queue(context, device); + + // write the data from 'a' and 'b' to the device + queue.enqueue_write_buffer(buffer_a, 0, 4 * sizeof(float), a); + queue.enqueue_write_buffer(buffer_b, 0, 4 * sizeof(float), b); + + // run the add kernel + queue.enqueue_1d_range_kernel(kernel, 0, 4, 0); + + // transfer results back to the host array 'c' + queue.enqueue_read_buffer(buffer_c, 0, 4 * sizeof(float), c); + + // print out results in 'c' + std::cout << "c: [" << c[0] << ", " + << c[1] << ", " + << c[2] << ", " + << c[3] << "]" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/simple_moving_average.cpp b/src/boost/libs/compute/example/simple_moving_average.cpp new file mode 100644 index 00000000..968db393 --- /dev/null +++ b/src/boost/libs/compute/example/simple_moving_average.cpp @@ -0,0 +1,139 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Benoit Dequidt <benoit.dequidt@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <cstdlib> + +#include <boost/compute/core.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/inclusive_scan.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/type_traits/type_name.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +/// warning precision is not precise due +/// to the float error accumulation when size is large enough +/// for more precision use double +/// or a kahan sum else results can diverge +/// from the CPU implementation +compute::program make_sma_program(const compute::context& context) +{ + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void SMA(__global const float *scannedValues, int size, __global float *output, int wSize) + { + const int gid = get_global_id(0); + + float cumValues = 0.f; + int endIdx = gid + wSize/2; + int startIdx = gid -1 - wSize/2; + + if(endIdx > size -1) + endIdx = size -1; + + cumValues += scannedValues[endIdx]; + if(startIdx < 0) + startIdx = -1; + else + cumValues -= scannedValues[startIdx]; + + output[gid] =(float)( cumValues / ( float )(endIdx - startIdx)); + } + ); + + // create sma program + return compute::program::build_with_source(source,context); +} + +bool check_results(const std::vector<float>& values, const std::vector<float>& smoothValues, unsigned int wSize) +{ + int size = values.size(); + if(size != (int)smoothValues.size()) return false; + + int semiWidth = wSize/2; + + bool ret = true; + for(int idx = 0 ; idx < size ; ++idx) + { + int start = (std::max)(idx - semiWidth,0); + int end = (std::min)(idx + semiWidth,size-1); + float res = 0; + for(int j = start ; j <= end ; ++j) + { + res+= values[j]; + } + + res /= float(end - start +1); + + if(std::abs(res-smoothValues[idx]) > 1e-3) + { + std::cout << "idx = " << idx << " -- expected = " << res << " -- result = " << smoothValues[idx] << std::endl; + ret = false; + } + } + + return ret; +} + +// generate a uniform law over [0,10] +float myRand() +{ + static const double divisor = double(RAND_MAX)+1.; + return double(rand())/divisor * 10.; +} + +int main() +{ + unsigned int size = 1024; + // wSize must be odd + unsigned int wSize = 21; + // get the default device + compute::device device = compute::system::default_device(); + // create a context for the device + compute::context context(device); + // get the program + compute::program program = make_sma_program(context); + + // create vector of random numbers on the host + std::vector<float> host_vector(size); + std::vector<float> host_result(size); + std::generate(host_vector.begin(), host_vector.end(), myRand); + + compute::vector<float> a(size,context); + compute::vector<float> b(size,context); + compute::vector<float> c(size,context); + compute::command_queue queue(context, device); + + compute::copy(host_vector.begin(),host_vector.end(),a.begin(),queue); + + // scan values + compute::inclusive_scan(a.begin(),a.end(),b.begin(),queue); + // sma kernel + compute::kernel kernel(program, "SMA"); + kernel.set_arg(0,b.get_buffer()); + kernel.set_arg(1,(int)b.size()); + kernel.set_arg(2,c.get_buffer()); + kernel.set_arg(3,(int)wSize); + + using compute::uint_; + uint_ tpb = 128; + uint_ workSize = size; + queue.enqueue_1d_range_kernel(kernel,0,workSize,tpb); + + compute::copy(c.begin(),c.end(),host_result.begin(),queue); + + bool res = check_results(host_vector,host_result,wSize); + std::string status = res ? "results are equivalent" : "GPU results differs from CPU one's"; + std::cout << status << std::endl; + + return 0; +} + diff --git a/src/boost/libs/compute/example/sort_vector.cpp b/src/boost/libs/compute/example/sort_vector.cpp new file mode 100644 index 00000000..39ec8ea7 --- /dev/null +++ b/src/boost/libs/compute/example/sort_vector.cpp @@ -0,0 +1,68 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/container/vector.hpp> + +namespace compute = boost::compute; + +int rand_int() +{ + return rand() % 100; +} + +// this example demonstrates how to sort a vector of ints on the GPU +int main() +{ + // create vector of random values on the host + std::vector<int> host_vector(10); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // print out input vector + std::cout << "input: [ "; + for(size_t i = 0; i < host_vector.size(); i++){ + std::cout << host_vector[i]; + + if(i != host_vector.size() - 1){ + std::cout << ", "; + } + } + std::cout << " ]" << std::endl; + + // transfer the values to the device + compute::vector<int> device_vector = host_vector; + + // sort the values on the device + compute::sort(device_vector.begin(), device_vector.end()); + + // transfer the values back to the host + compute::copy(device_vector.begin(), + device_vector.end(), + host_vector.begin()); + + // print out the sorted vector + std::cout << "output: [ "; + for(size_t i = 0; i < host_vector.size(); i++){ + std::cout << host_vector[i]; + + if(i != host_vector.size() - 1){ + std::cout << ", "; + } + } + std::cout << " ]" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/example/threefry_engine.cpp b/src/boost/libs/compute/example/threefry_engine.cpp new file mode 100644 index 00000000..5cbf6c8e --- /dev/null +++ b/src/boost/libs/compute/example/threefry_engine.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Muhammad Junaid Muzammil <mjunaidmuzammil@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://kylelutz.github.com/compute for more information. +//---------------------------------------------------------------------------// + + +#include <boost/compute/random/threefry_engine.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/context.hpp> +#include <boost/compute/device.hpp> +#include <boost/compute/system.hpp> +#include <iostream> + +int main() +{ + using boost::compute::uint_; + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + boost::compute::threefry_engine<> rng(queue); + boost::compute::vector<uint_> vector_ctr(20, context); + + uint32_t ctr[20]; + for(int i = 0; i < 10; i++) { + ctr[i*2] = i; + ctr[i*2+1] = 0; + } + boost::compute::copy(ctr, ctr+20, vector_ctr.begin(), queue); + rng.generate(vector_ctr.begin(), vector_ctr.end(), queue); + boost::compute::copy(vector_ctr.begin(), vector_ctr.end(), ctr, queue); + + for(int i = 0; i < 10; i++) { + std::cout << std::hex << ctr[i*2] << " " << ctr[i*2+1] << std::endl; + } + return 0; +} + diff --git a/src/boost/libs/compute/example/time_copy.cpp b/src/boost/libs/compute/example/time_copy.cpp new file mode 100644 index 00000000..35168770 --- /dev/null +++ b/src/boost/libs/compute/example/time_copy.cpp @@ -0,0 +1,63 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +//[time_copy_example + +#include <vector> +#include <cstdlib> +#include <iostream> + +#include <boost/compute/event.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/async/future.hpp> +#include <boost/compute/container/vector.hpp> + +namespace compute = boost::compute; + +int main() +{ + // get the default device + compute::device gpu = compute::system::default_device(); + + // create context for default device + compute::context context(gpu); + + // create command queue with profiling enabled + compute::command_queue queue( + context, gpu, compute::command_queue::enable_profiling + ); + + // generate random data on the host + std::vector<int> host_vector(16000000); + std::generate(host_vector.begin(), host_vector.end(), rand); + + // create a vector on the device + compute::vector<int> device_vector(host_vector.size(), context); + + // copy data from the host to the device + compute::future<void> future = compute::copy_async( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + // wait for copy to finish + future.wait(); + + // get elapsed time from event profiling information + boost::chrono::milliseconds duration = + future.get_event().duration<boost::chrono::milliseconds>(); + + // print elapsed time in milliseconds + std::cout << "time: " << duration.count() << " ms" << std::endl; + + return 0; +} + +//] diff --git a/src/boost/libs/compute/example/transform_sqrt.cpp b/src/boost/libs/compute/example/transform_sqrt.cpp new file mode 100644 index 00000000..860063fc --- /dev/null +++ b/src/boost/libs/compute/example/transform_sqrt.cpp @@ -0,0 +1,58 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +//[transform_sqrt_example + +#include <vector> +#include <algorithm> + +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/math.hpp> + +namespace compute = boost::compute; + +int main() +{ + // get default device and setup context + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + + // generate random data on the host + std::vector<float> host_vector(10000); + std::generate(host_vector.begin(), host_vector.end(), rand); + + // create a vector on the device + compute::vector<float> device_vector(host_vector.size(), context); + + // transfer data from the host to the device + compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + // calculate the square-root of each element in-place + compute::transform( + device_vector.begin(), + device_vector.end(), + device_vector.begin(), + compute::sqrt<float>(), + queue + ); + + // copy values back to the host + compute::copy( + device_vector.begin(), device_vector.end(), host_vector.begin(), queue + ); + + return 0; +} + +//] diff --git a/src/boost/libs/compute/example/vector_addition.cpp b/src/boost/libs/compute/example/vector_addition.cpp new file mode 100644 index 00000000..1f3aa92d --- /dev/null +++ b/src/boost/libs/compute/example/vector_addition.cpp @@ -0,0 +1,57 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/operator.hpp> + +namespace compute = boost::compute; + +// this example demonstrates how to use Boost.Compute's STL +// implementation to add two vectors on the GPU +int main() +{ + // setup input arrays + float a[] = { 1, 2, 3, 4 }; + float b[] = { 5, 6, 7, 8 }; + + // make space for the output + float c[] = { 0, 0, 0, 0 }; + + // create vectors and transfer data for the input arrays 'a' and 'b' + compute::vector<float> vector_a(a, a + 4); + compute::vector<float> vector_b(b, b + 4); + + // create vector for the output array + compute::vector<float> vector_c(4); + + // add the vectors together + compute::transform( + vector_a.begin(), + vector_a.end(), + vector_b.begin(), + vector_c.begin(), + compute::plus<float>() + ); + + // transfer results back to the host array 'c' + compute::copy(vector_c.begin(), vector_c.end(), c); + + // print out results in 'c' + std::cout << "c: [" << c[0] << ", " + << c[1] << ", " + << c[2] << ", " + << c[3] << "]" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/index.html b/src/boost/libs/compute/index.html new file mode 100644 index 00000000..a5accd49 --- /dev/null +++ b/src/boost/libs/compute/index.html @@ -0,0 +1,20 @@ +<html> +<head> +<meta http-equiv="refresh" content="0; URL=doc/html/index.html"> +</head> +<body> +Automatic redirection failed, please go to +<a href="doc/html/index.html">doc/html/index.html</a> +<hr> +<tt> +Boost.Compute<br> +<br> +Copyright (C) 2013-2015 Kyle Lutz<br> +<br> +Distributed under the Boost Software License, Version 1.0. (See +accompanying file LICENSE_1_0.txt or copy at +<a href=http://www.boost.org/LICENSE_1_0.txt>http://www.boost.org/LICENSE_1_0.txt</a>) <br> +<br> +</tt> +</body> +</html> diff --git a/src/boost/libs/compute/meta/libraries.json b/src/boost/libs/compute/meta/libraries.json new file mode 100644 index 00000000..9e70fdd4 --- /dev/null +++ b/src/boost/libs/compute/meta/libraries.json @@ -0,0 +1,14 @@ +{ + "key": "compute", + "name": "Compute", + "authors": [ + "Kyle Lutz" + ], + "description": "Parallel/GPU-computing library", + "category": [ + "Concurrent" + ], + "maintainers": [ + "Kyle Lutz <kyle.r.lutz -at- gmail.com>" + ] +} diff --git a/src/boost/libs/compute/perf/CMakeLists.txt b/src/boost/libs/compute/perf/CMakeLists.txt new file mode 100644 index 00000000..b04429e9 --- /dev/null +++ b/src/boost/libs/compute/perf/CMakeLists.txt @@ -0,0 +1,210 @@ +# --------------------------------------------------------------------------- +# Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +# +# Distributed under the Boost Software License, Version 1.0 +# See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt +# +# --------------------------------------------------------------------------- + +include_directories(../include) + +set(PERF_BOOST_COMPONENTS system timer chrono program_options) + +if (${BOOST_COMPUTE_USE_OFFLINE_CACHE}) + set(PERF_BOOST_COMPONENTS ${PERF_BOOST_COMPONENTS} filesystem) +endif() + +if(${BOOST_COMPUTE_THREAD_SAFE} AND NOT ${BOOST_COMPUTE_USE_CPP11}) + set(PERF_BOOST_COMPONENTS ${PERF_BOOST_COMPONENTS} thread) +elseif(${BOOST_COMPUTE_HAVE_BOLT} AND ${BOOST_COMPUTE_USE_CPP11}) + set(PERF_BOOST_COMPONENTS ${PERF_BOOST_COMPONENTS} thread) +endif() + +if(${BOOST_COMPUTE_HAVE_BOLT} AND ${BOOST_COMPUTE_USE_CPP11}) + set(PERF_BOOST_COMPONENTS ${PERF_BOOST_COMPONENTS} date_time) +endif() + +if(PERF_BOOST_COMPONENTS) + list(REMOVE_DUPLICATES PERF_BOOST_COMPONENTS) +endif() +find_package(Boost 1.54 REQUIRED COMPONENTS ${PERF_BOOST_COMPONENTS}) +include_directories(SYSTEM ${Boost_INCLUDE_DIRS}) + +set(BENCHMARKS + accumulate + bernoulli_distribution + binary_find + cart_to_polar + comparison_sort + copy_if + copy_to_device + count + discrete_distribution + erase_remove + exclusive_scan + fill + find + find_end + includes + inner_product + is_permutation + is_sorted + max_element + merge + next_permutation + nth_element + partial_sum + partition + partition_point + prev_permutation + reverse + reverse_copy + rotate + rotate_copy + host_sort + random_number_engine + reduce_by_key + saxpy + search + search_n + set_difference + set_intersection + set_symmetric_difference + set_union + sort + sort_by_key + sort_float + stable_partition + uniform_int_distribution + unique + unique_copy +) + +foreach(BENCHMARK ${BENCHMARKS}) + set(PERF_TARGET perf_${BENCHMARK}) + add_executable(${PERF_TARGET} perf_${BENCHMARK}.cpp) + target_link_libraries(${PERF_TARGET} ${OpenCL_LIBRARIES} ${Boost_LIBRARIES}) +endforeach() + +# stl benchmarks (for comparison) +set(STL_BENCHMARKS + stl_accumulate + stl_count + stl_find + stl_find_end + stl_includes + stl_inner_product + stl_max_element + stl_merge + stl_next_permutation + stl_partial_sum + stl_partition + stl_prev_permutation + stl_reverse + stl_reverse_copy + stl_rotate + stl_rotate_copy + stl_saxpy + stl_search + stl_search_n + stl_set_difference + stl_set_intersection + stl_set_symmetric_difference + stl_set_union + stl_sort + stl_stable_partition + stl_unique + stl_unique_copy +) + +# stl benchmarks which require c++11 +if(${BOOST_COMPUTE_USE_CPP11}) + list(APPEND + STL_BENCHMARKS + stl_is_permutation + stl_partition_point + ) +endif() + +foreach(BENCHMARK ${STL_BENCHMARKS}) + set(PERF_TARGET perf_${BENCHMARK}) + add_executable(${PERF_TARGET} perf_${BENCHMARK}.cpp) + target_link_libraries(${PERF_TARGET} ${Boost_LIBRARIES}) +endforeach() + +# cuda/thrust benchmarks (for comparison) +if(${BOOST_COMPUTE_HAVE_CUDA}) + find_package(CUDA 5.0 REQUIRED) + + set(CUDA_BENCHMARKS + thrust_accumulate + thrust_count + thrust_exclusive_scan + thrust_find + thrust_inner_product + thrust_merge + thrust_partial_sum + thrust_partition + thrust_reduce_by_key + thrust_reverse + thrust_reverse_copy + thrust_rotate + thrust_saxpy + thrust_set_difference + thrust_sort + thrust_unique + ) + + foreach(BENCHMARK ${CUDA_BENCHMARKS}) + set(PERF_TARGET perf_${BENCHMARK}) + cuda_add_executable(${PERF_TARGET} perf_${BENCHMARK}.cu) + target_link_libraries(${PERF_TARGET} ${CUDA_LIBRARIES} ${Boost_LIBRARIES}) + endforeach() +endif() + +# intel tbb benchmarks (for comparison) +if(${BOOST_COMPUTE_HAVE_TBB}) + find_package(TBB REQUIRED) + include_directories(SYSTEM ${TBB_INCLUDE_DIRS}) + + set(TBB_BENCHMARKS + tbb_accumulate + tbb_merge + tbb_sort + ) + + foreach(BENCHMARK ${TBB_BENCHMARKS}) + set(PERF_TARGET perf_${BENCHMARK}) + add_executable(${PERF_TARGET} perf_${BENCHMARK}.cpp) + target_link_libraries(${PERF_TARGET} ${TBB_LIBRARIES} ${Boost_LIBRARIES}) + endforeach() +endif() + +# bolt c++ template lib benchmarks (for comparison) +if(${BOOST_COMPUTE_HAVE_BOLT} AND ${BOOST_COMPUTE_USE_CPP11}) + find_package(Bolt REQUIRED) + include_directories(SYSTEM ${BOLT_INCLUDE_DIRS}) + + set(BOLT_BENCHMARKS + bolt_accumulate + bolt_count + bolt_exclusive_scan + bolt_fill + bolt_inner_product + bolt_max_element + bolt_merge + bolt_partial_sum + bolt_reduce_by_key + bolt_saxpy + bolt_sort + ) + + foreach(BENCHMARK ${BOLT_BENCHMARKS}) + set(PERF_TARGET perf_${BENCHMARK}) + add_executable(${PERF_TARGET} perf_${BENCHMARK}.cpp) + target_link_libraries(${PERF_TARGET} ${OpenCL_LIBRARIES} ${BOLT_LIBRARIES} ${Boost_LIBRARIES}) + endforeach() +elseif(${BOOST_COMPUTE_HAVE_BOLT} AND NOT ${BOOST_COMPUTE_USE_CPP11}) + message(WARNING "BOOST_COMPUTE_USE_CPP11 must be ON for building Bolt C++ Template Library performance tests.") +endif() diff --git a/src/boost/libs/compute/perf/perf.hpp b/src/boost/libs/compute/perf/perf.hpp new file mode 100644 index 00000000..cce0328c --- /dev/null +++ b/src/boost/libs/compute/perf/perf.hpp @@ -0,0 +1,109 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#ifndef PERF_HPP +#define PERF_HPP + +// this header contains general purpose functions and variables used by +// the boost.compute performance benchmarks. + +#include <vector> +#include <cstdlib> +#include <algorithm> + +#include <boost/lexical_cast.hpp> +#include <boost/timer/timer.hpp> + +static size_t PERF_N = 1024; +static size_t PERF_TRIALS = 3; + +// parses command line arguments and sets the corresponding perf variables +inline void perf_parse_args(int argc, char *argv[]) +{ + if(argc >= 2){ + PERF_N = boost::lexical_cast<size_t>(argv[1]); + } + + if(argc >= 3){ + PERF_TRIALS = boost::lexical_cast<size_t>(argv[2]); + } +} + +// generates a vector of random numbers +template<class T> +std::vector<T> generate_random_vector(const size_t size) +{ + std::vector<T> vector(size); + std::generate(vector.begin(), vector.end(), rand); + return vector; +} + +// a simple timer wrapper which records multiple time entries +class perf_timer +{ +public: + typedef boost::timer::nanosecond_type nanosecond_type; + + perf_timer() + { + timer.stop(); + } + + void start() + { + timer.start(); + } + + void stop() + { + timer.stop(); + times.push_back(timer.elapsed().wall); + } + + size_t trials() const + { + return times.size(); + } + + void clear() + { + times.clear(); + } + + nanosecond_type last_time() const + { + return times.back(); + } + + nanosecond_type min_time() const + { + return *std::min_element(times.begin(), times.end()); + } + + nanosecond_type max_time() const + { + return *std::max_element(times.begin(), times.end()); + } + + boost::timer::cpu_timer timer; + std::vector<boost::timer::nanosecond_type> times; +}; + +// returns the rate (in MB/s) for processing 'count' items of type 'T' +// in 'time' nanoseconds +template<class T> +double perf_rate(const size_t count, perf_timer::nanosecond_type time) +{ + const size_t byte_count = count * sizeof(T); + + return (double(byte_count) / 1024 / 1024) / (time / 1e9); +} + +#endif // PERF_HPP diff --git a/src/boost/libs/compute/perf/perf.py b/src/boost/libs/compute/perf/perf.py new file mode 100755 index 00000000..c7b33f63 --- /dev/null +++ b/src/boost/libs/compute/perf/perf.py @@ -0,0 +1,238 @@ +#!/usr/bin/python + +# Copyright (c) 2014 Kyle Lutz <kyle.r.lutz@gmail.com> +# Distributed under the Boost Software License, Version 1.0 +# See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt +# +# See http://boostorg.github.com/compute for more information. + +# driver script for boost.compute benchmarking. will run a +# benchmark for a given function (e.g. accumulate, sort). + +import os +import sys +import subprocess + +try: + import pylab +except: + print('pylab not found, no ploting...') + pass + +def run_perf_process(name, size, backend = ""): + if not backend: + proc = "perf_%s" % name + else: + proc = "perf_%s_%s" % (backend, name) + + filename = "./perf/" + proc + + if not os.path.isfile(filename): + print("Error: failed to find ", filename, " for running") + return 0 + try: + output = subprocess.check_output([filename, str(int(size))]) + except: + return 0 + + t = 0 + for line in output.decode('utf8').split("\n"): + if line.startswith("time:"): + t = float(line.split(":")[1].split()[0]) + + return t + +class Report: + def __init__(self, name): + self.name = name + self.samples = {} + + def add_sample(self, name, size, time): + if not name in self.samples: + self.samples[name] = [] + + self.samples[name].append((size, time)) + + def display(self): + for name in self.samples.keys(): + print('=== %s with %s ===' % (self.name, name)) + print('size,time (ms)') + + for sample in self.samples[name]: + print('%d,%f' % sample) + + def plot_time(self, name): + if not name in self.samples: + return + + x = [] + y = [] + + any_valid_samples = False + + for sample in self.samples[name]: + if sample[1] == 0: + continue + + x.append(sample[0]) + y.append(sample[1]) + any_valid_samples = True + + if not any_valid_samples: + return + + pylab.loglog(x, y, marker='o', label=name) + pylab.xlabel("Size") + pylab.ylabel("Time (ms)") + pylab.title(self.name) + + def plot_rate(self, name): + if not name in self.samples: + return + + x = [] + y = [] + + any_valid_samples = False + + for sample in self.samples[name]: + if sample[1] == 0: + continue + + x.append(sample[0]) + y.append(float(sample[0]) / (float(sample[1]) * 1e-3)) + any_valid_samples = True + + if not any_valid_samples: + return + + pylab.loglog(x, y, marker='o', label=name) + pylab.xlabel("Size") + pylab.ylabel("Rate (values/s)") + pylab.title(self.name) + +def run_benchmark(name, sizes, vs=[]): + report = Report(name) + + for size in sizes: + time = run_perf_process(name, size) + + report.add_sample("compute", size, time) + + competitors = { + "thrust" : [ + "accumulate", + "count", + "exclusive_scan", + "find", + "inner_product", + "merge", + "partial_sum", + "partition", + "reduce_by_key", + "reverse", + "reverse_copy", + "rotate", + "saxpy", + "sort", + "unique" + ], + "bolt" : [ + "accumulate", + "count", + "exclusive_scan", + "fill", + "inner_product", + "max_element", + "merge", + "partial_sum", + "reduce_by_key", + "saxpy", + "sort" + ], + "tbb": [ + "accumulate", + "merge", + "sort" + ], + "stl": [ + "accumulate", + "count", + "find", + "find_end", + "includes", + "inner_product", + "is_permutation", + "max_element", + "merge", + "next_permutation", + "nth_element", + "partial_sum", + "partition", + "partition_point", + "prev_permutation", + "reverse", + "reverse_copy", + "rotate", + "rotate_copy", + "saxpy", + "search", + "search_n", + "set_difference", + "set_intersection", + "set_symmetric_difference", + "set_union", + "sort", + "stable_partition", + "unique", + "unique_copy" + ] + } + + for other in vs: + if not other in competitors: + continue + if not name in competitors[other]: + continue + + for size in sizes: + time = run_perf_process(name, size, other) + report.add_sample(other, size, time) + + return report + +if __name__ == '__main__': + test = "sort" + if len(sys.argv) >= 2: + test = sys.argv[1] + print('running %s perf test' % test) + + sizes = [ pow(2, x) for x in range(1, 26) ] + + sizes = sorted(sizes) + + competitors = ["bolt", "tbb", "thrust", "stl"] + + report = run_benchmark(test, sizes, competitors) + + plot = None + if "--plot-time" in sys.argv: + plot = "time" + elif "--plot-rate" in sys.argv: + plot = "rate" + + if plot == "time": + report.plot_time("compute") + for competitor in competitors: + report.plot_time(competitor) + elif plot == "rate": + report.plot_rate("compute") + for competitor in competitors: + report.plot_rate(competitor) + + if plot: + pylab.legend(loc='upper left') + pylab.show() + else: + report.display() diff --git a/src/boost/libs/compute/perf/perf_accumulate.cpp b/src/boost/libs/compute/perf/perf_accumulate.cpp new file mode 100644 index 00000000..bd4276e6 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_accumulate.cpp @@ -0,0 +1,140 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/program_options.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/accumulate.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +namespace po = boost::program_options; +namespace compute = boost::compute; + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +template<class T> +double perf_accumulate(const compute::vector<T>& data, + const size_t trials, + compute::command_queue& queue) +{ + perf_timer t; + for(size_t trial = 0; trial < trials; trial++){ + t.start(); + compute::accumulate(data.begin(), data.end(), T(0), queue); + queue.finish(); + t.stop(); + } + return t.min_time(); +} + +template<class T> +void tune_accumulate(const compute::vector<T>& data, + const size_t trials, + compute::command_queue& queue) +{ + boost::shared_ptr<compute::detail::parameter_cache> + params = compute::detail::parameter_cache::get_global_cache(queue.get_device()); + + const std::string cache_key = + std::string("__boost_reduce_on_gpu_") + compute::type_name<T>(); + + const compute::uint_ tpbs[] = { 4, 8, 16, 32, 64, 128, 256, 512, 1024 }; + const compute::uint_ vpts[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; + + double min_time = (std::numeric_limits<double>::max)(); + compute::uint_ best_tpb = 0; + compute::uint_ best_vpt = 0; + + for(size_t i = 0; i < sizeof(tpbs) / sizeof(*tpbs); i++){ + params->set(cache_key, "tpb", tpbs[i]); + for(size_t j = 0; j < sizeof(vpts) / sizeof(*vpts); j++){ + params->set(cache_key, "vpt", vpts[j]); + + try { + const double t = perf_accumulate(data, trials, queue); + if(t < min_time){ + best_tpb = tpbs[i]; + best_vpt = vpts[j]; + min_time = t; + } + } + catch(compute::opencl_error&){ + // invalid parameters for this device, skip + } + } + } + + // store optimal parameters + params->set(cache_key, "tpb", best_tpb); + params->set(cache_key, "vpt", best_vpt); +} + +int main(int argc, char *argv[]) +{ + // setup command line arguments + po::options_description options("options"); + options.add_options() + ("help", "show usage instructions") + ("size", po::value<size_t>()->default_value(8192), "input size") + ("trials", po::value<size_t>()->default_value(3), "number of trials to run") + ("tune", "run tuning procedure") + ; + po::positional_options_description positional_options; + positional_options.add("size", 1); + + // parse command line + po::variables_map vm; + po::store( + po::command_line_parser(argc, argv) + .options(options).positional(positional_options).run(), + vm + ); + po::notify(vm); + + const size_t size = vm["size"].as<size_t>(); + const size_t trials = vm["trials"].as<size_t>(); + std::cout << "size: " << size << std::endl; + + // setup context and queue for the default device + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_data(size); + std::generate(host_data.begin(), host_data.end(), rand_int); + + // create vector on the device and copy the data + compute::vector<int> device_data( + host_data.begin(), host_data.end(), queue + ); + + // run tuning proceure (if requested) + if(vm.count("tune")){ + tune_accumulate(device_data, trials, queue); + } + + // run benchmark + double t = perf_accumulate(device_data, trials, queue); + std::cout << "time: " << t / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bernoulli_distribution.cpp b/src/boost/libs/compute/perf/perf_bernoulli_distribution.cpp new file mode 100644 index 00000000..bffbe58f --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bernoulli_distribution.cpp @@ -0,0 +1,46 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/bernoulli_distribution.hpp> + +#include "perf.hpp" + +namespace compute = boost::compute; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + + compute::vector<bool> vector(PERF_N, context); + + compute::default_random_engine rng(queue); + compute::bernoulli_distribution<float> dist(0.5); + + perf_timer t; + t.start(); + dist.generate(vector.begin(), vector.end(), rng, queue); + queue.finish(); + t.stop(); + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_binary_find.cpp b/src/boost/libs/compute/perf/perf_binary_find.cpp new file mode 100644 index 00000000..ee7c4631 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_binary_find.cpp @@ -0,0 +1,71 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/algorithm/detail/binary_find.hpp> +#include <boost/compute/algorithm/partition.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + using boost::compute::_1; + boost::compute::partition( + device_vector.begin(), device_vector.end(), _1 < 20, queue + ); + + // just to be sure everything is finished before measuring execution time + // of binary_find algorithm + queue.finish(); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::detail::binary_find( + device_vector.begin(), device_vector.end(), _1 >= 20, queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_accumulate.cpp b/src/boost/libs/compute/perf/perf_bolt_accumulate.cpp new file mode 100644 index 00000000..5a6b9b9c --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_accumulate.cpp @@ -0,0 +1,51 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> +#include <bolt/cl/reduce.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create host vector + std::vector<int> host_vec = generate_random_vector<int>(PERF_N); + + // create device vectors + bolt::cl::device_vector<int> device_vec(PERF_N); + + // transfer data to the device + bolt::cl::copy(host_vec.begin(), host_vec.end(), device_vec.begin()); + + int sum = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + sum = bolt::cl::reduce(device_vec.begin(), device_vec.end()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "sum: " << sum << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_count.cpp b/src/boost/libs/compute/perf/perf_bolt_count.cpp new file mode 100644 index 00000000..a23c5ac3 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_count.cpp @@ -0,0 +1,57 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/count.h> +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create vector of random numbers on the host + std::vector<int> h_vec(PERF_N); + std::generate(h_vec.begin(), h_vec.end(), rand_int); + + // create device vector + bolt::cl::device_vector<int> d_vec(PERF_N); + + // transfer data to the device + bolt::cl::copy(h_vec.begin(), h_vec.end(), d_vec.begin()); + + size_t count = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + count = bolt::cl::count(ctrl, d_vec.begin(), d_vec.end(), 4); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "count: " << count << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_exclusive_scan.cpp b/src/boost/libs/compute/perf/perf_bolt_exclusive_scan.cpp new file mode 100644 index 00000000..a60e4655 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_exclusive_scan.cpp @@ -0,0 +1,52 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/scan.h> +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create vector of random numbers on the host + std::vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // create device vector + bolt::cl::device_vector<int> d_vec(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + // transfer data to the device + bolt::cl::copy(h_vec.begin(), h_vec.end(), d_vec.begin()); + + t.start(); + bolt::cl::exclusive_scan(d_vec.begin(), d_vec.end(), d_vec.begin()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + bolt::cl::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_fill.cpp b/src/boost/libs/compute/perf/perf_bolt_fill.cpp new file mode 100644 index 00000000..50b6e85e --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_fill.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/fill.h> +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create device vector (filled with zeros) + bolt::cl::device_vector<int> d_vec(PERF_N, 0); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + bolt::cl::fill(d_vec.begin(), d_vec.end(), int(trial)); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_inner_product.cpp b/src/boost/libs/compute/perf/perf_bolt_inner_product.cpp new file mode 100644 index 00000000..4c9652e6 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_inner_product.cpp @@ -0,0 +1,56 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/inner_product.h> +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create host vectors + std::vector<int> host_x = generate_random_vector<int>(PERF_N); + std::vector<int> host_y = generate_random_vector<int>(PERF_N); + + // create device vectors + bolt::cl::device_vector<int> device_x(PERF_N); + bolt::cl::device_vector<int> device_y(PERF_N); + + // transfer data to the device + bolt::cl::copy(host_x.begin(), host_x.end(), device_x.begin()); + bolt::cl::copy(host_y.begin(), host_y.end(), device_y.begin()); + + int product = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + product = bolt::cl::inner_product( + device_x.begin(), device_x.end(), device_y.begin(), 0 + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "product: " << product << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_max_element.cpp b/src/boost/libs/compute/perf/perf_bolt_max_element.cpp new file mode 100644 index 00000000..238b1ba2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_max_element.cpp @@ -0,0 +1,69 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> +#include <bolt/cl/max_element.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>(rand() % 10000000); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create host vector + std::vector<int> host_vec = generate_random_vector<int>(PERF_N); + + // create device vectors + bolt::cl::device_vector<int> device_vec(PERF_N); + + // transfer data to the device + bolt::cl::copy(host_vec.begin(), host_vec.end(), device_vec.begin()); + + bolt::cl::device_vector<int>::iterator max_iter = device_vec.begin(); + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + max_iter = bolt::cl::max_element(device_vec.begin(), device_vec.end()); + t.stop(); + } + + int device_max = *max_iter; + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "max: " << device_max << std::endl; + + // verify max is correct + int host_max = *std::max_element(host_vec.begin(), host_vec.end()); + if(device_max != host_max){ + std::cout << "ERROR: " + << "device_max (" << device_max << ") " + << "!= " + << "host_max (" << host_max << ")" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_merge.cpp b/src/boost/libs/compute/perf/perf_bolt_merge.cpp new file mode 100644 index 00000000..c5ee12ac --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_merge.cpp @@ -0,0 +1,60 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/merge.h> +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vec1 = generate_random_vector<int>(std::floor(PERF_N / 2.0)); + std::vector<int> host_vec2 = generate_random_vector<int>(std::ceil(PERF_N / 2.0)); + // sort them + std::sort(host_vec1.begin(), host_vec1.end()); + std::sort(host_vec2.begin(), host_vec2.end()); + + // create device vectors + bolt::cl::device_vector<int> device_vec1(PERF_N); + bolt::cl::device_vector<int> device_vec2(PERF_N); + bolt::cl::device_vector<int> device_vec3(PERF_N); + + // transfer data to the device + bolt::cl::copy(host_vec1.begin(), host_vec1.end(), device_vec1.begin()); + bolt::cl::copy(host_vec2.begin(), host_vec2.end(), device_vec2.begin()); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + bolt::cl::merge( + device_vec1.begin(), device_vec1.end(), + device_vec2.begin(), device_vec2.end(), + device_vec3.begin() + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_partial_sum.cpp b/src/boost/libs/compute/perf/perf_bolt_partial_sum.cpp new file mode 100644 index 00000000..2f9c830e --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_partial_sum.cpp @@ -0,0 +1,53 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/scan.h> +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create vector of random numbers on the host + std::vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // create device vector + bolt::cl::device_vector<int> d_vec(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + // transfer data to the device + bolt::cl::copy(h_vec.begin(), h_vec.end(), d_vec.begin()); + + t.start(); + bolt::cl::inclusive_scan(d_vec.begin(), d_vec.end(), d_vec.begin()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + bolt::cl::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); + + return 0; +} + diff --git a/src/boost/libs/compute/perf/perf_bolt_reduce_by_key.cpp b/src/boost/libs/compute/perf/perf_bolt_reduce_by_key.cpp new file mode 100644 index 00000000..e7668498 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_reduce_by_key.cpp @@ -0,0 +1,100 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> +#include <bolt/cl/reduce_by_key.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +struct unique_key { + int current; + int avgValuesNoPerKey; + + unique_key() + { + current = 0; + avgValuesNoPerKey = 512; + } + + int operator()() + { + double p = double(1.0) / static_cast<double>(avgValuesNoPerKey); + if((rand() / double(RAND_MAX)) <= p) + return ++current; + return current; + } +} UniqueKey; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create vector of keys and random values + std::vector<int> host_keys(PERF_N); + std::vector<int> host_values(PERF_N); + std::generate(host_keys.begin(), host_keys.end(), UniqueKey); + std::generate(host_values.begin(), host_values.end(), rand_int); + + // create device vectors for data + bolt::cl::device_vector<int> device_keys(PERF_N); + bolt::cl::device_vector<int> device_values(PERF_N); + + // transfer data to the device + bolt::cl::copy(host_keys.begin(), host_keys.end(), device_keys.begin()); + bolt::cl::copy(host_values.begin(), host_values.end(), device_values.begin()); + + // create device vectors for the results + bolt::cl::device_vector<int> device_keys_results(PERF_N); + bolt::cl::device_vector<int> device_values_results(PERF_N); + + typedef bolt::cl::device_vector<int>::iterator iterType; + bolt::cl::pair<iterType, iterType> result = { + device_keys_results.begin(), + device_values_results.begin() + }; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + result = bolt::cl::reduce_by_key(device_keys.begin(), + device_keys.end(), + device_values.begin(), + device_keys_results.begin(), + device_values_results.begin()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + size_t result_size = bolt::cl::distance(device_keys_results.begin(), result.first); + if(result_size != static_cast<size_t>(host_keys[PERF_N-1] + 1)){ + std::cout << "ERROR: " + << "wrong number of keys" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_saxpy.cpp b/src/boost/libs/compute/perf/perf_bolt_saxpy.cpp new file mode 100644 index 00000000..201f683a --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_saxpy.cpp @@ -0,0 +1,76 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <algorithm> +#include <vector> + +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> +#include <bolt/cl/transform.h> + +#include "perf.hpp" + +BOLT_FUNCTOR(saxpy_functor, + struct saxpy_functor + { + float _a; + saxpy_functor(float a) : _a(a) {}; + + float operator() (const float &x, const float &y) const + { + return _a * x + y; + }; + }; +) + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + bolt::cl::control ctrl = bolt::cl::control::getDefault(); + ::cl::Device device = ctrl.getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create host vectors + std::vector<float> host_x(PERF_N); + std::vector<float> host_y(PERF_N); + std::generate(host_x.begin(), host_x.end(), rand); + std::generate(host_y.begin(), host_y.end(), rand); + + // create device vectors + bolt::cl::device_vector<float> device_x(PERF_N); + bolt::cl::device_vector<float> device_y(PERF_N); + + // transfer data to the device + bolt::cl::copy(host_x.begin(), host_x.end(), device_x.begin()); + bolt::cl::copy(host_y.begin(), host_y.end(), device_y.begin()); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + bolt::cl::transform( + device_x.begin(), device_x.end(), + device_y.begin(), + device_y.begin(), + saxpy_functor(2.5f) + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + bolt::cl::copy(device_x.begin(), device_x.end(), host_x.begin()); + bolt::cl::copy(device_y.begin(), device_y.end(), host_y.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_bolt_sort.cpp b/src/boost/libs/compute/perf/perf_bolt_sort.cpp new file mode 100644 index 00000000..2508ec06 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_bolt_sort.cpp @@ -0,0 +1,50 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <vector> + +#include <bolt/cl/sort.h> +#include <bolt/cl/copy.h> +#include <bolt/cl/device_vector.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + ::cl::Device device = bolt::cl::control::getDefault().getDevice(); + std::cout << "device: " << device.getInfo<CL_DEVICE_NAME>() << std::endl; + + // create host vector + std::vector<int> h_vec = generate_random_vector<int>(PERF_N); + // create device vector + bolt::cl::device_vector<int> d_vec(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + // transfer data to the device + bolt::cl::copy(h_vec.begin(), h_vec.end(), d_vec.begin()); + + t.start(); + bolt::cl::sort(d_vec.begin(), d_vec.end()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + bolt::cl::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_cart_to_polar.cpp b/src/boost/libs/compute/perf/perf_cart_to_polar.cpp new file mode 100644 index 00000000..e0d333eb --- /dev/null +++ b/src/boost/libs/compute/perf/perf_cart_to_polar.cpp @@ -0,0 +1,158 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define _USE_MATH_DEFINES +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +namespace compute = boost::compute; + +using compute::float2_; + +float rand_float() +{ + return (float(rand()) / float(RAND_MAX)) * 1000.f; +} + +void serial_cartesian_to_polar(const float *input, size_t n, float *output) +{ + for(size_t i = 0; i < n; i++){ + float x = input[i*2+0]; + float y = input[i*2+1]; + + float magnitude = std::sqrt(x*x + y*y); + float angle = std::atan2(y, x) * 180.f / M_PI; + + output[i*2+0] = magnitude; + output[i*2+1] = angle; + } +} + +void serial_polar_to_cartesian(const float *input, size_t n, float *output) +{ + for(size_t i = 0; i < n; i++){ + float magnitude = input[i*2+0]; + float angle = input[i*2+1]; + + float x = magnitude * cos(angle); + float y = magnitude * sin(angle); + + output[i*2+0] = x; + output[i*2+1] = y; + } +} + +// converts from cartesian coordinates (x, y) to polar coordinates (magnitude, angle) +BOOST_COMPUTE_FUNCTION(float2_, cartesian_to_polar, (float2_ p), +{ + float x = p.x; + float y = p.y; + + float magnitude = sqrt(x*x + y*y); + float angle = atan2(y, x) * 180.f / M_PI; + + return (float2)(magnitude, angle); +}); + +// converts from polar coordinates (magnitude, angle) to cartesian coordinates (x, y) +BOOST_COMPUTE_FUNCTION(float2_, polar_to_cartesian, (float2_ p), +{ + float magnitude = p.x; + float angle = p.y; + + float x = magnitude * cos(angle); + float y = magnitude * sin(angle); + + return (float2)(x, y) +}); + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<float> host_vector(PERF_N*2); + std::generate(host_vector.begin(), host_vector.end(), rand_float); + + // create vector on the device and copy the data + compute::vector<float2_> device_vector(PERF_N, context); + compute::copy_n( + reinterpret_cast<float2_ *>(&host_vector[0]), + PERF_N, + device_vector.begin(), + queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + compute::transform( + device_vector.begin(), + device_vector.end(), + device_vector.begin(), + cartesian_to_polar, + queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // perform saxpy on host + t.clear(); + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + serial_cartesian_to_polar(&host_vector[0], PERF_N, &host_vector[0]); + t.stop(); + } + std::cout << "host time: " << t.min_time() / 1e6 << " ms" << std::endl; + + std::vector<float> device_data(PERF_N*2); + compute::copy( + device_vector.begin(), + device_vector.end(), + reinterpret_cast<float2_ *>(&device_data[0]), + queue + ); + + for(size_t i = 0; i < PERF_N; i++){ + float host_value = host_vector[i]; + float device_value = device_data[i]; + + if(std::abs(device_value - host_value) > 1e-3){ + std::cout << "ERROR: " + << "value at " << i << " " + << "device_value (" << device_value << ") " + << "!= " + << "host_value (" << host_value << ")" + << std::endl; + return -1; + } + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_comparison_sort.cpp b/src/boost/libs/compute/perf/perf_comparison_sort.cpp new file mode 100644 index 00000000..fa63303f --- /dev/null +++ b/src/boost/libs/compute/perf/perf_comparison_sort.cpp @@ -0,0 +1,86 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2016 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/program_options.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +namespace po = boost::program_options; +namespace compute = boost::compute; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + using boost::compute::int_; + + // create vector of random numbers on the host + std::vector<int_> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand); + + // create vector on the device and copy the data + boost::compute::vector<int_> device_vector(PERF_N, context); + + // less function for float + BOOST_COMPUTE_FUNCTION(bool, comp, (int_ a, int_ b), + { + return a < b; + }); + + // sort vector + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + queue.finish(); + + t.start(); + boost::compute::sort( + device_vector.begin(), + device_vector.end(), + comp, + queue + ); + queue.finish(); + t.stop(); + }; + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // verify vector is sorted + if(!boost::compute::is_sorted(device_vector.begin(), + device_vector.end(), + comp, + queue)){ + std::cout << "ERROR: is_sorted() returned false" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_copy_if.cpp b/src/boost/libs/compute/perf/perf_copy_if.cpp new file mode 100644 index 00000000..b2c162f6 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_copy_if.cpp @@ -0,0 +1,122 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <boost/compute/core.hpp> +#include <boost/compute/closure.hpp> +#include <boost/compute/algorithm/copy_if.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/uniform_int_distribution.hpp> +#include <boost/compute/random/uniform_real_distribution.hpp> + +#include "perf.hpp" + +namespace compute = boost::compute; + +void test_copy_if_odd(compute::command_queue &queue) +{ + // create input and output vectors on the device + const compute::context &context = queue.get_context(); + compute::vector<int> input(PERF_N, context); + compute::vector<int> output(PERF_N, context); + + // generate random numbers between 1 and 10 + compute::default_random_engine rng(queue); + compute::uniform_int_distribution<int> d(1, 10); + d.generate(input.begin(), input.end(), rng, queue); + + BOOST_COMPUTE_FUNCTION(bool, is_odd, (int x), + { + return x & 1; + }); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + compute::vector<int>::iterator i = compute::copy_if( + input.begin(), input.end(), output.begin(), is_odd, queue + ); + queue.finish(); + t.stop(); + + float ratio = float(std::distance(output.begin(), i)) / PERF_N; + if(PERF_N > 1000 && (ratio < 0.45f || ratio > 0.55f)){ + std::cerr << "error: ratio is " << ratio << std::endl; + std::cerr << "error: ratio should be around 45-55%" << std::endl; + } + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; +} + +void test_copy_if_in_sphere(compute::command_queue &queue) +{ + using boost::compute::float4_; + + // create input and output vectors on the device + const compute::context &context = queue.get_context(); + compute::vector<float4_> input_points(PERF_N, context); + compute::vector<float4_> output_points(PERF_N, context); + + // generate random numbers in a cube + float radius = 5.0f; + compute::default_random_engine rng(queue); + compute::uniform_real_distribution<float> d(-radius, +radius); + d.generate( + compute::make_buffer_iterator<float>(input_points.get_buffer(), 0), + compute::make_buffer_iterator<float>(input_points.get_buffer(), PERF_N * 4), + rng, + queue + ); + + // predicate which returns true if the point lies within the sphere + BOOST_COMPUTE_CLOSURE(bool, is_in_sphere, (float4_ point), (radius), + { + // ignore fourth component + point.w = 0; + + return length(point) < radius; + }); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + compute::vector<float4_>::iterator i = compute::copy_if( + input_points.begin(), + input_points.end(), + output_points.begin(), + is_in_sphere, + queue + ); + queue.finish(); + t.stop(); + + float ratio = float(std::distance(output_points.begin(), i)) / PERF_N; + if(PERF_N > 1000 && (ratio < 0.5f || ratio > 0.6f)){ + std::cerr << "error: ratio is " << ratio << std::endl; + std::cerr << "error: ratio should be around 50-60%" << std::endl; + } + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + test_copy_if_odd(queue); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_copy_to_device.cpp b/src/boost/libs/compute/perf/perf_copy_to_device.cpp new file mode 100644 index 00000000..0cda3d0f --- /dev/null +++ b/src/boost/libs/compute/perf/perf_copy_to_device.cpp @@ -0,0 +1,55 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <vector> +#include <cstdlib> +#include <iostream> + +#include <boost/compute.hpp> + +int main(int argc, char *argv[]) +{ + size_t size = 1000; + if(argc >= 2){ + size = boost::lexical_cast<size_t>(argv[1]); + } + + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + + boost::compute::command_queue::properties + properties = boost::compute::command_queue::enable_profiling; + boost::compute::command_queue queue(context, device, properties); + + std::vector<int> host_vector(size); + std::generate(host_vector.begin(), host_vector.end(), rand); + + boost::compute::vector<int> device_vector(host_vector.size(), context); + + boost::compute::future<void> future = + boost::compute::copy_async(host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue); + + // wait for copy to finish + future.wait(); + + // get elapsed time in nanoseconds + size_t elapsed = + future.get_event().duration<boost::chrono::nanoseconds>().count(); + + std::cout << "time: " << elapsed / 1e6 << " ms" << std::endl; + + float rate = (float(size * sizeof(int)) / elapsed) * 1000.f; + std::cout << "rate: " << rate << " MB/s" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_count.cpp b/src/boost/libs/compute/perf/perf_count.cpp new file mode 100644 index 00000000..a47eb615 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_count.cpp @@ -0,0 +1,77 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/count.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + + size_t count = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + count = boost::compute::count( + device_vector.begin(), device_vector.end(), 4, queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "count: " << count << std::endl; + + // verify count is correct + size_t host_count = std::count(host_vector.begin(), + host_vector.end(), + 4); + if(count != host_count){ + std::cout << "ERROR: " + << "device_count (" << count << ") " + << "!= " + << "host_count (" << host_count << ")" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_discrete_distribution.cpp b/src/boost/libs/compute/perf/perf_discrete_distribution.cpp new file mode 100644 index 00000000..f6679eb1 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_discrete_distribution.cpp @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/discrete_distribution.hpp> + +#include "perf.hpp" + +namespace compute = boost::compute; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + + compute::vector<compute::uint_> vector(PERF_N, context); + + int weights[] = {1, 1}; + + compute::default_random_engine rng(queue); + compute::discrete_distribution<compute::uint_> dist(weights, weights+2); + + perf_timer t; + t.start(); + dist.generate(vector.begin(), vector.end(), rng, queue); + queue.finish(); + t.stop(); + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_erase_remove.cpp b/src/boost/libs/compute/perf/perf_erase_remove.cpp new file mode 100644 index 00000000..f567247f --- /dev/null +++ b/src/boost/libs/compute/perf/perf_erase_remove.cpp @@ -0,0 +1,61 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/remove.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 10.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + boost::compute::vector<int> device_vector( + host_vector.begin(), host_vector.end(), queue + ); + + t.start(); + device_vector.erase( + boost::compute::remove( + device_vector.begin(), device_vector.end(), 4, queue + ), + device_vector.end(), + queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_exclusive_scan.cpp b/src/boost/libs/compute/perf/perf_exclusive_scan.cpp new file mode 100644 index 00000000..e6c65135 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_exclusive_scan.cpp @@ -0,0 +1,97 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Benoit +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/exclusive_scan.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::vector<int> device_res(PERF_N,context); + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + + // sum vector + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + + t.start(); + boost::compute::exclusive_scan( + device_vector.begin(), + device_vector.end(), + device_res.begin(), + queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // verify sum is correct + std::partial_sum( + host_vector.begin(), + host_vector.end(), + host_vector.begin() + ); + + int device_sum = device_res.back(); + // when scan is exclusive values are shifted by one on the left + // compared to a inclusive scan + int host_sum = host_vector[host_vector.size()-2]; + + if(device_sum != host_sum){ + std::cout << "ERROR: " + << "device_sum (" << device_sum << ") " + << "!= " + << "host_sum (" << host_sum << ")" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_fill.cpp b/src/boost/libs/compute/perf/perf_fill.cpp new file mode 100644 index 00000000..9f35b6b0 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_fill.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector on the device (filled with zeros) + boost::compute::vector<int> vec(PERF_N, 0, queue); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::fill(vec.begin(), vec.end(), int(trial), queue); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_find.cpp b/src/boost/libs/compute/perf/perf_find.cpp new file mode 100644 index 00000000..3cfb75ad --- /dev/null +++ b/src/boost/libs/compute/perf/perf_find.cpp @@ -0,0 +1,88 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/find.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +// Max integer that can be generated by rand_int() function. +int rand_int_max = 25; + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * rand_int_max); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + + // trying to find element that isn't in vector (worst-case scenario) + int wanted = rand_int_max + 1; + + // device iterator + boost::compute::vector<int>::iterator device_result_it; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + device_result_it = boost::compute::find(device_vector.begin(), + device_vector.end(), + wanted, + queue); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // verify if found index is correct by comparing it with std::find() result + size_t host_result_index = std::distance(host_vector.begin(), + std::find(host_vector.begin(), + host_vector.end(), + wanted)); + size_t device_result_index = device_result_it.get_index(); + + if(device_result_index != host_result_index){ + std::cout << "ERROR: " + << "device_result_index (" << device_result_index << ") " + << "!= " + << "host_result_index (" << host_result_index << ")" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_find_end.cpp b/src/boost/libs/compute/perf/perf_find_end.cpp new file mode 100644 index 00000000..e20a7e8d --- /dev/null +++ b/src/boost/libs/compute/perf/perf_find_end.cpp @@ -0,0 +1,65 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/find_end.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + int pattern[] = {2, 6, 6, 7, 8, 4}; + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + boost::compute::vector<int> pattern_vector(pattern, pattern + 6, queue); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::find_end( + device_vector.begin(), device_vector.end(), + pattern_vector.begin(), pattern_vector.end(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_host_sort.cpp b/src/boost/libs/compute/perf/perf_host_sort.cpp new file mode 100644 index 00000000..d34b1c52 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_host_sort.cpp @@ -0,0 +1,65 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/timer/timer.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> random_vector(PERF_N); + std::generate(random_vector.begin(), random_vector.end(), rand); + + // create input vector for gpu + std::vector<int> gpu_vector = random_vector; + + // sort vector on gpu + boost::timer::cpu_timer t; + boost::compute::sort( + gpu_vector.begin(), gpu_vector.end(), queue + ); + queue.finish(); + std::cout << "time: " << t.elapsed().wall / 1e6 << " ms" << std::endl; + + // create input vector for host + std::vector<int> host_vector = random_vector; + + // sort vector on host + t.start(); + std::sort(host_vector.begin(), host_vector.end()); + std::cout << "host time: " << t.elapsed().wall / 1e6 << " ms" << std::endl; + + // ensure that both sorted vectors are equal + if(!std::equal(gpu_vector.begin(), gpu_vector.end(), host_vector.begin())){ + std::cerr << "ERROR: sorted vectors not the same" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_includes.cpp b/src/boost/libs/compute/perf/perf_includes.cpp new file mode 100644 index 00000000..0418a5d7 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_includes.cpp @@ -0,0 +1,68 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/includes.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vectors of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + std::sort(host_vector.begin(), host_vector.end()); + + // create vectors on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + boost::compute::vector<int> device_vector2(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector2.begin(), queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::includes( + device_vector.begin(), device_vector.end(), + device_vector2.begin(), device_vector2.end(), + queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_inner_product.cpp b/src/boost/libs/compute/perf/perf_inner_product.cpp new file mode 100644 index 00000000..112a4bc6 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_inner_product.cpp @@ -0,0 +1,74 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/inner_product.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + std::vector<int> h1(PERF_N); + std::vector<int> h2(PERF_N); + std::generate(h1.begin(), h1.end(), rand_int); + std::generate(h2.begin(), h2.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> d1(PERF_N, context); + boost::compute::vector<int> d2(PERF_N, context); + boost::compute::copy(h1.begin(), h1.end(), d1.begin(), queue); + boost::compute::copy(h2.begin(), h2.end(), d2.begin(), queue); + + int product = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + product = boost::compute::inner_product( + d1.begin(), d1.end(), d2.begin(), int(0), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // verify product is correct + int host_product = std::inner_product( + h1.begin(), h1.end(), h2.begin(), int(0) + ); + if(product != host_product){ + std::cout << "ERROR: " + << "device_product (" << product << ") " + << "!= " + << "host_product (" << host_product << ")" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_is_permutation.cpp b/src/boost/libs/compute/perf/perf_is_permutation.cpp new file mode 100644 index 00000000..39c72bf1 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_is_permutation.cpp @@ -0,0 +1,66 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/is_permutation.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + boost::compute::vector<int> device_vector2(PERF_N, context); + boost::compute::copy( + host_vector.rbegin(), host_vector.rend(), device_vector2.begin(), queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::is_permutation( + device_vector.begin(), device_vector.end(), + device_vector2.begin(), device_vector2.end(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_is_sorted.cpp b/src/boost/libs/compute/perf/perf_is_sorted.cpp new file mode 100644 index 00000000..f16a3172 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_is_sorted.cpp @@ -0,0 +1,63 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/algorithm/reverse.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + // sort and then reverse the random vector + boost::compute::sort(device_vector.begin(), device_vector.end(), queue); + boost::compute::reverse(device_vector.begin(), device_vector.end(), queue); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + bool sorted = boost::compute::is_sorted( + device_vector.begin(), device_vector.end(), queue + ); + queue.finish(); + t.stop(); + if(sorted){ + std::cerr << "ERROR: is_sorted() returned true" << std::endl; + } + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_max_element.cpp b/src/boost/libs/compute/perf/perf_max_element.cpp new file mode 100644 index 00000000..0e47c67e --- /dev/null +++ b/src/boost/libs/compute/perf/perf_max_element.cpp @@ -0,0 +1,93 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Rastko Anicic <anicic.rastko@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/max_element.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>(rand() % 10000000); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + + boost::compute::vector<int>::iterator device_max_iter + = device_vector.begin(); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + device_max_iter = boost::compute::max_element( + device_vector.begin(), device_vector.end(), queue + ); + queue.finish(); + t.stop(); + } + + int device_max = device_max_iter.read(queue); + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "max: " << device_max << std::endl; + + // verify max is correct + std::vector<int>::iterator host_max_iter + = std::max_element(host_vector.begin(), host_vector.end()); + + int host_max = *host_max_iter; + if(device_max != host_max){ + std::cout << "ERROR: " + << "device_max (" << device_max << ") " + << "!= " + << "host_max (" << host_max << ")" + << std::endl; + return -1; + } + + size_t host_max_idx = std::distance(host_vector.begin(), host_max_iter); + size_t device_max_idx = std::distance(device_vector.begin(), device_max_iter); + if(device_max_idx != host_max_idx){ + std::cout << "ERROR: " + << "device_max index (" << device_max_idx << ") " + << "!= " + << "host_max index (" << host_max_idx << ")" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_merge.cpp b/src/boost/libs/compute/perf/perf_merge.cpp new file mode 100644 index 00000000..58ea836f --- /dev/null +++ b/src/boost/libs/compute/perf/perf_merge.cpp @@ -0,0 +1,69 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <cmath> +#include <vector> +#include <algorithm> +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/merge.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + std::vector<int> v1 = generate_random_vector<int>(std::floor(PERF_N / 2.0)); + std::vector<int> v2 = generate_random_vector<int>(std::ceil(PERF_N / 2.0)); + std::vector<int> v3(PERF_N); + + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + boost::compute::vector<int> gpu_v1(v1.begin(), v1.end(), queue); + boost::compute::vector<int> gpu_v2(v2.begin(), v2.end(), queue); + boost::compute::vector<int> gpu_v3(PERF_N, context); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::merge(gpu_v1.begin(), gpu_v1.end(), + gpu_v2.begin(), gpu_v2.end(), + gpu_v3.begin(), + queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + std::vector<int> check_v3(PERF_N); + boost::compute::copy(gpu_v3.begin(), gpu_v3.end(), check_v3.begin(), queue); + queue.finish(); + + std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin()); + bool ok = std::equal(check_v3.begin(), check_v3.end(), v3.begin()); + if(!ok){ + std::cerr << "ERROR: merged ranges different" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_next_permutation.cpp b/src/boost/libs/compute/perf/perf_next_permutation.cpp new file mode 100644 index 00000000..62f0bbb0 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_next_permutation.cpp @@ -0,0 +1,65 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/next_permutation.hpp> +#include <boost/compute/algorithm/prev_permutation.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + std::sort(host_vector.begin(), host_vector.end(), std::greater<int>()); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::next_permutation( + device_vector.begin(), device_vector.end(), queue + ); + queue.finish(); + t.stop(); + boost::compute::prev_permutation( + device_vector.begin(), device_vector.end(), queue + ); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_nth_element.cpp b/src/boost/libs/compute/perf/perf_nth_element.cpp new file mode 100644 index 00000000..07627cb4 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_nth_element.cpp @@ -0,0 +1,60 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/nth_element.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::nth_element( + device_vector.begin(), device_vector.begin()+(PERF_N/2), device_vector.end(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_partial_sum.cpp b/src/boost/libs/compute/perf/perf_partial_sum.cpp new file mode 100644 index 00000000..1c02b4c4 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_partial_sum.cpp @@ -0,0 +1,97 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/partial_sum.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + using boost::compute::int_; + + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int_> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int_> device_vector(PERF_N, context); + boost::compute::vector<int_> device_res(PERF_N,context); + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + + // sum vector + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + + t.start(); + boost::compute::partial_sum( + device_vector.begin(), + device_vector.end(), + device_res.begin(), + queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // verify sum is correct + std::partial_sum( + host_vector.begin(), + host_vector.end(), + host_vector.begin() + ); + + int device_sum = device_res.back(); + int host_sum = host_vector.back(); + + if(device_sum != host_sum){ + std::cout << "ERROR: " + << "device_sum (" << device_sum << ") " + << "!= " + << "host_sum (" << host_sum << ")" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_partition.cpp b/src/boost/libs/compute/perf/perf_partition.cpp new file mode 100644 index 00000000..b765d736 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_partition.cpp @@ -0,0 +1,66 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/partition.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + using boost::compute::_1; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + t.start(); + boost::compute::partition( + device_vector.begin(), device_vector.end(), _1 < 10, queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_partition_point.cpp b/src/boost/libs/compute/perf/perf_partition_point.cpp new file mode 100644 index 00000000..91261aa1 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_partition_point.cpp @@ -0,0 +1,68 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/algorithm/partition.hpp> +#include <boost/compute/algorithm/partition_point.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + using boost::compute::_1; + boost::compute::partition( + device_vector.begin(), device_vector.end(), _1 < 20, queue + ); + + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::partition_point( + device_vector.begin(), device_vector.end(), _1 < 20, queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_prev_permutation.cpp b/src/boost/libs/compute/perf/perf_prev_permutation.cpp new file mode 100644 index 00000000..bb7d76d2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_prev_permutation.cpp @@ -0,0 +1,65 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/next_permutation.hpp> +#include <boost/compute/algorithm/prev_permutation.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + std::sort(host_vector.begin(), host_vector.end()); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::prev_permutation( + device_vector.begin(), device_vector.end(), queue + ); + queue.finish(); + t.stop(); + boost::compute::next_permutation( + device_vector.begin(), device_vector.end(), queue + ); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_random_number_engine.cpp b/src/boost/libs/compute/perf/perf_random_number_engine.cpp new file mode 100644 index 00000000..db25d437 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_random_number_engine.cpp @@ -0,0 +1,101 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <vector> + +#include <boost/program_options.hpp> + +#include <boost/compute/container/vector.hpp> +#include <boost/compute/core.hpp> +#include <boost/compute/random.hpp> + +#include "perf.hpp" + +namespace compute = boost::compute; +namespace po = boost::program_options; + +template<class Engine> +void perf_random_number_engine(const size_t size, + const size_t trials, + compute::command_queue& queue) +{ + typedef typename Engine::result_type T; + + // create random number engine + Engine engine(queue); + + // create vector on the device + std::cout << "size = " << size << std::endl; + compute::vector<T> vector(size, queue.get_context()); + + // generate random numbers + perf_timer t; + for(size_t i = 0; i < trials; i++){ + t.start(); + engine.generate(vector.begin(), vector.end(), queue); + queue.finish(); + t.stop(); + } + + // print result + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "rate: " << perf_rate<T>(size, t.min_time()) << " MB/s" << std::endl; +} + +int main(int argc, char *argv[]) +{ + // setup and parse command line options + po::options_description options("options"); + options.add_options() + ("help", "show usage instructions") + ("size", po::value<size_t>()->default_value(8192), "number of values") + ("trials", po::value<size_t>()->default_value(3), "number of trials") + ("engine", po::value<std::string>()->default_value("default_random_engine"), "random number engine") + ; + po::variables_map vm; + po::store(po::parse_command_line(argc, argv, options), vm); + po::notify(vm); + + if(vm.count("help")) { + std::cout << options << std::endl; + return 0; + } + + // setup context and queue for the default device + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + + // get command line options + const size_t size = vm["size"].as<size_t>(); + const size_t trials = vm["trials"].as<size_t>(); + const std::string& engine = vm["engine"].as<std::string>(); + + // run benchmark + if(engine == "default_random_engine"){ + perf_random_number_engine<compute::default_random_engine>(size, trials, queue); + } + else if(engine == "mersenne_twister_engine"){ + perf_random_number_engine<compute::mt19937>(size, trials, queue); + } + else if(engine == "linear_congruential_engine"){ + perf_random_number_engine<compute::linear_congruential_engine<> >(size, trials, queue); + } + else if(engine == "threefry_engine"){ + perf_random_number_engine<compute::threefry_engine<> >(size, trials, queue); + } + else { + std::cerr << "error: unknown random number engine '" << engine << "'" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_reduce_by_key.cpp b/src/boost/libs/compute/perf/perf_reduce_by_key.cpp new file mode 100644 index 00000000..c88d450e --- /dev/null +++ b/src/boost/libs/compute/perf/perf_reduce_by_key.cpp @@ -0,0 +1,114 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/reduce_by_key.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +struct unique_key { + int current; + int avgValuesNoPerKey; + + unique_key() + { + current = 0; + avgValuesNoPerKey = 512; + } + + int operator()() + { + double p = double(1.0) / static_cast<double>(avgValuesNoPerKey); + if((rand() / double(RAND_MAX)) <= p) + return ++current; + return current; + } +} UniqueKey; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of keys and random values + std::vector<int> host_keys(PERF_N); + std::vector<int> host_values(PERF_N); + std::generate(host_keys.begin(), host_keys.end(), UniqueKey); + std::generate(host_values.begin(), host_values.end(), rand_int); + + // create vectors for keys and values on the device and copy the data + boost::compute::vector<int> device_keys(PERF_N, context); + boost::compute::vector<int> device_values(PERF_N,context); + boost::compute::copy( + host_keys.begin(), + host_keys.end(), + device_keys.begin(), + queue + ); + boost::compute::copy( + host_values.begin(), + host_values.end(), + device_values.begin(), + queue + ); + + // vectors for the results + boost::compute::vector<int> device_keys_results(PERF_N, context); + boost::compute::vector<int> device_values_results(PERF_N,context); + + typedef boost::compute::vector<int>::iterator iterType; + std::pair<iterType, iterType> result( + device_keys_results.begin(), + device_values_results.begin() + ); + + // reduce by key + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + result = boost::compute::reduce_by_key(device_keys.begin(), + device_keys.end(), + device_values.begin(), + device_keys_results.begin(), + device_values_results.begin(), + queue); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + size_t result_size = std::distance(device_keys_results.begin(), result.first); + if(result_size != static_cast<size_t>(host_keys[PERF_N-1] + 1)){ + std::cout << "ERROR: " + << "wrong number of keys" << result_size << "\n" << (host_keys[PERF_N-1] + 1) + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_reverse.cpp b/src/boost/libs/compute/perf/perf_reverse.cpp new file mode 100644 index 00000000..64369a78 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_reverse.cpp @@ -0,0 +1,60 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/reverse.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::reverse( + device_vector.begin(), device_vector.end(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_reverse_copy.cpp b/src/boost/libs/compute/perf/perf_reverse_copy.cpp new file mode 100644 index 00000000..5ce01c9b --- /dev/null +++ b/src/boost/libs/compute/perf/perf_reverse_copy.cpp @@ -0,0 +1,65 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/reverse_copy.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + // create vector on the device for reversed data + boost::compute::vector<int> device_reversed_vector(PERF_N, context); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::reverse_copy( + device_vector.begin(), device_vector.end(), + device_reversed_vector.begin(), + queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_rotate.cpp b/src/boost/libs/compute/perf/perf_rotate.cpp new file mode 100644 index 00000000..49f85d57 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_rotate.cpp @@ -0,0 +1,60 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/rotate.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::rotate( + device_vector.begin(), device_vector.begin()+(PERF_N/2), device_vector.end(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_rotate_copy.cpp b/src/boost/libs/compute/perf/perf_rotate_copy.cpp new file mode 100644 index 00000000..97111ef5 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_rotate_copy.cpp @@ -0,0 +1,62 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/rotate_copy.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + boost::compute::vector<int> device_vector2(PERF_N, context); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::rotate_copy( + device_vector.begin(), device_vector.begin()+(PERF_N/2), device_vector.end(), device_vector2.begin(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_saxpy.cpp b/src/boost/libs/compute/perf/perf_saxpy.cpp new file mode 100644 index 00000000..99ffc55d --- /dev/null +++ b/src/boost/libs/compute/perf/perf_saxpy.cpp @@ -0,0 +1,162 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/program_options.hpp> + +#include <boost/compute/lambda.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +namespace po = boost::program_options; +namespace compute = boost::compute; + +float rand_float() +{ + return (float(rand()) / float(RAND_MAX)) * 1000.f; +} + +template<class T> +double perf_saxpy(const compute::vector<T>& x, + const compute::vector<T>& y, + const T alpha, + const size_t trials, + compute::command_queue& queue) +{ + // create vector on the device to store the result + compute::vector<T> result(x.size(), queue.get_context()); + + perf_timer t; + for(size_t trial = 0; trial < trials; trial++){ + compute::fill(result.begin(), result.end(), T(0), queue); + queue.finish(); + + t.start(); + + using compute::lambda::_1; + using compute::lambda::_2; + + compute::transform( + x.begin(), x.end(), y.begin(), result.begin(), alpha * _1 + _2, queue + ); + + queue.finish(); + t.stop(); + } + + return t.min_time(); +} + +template<class T> +void tune_saxpy(const compute::vector<T>& x, + const compute::vector<T>& y, + const T alpha, + const size_t trials, + compute::command_queue& queue) +{ + boost::shared_ptr<compute::detail::parameter_cache> + params = compute::detail::parameter_cache::get_global_cache(queue.get_device()); + + const std::string cache_key = + std::string("__boost_copy_kernel_") + boost::lexical_cast<std::string>(sizeof(T)); + + const compute::uint_ tpbs[] = { 4, 8, 16, 32, 64, 128, 256, 512, 1024 }; + const compute::uint_ vpts[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; + + double min_time = (std::numeric_limits<double>::max)(); + compute::uint_ best_tpb = 0; + compute::uint_ best_vpt = 0; + + for(size_t i = 0; i < sizeof(tpbs) / sizeof(*tpbs); i++){ + params->set(cache_key, "tpb", tpbs[i]); + for(size_t j = 0; j < sizeof(vpts) / sizeof(*vpts); j++){ + params->set(cache_key, "vpt", vpts[j]); + + try { + const double t = perf_saxpy(x, y, alpha, trials, queue); + if(t < min_time){ + best_tpb = tpbs[i]; + best_vpt = vpts[j]; + min_time = t; + } + } + catch(compute::opencl_error&){ + // invalid parameters for this device, skip + } + } + } + + // store optimal parameters + params->set(cache_key, "tpb", best_tpb); + params->set(cache_key, "vpt", best_vpt); +} + +int main(int argc, char *argv[]) +{ + // setup command line arguments + po::options_description options("options"); + options.add_options() + ("help", "show usage instructions") + ("size", po::value<size_t>()->default_value(8192), "input size") + ("trials", po::value<size_t>()->default_value(3), "number of trials to run") + ("tune", "run tuning procedure") + ("alpha", po::value<double>()->default_value(2.5), "saxpy alpha value") + ; + po::positional_options_description positional_options; + positional_options.add("size", 1); + + // parse command line + po::variables_map vm; + po::store( + po::command_line_parser(argc, argv) + .options(options).positional(positional_options).run(), + vm + ); + po::notify(vm); + + const size_t size = vm["size"].as<size_t>(); + const size_t trials = vm["trials"].as<size_t>(); + const float alpha = vm["alpha"].as<double>(); + std::cout << "size: " << size << std::endl; + + // setup context and queue for the default device + compute::device device = boost::compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<float> host_x(size); + std::vector<float> host_y(size); + std::generate(host_x.begin(), host_x.end(), rand_float); + std::generate(host_y.begin(), host_y.end(), rand_float); + + // create vector on the device and copy the data + compute::vector<float> x(host_x.begin(), host_x.end(), queue); + compute::vector<float> y(host_y.begin(), host_y.end(), queue); + + // run tuning proceure (if requested) + if(vm.count("tune")){ + tune_saxpy(x, y, alpha, trials, queue); + } + + // run benchmark + double t = perf_saxpy(x, y, alpha, trials, queue); + std::cout << "time: " << t / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_search.cpp b/src/boost/libs/compute/perf/perf_search.cpp new file mode 100644 index 00000000..b76e9755 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_search.cpp @@ -0,0 +1,65 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/search.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + int pattern[] = {2, 6, 6, 7, 8, 4}; + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + boost::compute::vector<int> pattern_vector(pattern, pattern + 6, queue); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::search( + device_vector.begin(), device_vector.end(), + pattern_vector.begin(), pattern_vector.end(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_search_n.cpp b/src/boost/libs/compute/perf/perf_search_n.cpp new file mode 100644 index 00000000..31fa0adb --- /dev/null +++ b/src/boost/libs/compute/perf/perf_search_n.cpp @@ -0,0 +1,61 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/search_n.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::search_n( + device_vector.begin(), device_vector.end(), + 5, 2, queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_set_difference.cpp b/src/boost/libs/compute/perf/perf_set_difference.cpp new file mode 100644 index 00000000..b1b28573 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_set_difference.cpp @@ -0,0 +1,75 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/set_difference.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vectors of random numbers on the host + std::vector<int> v1(std::floor(PERF_N / 2.0)); + std::vector<int> v2(std::ceil(PERF_N / 2.0)); + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + // create vectors on the device and copy the data + boost::compute::vector<int> gpu_v1(std::floor(PERF_N / 2.0), context); + boost::compute::vector<int> gpu_v2(std::ceil(PERF_N / 2.0), context); + + boost::compute::copy( + v1.begin(), v1.end(), gpu_v1.begin(), queue + ); + boost::compute::copy( + v2.begin(), v2.end(), gpu_v2.begin(), queue + ); + + boost::compute::vector<int> gpu_v3(PERF_N, context); + boost::compute::vector<int>::iterator gpu_v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + gpu_v3_end = boost::compute::set_difference( + gpu_v1.begin(), gpu_v1.end(), + gpu_v2.begin(), gpu_v2.end(), + gpu_v3.begin(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << std::distance(gpu_v3.begin(), gpu_v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_set_intersection.cpp b/src/boost/libs/compute/perf/perf_set_intersection.cpp new file mode 100644 index 00000000..dbfeb42f --- /dev/null +++ b/src/boost/libs/compute/perf/perf_set_intersection.cpp @@ -0,0 +1,75 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/set_intersection.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vectors of random numbers on the host + std::vector<int> v1(std::floor(PERF_N / 2.0)); + std::vector<int> v2(std::ceil(PERF_N / 2.0)); + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + // create vectors on the device and copy the data + boost::compute::vector<int> gpu_v1(std::floor(PERF_N / 2.0), context); + boost::compute::vector<int> gpu_v2(std::ceil(PERF_N / 2.0), context); + + boost::compute::copy( + v1.begin(), v1.end(), gpu_v1.begin(), queue + ); + boost::compute::copy( + v2.begin(), v2.end(), gpu_v2.begin(), queue + ); + + boost::compute::vector<int> gpu_v3(PERF_N, context); + boost::compute::vector<int>::iterator gpu_v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + gpu_v3_end = boost::compute::set_intersection( + gpu_v1.begin(), gpu_v1.end(), + gpu_v2.begin(), gpu_v2.end(), + gpu_v3.begin(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << std::distance(gpu_v3.begin(), gpu_v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_set_symmetric_difference.cpp b/src/boost/libs/compute/perf/perf_set_symmetric_difference.cpp new file mode 100644 index 00000000..9449c585 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_set_symmetric_difference.cpp @@ -0,0 +1,75 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/set_symmetric_difference.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vectors of random numbers on the host + std::vector<int> v1(std::floor(PERF_N / 2.0)); + std::vector<int> v2(std::ceil(PERF_N / 2.0)); + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + // create vectors on the device and copy the data + boost::compute::vector<int> gpu_v1(std::floor(PERF_N / 2.0), context); + boost::compute::vector<int> gpu_v2(std::ceil(PERF_N / 2.0), context); + + boost::compute::copy( + v1.begin(), v1.end(), gpu_v1.begin(), queue + ); + boost::compute::copy( + v2.begin(), v2.end(), gpu_v2.begin(), queue + ); + + boost::compute::vector<int> gpu_v3(PERF_N, context); + boost::compute::vector<int>::iterator gpu_v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + gpu_v3_end = boost::compute::set_symmetric_difference( + gpu_v1.begin(), gpu_v1.end(), + gpu_v2.begin(), gpu_v2.end(), + gpu_v3.begin(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << std::distance(gpu_v3.begin(), gpu_v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_set_union.cpp b/src/boost/libs/compute/perf/perf_set_union.cpp new file mode 100644 index 00000000..3a336cb6 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_set_union.cpp @@ -0,0 +1,75 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/set_union.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vectors of random numbers on the host + std::vector<int> v1(std::floor(PERF_N / 2.0)); + std::vector<int> v2(std::ceil(PERF_N / 2.0)); + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + // create vectors on the device and copy the data + boost::compute::vector<int> gpu_v1(std::floor(PERF_N / 2.0), context); + boost::compute::vector<int> gpu_v2(std::ceil(PERF_N / 2.0), context); + + boost::compute::copy( + v1.begin(), v1.end(), gpu_v1.begin(), queue + ); + boost::compute::copy( + v2.begin(), v2.end(), gpu_v2.begin(), queue + ); + + boost::compute::vector<int> gpu_v3(PERF_N, context); + boost::compute::vector<int>::iterator gpu_v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + gpu_v3_end = boost::compute::set_union( + gpu_v1.begin(), gpu_v1.end(), + gpu_v2.begin(), gpu_v2.end(), + gpu_v3.begin(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << std::distance(gpu_v3.begin(), gpu_v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_sort.cpp b/src/boost/libs/compute/perf/perf_sort.cpp new file mode 100644 index 00000000..458203ed --- /dev/null +++ b/src/boost/libs/compute/perf/perf_sort.cpp @@ -0,0 +1,130 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/program_options.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +namespace po = boost::program_options; +namespace compute = boost::compute; + +template<class T> +double perf_sort(const std::vector<T>& data, + const size_t trials, + compute::command_queue& queue) +{ + compute::vector<T> vec(data.size(), queue.get_context()); + + perf_timer t; + for(size_t trial = 0; trial < trials; trial++){ + compute::copy(data.begin(), data.end(), vec.begin(), queue); + t.start(); + compute::sort(vec.begin(), vec.end(), queue); + queue.finish(); + t.stop(); + + if(!compute::is_sorted(vec.begin(), vec.end(), queue)){ + std::cerr << "ERROR: is_sorted() returned false" << std::endl; + } + } + return t.min_time(); +} + +template<class T> +void tune_sort(const std::vector<T>& data, + const size_t trials, + compute::command_queue& queue) +{ + boost::shared_ptr<compute::detail::parameter_cache> + params = compute::detail::parameter_cache::get_global_cache(queue.get_device()); + + const std::string cache_key = + std::string("__boost_radix_sort_") + compute::type_name<T>(); + + const compute::uint_ tpbs[] = { 32, 64, 128, 256, 512, 1024 }; + + double min_time = (std::numeric_limits<double>::max)(); + compute::uint_ best_tpb = 0; + + for(size_t i = 0; i < sizeof(tpbs) / sizeof(*tpbs); i++){ + params->set(cache_key, "tpb", tpbs[i]); + + try { + const double t = perf_sort(data, trials, queue); + if(t < min_time){ + best_tpb = tpbs[i]; + min_time = t; + } + } + catch(compute::opencl_error&){ + // invalid work group size for this device, skip + } + } + + // store optimal parameters + params->set(cache_key, "tpb", best_tpb); +} + +int main(int argc, char *argv[]) +{ + // setup command line arguments + po::options_description options("options"); + options.add_options() + ("help", "show usage instructions") + ("size", po::value<size_t>()->default_value(8192), "input size") + ("trials", po::value<size_t>()->default_value(3), "number of trials to run") + ("tune", "run tuning procedure") + ; + po::positional_options_description positional_options; + positional_options.add("size", 1); + + // parse command line + po::variables_map vm; + po::store( + po::command_line_parser(argc, argv) + .options(options).positional(positional_options).run(), + vm + ); + po::notify(vm); + + const size_t size = vm["size"].as<size_t>(); + const size_t trials = vm["trials"].as<size_t>(); + std::cout << "size: " << size << std::endl; + + // setup context and queue for the default device + compute::device device = boost::compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<unsigned int> data(size); + std::generate(data.begin(), data.end(), rand); + + // run tuning proceure (if requested) + if(vm.count("tune")){ + tune_sort(data, trials, queue); + } + + // run sort benchmark + double t = perf_sort(data, trials, queue); + std::cout << "time: " << t / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_sort_by_key.cpp b/src/boost/libs/compute/perf/perf_sort_by_key.cpp new file mode 100644 index 00000000..57c3fc83 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_sort_by_key.cpp @@ -0,0 +1,79 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/sort_by_key.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + using boost::compute::int_; + using boost::compute::long_; + + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int_> host_keys(PERF_N); + std::generate(host_keys.begin(), host_keys.end(), rand); + std::vector<long_> host_values(PERF_N); + std::copy(host_keys.begin(), host_keys.end(), host_values.begin()); + + // create vector on the device and copy the data + boost::compute::vector<int_> device_keys(PERF_N, context); + boost::compute::vector<long_> device_values(PERF_N, context); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + boost::compute::copy( + host_keys.begin(), host_keys.end(), device_keys.begin(), queue + ); + boost::compute::copy( + host_values.begin(), host_values.end(), device_values.begin(), queue + ); + + t.start(); + // sort vector + boost::compute::sort_by_key( + device_keys.begin(), device_keys.end(), device_values.begin(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // verify keys are sorted + if(!boost::compute::is_sorted(device_keys.begin(), device_keys.end(), queue)){ + std::cout << "ERROR: is_sorted() returned false for the keys" << std::endl; + return -1; + } + // verify values are sorted + if(!boost::compute::is_sorted(device_values.begin(), device_values.end(), queue)){ + std::cout << "ERROR: is_sorted() returned false for the values" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_sort_float.cpp b/src/boost/libs/compute/perf/perf_sort_float.cpp new file mode 100644 index 00000000..1b2d5f5e --- /dev/null +++ b/src/boost/libs/compute/perf/perf_sort_float.cpp @@ -0,0 +1,72 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +float rand_float() +{ + return ((rand() / float(RAND_MAX)) - 0.5f) * 100000.0f; +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<float> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_float); + + // create vector on the device and copy the data + boost::compute::vector<float> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + + // sort vector + perf_timer t; + t.start(); + boost::compute::sort( + device_vector.begin(), + device_vector.end(), + queue + ); + queue.finish(); + t.stop(); + std::cout << "time: " << t.last_time() / 1e6 << " ms" << std::endl; + + // verify vector is sorted + if(!boost::compute::is_sorted(device_vector.begin(), + device_vector.end(), + queue)){ + std::cout << "ERROR: is_sorted() returned false" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stable_partition.cpp b/src/boost/libs/compute/perf/perf_stable_partition.cpp new file mode 100644 index 00000000..f7ef1063 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stable_partition.cpp @@ -0,0 +1,62 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/stable_partition.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + using boost::compute::_1; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + boost::compute::stable_partition( + device_vector.begin(), device_vector.end(), _1 < 10, queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_accumulate.cpp b/src/boost/libs/compute/perf/perf_stl_accumulate.cpp new file mode 100644 index 00000000..c28d2d03 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_accumulate.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + int sum = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + sum = std::accumulate(host_vector.begin(), host_vector.end(), int(0)); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "sum: " << sum << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_count.cpp b/src/boost/libs/compute/perf/perf_stl_count.cpp new file mode 100644 index 00000000..9df13f86 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_count.cpp @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // count values equal to four in the vector + size_t count = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + count = std::count( + host_vector.begin(), host_vector.end(), 4 + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "count: " << count << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_find.cpp b/src/boost/libs/compute/perf/perf_stl_find.cpp new file mode 100644 index 00000000..b5d3eed2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_find.cpp @@ -0,0 +1,58 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include "perf.hpp" + +// Max integer that can be generated by rand_int() function. +int rand_int_max = 25; + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * rand_int_max); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // trying to find element that isn't in vector (worst-case scenario) + int wanted = rand_int_max + 1; + + // result + std::vector<int>::iterator host_result_it; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + host_result_it = std::find(host_vector.begin(), host_vector.end(), wanted); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // verify + if(host_result_it != host_vector.end()){ + std::cout << "ERROR: " + << "host_result_iterator != " + << "host_vector.end()" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_find_end.cpp b/src/boost/libs/compute/perf/perf_stl_find_end.cpp new file mode 100644 index 00000000..cb1233b1 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_find_end.cpp @@ -0,0 +1,44 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + int pattern[] = {2, 6, 6, 7, 8, 4}; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::find_end(host_vector.begin(), host_vector.end(), + pattern, pattern + 6); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_includes.cpp b/src/boost/libs/compute/perf/perf_stl_includes.cpp new file mode 100644 index 00000000..b71dbf3c --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_includes.cpp @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <vector> +#include <algorithm> +#include <iostream> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + std::vector<int> v1(PERF_N); + std::generate(v1.begin(), v1.end(), rand_int); + + std::vector<int> v2(v1); + + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::includes( + v1.begin(), v1.end(), + v2.begin(), v2.end() + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_inner_product.cpp b/src/boost/libs/compute/perf/perf_stl_inner_product.cpp new file mode 100644 index 00000000..884f06c9 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_inner_product.cpp @@ -0,0 +1,46 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + std::vector<int> h1(PERF_N); + std::vector<int> h2(PERF_N); + std::generate(h1.begin(), h1.end(), rand_int); + std::generate(h2.begin(), h2.end(), rand_int); + + int product = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + product = std::inner_product( + h1.begin(), h1.end(), h2.begin(), int(0) + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "product: " << product << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_is_permutation.cpp b/src/boost/libs/compute/perf/perf_stl_is_permutation.cpp new file mode 100644 index 00000000..1384e8e9 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_is_permutation.cpp @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + std::vector<int> host_vector2(PERF_N); + std::copy(host_vector.rbegin(), host_vector.rend(), host_vector2.begin()); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::is_permutation(host_vector.begin(), host_vector.end(), + host_vector2.begin()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_max_element.cpp b/src/boost/libs/compute/perf/perf_stl_max_element.cpp new file mode 100644 index 00000000..3fa61267 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_max_element.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Rastko Anicic <anicic.rastko@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>(rand() % 10000000); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + int max = 0; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + max = *(std::max_element(host_vector.begin(), host_vector.end())); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "max: " << max << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_merge.cpp b/src/boost/libs/compute/perf/perf_stl_merge.cpp new file mode 100644 index 00000000..0a842a04 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_merge.cpp @@ -0,0 +1,38 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <vector> +#include <algorithm> +#include <iostream> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + std::vector<int> v1 = generate_random_vector<int>(std::floor(PERF_N / 2.0)); + std::vector<int> v2 = generate_random_vector<int>(std::ceil(PERF_N / 2.0)); + std::vector<int> v3(PERF_N); + + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_next_permutation.cpp b/src/boost/libs/compute/perf/perf_stl_next_permutation.cpp new file mode 100644 index 00000000..22148975 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_next_permutation.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + std::sort(host_vector.begin(), host_vector.end(), std::greater<int>()); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::next_permutation(host_vector.begin(), host_vector.end()); + t.stop(); + std::prev_permutation(host_vector.begin(), host_vector.end()); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_partial_sum.cpp b/src/boost/libs/compute/perf/perf_stl_partial_sum.cpp new file mode 100644 index 00000000..533defb2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_partial_sum.cpp @@ -0,0 +1,51 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + using boost::compute::int_; + + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int_> v(PERF_N); + std::vector<int_> r(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + std::generate(v.begin(), v.end(), rand_int); + t.start(); + std::partial_sum( + v.begin(), + v.end(), + r.begin() + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_partition.cpp b/src/boost/libs/compute/perf/perf_stl_partition.cpp new file mode 100644 index 00000000..56aadd0d --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_partition.cpp @@ -0,0 +1,46 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +bool less_than_10(int value) +{ + return value < 10; +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::partition(host_vector.begin(), host_vector.end(), less_than_10); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_partition_point.cpp b/src/boost/libs/compute/perf/perf_stl_partition_point.cpp new file mode 100644 index 00000000..94b1c263 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_partition_point.cpp @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +bool less_than_20(int value) +{ + return value < 20; +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + std::partition(host_vector.begin(), host_vector.end(), + less_than_20); + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::partition_point(host_vector.begin(), host_vector.end(), + less_than_20); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_prev_permutation.cpp b/src/boost/libs/compute/perf/perf_stl_prev_permutation.cpp new file mode 100644 index 00000000..f246ba2a --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_prev_permutation.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + std::sort(host_vector.begin(), host_vector.end()); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::prev_permutation(host_vector.begin(), host_vector.end()); + t.stop(); + std::next_permutation(host_vector.begin(), host_vector.end()); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_reverse.cpp b/src/boost/libs/compute/perf/perf_stl_reverse.cpp new file mode 100644 index 00000000..b2ee2ef6 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_reverse.cpp @@ -0,0 +1,41 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::reverse(host_vector.begin(), host_vector.end()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_reverse_copy.cpp b/src/boost/libs/compute/perf/perf_stl_reverse_copy.cpp new file mode 100644 index 00000000..1397e9a7 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_reverse_copy.cpp @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector for reversed data + std::vector<int> host_reversed_vector(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::reverse_copy(host_vector.begin(), host_vector.end(), + host_reversed_vector.begin()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_rotate.cpp b/src/boost/libs/compute/perf/perf_stl_rotate.cpp new file mode 100644 index 00000000..f90acef2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_rotate.cpp @@ -0,0 +1,41 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::rotate(host_vector.begin(), host_vector.begin()+(PERF_N/2), host_vector.end()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_rotate_copy.cpp b/src/boost/libs/compute/perf/perf_stl_rotate_copy.cpp new file mode 100644 index 00000000..516d11c2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_rotate_copy.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + std::vector<int> host_vector2(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::rotate_copy(host_vector.begin(), host_vector.begin()+(PERF_N/2), host_vector.end(), host_vector2.begin()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_saxpy.cpp b/src/boost/libs/compute/perf/perf_stl_saxpy.cpp new file mode 100644 index 00000000..8ab33535 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_saxpy.cpp @@ -0,0 +1,52 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include "perf.hpp" + +float rand_float() +{ + return (float(rand()) / float(RAND_MAX)) * 1000.f; +} + +// y <- alpha * x + y +void serial_saxpy(size_t n, float alpha, const float *x, float *y) +{ + for(size_t i = 0; i < n; i++){ + y[i] = alpha * x[i] + y[i]; + } +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + float alpha = 2.5f; + + std::vector<float> host_x(PERF_N); + std::vector<float> host_y(PERF_N); + std::generate(host_x.begin(), host_x.end(), rand_float); + std::generate(host_y.begin(), host_y.end(), rand_float); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + serial_saxpy(PERF_N, alpha, &host_x[0], &host_y[0]); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_search.cpp b/src/boost/libs/compute/perf/perf_stl_search.cpp new file mode 100644 index 00000000..8166d35e --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_search.cpp @@ -0,0 +1,44 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + int pattern[] = {2, 6, 6, 7, 8, 4}; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::search(host_vector.begin(), host_vector.end(), + pattern, pattern + 6); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_search_n.cpp b/src/boost/libs/compute/perf/perf_stl_search_n.cpp new file mode 100644 index 00000000..76a6bb07 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_search_n.cpp @@ -0,0 +1,41 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::search_n(host_vector.begin(), host_vector.end(), 5, 2); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_set_difference.cpp b/src/boost/libs/compute/perf/perf_stl_set_difference.cpp new file mode 100644 index 00000000..c5d0802d --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_set_difference.cpp @@ -0,0 +1,54 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <vector> +#include <algorithm> +#include <iostream> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + std::vector<int> v1(std::floor(PERF_N / 2.0)); + std::vector<int> v2(std::ceil(PERF_N / 2.0)); + + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + std::vector<int> v3(PERF_N); + std::vector<int>::iterator v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + v3_end = std::set_difference( + v1.begin(), v1.end(), + v2.begin(), v2.end(), + v3.begin() + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << std::distance(v3.begin(), v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_set_intersection.cpp b/src/boost/libs/compute/perf/perf_stl_set_intersection.cpp new file mode 100644 index 00000000..6aa3493b --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_set_intersection.cpp @@ -0,0 +1,54 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <vector> +#include <algorithm> +#include <iostream> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + std::vector<int> v1(std::floor(PERF_N / 2.0)); + std::vector<int> v2(std::ceil(PERF_N / 2.0)); + + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + std::vector<int> v3(PERF_N); + std::vector<int>::iterator v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + v3_end = std::set_intersection( + v1.begin(), v1.end(), + v2.begin(), v2.end(), + v3.begin() + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << std::distance(v3.begin(), v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_set_symmetric_difference.cpp b/src/boost/libs/compute/perf/perf_stl_set_symmetric_difference.cpp new file mode 100644 index 00000000..c22c70a7 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_set_symmetric_difference.cpp @@ -0,0 +1,54 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <vector> +#include <algorithm> +#include <iostream> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + std::vector<int> v1(std::floor(PERF_N / 2.0)); + std::vector<int> v2(std::ceil(PERF_N / 2.0)); + + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + std::vector<int> v3(PERF_N); + std::vector<int>::iterator v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + v3_end = std::set_symmetric_difference( + v1.begin(), v1.end(), + v2.begin(), v2.end(), + v3.begin() + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << std::distance(v3.begin(), v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_set_union.cpp b/src/boost/libs/compute/perf/perf_stl_set_union.cpp new file mode 100644 index 00000000..9d4fe3a8 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_set_union.cpp @@ -0,0 +1,54 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <vector> +#include <algorithm> +#include <iostream> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + std::vector<int> v1(std::floor(PERF_N / 2.0)); + std::vector<int> v2(std::ceil(PERF_N / 2.0)); + + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + std::vector<int> v3(PERF_N); + std::vector<int>::iterator v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + v3_end = std::set_union( + v1.begin(), v1.end(), + v2.begin(), v2.end(), + v3.begin() + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << std::distance(v3.begin(), v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_sort.cpp b/src/boost/libs/compute/perf/perf_stl_sort.cpp new file mode 100644 index 00000000..c9d4294b --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_sort.cpp @@ -0,0 +1,33 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + std::vector<int> v; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + v = generate_random_vector<int>(PERF_N); + t.start(); + std::sort(v.begin(), v.end()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_stable_partition.cpp b/src/boost/libs/compute/perf/perf_stl_stable_partition.cpp new file mode 100644 index 00000000..ee4993cc --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_stable_partition.cpp @@ -0,0 +1,47 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +bool less_than_10(int value) +{ + return value < 10; +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + std::stable_partition(host_vector.begin(), host_vector.end(), + less_than_10); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_unique.cpp b/src/boost/libs/compute/perf/perf_stl_unique.cpp new file mode 100644 index 00000000..f4f97b4b --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_unique.cpp @@ -0,0 +1,41 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + std::generate(host_vector.begin(), host_vector.end(), rand_int); + t.start(); + std::unique(host_vector.begin(), host_vector.end()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_stl_unique_copy.cpp b/src/boost/libs/compute/perf/perf_stl_unique_copy.cpp new file mode 100644 index 00000000..77705fa2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_stl_unique_copy.cpp @@ -0,0 +1,44 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::vector<int> host_vector2(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + std::generate(host_vector.begin(), host_vector.end(), rand_int); + t.start(); + std::unique_copy( + host_vector.begin(), host_vector.end(), host_vector2.begin() + ); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_tbb_accumulate.cpp b/src/boost/libs/compute/perf/perf_tbb_accumulate.cpp new file mode 100644 index 00000000..319ad8af --- /dev/null +++ b/src/boost/libs/compute/perf/perf_tbb_accumulate.cpp @@ -0,0 +1,75 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <tbb/blocked_range.h> +#include <tbb/parallel_reduce.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +template<class T> +struct Sum { + T value; + Sum() : value(0) {} + Sum( Sum& s, tbb::split ) {value = 0;} + void operator()( const tbb::blocked_range<T*>& r ) { + T temp = value; + for( T* a=r.begin(); a!=r.end(); ++a ) { + temp += *a; + } + value = temp; + } + void join( Sum& rhs ) {value += rhs.value;} +}; + +template<class T> +T ParallelSum( T array[], size_t n ) { + Sum<T> total; + tbb::parallel_reduce( tbb::blocked_range<T*>( array, array+n ), + total ); + return total.value; +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + int sum = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + sum = ParallelSum<int>(&host_vector[0], host_vector.size()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "sum: " << sum << std::endl; + + int host_sum = std::accumulate(host_vector.begin(), host_vector.end(), int(0)); + if(sum != host_sum){ + std::cerr << "ERROR: sum (" << sum << ") != (" << host_sum << ")" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_tbb_merge.cpp b/src/boost/libs/compute/perf/perf_tbb_merge.cpp new file mode 100644 index 00000000..a7aa814e --- /dev/null +++ b/src/boost/libs/compute/perf/perf_tbb_merge.cpp @@ -0,0 +1,95 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <tbb/parallel_for.h> + +#include "perf.hpp" + +// example from: http://www.threadingbuildingblocks.org/docs/help/reference/algorithms/parallel_for_func.htm +using namespace tbb; + +template<typename Iterator> +struct ParallelMergeRange { + static size_t grainsize; + Iterator begin1, end1; // [begin1,end1) is 1st sequence to be merged + Iterator begin2, end2; // [begin2,end2) is 2nd sequence to be merged + Iterator out; // where to put merged sequence + bool empty() const {return (end1-begin1)+(end2-begin2)==0;} + bool is_divisible() const { + return (std::min)( end1-begin1, end2-begin2 ) > grainsize; + } + ParallelMergeRange( ParallelMergeRange& r, split ) { + if( r.end1-r.begin1 < r.end2-r.begin2 ) { + std::swap(r.begin1,r.begin2); + std::swap(r.end1,r.end2); + } + Iterator m1 = r.begin1 + (r.end1-r.begin1)/2; + Iterator m2 = std::lower_bound( r.begin2, r.end2, *m1 ); + begin1 = m1; + begin2 = m2; + end1 = r.end1; + end2 = r.end2; + out = r.out + (m1-r.begin1) + (m2-r.begin2); + r.end1 = m1; + r.end2 = m2; + } + ParallelMergeRange( Iterator begin1_, Iterator end1_, + Iterator begin2_, Iterator end2_, + Iterator out_ ) : + begin1(begin1_), end1(end1_), + begin2(begin2_), end2(end2_), out(out_) + {} +}; + +template<typename Iterator> +size_t ParallelMergeRange<Iterator>::grainsize = 1000; + +template<typename Iterator> +struct ParallelMergeBody { + void operator()( ParallelMergeRange<Iterator>& r ) const { + std::merge( r.begin1, r.end1, r.begin2, r.end2, r.out ); + } +}; + +template<typename Iterator> +void ParallelMerge( Iterator begin1, Iterator end1, Iterator begin2, Iterator end2, Iterator out ) { + parallel_for( + ParallelMergeRange<Iterator>(begin1,end1,begin2,end2,out), + ParallelMergeBody<Iterator>(), + simple_partitioner() + ); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + std::vector<int> v1 = generate_random_vector<int>(PERF_N / 2); + std::vector<int> v2 = generate_random_vector<int>(PERF_N / 2); + std::vector<int> v3(PERF_N); + + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + ParallelMerge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_tbb_sort.cpp b/src/boost/libs/compute/perf/perf_tbb_sort.cpp new file mode 100644 index 00000000..2f79b5b2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_tbb_sort.cpp @@ -0,0 +1,35 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <vector> + +#include <tbb/parallel_sort.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + std::vector<int> v(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + v = generate_random_vector<int>(PERF_N); + t.start(); + tbb::parallel_sort(v.begin(), v.end()); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_accumulate.cu b/src/boost/libs/compute/perf/perf_thrust_accumulate.cu new file mode 100644 index 00000000..76b72321 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_accumulate.cu @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/reduce.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // transfer data to the device + thrust::device_vector<int> d_vec = h_vec; + + int sum = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + sum = thrust::reduce(d_vec.begin(), d_vec.end()); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "sum: " << sum << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_count.cu b/src/boost/libs/compute/perf/perf_thrust_count.cu new file mode 100644 index 00000000..d69df901 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_count.cu @@ -0,0 +1,49 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <thrust/count.h> +#include <thrust/host_vector.h> +#include <thrust/device_vector.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + thrust::host_vector<int> host_vector(PERF_N); + thrust::generate(host_vector.begin(), host_vector.end(), rand_int); + + thrust::device_vector<int> v = host_vector; + + size_t count = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + count = thrust::count(v.begin(), v.end(), 4); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "count: " << count << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_exclusive_scan.cu b/src/boost/libs/compute/perf/perf_thrust_exclusive_scan.cu new file mode 100644 index 00000000..df1367a2 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_exclusive_scan.cu @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Benoit +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/scan.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // transfer data to the device + thrust::device_vector<int> d_vec = h_vec; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + d_vec = h_vec; + + t.start(); + thrust::exclusive_scan(d_vec.begin(), d_vec.end(), d_vec.begin()); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + thrust::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_find.cu b/src/boost/libs/compute/perf/perf_thrust_find.cu new file mode 100644 index 00000000..e1482604 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_find.cu @@ -0,0 +1,65 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <thrust/find.h> +#include <thrust/host_vector.h> +#include <thrust/device_vector.h> + +#include "perf.hpp" + +// Max integer that can be generated by rand_int() function. +int rand_int_max = 25; + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * rand_int_max); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // create vector of random numbers on the host + thrust::host_vector<int> host_vector(PERF_N); + thrust::generate(host_vector.begin(), host_vector.end(), rand_int); + + thrust::device_vector<int> v = host_vector; + + // trying to find element that isn't in vector (worst-case scenario) + int wanted = rand_int_max + 1; + + // result + thrust::device_vector<int>::iterator device_result_it; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + device_result_it = thrust::find(v.begin(), v.end(), wanted); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // verify + if(device_result_it != v.end()){ + std::cout << "ERROR: " + << "device_result_iterator != " + << "v.end()" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_inner_product.cu b/src/boost/libs/compute/perf/perf_thrust_inner_product.cu new file mode 100644 index 00000000..6d01fc53 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_inner_product.cu @@ -0,0 +1,49 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <iterator> +#include <algorithm> + +#include <thrust/device_vector.h> +#include <thrust/host_vector.h> +#include <thrust/inner_product.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> host_x(PERF_N); + thrust::host_vector<int> host_y(PERF_N); + std::generate(host_x.begin(), host_x.end(), rand); + std::generate(host_y.begin(), host_y.end(), rand); + + // transfer data to the device + thrust::device_vector<int> device_x = host_x; + thrust::device_vector<int> device_y = host_y; + + int product = 0; + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + product = thrust::inner_product( + device_x.begin(), device_x.end(), device_y.begin(), 0 + ); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "product: " << product << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_merge.cu b/src/boost/libs/compute/perf/perf_thrust_merge.cu new file mode 100644 index 00000000..f269c939 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_merge.cu @@ -0,0 +1,63 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <iterator> +#include <algorithm> + +#include <thrust/device_vector.h> +#include <thrust/host_vector.h> +#include <thrust/merge.h> +#include <thrust/sort.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> v1(std::floor(PERF_N / 2.0)); + thrust::host_vector<int> v2(std::ceil(PERF_N / 2.0)); + std::generate(v1.begin(), v1.end(), rand); + std::generate(v2.begin(), v2.end(), rand); + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + // transfer data to the device + thrust::device_vector<int> gpu_v1 = v1; + thrust::device_vector<int> gpu_v2 = v2; + thrust::device_vector<int> gpu_v3(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + thrust::merge( + gpu_v1.begin(), gpu_v1.end(), + gpu_v2.begin(), gpu_v2.end(), + gpu_v3.begin() + ); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + thrust::host_vector<int> check_v3 = gpu_v3; + + thrust::host_vector<int> v3(PERF_N); + std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v3.begin()); + bool ok = std::equal(check_v3.begin(), check_v3.end(), v3.begin()); + if(!ok){ + std::cerr << "ERROR: merged ranges different" << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_partial_sum.cu b/src/boost/libs/compute/perf/perf_thrust_partial_sum.cu new file mode 100644 index 00000000..e30e80b5 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_partial_sum.cu @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/scan.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // transfer data to the device + thrust::device_vector<int> d_vec = h_vec; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + d_vec = h_vec; + + t.start(); + thrust::inclusive_scan(d_vec.begin(), d_vec.end(), d_vec.begin()); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + thrust::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_partition.cu b/src/boost/libs/compute/perf/perf_thrust_partition.cu new file mode 100644 index 00000000..5c89014c --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_partition.cu @@ -0,0 +1,60 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/partition.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +struct less_than_ten : public thrust::unary_function<bool, int> +{ + __device__ bool operator()(int x) const + { + return x < 10; + } +}; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec(PERF_N); + std::generate(h_vec.begin(), h_vec.end(), rand_int); + + thrust::device_vector<int> d_vec(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + d_vec = h_vec; + + t.start(); + thrust::partition( + d_vec.begin(), d_vec.end(), less_than_ten() + ); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_reduce_by_key.cu b/src/boost/libs/compute/perf/perf_thrust_reduce_by_key.cu new file mode 100644 index 00000000..a445c137 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_reduce_by_key.cu @@ -0,0 +1,92 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/reduce.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +struct unique_key { + int current; + int avgValuesNoPerKey; + + unique_key() + { + current = 0; + avgValuesNoPerKey = 512; + } + + int operator()() + { + double p = double(1.0) / static_cast<double>(avgValuesNoPerKey); + if((rand() / double(RAND_MAX)) <= p) + return ++current; + return current; + } +} UniqueKey; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + + // create vector of keys and random values + thrust::host_vector<int> host_keys(PERF_N); + thrust::host_vector<int> host_values(PERF_N); + std::generate(host_keys.begin(), host_keys.end(), UniqueKey); + std::generate(host_values.begin(), host_values.end(), rand_int); + + // transfer data to the device + thrust::device_vector<int> device_keys = host_keys; + thrust::device_vector<int> device_values = host_values; + + // create device vectors for the results + thrust::device_vector<int> device_keys_results(PERF_N); + thrust::device_vector<int> device_values_results(PERF_N); + + typedef typename thrust::device_vector<int>::iterator iterType; + thrust::pair<iterType, iterType> result; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + result = thrust::reduce_by_key(device_keys.begin(), + device_keys.end(), + device_values.begin(), + device_keys_results.begin(), + device_values_results.begin()); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + size_t result_size = thrust::distance(device_keys_results.begin(), result.first); + if(result_size != static_cast<size_t>(host_keys[PERF_N-1] + 1)){ + std::cout << "ERROR: " + << "wrong number of keys" + << std::endl; + return -1; + } + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_reverse.cu b/src/boost/libs/compute/perf/perf_thrust_reverse.cu new file mode 100644 index 00000000..1927ca6a --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_reverse.cu @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/reverse.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // transfer data to the device + thrust::device_vector<int> d_vec; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + d_vec = h_vec; + + t.start(); + thrust::reverse(d_vec.begin(), d_vec.end()); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + thrust::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_reverse_copy.cu b/src/boost/libs/compute/perf/perf_thrust_reverse_copy.cu new file mode 100644 index 00000000..af1a044d --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_reverse_copy.cu @@ -0,0 +1,47 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/reverse.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // transfer data to the device + thrust::device_vector<int> d_vec; + d_vec = h_vec; + + // device vector for reversed data + thrust::device_vector<int> d_reversed_vec(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + thrust::reverse_copy(d_vec.begin(), d_vec.end(), d_reversed_vec.begin()); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_rotate.cu b/src/boost/libs/compute/perf/perf_thrust_rotate.cu new file mode 100644 index 00000000..108bb99b --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_rotate.cu @@ -0,0 +1,51 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/host_vector.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // transfer data to the device + thrust::device_vector<int> d_vec; + + size_t rotate_distance = PERF_N / 2; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + d_vec = h_vec; + + t.start(); + // there is no thrust::rotate() so we implement it manually with copy() + thrust::device_vector<int> tmp(d_vec.begin(), d_vec.begin() + rotate_distance); + thrust::copy(d_vec.begin() + rotate_distance, d_vec.end(), d_vec.begin()); + thrust::copy(tmp.begin(), tmp.end(), d_vec.begin() + rotate_distance); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + thrust::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_saxpy.cu b/src/boost/libs/compute/perf/perf_thrust_saxpy.cu new file mode 100644 index 00000000..aa35a191 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_saxpy.cu @@ -0,0 +1,63 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <iterator> +#include <algorithm> + +#include <thrust/device_vector.h> +#include <thrust/functional.h> +#include <thrust/host_vector.h> +#include <thrust/transform.h> + +#include "perf.hpp" + +struct saxpy_functor : public thrust::binary_function<float,float,float> +{ + const float a; + + saxpy_functor(float _a) : a(_a) {} + + __host__ __device__ + float operator()(const float& x, const float& y) const + { + return a * x + y; + } +}; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> host_x(PERF_N); + thrust::host_vector<int> host_y(PERF_N); + std::generate(host_x.begin(), host_x.end(), rand); + std::generate(host_y.begin(), host_y.end(), rand); + + // transfer data to the device + thrust::device_vector<int> device_x = host_x; + thrust::device_vector<int> device_y = host_y; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + thrust::transform(device_x.begin(), device_x.end(), device_y.begin(), device_y.begin(), saxpy_functor(2.5f)); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + thrust::copy(device_x.begin(), device_x.end(), host_x.begin()); + thrust::copy(device_y.begin(), device_y.end(), host_y.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_set_difference.cu b/src/boost/libs/compute/perf/perf_thrust_set_difference.cu new file mode 100644 index 00000000..3465f214 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_set_difference.cu @@ -0,0 +1,61 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <iostream> +#include <iterator> +#include <algorithm> + +#include <thrust/device_vector.h> +#include <thrust/host_vector.h> +#include <thrust/set_operations.h> +#include <thrust/sort.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> v1(std::floor(PERF_N / 2.0)); + thrust::host_vector<int> v2(std::ceil(PERF_N / 2.0)); + std::generate(v1.begin(), v1.end(), rand_int); + std::generate(v2.begin(), v2.end(), rand_int); + std::sort(v1.begin(), v1.end()); + std::sort(v2.begin(), v2.end()); + + // transfer data to the device + thrust::device_vector<int> gpu_v1 = v1; + thrust::device_vector<int> gpu_v2 = v2; + thrust::device_vector<int> gpu_v3(PERF_N); + + thrust::device_vector<int>::iterator gpu_v3_end; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + t.start(); + gpu_v3_end = thrust::set_difference( + gpu_v1.begin(), gpu_v1.end(), + gpu_v2.begin(), gpu_v2.end(), + gpu_v3.begin() + ); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + std::cout << "size: " << thrust::distance(gpu_v3.begin(), gpu_v3_end) << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_sort.cu b/src/boost/libs/compute/perf/perf_thrust_sort.cu new file mode 100644 index 00000000..b2d90939 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_sort.cu @@ -0,0 +1,48 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/sort.h> + +#include "perf.hpp" + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec = generate_random_vector<int>(PERF_N); + + // transfer data to the device + thrust::device_vector<int> d_vec; + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + d_vec = h_vec; + + t.start(); + thrust::sort(d_vec.begin(), d_vec.end()); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + // transfer data back to host + thrust::copy(d_vec.begin(), d_vec.end(), h_vec.begin()); + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_thrust_unique.cu b/src/boost/libs/compute/perf/perf_thrust_unique.cu new file mode 100644 index 00000000..6030f291 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_thrust_unique.cu @@ -0,0 +1,50 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <cstdlib> +#include <iostream> + +#include <thrust/copy.h> +#include <thrust/device_vector.h> +#include <thrust/generate.h> +#include <thrust/host_vector.h> +#include <thrust/unique.h> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + + std::cout << "size: " << PERF_N << std::endl; + thrust::host_vector<int> h_vec(PERF_N); + std::generate(h_vec.begin(), h_vec.end(), rand_int); + + thrust::device_vector<int> d_vec(PERF_N); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + d_vec = h_vec; + + t.start(); + thrust::unique(d_vec.begin(), d_vec.end()); + cudaDeviceSynchronize(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_uniform_int_distribution.cpp b/src/boost/libs/compute/perf/perf_uniform_int_distribution.cpp new file mode 100644 index 00000000..57973a81 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_uniform_int_distribution.cpp @@ -0,0 +1,46 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/uniform_int_distribution.hpp> + +#include "perf.hpp" + +namespace compute = boost::compute; + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + compute::device device = compute::system::default_device(); + compute::context context(device); + compute::command_queue queue(context, device); + + compute::vector<compute::uint_> vector(PERF_N, context); + + compute::default_random_engine rng(queue); + compute::uniform_int_distribution<compute::uint_> dist(0, 1); + + perf_timer t; + t.start(); + dist.generate(vector.begin(), vector.end(), rng, queue); + queue.finish(); + t.stop(); + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_unique.cpp b/src/boost/libs/compute/perf/perf_unique.cpp new file mode 100644 index 00000000..b25801f1 --- /dev/null +++ b/src/boost/libs/compute/perf/perf_unique.cpp @@ -0,0 +1,60 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/unique.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + t.start(); + boost::compute::unique( + device_vector.begin(), device_vector.end(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perf_unique_copy.cpp b/src/boost/libs/compute/perf/perf_unique_copy.cpp new file mode 100644 index 00000000..d7ff98af --- /dev/null +++ b/src/boost/libs/compute/perf/perf_unique_copy.cpp @@ -0,0 +1,61 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <algorithm> +#include <iostream> +#include <numeric> +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/unique_copy.hpp> +#include <boost/compute/container/vector.hpp> + +#include "perf.hpp" + +int rand_int() +{ + return static_cast<int>((rand() / double(RAND_MAX)) * 25.0); +} + +int main(int argc, char *argv[]) +{ + perf_parse_args(argc, argv); + std::cout << "size: " << PERF_N << std::endl; + + // setup context and queue for the default device + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context(device); + boost::compute::command_queue queue(context, device); + std::cout << "device: " << device.name() << std::endl; + + // create vector of random numbers on the host + std::vector<int> host_vector(PERF_N); + std::generate(host_vector.begin(), host_vector.end(), rand_int); + + // create vector on the device and copy the data + boost::compute::vector<int> device_vector(PERF_N, context); + boost::compute::vector<int> device_vector2(PERF_N, context); + + perf_timer t; + for(size_t trial = 0; trial < PERF_TRIALS; trial++){ + boost::compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + t.start(); + boost::compute::unique_copy( + device_vector.begin(), device_vector.end(), device_vector2.begin(), queue + ); + queue.finish(); + t.stop(); + } + std::cout << "time: " << t.min_time() / 1e6 << " ms" << std::endl; + + return 0; +} diff --git a/src/boost/libs/compute/perf/perfdoc.py b/src/boost/libs/compute/perf/perfdoc.py new file mode 100755 index 00000000..e9c60362 --- /dev/null +++ b/src/boost/libs/compute/perf/perfdoc.py @@ -0,0 +1,70 @@ +#!/usr/bin/python + +# Copyright (c) 2014 Kyle Lutz <kyle.r.lutz@gmail.com> +# Distributed under the Boost Software License, Version 1.0 +# See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt +# +# See http://boostorg.github.com/compute for more information. + +import os +import sys +import pylab + +from perf import run_benchmark + +fignum = 0 + +def plot_to_file(report, filename): + global fignum + fignum += 1 + pylab.figure(fignum) + + run_to_label = { + "stl" : "C++ STL", + "thrust" : "Thrust", + "compute" : "Boost.Compute", + "bolt" : "Bolt" + } + + for run in sorted(report.samples.keys()): + x = [] + y = [] + + for sample in report.samples[run]: + x.append(sample[0]) + y.append(sample[1]) + + pylab.loglog(x, y, marker='o', label=run_to_label[run]) + + pylab.xlabel("Size") + pylab.ylabel("Time (ms)") + pylab.legend(loc='upper left') + pylab.savefig(filename) + +if __name__ == '__main__': + sizes = [pow(2, x) for x in range(10, 26)] + algorithms = [ + "accumulate", + "count", + "inner_product", + "merge", + "partial_sum", + "partition", + "reverse", + "rotate", + "saxpy", + "sort", + "unique", + ] + + try: + os.mkdir("perf_plots") + except OSError: + pass + + for algorithm in algorithms: + print("running '%s'" % (algorithm)) + report = run_benchmark(algorithm, sizes, ["stl", "thrust", "bolt"]) + plot_to_file(report, "perf_plots/%s_time_plot.png" % algorithm) + diff --git a/src/boost/libs/compute/test/CMakeLists.txt b/src/boost/libs/compute/test/CMakeLists.txt new file mode 100644 index 00000000..1aa99ff9 --- /dev/null +++ b/src/boost/libs/compute/test/CMakeLists.txt @@ -0,0 +1,236 @@ +# --------------------------------------------------------------------------- +# Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +# +# Distributed under the Boost Software License, Version 1.0 +# See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt +# +# --------------------------------------------------------------------------- + +include_directories(../include) + +set(BOOST_COMPONENTS unit_test_framework) + +if(${BOOST_COMPUTE_USE_CPP11}) + # allow tests to use C++11 features + add_definitions(-DBOOST_COMPUTE_USE_CPP11) +endif() + +if (${BOOST_COMPUTE_USE_OFFLINE_CACHE}) + set(BOOST_COMPONENTS ${BOOST_COMPONENTS} system filesystem) + add_definitions(-DBOOST_COMPUTE_USE_OFFLINE_CACHE) +endif() + +if(${BOOST_COMPUTE_THREAD_SAFE} AND NOT ${BOOST_COMPUTE_USE_CPP11}) + set(BOOST_COMPONENTS ${BOOST_COMPONENTS} system thread) +endif() + +if(MSVC AND BOOST_COMPONENTS) + set(BOOST_COMPONENTS ${BOOST_COMPONENTS} chrono) +endif() + +if(BOOST_COMPONENTS) + list(REMOVE_DUPLICATES BOOST_COMPONENTS) +endif() +find_package(Boost 1.54 REQUIRED COMPONENTS ${BOOST_COMPONENTS}) + +if(NOT MSVC) + add_definitions(-DBOOST_TEST_DYN_LINK) +else() + if(MSVC AND ${BOOST_COMPUTE_BOOST_ALL_DYN_LINK}) + add_definitions(-DBOOST_TEST_DYN_LINK) + endif() +endif() + +# enable automatic kernel compilation error messages for tests +add_definitions(-DBOOST_COMPUTE_DEBUG_KERNEL_COMPILATION) + +# enable code coverage generation (only with GCC for now) +if(${BOOST_COMPUTE_ENABLE_COVERAGE} AND ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU") + add_definitions(-fprofile-arcs -ftest-coverage) +endif() + +# add path to test data dir +add_definitions(-DBOOST_COMPUTE_TEST_DATA_PATH="${CMAKE_CURRENT_SOURCE_DIR}/data") + +function(add_compute_test TEST_NAME TEST_SOURCE) + get_filename_component(TEST_TARGET ${TEST_SOURCE} NAME_WE) + add_executable(${TEST_TARGET} ${TEST_SOURCE}) + target_link_libraries(${TEST_TARGET} + ${OpenCL_LIBRARIES} + ${Boost_LIBRARIES} + ) + + # link with coverage library + if(${BOOST_COMPUTE_ENABLE_COVERAGE} AND ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU") + target_link_libraries(${TEST_TARGET} -fprofile-arcs -ftest-coverage) + endif() + + add_test(${TEST_NAME} ${TEST_TARGET}) +endfunction() + +add_compute_test("core.buffer" test_buffer.cpp) +add_compute_test("core.closure" test_closure.cpp) +add_compute_test("core.command_queue" test_command_queue.cpp) +add_compute_test("core.context" test_context.cpp) +add_compute_test("core.device" test_device.cpp) +add_compute_test("core.event" test_event.cpp) +add_compute_test("core.function" test_function.cpp) +add_compute_test("core.kernel" test_kernel.cpp) +add_compute_test("core.pipe" test_pipe.cpp) +add_compute_test("core.platform" test_platform.cpp) +add_compute_test("core.program" test_program.cpp) +add_compute_test("core.system" test_system.cpp) +add_compute_test("core.type_traits" test_type_traits.cpp) +add_compute_test("core.user_event" test_user_event.cpp) + +add_compute_test("utility.extents" test_extents.cpp) +add_compute_test("utility.invoke" test_invoke.cpp) +add_compute_test("utility.program_cache" test_program_cache.cpp) +add_compute_test("utility.wait_list" test_wait_list.cpp) + +add_compute_test("algorithm.accumulate" test_accumulate.cpp) +add_compute_test("algorithm.adjacent_difference" test_adjacent_difference.cpp) +add_compute_test("algorithm.adjacent_find" test_adjacent_find.cpp) +add_compute_test("algorithm.any_all_none_of" test_any_all_none_of.cpp) +add_compute_test("algorithm.binary_search" test_binary_search.cpp) +add_compute_test("algorithm.copy" test_copy.cpp) +add_compute_test("algorithm.copy_type_mismatch" test_copy_type_mismatch.cpp) +add_compute_test("algorithm.copy_if" test_copy_if.cpp) +add_compute_test("algorithm.count" test_count.cpp) +add_compute_test("algorithm.equal" test_equal.cpp) +add_compute_test("algorithm.equal_range" test_equal_range.cpp) +add_compute_test("algorithm.extrema" test_extrema.cpp) +add_compute_test("algorithm.fill" test_fill.cpp) +add_compute_test("algorithm.find" test_find.cpp) +add_compute_test("algorithm.find_end" test_find_end.cpp) +add_compute_test("algorithm.for_each" test_for_each.cpp) +add_compute_test("algorithm.gather" test_gather.cpp) +add_compute_test("algorithm.generate" test_generate.cpp) +add_compute_test("algorithm.includes" test_includes.cpp) +add_compute_test("algorithm.inner_product" test_inner_product.cpp) +add_compute_test("algorithm.inplace_merge" test_inplace_merge.cpp) +add_compute_test("algorithm.inplace_reduce" test_inplace_reduce.cpp) +add_compute_test("algorithm.insertion_sort" test_insertion_sort.cpp) +add_compute_test("algorithm.iota" test_iota.cpp) +add_compute_test("algorithm.is_permutation" test_is_permutation.cpp) +add_compute_test("algorithm.is_sorted" test_is_sorted.cpp) +add_compute_test("algorithm.merge_sort_gpu" test_merge_sort_gpu.cpp) +add_compute_test("algorithm.merge" test_merge.cpp) +add_compute_test("algorithm.mismatch" test_mismatch.cpp) +add_compute_test("algorithm.next_permutation" test_next_permutation.cpp) +add_compute_test("algorithm.nth_element" test_nth_element.cpp) +add_compute_test("algorithm.partial_sum" test_partial_sum.cpp) +add_compute_test("algorithm.partition" test_partition.cpp) +add_compute_test("algorithm.partition_point" test_partition_point.cpp) +add_compute_test("algorithm.prev_permutation" test_prev_permutation.cpp) +add_compute_test("algorithm.radix_sort" test_radix_sort.cpp) +add_compute_test("algorithm.radix_sort_by_key" test_radix_sort_by_key.cpp) +add_compute_test("algorithm.random_fill" test_random_fill.cpp) +add_compute_test("algorithm.random_shuffle" test_random_shuffle.cpp) +add_compute_test("algorithm.reduce" test_reduce.cpp) +add_compute_test("algorithm.reduce_by_key" test_reduce_by_key.cpp) +add_compute_test("algorithm.remove" test_remove.cpp) +add_compute_test("algorithm.replace" test_replace.cpp) +add_compute_test("algorithm.reverse" test_reverse.cpp) +add_compute_test("algorithm.rotate" test_rotate.cpp) +add_compute_test("algorithm.rotate_copy" test_rotate_copy.cpp) +add_compute_test("algorithm.scan" test_scan.cpp) +add_compute_test("algorithm.scatter" test_scatter.cpp) +add_compute_test("algorithm.scatter_if" test_scatter_if.cpp) +add_compute_test("algorithm.search" test_search.cpp) +add_compute_test("algorithm.search_n" test_search_n.cpp) +add_compute_test("algorithm.set_difference" test_set_difference.cpp) +add_compute_test("algorithm.set_intersection" test_set_intersection.cpp) +add_compute_test("algorithm.set_symmetric_difference" test_set_symmetric_difference.cpp) +add_compute_test("algorithm.set_union" test_set_union.cpp) +add_compute_test("algorithm.sort" test_sort.cpp) +add_compute_test("algorithm.sort_by_key" test_sort_by_key.cpp) +add_compute_test("algorithm.stable_partition" test_stable_partition.cpp) +add_compute_test("algorithm.stable_sort" test_stable_sort.cpp) +add_compute_test("algorithm.stable_sort_by_key" test_stable_sort_by_key.cpp) +add_compute_test("algorithm.transform" test_transform.cpp) +add_compute_test("algorithm.transform_if" test_transform_if.cpp) +add_compute_test("algorithm.transform_reduce" test_transform_reduce.cpp) +add_compute_test("algorithm.unique" test_unique.cpp) +add_compute_test("algorithm.unique_copy" test_unique_copy.cpp) +add_compute_test("algorithm.lexicographical_compare" test_lexicographical_compare.cpp) + +add_compute_test("allocator.buffer_allocator" test_buffer_allocator.cpp) +add_compute_test("allocator.pinned_allocator" test_pinned_allocator.cpp) + +add_compute_test("async.wait" test_async_wait.cpp) +add_compute_test("async.wait_guard" test_async_wait_guard.cpp) + +add_compute_test("container.array" test_array.cpp) +add_compute_test("container.dynamic_bitset" test_dynamic_bitset.cpp) +add_compute_test("container.flat_map" test_flat_map.cpp) +add_compute_test("container.flat_set" test_flat_set.cpp) +add_compute_test("container.mapped_view" test_mapped_view.cpp) +add_compute_test("container.stack" test_stack.cpp) +add_compute_test("container.string" test_string.cpp) +add_compute_test("container.valarray" test_valarray.cpp) +add_compute_test("container.vector" test_vector.cpp) + +add_compute_test("exception.context_error" test_context_error.cpp) +add_compute_test("exception.no_device_found" test_no_device_found.cpp) +add_compute_test("exception.opencl_error" test_opencl_error.cpp) +add_compute_test("exception.unsupported_extension" test_unsupported_extension.cpp) + +add_compute_test("functional.as" test_functional_as.cpp) +add_compute_test("functional.bind" test_functional_bind.cpp) +add_compute_test("functional.convert" test_functional_convert.cpp) +add_compute_test("functional.get" test_functional_get.cpp) +add_compute_test("functional.hash" test_functional_hash.cpp) +add_compute_test("functional.identity" test_functional_identity.cpp) +add_compute_test("functional.popcount" test_functional_popcount.cpp) +add_compute_test("functional.unpack" test_functional_unpack.cpp) + +add_compute_test("image.image1d" test_image1d.cpp) +add_compute_test("image.image2d" test_image2d.cpp) +add_compute_test("image.image3d" test_image3d.cpp) +add_compute_test("image.image_sampler" test_image_sampler.cpp) + +add_compute_test("iterator.buffer_iterator" test_buffer_iterator.cpp) +add_compute_test("iterator.constant_iterator" test_constant_iterator.cpp) +add_compute_test("iterator.counting_iterator" test_counting_iterator.cpp) +add_compute_test("iterator.discard_iterator" test_discard_iterator.cpp) +add_compute_test("iterator.function_input_iterator" test_function_input_iterator.cpp) +add_compute_test("iterator.permutation_iterator" test_permutation_iterator.cpp) +add_compute_test("iterator.strided_iterator" test_strided_iterator.cpp) +add_compute_test("iterator.transform_iterator" test_transform_iterator.cpp) +add_compute_test("iterator.zip_iterator" test_zip_iterator.cpp) + +add_compute_test("memory.local_buffer" test_local_buffer.cpp) +add_compute_test("memory.svm_ptr" test_svm_ptr.cpp) + +add_compute_test("random.bernoulli_distribution" test_bernoulli_distribution.cpp) +add_compute_test("random.discrete_distribution" test_discrete_distribution.cpp) +add_compute_test("random.linear_congruential_engine" test_linear_congruential_engine.cpp) +add_compute_test("random.mersenne_twister_engine" test_mersenne_twister_engine.cpp) +add_compute_test("random.threefry_engine" test_threefry_engine.cpp) +add_compute_test("random.normal_distribution" test_normal_distribution.cpp) +add_compute_test("random.uniform_int_distribution" test_uniform_int_distribution.cpp) +add_compute_test("random.uniform_real_distribution" test_uniform_real_distribution.cpp) + +add_compute_test("types.fundamental" test_types.cpp) +add_compute_test("types.complex" test_complex.cpp) +add_compute_test("types.pair" test_pair.cpp) +add_compute_test("types.tuple" test_tuple.cpp) +add_compute_test("types.struct" test_struct.cpp) + +add_compute_test("type_traits.result_of" test_result_of.cpp) + +add_compute_test("experimental.clamp_range" test_clamp_range.cpp) +add_compute_test("experimental.malloc" test_malloc.cpp) +add_compute_test("experimental.sort_by_transform" test_sort_by_transform.cpp) +add_compute_test("experimental.tabulate" test_tabulate.cpp) + +# miscellaneous tests +add_compute_test("misc.amd_cpp_kernel_language" test_amd_cpp_kernel_language.cpp) +add_compute_test("misc.lambda" test_lambda.cpp) +add_compute_test("misc.user_defined_types" test_user_defined_types.cpp) +add_compute_test("misc.literal_conversion" test_literal_conversion.cpp) + +# extra tests (interop tests, linkage tests, etc.) +add_subdirectory(extra) diff --git a/src/boost/libs/compute/test/Jamfile.v2 b/src/boost/libs/compute/test/Jamfile.v2 new file mode 100644 index 00000000..f1a6bfe5 --- /dev/null +++ b/src/boost/libs/compute/test/Jamfile.v2 @@ -0,0 +1,49 @@ +# (C) Copyright 2015: Kyle Lutz +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +import testing ; + +lib boost_unit_test_framework ; + +obj has_opencl : check/has_opencl.cpp ; +explicit has_opencl ; + +project + : source-location . + : requirements + <define>BOOST_ALL_NO_LIB=1 + <toolset>msvc:<define>_SCL_SECURE_NO_WARNINGS + <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS + <toolset>msvc:<define>NOMINMAX + <toolset>msvc:<cxxflags>/wd4003 # Not enough actual parameters for a BOOST_PP macro + <toolset>msvc:<cxxflags>/wd4244 # Warning C4244: 'initializing': conversion from 'double' to 'int', possible loss of data + <toolset>msvc:<cxxflags>/wd4305 # Warning C4305: 'initializing': truncation from 'double' to 'float' + <toolset>msvc:<cxxflags>/wd4800 # Warning C4800: 'uint32_t' : forcing value to bool 'true' or 'false' (performance warning) + <toolset>msvc:<cxxflags>/wd4838 # Warning C4838: conversion from 'double' to 'float' requires a narrowing conversion + <library>/boost/test//boost_unit_test_framework + + [ check-target-builds has_opencl "OpenCL" : : <build>no ] + ; + +rule test_all +{ + local all_rules = ; + + for local fileb in [ glob *.cpp ] + { + all_rules += [ run $(fileb) + : + : + : + <link>shared:<define>BOOST_TEST_DYN_LINK=1 + <host-os>linux:<linkflags>"-lOpenCL" + <host-os>darwin:<linkflags>"-framework OpenCL" + <host-os>freebsd:<linkflags>"-lOpenCL" + ] ; + } + + return $(all_rules) ; +} + +test-suite compute : [ test_all r ] : ; diff --git a/src/boost/libs/compute/test/check/has_opencl.cpp b/src/boost/libs/compute/test/check/has_opencl.cpp new file mode 100644 index 00000000..10769d2b --- /dev/null +++ b/src/boost/libs/compute/test/check/has_opencl.cpp @@ -0,0 +1,11 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2017 Kohei Takahashi +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <boost/compute/cl.hpp> diff --git a/src/boost/libs/compute/test/check_macros.hpp b/src/boost/libs/compute/test/check_macros.hpp new file mode 100644 index 00000000..f3e609ed --- /dev/null +++ b/src/boost/libs/compute/test/check_macros.hpp @@ -0,0 +1,84 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#ifndef BOOST_COMPUTE_TEST_CHECK_MACROS_HPP +#define BOOST_COMPUTE_TEST_CHECK_MACROS_HPP + +#define LIST_ARRAY_VALUES(z, n, data) \ + BOOST_PP_COMMA_IF(n) BOOST_PP_ARRAY_ELEM(n, data) + +// checks 'size' values of 'type' in the device range 'actual` +// against the values given in the array 'expected' +#define CHECK_RANGE_EQUAL(type, size, actual, expected) \ + { \ + type _actual[size]; \ + boost::compute::copy( \ + actual.begin(), actual.begin()+size, _actual, queue \ + ); \ + const type _expected[size] = { \ + BOOST_PP_REPEAT(size, LIST_ARRAY_VALUES, (size, expected)) \ + }; \ + BOOST_CHECK_EQUAL_COLLECTIONS( \ + _actual, _actual + size, _expected, _expected + size \ + ); \ + } + +template <typename Left, typename Right, typename ToleranceBaseType> +inline void +equal_close_impl(Left left_begin, + Left left_end, + Right right_begin, + Right right_end, + ToleranceBaseType tolerance) +{ + for(; left_begin != (left_end); ++left_begin, ++right_begin) { + BOOST_CHECK_CLOSE(*left_begin, *right_begin, tolerance); \ + } +} + +#define BOOST_COMPUTE_TEST_CHECK_CLOSE_COLLECTIONS(L_begin, L_end, R_begin, R_end, tolerance) \ + { \ + equal_close_impl(L_begin, L_end, R_begin, R_end, tolerance); \ + } + +#define CHECK_RANGE_CLOSE(type, size, actual, expected, tolerance) \ + { \ + type _actual[size]; \ + boost::compute::copy( \ + actual.begin(), actual.begin()+size, _actual, queue \ + ); \ + const type _expected[size] = { \ + BOOST_PP_REPEAT(size, LIST_ARRAY_VALUES, (size, expected)) \ + }; \ + BOOST_COMPUTE_TEST_CHECK_CLOSE_COLLECTIONS( \ + _actual, _actual + size, _expected, _expected + size, tolerance \ + ); \ + } + +#define CHECK_HOST_RANGE_EQUAL(type, size, actual, expected) \ + { \ + const type _expected[size] = { \ + BOOST_PP_REPEAT(size, LIST_ARRAY_VALUES, (size, expected)) \ + }; \ + BOOST_CHECK_EQUAL_COLLECTIONS( \ + actual, actual + size, _expected, _expected + size \ + ); \ + } + +#define CHECK_STRING_EQUAL(actual, expected) \ + { \ + std::string _actual(actual.size(), '\0'); \ + boost::compute::copy( \ + actual.begin(), actual.end(), _actual.begin(), queue \ + ); \ + BOOST_CHECK_EQUAL(_actual, expected); \ + } + +#endif // BOOST_COMPUTE_TEST_CHECK_MACROS_HPP diff --git a/src/boost/libs/compute/test/context_setup.hpp b/src/boost/libs/compute/test/context_setup.hpp new file mode 100644 index 00000000..bff606ec --- /dev/null +++ b/src/boost/libs/compute/test/context_setup.hpp @@ -0,0 +1,33 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Denis Demidov +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#ifndef BOOST_COMPUTE_TEST_CONTEXT_SETUP_HPP +#define BOOST_COMPUTE_TEST_CONTEXT_SETUP_HPP + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> + +#include "opencl_version_check.hpp" + +struct Context { + boost::compute::device device; + boost::compute::context context; + boost::compute::command_queue queue; + + Context() : + device ( boost::compute::system::default_device() ), + context( boost::compute::system::default_context() ), + queue ( boost::compute::system::default_queue() ) + {} +}; + +BOOST_FIXTURE_TEST_SUITE(compute_test, Context) + +#endif diff --git a/src/boost/libs/compute/test/data/invalid_program.cl b/src/boost/libs/compute/test/data/invalid_program.cl new file mode 100644 index 00000000..3a9de877 --- /dev/null +++ b/src/boost/libs/compute/test/data/invalid_program.cl @@ -0,0 +1,10 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2017 Kristian Popov <kristian.popov@outlook.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// +__kernel void foo(__global int *input) { !@#$%^&*() } diff --git a/src/boost/libs/compute/test/data/program.cl b/src/boost/libs/compute/test/data/program.cl new file mode 100644 index 00000000..c8962b88 --- /dev/null +++ b/src/boost/libs/compute/test/data/program.cl @@ -0,0 +1,15 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2017 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +__kernel void foobar(__global int* x) +{ + const int gid = get_global_id(0); + x[gid] = gid; +} diff --git a/src/boost/libs/compute/test/data/program.spirv32 b/src/boost/libs/compute/test/data/program.spirv32 Binary files differnew file mode 100644 index 00000000..79eb6153 --- /dev/null +++ b/src/boost/libs/compute/test/data/program.spirv32 diff --git a/src/boost/libs/compute/test/data/program.spirv64 b/src/boost/libs/compute/test/data/program.spirv64 Binary files differnew file mode 100644 index 00000000..57113d41 --- /dev/null +++ b/src/boost/libs/compute/test/data/program.spirv64 diff --git a/src/boost/libs/compute/test/extra/CMakeLists.txt b/src/boost/libs/compute/test/extra/CMakeLists.txt new file mode 100644 index 00000000..4795a6cc --- /dev/null +++ b/src/boost/libs/compute/test/extra/CMakeLists.txt @@ -0,0 +1,81 @@ +# --------------------------------------------------------------------------- +# Copyright (c) 2015 Kyle Lutz <kyle.r.lutz@gmail.com> +# +# Distributed under the Boost Software License, Version 1.0 +# See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt +# +# --------------------------------------------------------------------------- + +# include local test headers +include_directories(..) + +# Check for linkage problems +add_executable(test_multiple_objects + test_multiple_objects1.cpp + test_multiple_objects2.cpp + ) +target_link_libraries(test_multiple_objects + ${OPENCL_LIBRARIES} + ${Boost_LIBRARIES} + ) +# link with coverage library +if(${BOOST_COMPUTE_ENABLE_COVERAGE} AND ${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU") + target_link_libraries(test_multiple_objects -fprofile-arcs -ftest-coverage) +endif() +add_test("misc.multiple_objects" test_multiple_objects) + +# eigen interop tests +if(${BOOST_COMPUTE_HAVE_EIGEN}) + find_package(Eigen REQUIRED) + include_directories(SYSTEM ${EIGEN_INCLUDE_DIRS}) + add_compute_test("interop.eigen" test_interop_eigen.cpp) +endif() + +# opencv interop tests +if(${BOOST_COMPUTE_HAVE_OPENCV}) + find_package(OpenCV REQUIRED) + include_directories(SYSTEM ${OpenCV_INCLUDE_DIRS}) + add_compute_test("interop.opencv" test_interop_opencv.cpp) + target_link_libraries(test_interop_opencv ${OpenCV_LIBS}) +endif() + +# qt interop tests +if(${BOOST_COMPUTE_HAVE_QT}) + # look for Qt4 in the first place + find_package(Qt4 QUIET) + + if(${QT4_FOUND}) + find_package(Qt4 REQUIRED COMPONENTS QtCore QtGui QtOpenGL) + include(${QT_USE_FILE}) + else() + find_package(Qt5Widgets QUIET) + + # look for Qt5 + if(${Qt5Widgets_FOUND}) + find_package(Qt5Core REQUIRED) + find_package(Qt5Widgets REQUIRED) + find_package(Qt5OpenGL REQUIRED) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5OpenGL_EXECUTABLE_COMPILE_FLAGS}") + set(QT_LIBRARIES ${Qt5OpenGL_LIBRARIES}) + else() + # no valid Qt framework found + message(FATAL_ERROR "Error: Did not find Qt4 or Qt5") + endif() + endif() + + add_compute_test("interop.qt" test_interop_qt.cpp) + target_link_libraries(test_interop_qt ${QT_LIBRARIES}) + + # the opengl interop test depends on qt to create the opengl context + add_compute_test("interop.opengl" test_interop_opengl.cpp) + target_link_libraries(test_interop_opengl ${QT_LIBRARIES}) +endif() + +# vtk interop tests +if(${BOOST_COMPUTE_HAVE_VTK}) + find_package(VTK REQUIRED) + include(${VTK_USE_FILE}) + add_compute_test("interop.vtk" test_interop_vtk.cpp) + target_link_libraries(test_interop_vtk ${VTK_LIBRARIES}) +endif() diff --git a/src/boost/libs/compute/test/extra/test_interop_eigen.cpp b/src/boost/libs/compute/test/extra/test_interop_eigen.cpp new file mode 100644 index 00000000..a184de9b --- /dev/null +++ b/src/boost/libs/compute/test/extra/test_interop_eigen.cpp @@ -0,0 +1,106 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInteropEigen +#include <boost/test/unit_test.hpp> + +#include <boost/compute/closure.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/interop/eigen.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bcl = boost::compute; + +BOOST_AUTO_TEST_CASE(eigen) +{ + Eigen::MatrixXf mat(3, 3); + mat << 1, 2, 3, + 6, 5, 4, + 7, 8, 9; + + // copy matrix to gpu buffer + bcl::vector<float> vec(9, context); + bcl::eigen_copy_matrix_to_buffer(mat, vec.begin(), queue); + CHECK_RANGE_EQUAL(float, 9, vec, (1, 6, 7, 2, 5, 8, 3, 4, 9)); + + // transpose matrix and then copy to gpu buffer + mat = mat.transpose().eval(); + bcl::eigen_copy_matrix_to_buffer(mat, vec.begin(), queue); + CHECK_RANGE_EQUAL(float, 9, vec, (1, 2, 3, 6, 5, 4, 7, 8, 9)); + + // set matrix to zero and copy data back from gpu buffer + mat.setZero(); + bcl::eigen_copy_buffer_to_matrix(vec.begin(), mat, queue); + BOOST_CHECK(mat.isZero() == false); + BOOST_CHECK_EQUAL(mat.sum(), 45); +} + +BOOST_AUTO_TEST_CASE(eigen_types) +{ + BOOST_CHECK(std::strcmp(bcl::type_name<Eigen::Vector2i>(), "int2") == 0); + BOOST_CHECK(std::strcmp(bcl::type_name<Eigen::Vector2f>(), "float2") == 0); + BOOST_CHECK(std::strcmp(bcl::type_name<Eigen::Vector4f>(), "float4") == 0); + BOOST_CHECK(std::strcmp(bcl::type_name<Eigen::Vector4d>(), "double4") == 0); +} + +BOOST_AUTO_TEST_CASE(multiply_matrix4) +{ + std::vector<Eigen::Vector4f> host_vectors; + std::vector<Eigen::Matrix4f> host_matrices; + + Eigen::Matrix4f matrix; + matrix << 1, 2, 0, 3, + 2, 1, 2, 0, + 0, 3, 1, 2, + 2, 0, 2, 1; + + host_vectors.push_back(Eigen::Vector4f(1, 2, 3, 4)); + host_vectors.push_back(Eigen::Vector4f(4, 3, 2, 1)); + host_vectors.push_back(Eigen::Vector4f(1, 2, 3, 4)); + host_vectors.push_back(Eigen::Vector4f(4, 3, 2, 1)); + + // store the eigen 4x4 matrix as a float16 + bcl::float16_ M = + bcl::eigen_matrix4f_to_float16(matrix); + + // returns the result of M*x + BOOST_COMPUTE_CLOSURE(Eigen::Vector4f, transform4x4, (const Eigen::Vector4f x), (M), + { + float4 r; + r.x = dot(M.s048c, x); + r.y = dot(M.s159d, x); + r.z = dot(M.s26ae, x); + r.w = dot(M.s37bf, x); + return r; + }); + + bcl::vector<Eigen::Vector4f> vectors(4, context); + bcl::vector<Eigen::Vector4f> results(4, context); + + bcl::copy(host_vectors.begin(), host_vectors.end(), vectors.begin(), queue); + + bcl::transform( + vectors.begin(), vectors.end(), results.begin(), transform4x4, queue + ); + + std::vector<Eigen::Vector4f> host_results(4); + bcl::copy(results.begin(), results.end(), host_results.begin(), queue); + + BOOST_CHECK((matrix * host_vectors[0]) == host_results[0]); + BOOST_CHECK((matrix * host_vectors[1]) == host_results[1]); + BOOST_CHECK((matrix * host_vectors[2]) == host_results[2]); + BOOST_CHECK((matrix * host_vectors[3]) == host_results[3]); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/extra/test_interop_opencv.cpp b/src/boost/libs/compute/test/extra/test_interop_opencv.cpp new file mode 100644 index 00000000..4d959360 --- /dev/null +++ b/src/boost/libs/compute/test/extra/test_interop_opencv.cpp @@ -0,0 +1,105 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInteropOpenCV +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/algorithm/reverse.hpp> +#include <boost/compute/interop/opencv.hpp> +#include <opencv2/imgproc/imgproc.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bcl = boost::compute; + +BOOST_AUTO_TEST_CASE(opencv_mat_to_buffer) +{ + // create opencv mat + cv::Mat mat(1, 4, CV_32F); + mat.at<float>(0, 0) = 0.0f; + mat.at<float>(0, 1) = 2.5f; + mat.at<float>(0, 2) = 4.1f; + mat.at<float>(0, 3) = 5.6f; + + // copy mat to gpu vector + bcl::vector<float> vector(4, context); + bcl::opencv_copy_mat_to_buffer(mat, vector.begin(), queue); + CHECK_RANGE_EQUAL(float, 4, vector, (0.0f, 2.5f, 4.1f, 5.6f)); + + // reverse gpu vector and copy back to mat + bcl::reverse(vector.begin(), vector.end(), queue); + bcl::opencv_copy_buffer_to_mat(vector.begin(), mat, queue); + BOOST_CHECK_EQUAL(mat.at<float>(0), 5.6f); + BOOST_CHECK_EQUAL(mat.at<float>(1), 4.1f); + BOOST_CHECK_EQUAL(mat.at<float>(2), 2.5f); + BOOST_CHECK_EQUAL(mat.at<float>(3), 0.0f); +} + +BOOST_AUTO_TEST_CASE(opencv_image_format) +{ + // 8-bit uchar BGRA + BOOST_CHECK( + bcl::opencv_get_mat_image_format(cv::Mat(32, 32, CV_8UC4)) == + bcl::image_format(CL_BGRA, CL_UNORM_INT8) + ); + + // 32-bit float + BOOST_CHECK( + bcl::opencv_get_mat_image_format(cv::Mat(32, 32, CV_32F)) == + bcl::image_format(CL_INTENSITY, CL_FLOAT) + ); + + // 32-bit float RGBA + BOOST_CHECK( + bcl::opencv_get_mat_image_format(cv::Mat(32, 32, CV_32FC4)) == + bcl::image_format(CL_RGBA, CL_FLOAT) + ); + + // 16-bit uchar BGRA + BOOST_CHECK( + bcl::opencv_get_mat_image_format(cv::Mat(32, 32, CV_16UC4)) == + bcl::image_format(CL_BGRA, CL_UNORM_INT16) + ); + + // 8-bit uchar + BOOST_CHECK( + bcl::opencv_get_mat_image_format(cv::Mat(32, 32, CV_8UC1)) == + bcl::image_format(CL_INTENSITY, CL_UNORM_INT8) + ); +} + +BOOST_AUTO_TEST_CASE(opencv_float_mat_image2d) +{ + REQUIRES_OPENCL_VERSION(1,2); + + cv::Vec4f pixel; + // create opencv mat + cv::Mat mat(2, 2, CV_32FC4, cv::Scalar(100, 150, 200, 255)); + // transfer image to gpu + bcl::image2d image = + bcl::opencv_create_image2d_with_mat( + mat, + bcl::image2d::read_only, + queue + ); + // copy the data back to cpu + bcl::opencv_copy_image_to_mat(image, mat, queue); + + pixel = mat.at<cv::Vec4f>(1,1); + BOOST_CHECK_EQUAL(pixel[0], 100.0f); + BOOST_CHECK_EQUAL(pixel[1], 150.0f); + BOOST_CHECK_EQUAL(pixel[2], 200.0f); + BOOST_CHECK_EQUAL(pixel[3], 255.0f); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/extra/test_interop_opengl.cpp b/src/boost/libs/compute/test/extra/test_interop_opengl.cpp new file mode 100644 index 00000000..876abfab --- /dev/null +++ b/src/boost/libs/compute/test/extra/test_interop_opengl.cpp @@ -0,0 +1,28 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInteropOpenGL +#include <boost/test/unit_test.hpp> + +#include <boost/compute/interop/opengl.hpp> + +BOOST_AUTO_TEST_CASE(opengl_buffer) +{ +} + +BOOST_AUTO_TEST_CASE(type_name) +{ + BOOST_CHECK_EQUAL( + boost::compute::type_name<boost::compute::opengl_texture>(), "image2d_t" + ); + BOOST_CHECK_EQUAL( + boost::compute::type_name<boost::compute::opengl_renderbuffer>(), "image2d_t" + ); +} diff --git a/src/boost/libs/compute/test/extra/test_interop_qt.cpp b/src/boost/libs/compute/test/extra/test_interop_qt.cpp new file mode 100644 index 00000000..a07f44fb --- /dev/null +++ b/src/boost/libs/compute/test/extra/test_interop_qt.cpp @@ -0,0 +1,95 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInteropQt +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/detail/is_contiguous_iterator.hpp> +#include <boost/compute/interop/qt.hpp> + +#include <QList> +#include <QVector> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bcl = boost::compute; + +BOOST_AUTO_TEST_CASE(qimage_format) +{ + BOOST_CHECK( + bcl::qt_qimage_format_to_image_format(QImage::Format_RGB32) == + bcl::image_format(CL_BGRA, CL_UNORM_INT8) + ); +} + +BOOST_AUTO_TEST_CASE(copy_qvector_to_device) +{ + QList<int> qvector; + qvector.append(0); + qvector.append(2); + qvector.append(4); + qvector.append(6); + + bcl::vector<int> vector(4, context); + bcl::copy(qvector.begin(), qvector.end(), vector.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, vector, (0, 2, 4, 6)); +} + +BOOST_AUTO_TEST_CASE(copy_qlist_to_device) +{ + QList<int> list; + list.append(1); + list.append(3); + list.append(5); + list.append(7); + + bcl::vector<int> vector(4, context); + bcl::copy(list.begin(), list.end(), vector.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, vector, (1, 3, 5, 7)); +} + +BOOST_AUTO_TEST_CASE(qvector_of_qpoint) +{ + QVector<QPoint> qt_points; + qt_points.append(QPoint(0, 1)); + qt_points.append(QPoint(2, 3)); + qt_points.append(QPoint(4, 5)); + qt_points.append(QPoint(6, 7)); + + bcl::vector<QPoint> bcl_points(qt_points.size(), context); + bcl::copy(qt_points.begin(), qt_points.end(), bcl_points.begin(), queue); +} + +BOOST_AUTO_TEST_CASE(qvector_of_qpointf) +{ + QVector<QPointF> qt_points; + qt_points.append(QPointF(0.3f, 1.7f)); + qt_points.append(QPointF(2.3f, 3.7f)); + qt_points.append(QPointF(4.3f, 5.7f)); + qt_points.append(QPointF(6.3f, 7.7f)); + + bcl::vector<QPointF> bcl_points(qt_points.size(), context); + bcl::copy(qt_points.begin(), qt_points.end(), bcl_points.begin(), queue); +} + +BOOST_AUTO_TEST_CASE(qvector_iterator) +{ + using boost::compute::detail::is_contiguous_iterator; + + BOOST_STATIC_ASSERT(is_contiguous_iterator<QVector<int>::iterator>::value == true); + BOOST_STATIC_ASSERT(is_contiguous_iterator<QVector<int>::const_iterator>::value == true); + BOOST_STATIC_ASSERT(is_contiguous_iterator<QList<int>::iterator>::value == false); + BOOST_STATIC_ASSERT(is_contiguous_iterator<QList<int>::const_iterator>::value == false); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/extra/test_interop_vtk.cpp b/src/boost/libs/compute/test/extra/test_interop_vtk.cpp new file mode 100644 index 00000000..ca98790f --- /dev/null +++ b/src/boost/libs/compute/test/extra/test_interop_vtk.cpp @@ -0,0 +1,118 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInteropVTK +#include <boost/test/unit_test.hpp> + +#include <vtkFloatArray.h> +#include <vtkMatrix4x4.h> +#include <vtkNew.h> +#include <vtkPoints.h> +#include <vtkSmartPointer.h> +#include <vtkUnsignedCharArray.h> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/detail/is_contiguous_iterator.hpp> +#include <boost/compute/interop/vtk.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(bounds) +{ + using compute::float4_; + + // create vtk points + vtkNew<vtkPoints> points; + points->InsertNextPoint(0.0, 0.0, 0.0); + points->InsertNextPoint(1.0, 2.0, 1.0); + points->InsertNextPoint(-1.0, -3.0, -1.0); + points->InsertNextPoint(0.5, 2.5, 1.5); + + // copy points to vector on gpu + compute::vector<float4_> vector(points->GetNumberOfPoints(), context); + compute::vtk_copy_points_to_buffer(points.GetPointer(), vector.begin(), queue); + + // compute bounds + double bounds[6]; + compute::vtk_compute_bounds(vector.begin(), vector.end(), bounds, queue); + + // check bounds + BOOST_CHECK_CLOSE(bounds[0], -1.0, 1e-8); + BOOST_CHECK_CLOSE(bounds[1], 1.0, 1e-8); + BOOST_CHECK_CLOSE(bounds[2], -3.0, 1e-8); + BOOST_CHECK_CLOSE(bounds[3], 2.5, 1e-8); + BOOST_CHECK_CLOSE(bounds[4], -1.0, 1e-8); + BOOST_CHECK_CLOSE(bounds[5], 1.5, 1e-8); +} + +BOOST_AUTO_TEST_CASE(copy_uchar_array) +{ + // create vtk uchar vector containing 3 RGBA colors + vtkNew<vtkUnsignedCharArray> array; + array->SetNumberOfComponents(4); + + unsigned char red[4] = { 255, 0, 0, 255 }; + array->InsertNextTupleValue(red); + unsigned char green[4] = { 0, 255, 0, 255 }; + array->InsertNextTupleValue(green); + unsigned char blue[4] = { 0, 0, 255, 255 }; + array->InsertNextTupleValue(blue); + + // create vector<uchar4> on device and copy values from vtk array + compute::vector<compute::uchar4_> vector(3, context); + compute::vtk_copy_data_array_to_buffer( + array.GetPointer(), + compute::make_buffer_iterator<compute::uchar_>(vector.get_buffer(), 0), + queue + ); + + // check values + std::vector<compute::uchar4_> host_vector(3); + compute::copy( + vector.begin(), vector.end(), host_vector.begin(), queue + ); + BOOST_CHECK(host_vector[0] == compute::uchar4_(255, 0, 0, 255)); + BOOST_CHECK(host_vector[1] == compute::uchar4_(0, 255, 0, 255)); + BOOST_CHECK(host_vector[2] == compute::uchar4_(0, 0, 255, 255)); +} + +BOOST_AUTO_TEST_CASE(sort_float_array) +{ + // create vtk float array + vtkNew<vtkFloatArray> array; + array->InsertNextValue(2.5f); + array->InsertNextValue(1.0f); + array->InsertNextValue(6.5f); + array->InsertNextValue(4.0f); + + // create vector on device and copy values from vtk array + compute::vector<float> vector(4, context); + compute::vtk_copy_data_array_to_buffer(array.GetPointer(), vector.begin(), queue); + + // sort values on the gpu + compute::sort(vector.begin(), vector.end(), queue); + CHECK_RANGE_EQUAL(float, 4, vector, (1.0f, 2.5f, 4.0f, 6.5f)); + + // copy sorted values back to the vtk array + compute::vtk_copy_buffer_to_data_array( + vector.begin(), vector.end(), array.GetPointer(), queue + ); + BOOST_CHECK_EQUAL(array->GetValue(0), 1.0f); + BOOST_CHECK_EQUAL(array->GetValue(1), 2.5f); + BOOST_CHECK_EQUAL(array->GetValue(2), 4.0f); + BOOST_CHECK_EQUAL(array->GetValue(3), 6.5f); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/extra/test_multiple_objects1.cpp b/src/boost/libs/compute/test/extra/test_multiple_objects1.cpp new file mode 100644 index 00000000..af80d7c1 --- /dev/null +++ b/src/boost/libs/compute/test/extra/test_multiple_objects1.cpp @@ -0,0 +1,21 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestMultipleObjects +#include <boost/test/unit_test.hpp> +#include <boost/compute.hpp> + +bool dummy_function(); + +BOOST_AUTO_TEST_CASE(multiple_objects) +{ + // It is enough if the test compiles. + BOOST_CHECK( dummy_function() ); +} diff --git a/src/boost/libs/compute/test/extra/test_multiple_objects2.cpp b/src/boost/libs/compute/test/extra/test_multiple_objects2.cpp new file mode 100644 index 00000000..8beb8b98 --- /dev/null +++ b/src/boost/libs/compute/test/extra/test_multiple_objects2.cpp @@ -0,0 +1,15 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <boost/compute.hpp> + +bool dummy_function() { + return true; +} diff --git a/src/boost/libs/compute/test/opencl_version_check.hpp b/src/boost/libs/compute/test/opencl_version_check.hpp new file mode 100644 index 00000000..2c7ad68a --- /dev/null +++ b/src/boost/libs/compute/test/opencl_version_check.hpp @@ -0,0 +1,20 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Denis Demidov +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#ifndef BOOST_COMPUTE_TEST_OPENCL_VERSION_CHECK_HPP +#define BOOST_COMPUTE_TEST_OPENCL_VERSION_CHECK_HPP + +#define REQUIRES_OPENCL_VERSION(major, minor) \ + if (!device.check_version(major, minor)) return + +#define REQUIRES_OPENCL_PLATFORM_VERSION(major, minor) \ + if (!device.platform().check_version(major, minor)) return + +#endif diff --git a/src/boost/libs/compute/test/quirks.hpp b/src/boost/libs/compute/test/quirks.hpp new file mode 100644 index 00000000..adffeb1f --- /dev/null +++ b/src/boost/libs/compute/test/quirks.hpp @@ -0,0 +1,128 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#ifndef BOOST_COMPUTE_TEST_QUIRKS_HPP +#define BOOST_COMPUTE_TEST_QUIRKS_HPP + +#include <boost/compute/device.hpp> +#include <boost/compute/platform.hpp> +#include <boost/compute/detail/vendor.hpp> + +// this file contains functions which check for 'quirks' or buggy +// behavior in OpenCL implementations. this allows us to skip certain +// tests when running on buggy platforms. + +// returns true if the device is a POCL device +inline bool is_pocl_device(const boost::compute::device &device) +{ + return device.platform().name() == "Portable Computing Language"; +} + +// returns true if the device is from Apple OpenCL platform +inline bool is_apple_device(const boost::compute::device &device) +{ + return device.platform().name() == "Apple"; +} + +// AMD platforms have a bug when using struct assignment. this affects +// algorithms like fill() when used with pairs/tuples. +// +// see: https://community.amd.com/thread/166622 +inline bool bug_in_struct_assignment(const boost::compute::device &device) +{ + return boost::compute::detail::is_amd_device(device); +} + +// clEnqueueSVMMemcpy() operation does not work on AMD devices. This affects +// copy() algorithm. This bug was fixed in AMD drivers for Windows. +// +// see: https://community.amd.com/thread/190585 +inline bool bug_in_svmmemcpy(const boost::compute::device &device) +{ + #ifdef _WIN32 + return false; + #else + return boost::compute::detail::is_amd_device(device); + #endif +} + +// For CPU devices on Apple platform local memory can not be used when work +// group size is not [1;1;1]. If work group size is greater "Invalid Work Group +// Size" error is thrown. (Apple OpenCL implementation can sometimes reduce +// max work group size for other reasons.) +// When local memory is not used max work group size for CPU devices on Apple +// platform should be [1024;1;1]. +inline bool is_apple_cpu_device(const boost::compute::device &device) +{ + return is_apple_device(device) && (device.type() & ::boost::compute::device::cpu); +} + +// On Apple devices clCreateBuffer does not return NULL and does no set error +// to CL_INVALID_BUFFER_SIZE when size of the buffer memory object is greater +// than CL_DEVICE_MAX_MEM_ALLOC_SIZE. +inline bool bug_in_clcreatebuffer(const boost::compute::device &device) +{ + return is_apple_device(device); +} + +// returns true if the device supports image samplers. +inline bool supports_image_samplers(const boost::compute::device &device) +{ + // POCL does not yet support image samplers and gives the following + // error when attempting to create one: + // + // pocl error: encountered unimplemented part of the OpenCL specs + // in clCreateSampler.c:28 + if(is_pocl_device(device)){ + return false; + } + + return true; +} + +// returns true if the device has remquo() built-in OpenCL function implementation +inline bool has_remquo_func(const boost::compute::device &device) +{ + // POCL does not have it + if(is_pocl_device(device)){ + return false; + } + return true; +} + +// returns true if the device supports clSetMemObjectDestructorCallback +inline bool supports_destructor_callback(const boost::compute::device &device) +{ + // unimplemented in POCL + return !is_pocl_device(device); +} + +// returns true if the device supports clCompileProgram +inline bool supports_compile_program(const boost::compute::device &device) +{ + // unimplemented in POCL + return !is_pocl_device(device); +} + +// returns true if the device supports clLinkProgram +inline bool supports_link_program(const boost::compute::device &device) +{ + // unimplemented in POCL + return !is_pocl_device(device); +} + +// See https://github.com/pocl/pocl/issues/577, POCL fails when a program +// with incorrect code is built for the 2nd time +inline bool pocl_bug_issue_577(const boost::compute::device &device) +{ + return is_pocl_device(device); +} + +#endif // BOOST_COMPUTE_TEST_QUIRKS_HPP diff --git a/src/boost/libs/compute/test/test_accumulate.cpp b/src/boost/libs/compute/test/test_accumulate.cpp new file mode 100644 index 00000000..b77c07df --- /dev/null +++ b/src/boost/libs/compute/test/test_accumulate.cpp @@ -0,0 +1,302 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestAccumulate +#include <boost/test/unit_test.hpp> + +#include <numeric> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/accumulate.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/container/mapped_view.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(sum_int) +{ + int data[] = { 2, 4, 6, 8 }; + boost::compute::vector<int> vector(data, data + 4, queue); + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 0, queue), + 20 + ); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), -10, queue), + 10 + ); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 5, queue), + 25 + ); +} + +BOOST_AUTO_TEST_CASE(product_int) +{ + int data[] = { 2, 4, 6, 8 }; + boost::compute::vector<int> vector(data, data + 4, queue); + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + vector.begin(), vector.end(), 1, boost::compute::multiplies<int>(), + queue), + 384 + ); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + vector.begin(), vector.end(), -1, boost::compute::multiplies<int>(), + queue), + -384 + ); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + vector.begin(), vector.end(), 2, boost::compute::multiplies<int>(), + queue), + 768 + ); +} + +BOOST_AUTO_TEST_CASE(quotient_int) +{ + int data[] = { 2, 8, 16 }; + boost::compute::vector<int> vector(data, data + 3, queue); + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + vector.begin(), + vector.end(), + 1024, + boost::compute::divides<int>(), + queue + ), + 4 + ); +} + +BOOST_AUTO_TEST_CASE(sum_counting_iterator) +{ + // sum 0 -> 9 + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + boost::compute::make_counting_iterator(0), + boost::compute::make_counting_iterator(10), + 0, + boost::compute::plus<int>(), + queue + ), + 45 + ); + + // sum 0 -> 9 + 7 + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + boost::compute::make_counting_iterator(0), + boost::compute::make_counting_iterator(10), + 7, + boost::compute::plus<int>(), + queue + ), + 52 + ); + + // sum 15 -> 24 + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + boost::compute::make_counting_iterator(15), + boost::compute::make_counting_iterator(25), + 0, + boost::compute::plus<int>(), + queue + ), + 195 + ); + + // sum -5 -> 10 + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + boost::compute::make_counting_iterator(-5), + boost::compute::make_counting_iterator(10), + 0, + boost::compute::plus<int>(), + queue + ), + 30 + ); + + // sum -5 -> 10 - 2 + BOOST_CHECK_EQUAL( + boost::compute::accumulate( + boost::compute::make_counting_iterator(-5), + boost::compute::make_counting_iterator(10), + -2, + boost::compute::plus<int>(), + queue + ), + 28 + ); +} + +BOOST_AUTO_TEST_CASE(sum_iota) +{ + // size 0 + boost::compute::vector<int> vector(0, context); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 0, queue), + 0 + ); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 4, queue), + 4 + ); + + // size 50 + vector.resize(50); + boost::compute::iota(vector.begin(), vector.end(), 0, queue); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 0, queue), + 1225 + ); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 11, queue), + 1236 + ); + + // size 1000 + vector.resize(1000); + boost::compute::iota(vector.begin(), vector.end(), 0, queue); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 0, queue), + 499500 + ); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), -45, queue), + 499455 + ); + + // size 1025 + vector.resize(1025); + boost::compute::iota(vector.begin(), vector.end(), 0, queue); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 0, queue), + 524800 + ); + + BOOST_CHECK_EQUAL( + boost::compute::accumulate(vector.begin(), vector.end(), 2, queue), + 524802 + ); +} + +BOOST_AUTO_TEST_CASE(min_and_max) +{ + using boost::compute::int2_; + + int data[] = { 5, 3, 1, 6, 4, 2 }; + boost::compute::vector<int> vector(data, data + 6, queue); + + BOOST_COMPUTE_FUNCTION(int2_, min_and_max, (int2_ accumulator, const int value), + { + return (int2)((min)(accumulator.x, value), (max)(accumulator.y, value)); + }); + + int2_ result = boost::compute::accumulate( + vector.begin(), vector.end(), int2_(100, -100), min_and_max, queue + ); + BOOST_CHECK_EQUAL(result[0], 1); + BOOST_CHECK_EQUAL(result[1], 6); +} + +BOOST_AUTO_TEST_CASE(min_max) +{ + float data[] = { 1.2f, 5.5f, 0.1f, 9.6f, 4.2f, 6.7f, 9.0f, 3.4f }; + boost::compute::vector<float> vec(data, data + 8, queue); + + using ::boost::compute::min; + using ::boost::compute::max; + + float min_value = boost::compute::accumulate( + vec.begin(), vec.end(), (std::numeric_limits<float>::max)(), min<float>(), queue + ); + BOOST_CHECK_EQUAL(min_value, 0.1f); + + float max_value = boost::compute::accumulate( + vec.begin(), vec.end(), (std::numeric_limits<float>::min)(), max<float>(), queue + ); + BOOST_CHECK_EQUAL(max_value, 9.6f); + + // find min with init less than any value in the array + min_value = boost::compute::accumulate( + vec.begin(), vec.end(), -1.f, min<float>(), queue + ); + BOOST_CHECK_EQUAL(min_value, -1.f); + + // find max with init greater than any value in the array + max_value = boost::compute::accumulate( + vec.begin(), vec.end(), 10.f, max<float>(), queue + ); + BOOST_CHECK_EQUAL(max_value, 10.f); +} + +template<class T> +void ensure_std_accumulate_equality(const std::vector<T> &data, + boost::compute::command_queue &queue) +{ + boost::compute::mapped_view<T> view(&data[0], data.size(), queue.get_context()); + + BOOST_CHECK_EQUAL( + std::accumulate(data.begin(), data.end(), 0), + boost::compute::accumulate(view.begin(), view.end(), 0, queue) + ); +} + +BOOST_AUTO_TEST_CASE(std_accumulate_equality) +{ + // test accumulate() with int + int data1[] = { 1, 2, 3, 4 }; + std::vector<int> vec1(data1, data1 + 4); + ensure_std_accumulate_equality(vec1, queue); + + vec1.resize(10000); + std::fill(vec1.begin(), vec1.end(), 2); + ensure_std_accumulate_equality(vec1, queue); + + // test accumulate() with float + float data2[] = { 1.2f, 2.3f, 4.5f, 6.7f, 8.9f }; + std::vector<float> vec2(data2, data2 + 5); + ensure_std_accumulate_equality(vec2, queue); + + vec2.resize(10000); + std::fill(vec2.begin(), vec2.end(), 1.01f); + ensure_std_accumulate_equality(vec2, queue); + + // test accumulate() with double + if(device.supports_extension("cl_khr_fp64")){ + double data3[] = { 1.2, 2.3, 4.5, 6.7, 8.9 }; + std::vector<double> vec3(data3, data3 + 5); + ensure_std_accumulate_equality(vec3, queue); + + vec3.resize(10000); + std::fill(vec3.begin(), vec3.end(), 2.02); + ensure_std_accumulate_equality(vec3, queue); + } +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_adjacent_difference.cpp b/src/boost/libs/compute/test/test_adjacent_difference.cpp new file mode 100644 index 00000000..0fca4dab --- /dev/null +++ b/src/boost/libs/compute/test/test_adjacent_difference.cpp @@ -0,0 +1,102 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestAdjacentDifference +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/all_of.hpp> +#include <boost/compute/algorithm/adjacent_difference.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(adjacent_difference_int) +{ + using compute::int_; + + compute::vector<int_> a(5, context); + compute::iota(a.begin(), a.end(), 0, queue); + CHECK_RANGE_EQUAL(int_, 5, a, (0, 1, 2, 3, 4)); + + compute::vector<int_> b(5, context); + compute::vector<int_>::iterator iter = + compute::adjacent_difference(a.begin(), a.end(), b.begin(), queue); + BOOST_CHECK(iter == b.end()); + CHECK_RANGE_EQUAL(int_, 5, b, (0, 1, 1, 1, 1)); + + int_ data[] = { 1, 9, 36, 48, 81 }; + compute::copy(data, data + 5, a.begin(), queue); + CHECK_RANGE_EQUAL(int_, 5, a, (1, 9, 36, 48, 81)); + + iter = compute::adjacent_difference(a.begin(), a.end(), b.begin(), queue); + BOOST_CHECK(iter == b.end()); + CHECK_RANGE_EQUAL(int_, 5, b, (1, 8, 27, 12, 33)); +} + +BOOST_AUTO_TEST_CASE(adjacent_difference_first_eq_last) +{ + using compute::int_; + + compute::vector<int_> a(size_t(5), int_(1), queue); + compute::vector<int_> b(size_t(5), int_(0), queue); + compute::vector<int_>::iterator iter = + compute::adjacent_difference(a.begin(), a.begin(), b.begin(), queue); + BOOST_CHECK(iter == b.begin()); + CHECK_RANGE_EQUAL(int_, 5, b, (0, 0, 0, 0, 0)); +} + +BOOST_AUTO_TEST_CASE(adjacent_difference_first_eq_result) +{ + using compute::int_; + + compute::vector<int_> a(5, context); + compute::iota(a.begin(), a.end(), 0, queue); + CHECK_RANGE_EQUAL(int_, 5, a, (0, 1, 2, 3, 4)); + + compute::vector<int_>::iterator iter = + compute::adjacent_difference(a.begin(), a.end(), a.begin(), queue); + BOOST_CHECK(iter == a.end()); + CHECK_RANGE_EQUAL(int_, 5, a, (0, 1, 1, 1, 1)); +} + +BOOST_AUTO_TEST_CASE(all_same) +{ + using compute::int_; + + compute::vector<int_> input(1000, context); + compute::fill(input.begin(), input.end(), 42, queue); + + compute::vector<int_> output(input.size(), context); + + compute::adjacent_difference( + input.begin(), input.end(), output.begin(), queue + ); + + int_ first; + compute::copy_n(output.begin(), 1, &first, queue); + BOOST_CHECK_EQUAL(first, 42); + + using compute::lambda::_1; + + BOOST_CHECK( + compute::all_of(output.begin() + 1, output.end(), _1 == 0, queue) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_adjacent_find.cpp b/src/boost/libs/compute/test/test_adjacent_find.cpp new file mode 100644 index 00000000..bfb864e4 --- /dev/null +++ b/src/boost/libs/compute/test/test_adjacent_find.cpp @@ -0,0 +1,68 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestAdjacentFind +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/adjacent_find.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(adjacent_find_int) +{ + int data[] = { 1, 3, 5, 5, 6, 7, 7, 8 }; + compute::vector<int> vec(data, data + 8, queue); + + compute::vector<int>::iterator iter = + compute::adjacent_find(vec.begin(), vec.end(), queue); + BOOST_CHECK(iter == vec.begin() + 2); +} + +BOOST_AUTO_TEST_CASE(adjacent_find_int2) +{ + using compute::int2_; + + compute::vector<int2_> vec(context); + vec.push_back(int2_(1, 2), queue); + vec.push_back(int2_(3, 4), queue); + vec.push_back(int2_(5, 6), queue); + vec.push_back(int2_(7, 8), queue); + vec.push_back(int2_(7, 8), queue); + + compute::vector<int2_>::iterator iter = + compute::adjacent_find(vec.begin(), vec.end(), queue); + BOOST_CHECK(iter == vec.begin() + 3); +} + +BOOST_AUTO_TEST_CASE(adjacent_find_iota) +{ + compute::vector<int> vec(2048, context); + compute::iota(vec.begin(), vec.end(), 1, queue); + BOOST_VERIFY( + compute::adjacent_find(vec.begin(), vec.end(), queue) == vec.end() + ); +} + +BOOST_AUTO_TEST_CASE(adjacent_find_fill) +{ + compute::vector<int> vec(2048, context); + compute::fill(vec.begin(), vec.end(), 7, queue); + BOOST_VERIFY( + compute::adjacent_find(vec.begin(), vec.end(), queue) == vec.begin() + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_amd_cpp_kernel_language.cpp b/src/boost/libs/compute/test/test_amd_cpp_kernel_language.cpp new file mode 100644 index 00000000..4a3c31f8 --- /dev/null +++ b/src/boost/libs/compute/test/test_amd_cpp_kernel_language.cpp @@ -0,0 +1,68 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestAmdCppKernel +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/kernel.hpp> +#include <boost/compute/program.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/detail/vendor.hpp> +#include <boost/compute/utility/source.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(amd_template_function) +{ + if(!compute::detail::is_amd_device(device)){ + std::cerr << "skipping amd_template_function test: c++ static kernel " + "language is only supported on AMD devices." << std::endl; + return; + } + + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + template<typename T> + inline T square(const T x) + { + return x * x; + } + + template<typename T> + __kernel void square_kernel(__global T *data) + { + const uint i = get_global_id(0); + data[i] = square(data[i]); + } + + template __attribute__((mangled_name(square_kernel_int))) + __kernel void square_kernel(__global int *data); + ); + + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vec(data, data + 4, queue); + + compute::program square_program = + compute::program::build_with_source(source, context, "-x clc++"); + + compute::kernel square_kernel(square_program, "square_kernel_int"); + square_kernel.set_arg(0, vec); + + queue.enqueue_1d_range_kernel(square_kernel, 0, vec.size(), 4); + + CHECK_RANGE_EQUAL(int, 4, vec, (1, 4, 9, 16)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_any_all_none_of.cpp b/src/boost/libs/compute/test/test_any_all_none_of.cpp new file mode 100644 index 00000000..29391af3 --- /dev/null +++ b/src/boost/libs/compute/test/test_any_all_none_of.cpp @@ -0,0 +1,89 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestAnyAllNoneOf +#include <boost/test/unit_test.hpp> + +#include <limits> +#include <cmath> + +#include <boost/compute/lambda.hpp> +#include <boost/compute/algorithm/all_of.hpp> +#include <boost/compute/algorithm/any_of.hpp> +#include <boost/compute/algorithm/none_of.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(any_all_none_of) +{ + int data[] = { 1, 2, 3, 4, 5, 6 }; + bc::vector<int> v(data, data + 6, queue); + + using ::boost::compute::_1; + + BOOST_CHECK(bc::any_of(v.begin(), v.end(), _1 == 6) == true); + BOOST_CHECK(bc::any_of(v.begin(), v.end(), _1 == 9) == false); + BOOST_CHECK(bc::none_of(v.begin(), v.end(), _1 == 6) == false); + BOOST_CHECK(bc::none_of(v.begin(), v.end(), _1 == 9) == true); + BOOST_CHECK(bc::all_of(v.begin(), v.end(), _1 == 6) == false); + BOOST_CHECK(bc::all_of(v.begin(), v.end(), _1 < 9) == true); + BOOST_CHECK(bc::all_of(v.begin(), v.end(), _1 < 6) == false); + BOOST_CHECK(bc::all_of(v.begin(), v.end(), _1 >= 1) == true); +} + +BOOST_AUTO_TEST_CASE(any_nan_inf) +{ + using ::boost::compute::_1; + using ::boost::compute::lambda::isinf; + using ::boost::compute::lambda::isnan; + using ::boost::compute::lambda::isfinite; + + float nan = std::sqrt(-1.f); + float inf = std::numeric_limits<float>::infinity(); + + float data[] = { 1.2f, 2.3f, nan, nan, 3.4f, inf, 4.5f, inf }; + compute::vector<float> vector(data, data + 8, queue); + + BOOST_CHECK(compute::any_of(vector.begin(), vector.end(), + isinf(_1) || isnan(_1), queue) == true); + BOOST_CHECK(compute::any_of(vector.begin(), vector.end(), + isfinite(_1), queue) == true); + BOOST_CHECK(compute::all_of(vector.begin(), vector.end(), + isfinite(_1), queue) == false); + BOOST_CHECK(compute::all_of(vector.begin(), vector.begin() + 2, + isfinite(_1), queue) == true); + BOOST_CHECK(compute::all_of(vector.begin() + 2, vector.begin() + 4, + isnan(_1), queue) == true); + BOOST_CHECK(compute::none_of(vector.begin(), vector.end(), + isinf(_1), queue) == false); + BOOST_CHECK(compute::none_of(vector.begin(), vector.begin() + 4, + isinf(_1), queue) == true); +} + +BOOST_AUTO_TEST_CASE(any_of_doctest) +{ + using boost::compute::lambda::_1; + + int data[] = { 1, 2, 3, 4 }; + boost::compute::vector<int> v(data, data + 4, queue); + + bool result = +//! [any_of] +boost::compute::any_of(v.begin(), v.end(), _1 < 0, queue); +//! [any_of] + + BOOST_CHECK(result == false); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_array.cpp b/src/boost/libs/compute/test/test_array.cpp new file mode 100644 index 00000000..7b203f76 --- /dev/null +++ b/src/boost/libs/compute/test/test_array.cpp @@ -0,0 +1,87 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestArray +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/array.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(concept_check) +{ + BOOST_CONCEPT_ASSERT((boost::Container<boost::compute::array<int, 3> >)); +// BOOST_CONCEPT_ASSERT((boost::SequenceConcept<boost::compute::array<int, 3> >)); + BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<boost::compute::array<int, 3>::iterator>)); + BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<boost::compute::array<int, 3>::const_iterator>)); +} + +BOOST_AUTO_TEST_CASE(size) +{ + boost::compute::array<int, 0> empty_array(context); + BOOST_CHECK_EQUAL(empty_array.size(), size_t(0)); + + boost::compute::array<int, 10> array10(context); + BOOST_CHECK_EQUAL(array10.size(), size_t(10)); +} + +BOOST_AUTO_TEST_CASE(at) +{ + boost::compute::array<int, 3> array(context); + array[0] = 3; + array[1] = -2; + array[2] = 5; + BOOST_CHECK_EQUAL(array.at(0), 3); + BOOST_CHECK_EQUAL(array.at(1), -2); + BOOST_CHECK_EQUAL(array.at(2), 5); + BOOST_CHECK_THROW(array.at(3), std::out_of_range); +} + +BOOST_AUTO_TEST_CASE(copy_from_vector) +{ + int data[] = { 3, 6, 9, 12 }; + boost::compute::vector<int> vector(data, data + 4, queue); + + boost::compute::array<int, 4> array(context); + boost::compute::copy(vector.begin(), vector.end(), array.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, array, (3, 6, 9, 12)); +} + +BOOST_AUTO_TEST_CASE(fill) +{ + boost::compute::array<int, 4> array(context); + array.fill(0); + CHECK_RANGE_EQUAL(int, 4, array, (0, 0, 0, 0)); + + array.fill(17); + CHECK_RANGE_EQUAL(int, 4, array, (17, 17, 17, 17)); +} + +BOOST_AUTO_TEST_CASE(swap) +{ + int data[] = { 1, 2, 6, 9 }; + boost::compute::array<int, 4> a(context); + boost::compute::copy(data, data + 4, a.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, a, (1, 2, 6, 9)); + + boost::compute::array<int, 4> b(context); + b.fill(3); + CHECK_RANGE_EQUAL(int, 4, b, (3, 3, 3, 3)); + + a.swap(b); + CHECK_RANGE_EQUAL(int, 4, a, (3, 3, 3, 3)); + CHECK_RANGE_EQUAL(int, 4, b, (1, 2, 6, 9)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_async_wait.cpp b/src/boost/libs/compute/test/test_async_wait.cpp new file mode 100644 index 00000000..0b9eebab --- /dev/null +++ b/src/boost/libs/compute/test/test_async_wait.cpp @@ -0,0 +1,72 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestAsyncWait +#include <boost/test/unit_test.hpp> + +#include <boost/compute/async/future.hpp> +#include <boost/compute/async/wait.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(empty) +{ +} + +#ifndef BOOST_COMPUTE_NO_VARIADIC_TEMPLATES +BOOST_AUTO_TEST_CASE(wait_for_copy) +{ + // wait list + compute::wait_list events; + + // create host data array + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + + // create vector on the device + compute::vector<int> vector(8, context); + + // fill vector with 9's + compute::future<void> fill_future = + compute::fill_async(vector.begin(), vector.end(), 9, queue); + + // wait for fill() to complete + compute::wait_for_all(fill_future); + + // check data on the device + CHECK_RANGE_EQUAL(int, 8, vector, (9, 9, 9, 9, 9, 9, 9, 9)); + + // copy each pair of values independently and asynchronously + compute::event copy1 = queue.enqueue_write_buffer_async( + vector.get_buffer(), 0 * sizeof(int), 2 * sizeof(int), data + 0 + ); + compute::event copy2 = queue.enqueue_write_buffer_async( + vector.get_buffer(), 2 * sizeof(int), 2 * sizeof(int), data + 2 + ); + compute::event copy3 = queue.enqueue_write_buffer_async( + vector.get_buffer(), 4 * sizeof(int), 2 * sizeof(int), data + 4 + ); + compute::event copy4 = queue.enqueue_write_buffer_async( + vector.get_buffer(), 6 * sizeof(int), 2 * sizeof(int), data + 6 + ); + + // wait for all copies to complete + compute::wait_for_all(copy1, copy2, copy3, copy4); + + // check data on the device + CHECK_RANGE_EQUAL(int, 8, vector, (1, 2, 3, 4, 5, 6, 7, 8)); +} +#endif // BOOST_COMPUTE_NO_VARIADIC_TEMPLATES + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_async_wait_guard.cpp b/src/boost/libs/compute/test/test_async_wait_guard.cpp new file mode 100644 index 00000000..626d25bb --- /dev/null +++ b/src/boost/libs/compute/test/test_async_wait_guard.cpp @@ -0,0 +1,51 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestAsyncWaitGuard +#include <boost/test/unit_test.hpp> + +#include <boost/compute/async/future.hpp> +#include <boost/compute/async/wait_guard.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +static size_t wait_num = 0; + +struct waitable_object +{ + void wait() + { + wait_num++; + } +}; + +BOOST_AUTO_TEST_CASE(wait_guard_test) +{ + waitable_object waitable; + + BOOST_CHECK(wait_num == 0); + { + compute::wait_guard<waitable_object> waitable_object_guard(waitable); + } + BOOST_CHECK(wait_num == 1); + { + compute::wait_guard<waitable_object> waitable_object_guard1(waitable); + compute::wait_guard<waitable_object> waitable_object_guard2(waitable); + } + BOOST_CHECK(wait_num == 3); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_bernoulli_distribution.cpp b/src/boost/libs/compute/test/test_bernoulli_distribution.cpp new file mode 100644 index 00000000..3172a83a --- /dev/null +++ b/src/boost/libs/compute/test/test_bernoulli_distribution.cpp @@ -0,0 +1,39 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestBernoulliDistribution +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/bernoulli_distribution.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(bernoulli_distribution_doctest) +{ + boost::compute::vector<bool> vec(10, context); + +//! [generate] +// initialize the default random engine +boost::compute::default_random_engine engine(queue); + +// setup the bernoulli distribution to produce booleans +// with parameter p = 0.25 +boost::compute::bernoulli_distribution<float> distribution(0.25f); + +// generate the random values and store them to 'vec' +distribution.generate(vec.begin(), vec.end(), engine, queue); +//! [generate] +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_binary_search.cpp b/src/boost/libs/compute/test/test_binary_search.cpp new file mode 100644 index 00000000..43e4fcff --- /dev/null +++ b/src/boost/libs/compute/test/test_binary_search.cpp @@ -0,0 +1,102 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestBinarySearch +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/binary_search.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/lower_bound.hpp> +#include <boost/compute/algorithm/upper_bound.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(binary_search_int) +{ + // test data = { 1, ..., 2, ..., 4, 4, 5, 7, ..., 9, ..., 10 } + boost::compute::vector<int> vector(size_t(4096), int(1), queue); + boost::compute::vector<int>::iterator first = vector.begin() + 128; + boost::compute::vector<int>::iterator last = first + (1024 - 128); + boost::compute::fill(first, last, int(2), queue); + last.write(4, queue); last++; + last.write(4, queue); last++; + last.write(5, queue); last++; + first = last; + last = first + 127; + boost::compute::fill(first, last, 7, queue); + first = last; + last = vector.end() - 1; + boost::compute::fill(first, last, 9, queue); + last.write(10, queue); + queue.finish(); + + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(0), queue) == false); + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(1), queue) == true); + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(2), queue) == true); + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(3), queue) == false); + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(4), queue) == true); + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(5), queue) == true); + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(6), queue) == false); + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(7), queue) == true); + BOOST_CHECK(boost::compute::binary_search(vector.begin(), vector.end(), int(8), queue) == false); +} + +BOOST_AUTO_TEST_CASE(range_bounds_int) +{ + // test data = { 1, ..., 2, ..., 4, 4, 5, 7, ..., 9, ..., 10 } + boost::compute::vector<int> vector(size_t(4096), int(1), queue); + boost::compute::vector<int>::iterator first = vector.begin() + 128; + boost::compute::vector<int>::iterator last = first + (1024 - 128); + boost::compute::fill(first, last, int(2), queue); + last.write(4, queue); last++; // 1024 + last.write(4, queue); last++; // 1025 + last.write(5, queue); last++; // 1026 + first = last; + last = first + 127; + boost::compute::fill(first, last, 7, queue); + first = last; + last = vector.end() - 1; + boost::compute::fill(first, last, 9, queue); + last.write(10, queue); + queue.finish(); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(0), queue) == vector.begin()); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(0), queue) == vector.begin()); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(1), queue) == vector.begin()); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(1), queue) == vector.begin() + 128); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(2), queue) == vector.begin() + 128); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(2), queue) == vector.begin() + 1024); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(4), queue) == vector.begin() + 1024); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(4), queue) == vector.begin() + 1026); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(5), queue) == vector.begin() + 1026); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(5), queue) == vector.begin() + 1027); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(6), queue) == vector.begin() + 1027); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(6), queue) == vector.begin() + 1027); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(7), queue) == vector.begin() + 1027); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(7), queue) == vector.begin() + (1027 + 127)); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(9), queue) == vector.begin() + (1027 + 127)); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(9), queue) == vector.end() - 1); + + BOOST_CHECK(boost::compute::lower_bound(vector.begin(), vector.end(), int(10), queue) == vector.end() - 1); + BOOST_CHECK(boost::compute::upper_bound(vector.begin(), vector.end(), int(10), queue) == vector.end()); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_buffer.cpp b/src/boost/libs/compute/test/test_buffer.cpp new file mode 100644 index 00000000..e86c41be --- /dev/null +++ b/src/boost/libs/compute/test/test_buffer.cpp @@ -0,0 +1,213 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestBuffer +#include <boost/test/unit_test.hpp> + +#include <boost/compute/buffer.hpp> +#include <boost/compute/system.hpp> +#include <boost/bind.hpp> + +#ifdef BOOST_COMPUTE_USE_CPP11 +#include <mutex> +#include <future> +#endif // BOOST_COMPUTE_USE_CPP11 + +#include "quirks.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(size) +{ + bc::buffer buffer(context, 100); + BOOST_CHECK_EQUAL(buffer.size(), size_t(100)); + BOOST_VERIFY(buffer.max_size() > buffer.size()); +} + +BOOST_AUTO_TEST_CASE(cl_context) +{ + bc::buffer buffer(context, 100); + BOOST_VERIFY(buffer.get_context() == context); +} + +BOOST_AUTO_TEST_CASE(equality_operator) +{ + bc::buffer a(context, 10); + bc::buffer b(context, 10); + BOOST_VERIFY(a == a); + BOOST_VERIFY(b == b); + BOOST_VERIFY(!(a == b)); + BOOST_VERIFY(a != b); + + a = b; + BOOST_VERIFY(a == b); + BOOST_VERIFY(!(a != b)); +} + +BOOST_AUTO_TEST_CASE(construct_from_cl_mem) +{ + // create cl_mem + cl_mem mem = clCreateBuffer(context, CL_MEM_READ_WRITE, 16, 0, 0); + BOOST_VERIFY(mem); + + // create boost::compute::buffer + boost::compute::buffer buffer(mem); + + // check buffer + BOOST_CHECK(buffer.get() == mem); + BOOST_CHECK(buffer.get_context() == context); + BOOST_CHECK_EQUAL(buffer.size(), size_t(16)); + + // cleanup cl_mem + clReleaseMemObject(mem); +} + +BOOST_AUTO_TEST_CASE(reference_count) +{ + using boost::compute::uint_; + + boost::compute::buffer buf(context, 16); + BOOST_CHECK_GE(buf.reference_count(), uint_(1)); +} + +BOOST_AUTO_TEST_CASE(get_size) +{ + boost::compute::buffer buf(context, 16); + BOOST_CHECK_EQUAL(buf.size(), size_t(16)); + BOOST_CHECK_EQUAL(buf.get_info<CL_MEM_SIZE>(), size_t(16)); + BOOST_CHECK_EQUAL(buf.get_info<size_t>(CL_MEM_SIZE), size_t(16)); +} + +#ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES +BOOST_AUTO_TEST_CASE(move_constructor) +{ + boost::compute::buffer buffer1(context, 16); + BOOST_CHECK(buffer1.get() != 0); + BOOST_CHECK_EQUAL(buffer1.size(), size_t(16)); + + boost::compute::buffer buffer2(std::move(buffer1)); + BOOST_CHECK(buffer1.get() == 0); + BOOST_CHECK(buffer2.get() != 0); + BOOST_CHECK_EQUAL(buffer2.size(), size_t(16)); +} +#endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES + +BOOST_AUTO_TEST_CASE(clone_buffer) +{ + boost::compute::buffer buffer1(context, 16); + boost::compute::buffer buffer2 = buffer1.clone(queue); + BOOST_CHECK(buffer1.get() != buffer2.get()); + BOOST_CHECK_EQUAL(buffer1.size(), buffer2.size()); + BOOST_CHECK(buffer1.get_memory_flags() == buffer2.get_memory_flags()); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_1_1 +#ifdef BOOST_COMPUTE_USE_CPP11 +std::mutex callback_mutex; +std::condition_variable callback_condition_variable; + +static void BOOST_COMPUTE_CL_CALLBACK +destructor_callback_function(cl_mem, void *user_data) +{ + std::lock_guard<std::mutex> lock(callback_mutex); + + bool *flag = static_cast<bool *>(user_data); + *flag = true; + + callback_condition_variable.notify_one(); +} + +BOOST_AUTO_TEST_CASE(destructor_callback) +{ + REQUIRES_OPENCL_VERSION(1,2); + + if(!supports_destructor_callback(device)) + { + return; + } + + bool invoked = false; + { + boost::compute::buffer buf(context, 128); + buf.set_destructor_callback(destructor_callback_function, &invoked); + } + + std::unique_lock<std::mutex> lock(callback_mutex); + callback_condition_variable.wait_for( + lock, std::chrono::seconds(1), [&](){ return invoked; } + ); + BOOST_CHECK(invoked == true); +} + +static void BOOST_COMPUTE_CL_CALLBACK +destructor_templated_callback_function(bool *flag) +{ + std::lock_guard<std::mutex> lock(callback_mutex); + *flag = true; + callback_condition_variable.notify_one(); +} + +BOOST_AUTO_TEST_CASE(destructor_templated_callback) +{ + REQUIRES_OPENCL_VERSION(1,2); + + if(!supports_destructor_callback(device)) + { + return; + } + + bool invoked = false; + { + boost::compute::buffer buf(context, 128); + buf.set_destructor_callback(boost::bind(destructor_templated_callback_function, &invoked)); + } + + std::unique_lock<std::mutex> lock(callback_mutex); + callback_condition_variable.wait_for( + lock, std::chrono::seconds(1), [&](){ return invoked; } + ); + + BOOST_CHECK(invoked == true); +} + +#endif // BOOST_COMPUTE_USE_CPP11 + +BOOST_AUTO_TEST_CASE(create_subbuffer) +{ + REQUIRES_OPENCL_VERSION(1, 1); + + size_t base_addr_align = device.get_info<CL_DEVICE_MEM_BASE_ADDR_ALIGN>() / 8; + size_t multiplier = 16; + size_t buffer_size = base_addr_align * multiplier; + size_t subbuffer_size = 64; + boost::compute::buffer buffer(context, buffer_size); + + for(size_t i = 0; i < multiplier; ++i) + { + boost::compute::buffer subbuffer = buffer.create_subbuffer( + boost::compute::buffer::read_write, base_addr_align * i, subbuffer_size); + BOOST_CHECK(buffer.get() != subbuffer.get()); + BOOST_CHECK_EQUAL(subbuffer.size(), subbuffer_size); + } +} + +#endif // BOOST_COMPUTE_CL_VERSION_1_1 + +BOOST_AUTO_TEST_CASE(create_buffer_doctest) +{ +//! [constructor] +boost::compute::buffer buf(context, 32 * sizeof(float)); +//! [constructor] + + BOOST_CHECK_EQUAL(buf.size(), 32 * sizeof(float)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_buffer_allocator.cpp b/src/boost/libs/compute/test/test_buffer_allocator.cpp new file mode 100644 index 00000000..abc8c6aa --- /dev/null +++ b/src/boost/libs/compute/test/test_buffer_allocator.cpp @@ -0,0 +1,29 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestBufferAllocator +#include <boost/test/unit_test.hpp> + +#include <boost/compute/allocator/buffer_allocator.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(allocate) +{ + compute::buffer_allocator<int> allocator(context); + + typedef compute::buffer_allocator<int>::pointer pointer; + pointer x = allocator.allocate(10); + allocator.deallocate(x, 10); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_buffer_iterator.cpp b/src/boost/libs/compute/test/test_buffer_iterator.cpp new file mode 100644 index 00000000..eb448188 --- /dev/null +++ b/src/boost/libs/compute/test/test_buffer_iterator.cpp @@ -0,0 +1,69 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestBufferIterator +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/reverse.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/buffer_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(value_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + compute::buffer_iterator<int>::value_type, int + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + compute::buffer_iterator<float>::value_type, float + >::value + )); +} + +BOOST_AUTO_TEST_CASE(reverse_external_buffer_doctest) +{ + int data[] = { 1, 2, 3 }; + compute::buffer buffer(context, 3 * sizeof(int)); + queue.enqueue_write_buffer(buffer, 0, 3 * sizeof(int), data); + + cl_mem external_mem_obj = buffer.get(); + +//! [reverse_external_buffer] +// create a buffer object wrapping the cl_mem object +boost::compute::buffer buf(external_mem_obj); + +// reverse the values in the buffer +boost::compute::reverse( + boost::compute::make_buffer_iterator<int>(buf, 0), + boost::compute::make_buffer_iterator<int>(buf, 3), + queue +); +//! [reverse_external_buffer] + + queue.enqueue_read_buffer(buf, 0, 3 * sizeof(int), data); + BOOST_CHECK_EQUAL(data[0], 3); + BOOST_CHECK_EQUAL(data[1], 2); + BOOST_CHECK_EQUAL(data[2], 1); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_clamp_range.cpp b/src/boost/libs/compute/test/test_clamp_range.cpp new file mode 100644 index 00000000..985ae2d6 --- /dev/null +++ b/src/boost/libs/compute/test/test_clamp_range.cpp @@ -0,0 +1,43 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestClampRange +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/experimental/clamp_range.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(clamp_float_range) +{ + float data[] = { 1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f }; + compute::vector<float> input(data, data + 8, queue); + + compute::vector<float> result(8, context); + compute::experimental::clamp_range( + input.begin(), + input.end(), + result.begin(), + 3.f, // low + 6.f, // high + queue + ); + CHECK_RANGE_EQUAL( + float, 8, result, + (3.f, 3.f, 3.f, 4.f, 5.f, 6.f, 6.f, 6.f) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_closure.cpp b/src/boost/libs/compute/test/test_closure.cpp new file mode 100644 index 00000000..0747cec7 --- /dev/null +++ b/src/boost/libs/compute/test/test_closure.cpp @@ -0,0 +1,223 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestClosure +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/closure.hpp> +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/algorithm/transform_reduce.hpp> +#include <boost/compute/container/array.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(add_two) +{ + int two = 2; + BOOST_COMPUTE_CLOSURE(int, add_two, (int x), (two), + { + return x + two; + }); + + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vector(data, data + 4, queue); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), add_two, queue + ); + CHECK_RANGE_EQUAL(int, 4, vector, (3, 4, 5, 6)); +} + +BOOST_AUTO_TEST_CASE(add_two_and_pi) +{ + int two = 2; + float pi = 3.14f; + BOOST_COMPUTE_CLOSURE(float, add_two_and_pi, (float x), (two, pi), + { + return x + two + pi; + }); + + float data[] = { 1.9f, 2.2f, 3.4f, 4.7f }; + compute::vector<float> vector(data, data + 4, queue); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), add_two_and_pi, queue + ); + + std::vector<float> results(4); + compute::copy(vector.begin(), vector.end(), results.begin(), queue); + BOOST_CHECK_CLOSE(results[0], 7.04f, 1e-6); + BOOST_CHECK_CLOSE(results[1], 7.34f, 1e-6); + BOOST_CHECK_CLOSE(results[2], 8.54f, 1e-6); + BOOST_CHECK_CLOSE(results[3], 9.84f, 1e-6); +} + +BOOST_AUTO_TEST_CASE(add_y) +{ + // setup input and output vectors + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> input(data, data + 4, queue); + compute::vector<int> output(4, context); + + // make closure which adds 'y' to each value + int y = 2; + BOOST_COMPUTE_CLOSURE(int, add_y, (int x), (y), + { + return x + y; + }); + + compute::transform( + input.begin(), input.end(), output.begin(), add_y, queue + ); + CHECK_RANGE_EQUAL(int, 4, output, (3, 4, 5, 6)); + + // change y and run again + y = 4; + + compute::transform( + input.begin(), input.end(), output.begin(), add_y, queue + ); + CHECK_RANGE_EQUAL(int, 4, output, (5, 6, 7, 8)); +} + +BOOST_AUTO_TEST_CASE(scale_add_vec) +{ + const int N = 10; + float s = 4.5; + compute::vector<float> a(N, context); + compute::vector<float> b(N, context); + a.assign(N, 1.0f, queue); + b.assign(N, 2.0f, queue); + + BOOST_COMPUTE_CLOSURE(float, scaleAddVec, (float b, float a), (s), + { + return b * s + a; + }); + compute::transform(b.begin(), b.end(), a.begin(), b.begin(), scaleAddVec, queue); +} + +BOOST_AUTO_TEST_CASE(capture_vector) +{ + int data[] = { 6, 7, 8, 9 }; + compute::vector<int> vec(data, data + 4, queue); + + BOOST_COMPUTE_CLOSURE(int, get_vec, (int i), (vec), + { + return vec[i]; + }); + + // run using a counting iterator to copy from vec to output + compute::vector<int> output(4, context); + compute::transform( + compute::make_counting_iterator(0), + compute::make_counting_iterator(4), + output.begin(), + get_vec, + queue + ); + CHECK_RANGE_EQUAL(int, 4, output, (6, 7, 8, 9)); + + // fill vec with 4's and run again + compute::fill(vec.begin(), vec.end(), 4, queue); + compute::transform( + compute::make_counting_iterator(0), + compute::make_counting_iterator(4), + output.begin(), + get_vec, + queue + ); + CHECK_RANGE_EQUAL(int, 4, output, (4, 4, 4, 4)); +} + +BOOST_AUTO_TEST_CASE(capture_array) +{ + int data[] = { 1, 2, 3, 4 }; + compute::array<int, 4> array(context); + compute::copy(data, data + 4, array.begin(), queue); + + BOOST_COMPUTE_CLOSURE(int, negative_array_value, (int i), (array), + { + return -array[i]; + }); + + compute::vector<int> output(4, context); + compute::transform( + compute::make_counting_iterator(0), + compute::make_counting_iterator(4), + output.begin(), + negative_array_value, + queue + ); + CHECK_RANGE_EQUAL(int, 4, output, (-1, -2, -3, -4)); +} + +BOOST_AUTO_TEST_CASE(triangle_area) +{ + using compute::uint4_; + using compute::float4_; + + compute::vector<uint4_> triangle_indices(context); + compute::vector<float4_> triangle_vertices(context); + + triangle_vertices.push_back(float4_(0, 0, 0, 1), queue); + triangle_vertices.push_back(float4_(1, 1, 0, 1), queue); + triangle_vertices.push_back(float4_(1, 0, 0, 1), queue); + triangle_vertices.push_back(float4_(2, 0, 0, 1), queue); + + triangle_indices.push_back(uint4_(0, 1, 2, 0), queue); + triangle_indices.push_back(uint4_(2, 1, 3, 0), queue); + + queue.finish(); + + BOOST_COMPUTE_CLOSURE(float, triangle_area, (const uint4_ i), (triangle_vertices), + { + // load triangle vertices + const float4 a = triangle_vertices[i.x]; + const float4 b = triangle_vertices[i.y]; + const float4 c = triangle_vertices[i.z]; + + // return area of triangle + return length(cross(b-a, c-a)) / 2; + }); + + // compute area of each triangle + compute::vector<float> triangle_areas(triangle_indices.size(), context); + + compute::transform( + triangle_indices.begin(), + triangle_indices.end(), + triangle_areas.begin(), + triangle_area, + queue + ); + + // compute total area of all triangles + float total_area = 0; + + compute::transform_reduce( + triangle_indices.begin(), + triangle_indices.end(), + &total_area, + triangle_area, + compute::plus<float>(), + queue + ); + BOOST_CHECK_CLOSE(total_area, 1.f, 1e-6); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_command_queue.cpp b/src/boost/libs/compute/test/test_command_queue.cpp new file mode 100644 index 00000000..dc409795 --- /dev/null +++ b/src/boost/libs/compute/test/test_command_queue.cpp @@ -0,0 +1,352 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestCommandQueue +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/kernel.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/program.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/utility/dim.hpp> +#include <boost/compute/utility/source.hpp> +#include <boost/compute/detail/diagnostic.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(get_context) +{ + BOOST_VERIFY(queue.get_context() == context); + BOOST_VERIFY(queue.get_info<CL_QUEUE_CONTEXT>() == context.get()); +} + +BOOST_AUTO_TEST_CASE(get_device) +{ + BOOST_VERIFY(queue.get_info<CL_QUEUE_DEVICE>() == device.get()); +} + +BOOST_AUTO_TEST_CASE(equality_operator) +{ + compute::command_queue queue1(context, device); + BOOST_CHECK(queue1 == queue1); + + compute::command_queue queue2 = queue1; + BOOST_CHECK(queue1 == queue2); + + compute::command_queue queue3(context, device); + BOOST_CHECK(queue1 != queue3); +} + +BOOST_AUTO_TEST_CASE(event_profiling) +{ + bc::command_queue queue(context, device, bc::command_queue::enable_profiling); + + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + bc::buffer buffer(context, sizeof(data)); + + bc::event event = + queue.enqueue_write_buffer_async(buffer, + 0, + sizeof(data), + static_cast<const void *>(data)); + queue.finish(); + + event.get_profiling_info<cl_ulong>(bc::event::profiling_command_queued); + event.get_profiling_info<cl_ulong>(bc::event::profiling_command_submit); + event.get_profiling_info<cl_ulong>(bc::event::profiling_command_start); + event.get_profiling_info<cl_ulong>(bc::event::profiling_command_end); +} + +BOOST_AUTO_TEST_CASE(kernel_profiling) +{ + // create queue with profiling enabled + boost::compute::command_queue queue( + context, device, boost::compute::command_queue::enable_profiling + ); + + // input data + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + boost::compute::buffer buffer(context, sizeof(data)); + + // copy input data to device + queue.enqueue_write_buffer(buffer, 0, sizeof(data), data); + + // setup kernel + const char source[] = + "__kernel void iscal(__global int *buffer, int alpha)\n" + "{\n" + " buffer[get_global_id(0)] *= alpha;\n" + "}\n"; + + boost::compute::program program = + boost::compute::program::create_with_source(source, context); + program.build(); + + boost::compute::kernel kernel(program, "iscal"); + kernel.set_arg(0, buffer); + kernel.set_arg(1, 2); + + // execute kernel + size_t global_work_offset = 0; + size_t global_work_size = 8; + + boost::compute::event event = + queue.enqueue_nd_range_kernel(kernel, + size_t(1), + &global_work_offset, + &global_work_size, + 0); + + // wait until kernel is finished + event.wait(); + + // check profiling information + event.get_profiling_info<cl_ulong>(bc::event::profiling_command_queued); + event.get_profiling_info<cl_ulong>(bc::event::profiling_command_submit); + event.get_profiling_info<cl_ulong>(bc::event::profiling_command_start); + event.get_profiling_info<cl_ulong>(bc::event::profiling_command_end); + + // read results back to host + queue.enqueue_read_buffer(buffer, 0, sizeof(data), data); + + // check results + BOOST_CHECK_EQUAL(data[0], 2); + BOOST_CHECK_EQUAL(data[1], 4); + BOOST_CHECK_EQUAL(data[2], 6); + BOOST_CHECK_EQUAL(data[3], 8); + BOOST_CHECK_EQUAL(data[4], 10); + BOOST_CHECK_EQUAL(data[5], 12); + BOOST_CHECK_EQUAL(data[6], 14); + BOOST_CHECK_EQUAL(data[7], 16); +} + +BOOST_AUTO_TEST_CASE(construct_from_cl_command_queue) +{ + // create cl_command_queue + cl_command_queue cl_queue; +#ifdef BOOST_COMPUTE_CL_VERSION_2_0 + if (device.check_version(2, 0)){ // runtime check + cl_queue = + clCreateCommandQueueWithProperties(context, device.id(), 0, 0); + } else +#endif // BOOST_COMPUTE_CL_VERSION_2_0 + { + // Suppress deprecated declarations warning + BOOST_COMPUTE_DISABLE_DEPRECATED_DECLARATIONS(); + cl_queue = + clCreateCommandQueue(context, device.id(), 0, 0); + BOOST_COMPUTE_ENABLE_DEPRECATED_DECLARATIONS(); + } + BOOST_VERIFY(cl_queue); + + // create boost::compute::command_queue + boost::compute::command_queue queue(cl_queue); + + // check queue + BOOST_CHECK(queue.get_context() == context); + BOOST_CHECK(cl_command_queue(queue) == cl_queue); + + // cleanup cl_command_queue + clReleaseCommandQueue(cl_queue); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_1_1 +BOOST_AUTO_TEST_CASE(write_buffer_rect) +{ + REQUIRES_OPENCL_VERSION(1, 1); + + // skip this test on AMD GPUs due to a buggy implementation + // of the clEnqueueWriteBufferRect() function + if(device.vendor() == "Advanced Micro Devices, Inc." && + device.type() & boost::compute::device::gpu){ + std::cerr << "skipping write_buffer_rect test on AMD GPU" << std::endl; + return; + } + + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + boost::compute::buffer buffer(context, 8 * sizeof(int)); + + // copy every other value to the buffer + size_t buffer_origin[] = { 0, 0, 0 }; + size_t host_origin[] = { 0, 0, 0 }; + size_t region[] = { sizeof(int), sizeof(int), 1 }; + + queue.enqueue_write_buffer_rect( + buffer, + buffer_origin, + host_origin, + region, + sizeof(int), + 0, + 2 * sizeof(int), + 0, + data + ); + + // check output values + int output[4]; + queue.enqueue_read_buffer(buffer, 0, 4 * sizeof(int), output); + BOOST_CHECK_EQUAL(output[0], 1); + BOOST_CHECK_EQUAL(output[1], 3); + BOOST_CHECK_EQUAL(output[2], 5); + BOOST_CHECK_EQUAL(output[3], 7); +} +#endif // BOOST_COMPUTE_CL_VERSION_1_1 + +static bool nullary_kernel_executed = false; + +static void nullary_kernel() +{ + nullary_kernel_executed = true; +} + +BOOST_AUTO_TEST_CASE(native_kernel) +{ + cl_device_exec_capabilities exec_capabilities = + device.get_info<CL_DEVICE_EXECUTION_CAPABILITIES>(); + if(!(exec_capabilities & CL_EXEC_NATIVE_KERNEL)){ + std::cerr << "skipping native_kernel test: " + << "device does not support CL_EXEC_NATIVE_KERNEL" + << std::endl; + return; + } + + compute::vector<int> vector(1000, context); + compute::fill(vector.begin(), vector.end(), 42, queue); + BOOST_CHECK_EQUAL(nullary_kernel_executed, false); + queue.enqueue_native_kernel(&nullary_kernel); + queue.finish(); + BOOST_CHECK_EQUAL(nullary_kernel_executed, true); +} + +BOOST_AUTO_TEST_CASE(copy_with_wait_list) +{ + int data1[] = { 1, 3, 5, 7 }; + int data2[] = { 2, 4, 6, 8 }; + + compute::buffer buf1(context, 4 * sizeof(int)); + compute::buffer buf2(context, 4 * sizeof(int)); + + compute::event write_event1 = + queue.enqueue_write_buffer_async(buf1, 0, buf1.size(), data1); + + compute::event write_event2 = + queue.enqueue_write_buffer_async(buf2, 0, buf2.size(), data2); + + compute::event read_event1 = + queue.enqueue_read_buffer_async(buf1, 0, buf1.size(), data2, write_event1); + + compute::event read_event2 = + queue.enqueue_read_buffer_async(buf2, 0, buf2.size(), data1, write_event2); + + read_event1.wait(); + read_event2.wait(); + + CHECK_HOST_RANGE_EQUAL(int, 4, data1, (2, 4, 6, 8)); + CHECK_HOST_RANGE_EQUAL(int, 4, data2, (1, 3, 5, 7)); +} + +#ifndef BOOST_COMPUTE_NO_HDR_INITIALIZER_LIST +BOOST_AUTO_TEST_CASE(enqueue_kernel_with_extents) +{ + using boost::compute::dim; + using boost::compute::uint_; + + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void foo(__global int *output1, __global int *output2) + { + output1[get_global_id(0)] = get_local_id(0); + output2[get_global_id(1)] = get_local_id(1); + } + ); + + compute::kernel kernel = + compute::kernel::create_with_source(source, "foo", context); + + compute::vector<uint_> output1(4, context); + compute::vector<uint_> output2(4, context); + + kernel.set_arg(0, output1); + kernel.set_arg(1, output2); + + queue.enqueue_nd_range_kernel(kernel, dim(0, 0), dim(4, 4), dim(1, 1)); + + CHECK_RANGE_EQUAL(int, 4, output1, (0, 0, 0, 0)); + CHECK_RANGE_EQUAL(int, 4, output2, (0, 0, 0, 0)); + + // Maximum number of work-items that can be specified in each + // dimension of the work-group to clEnqueueNDRangeKernel. + std::vector<size_t> max_work_item_sizes = + device.get_info<CL_DEVICE_MAX_WORK_ITEM_SIZES>(); + + if(max_work_item_sizes[0] < size_t(2)) { + return; + } + + queue.enqueue_nd_range_kernel(kernel, dim(0, 0), dim(4, 4), dim(2, 1)); + + CHECK_RANGE_EQUAL(int, 4, output1, (0, 1, 0, 1)); + CHECK_RANGE_EQUAL(int, 4, output2, (0, 0, 0, 0)); + + if(max_work_item_sizes[1] < size_t(2)) { + return; + } + + queue.enqueue_nd_range_kernel(kernel, dim(0, 0), dim(4, 4), dim(2, 2)); + + CHECK_RANGE_EQUAL(int, 4, output1, (0, 1, 0, 1)); + CHECK_RANGE_EQUAL(int, 4, output2, (0, 1, 0, 1)); +} +#endif // BOOST_COMPUTE_NO_HDR_INITIALIZER_LIST + +#ifdef BOOST_COMPUTE_CL_VERSION_2_1 +BOOST_AUTO_TEST_CASE(get_default_device_queue) +{ + REQUIRES_OPENCL_VERSION(2, 1); + + boost::compute::command_queue default_device_queue( + context, device, + boost::compute::command_queue::on_device | + boost::compute::command_queue::on_device_default | + boost::compute::command_queue::enable_out_of_order_execution + ); + BOOST_CHECK_NO_THROW(queue.get_info<CL_QUEUE_DEVICE_DEFAULT>()); + BOOST_CHECK_EQUAL( + queue.get_default_device_queue(), + default_device_queue + ); +} + +BOOST_AUTO_TEST_CASE(set_as_default_device_queue) +{ + REQUIRES_OPENCL_VERSION(2, 1); + + boost::compute::command_queue new_default_device_queue( + context, device, + boost::compute::command_queue::on_device | + boost::compute::command_queue::enable_out_of_order_execution + ); + new_default_device_queue.set_as_default_device_queue(); + BOOST_CHECK_EQUAL( + queue.get_default_device_queue(), + new_default_device_queue + ); +} +#endif + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_complex.cpp b/src/boost/libs/compute/test/test_complex.cpp new file mode 100644 index 00000000..35e143d1 --- /dev/null +++ b/src/boost/libs/compute/test/test_complex.cpp @@ -0,0 +1,173 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestComplex +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/complex.hpp> +#include <boost/compute/type_traits/type_name.hpp> + +#include "context_setup.hpp" + +// copies a vector of complex<float>'s on the host to the device +BOOST_AUTO_TEST_CASE(copy_complex_vector) +{ + std::vector<std::complex<float> > host_vector; + host_vector.push_back(std::complex<float>(1.0f, 2.0f)); + host_vector.push_back(std::complex<float>(-2.0f, 1.0f)); + host_vector.push_back(std::complex<float>(1.0f, -2.0f)); + host_vector.push_back(std::complex<float>(-2.0f, -1.0f)); + + boost::compute::vector<std::complex<float> > device_vector(context); + boost::compute::copy( + host_vector.begin(), + host_vector.end(), + device_vector.begin(), + queue + ); + queue.finish(); + BOOST_CHECK_EQUAL(std::complex<float>(device_vector[0]), std::complex<float>(1.0f, 2.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(device_vector[1]), std::complex<float>(-2.0f, 1.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(device_vector[2]), std::complex<float>(1.0f, -2.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(device_vector[3]), std::complex<float>(-2.0f, -1.0f)); +} + +// fills a vector of complex<float>'s on the device with a constant value +BOOST_AUTO_TEST_CASE(fill_complex_vector) +{ + boost::compute::vector<std::complex<float> > vector(6, context); + boost::compute::fill( + vector.begin(), + vector.end(), + std::complex<float>(2.0f, 5.0f), + queue + ); + queue.finish(); + BOOST_CHECK_EQUAL(std::complex<float>(vector[0]), std::complex<float>(2.0f, 5.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(vector[1]), std::complex<float>(2.0f, 5.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(vector[2]), std::complex<float>(2.0f, 5.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(vector[3]), std::complex<float>(2.0f, 5.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(vector[4]), std::complex<float>(2.0f, 5.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(vector[5]), std::complex<float>(2.0f, 5.0f)); +} + +// extracts the real and imag components of a vector of complex<float>'s using +// transform with the real() and imag() functions +BOOST_AUTO_TEST_CASE(extract_real_and_imag) +{ + boost::compute::vector<std::complex<float> > vector(context); + vector.push_back(std::complex<float>(1.0f, 3.0f), queue); + vector.push_back(std::complex<float>(3.0f, 1.0f), queue); + vector.push_back(std::complex<float>(5.0f, -1.0f), queue); + vector.push_back(std::complex<float>(7.0f, -3.0f), queue); + vector.push_back(std::complex<float>(9.0f, -5.0f), queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(5)); + + boost::compute::vector<float> reals(5, context); + boost::compute::transform( + vector.begin(), + vector.end(), + reals.begin(), + boost::compute::real<float>(), + queue + ); + queue.finish(); + BOOST_CHECK_EQUAL(float(reals[0]), float(1.0f)); + BOOST_CHECK_EQUAL(float(reals[1]), float(3.0f)); + BOOST_CHECK_EQUAL(float(reals[2]), float(5.0f)); + BOOST_CHECK_EQUAL(float(reals[3]), float(7.0f)); + BOOST_CHECK_EQUAL(float(reals[4]), float(9.0f)); + + boost::compute::vector<float> imags(5, context); + boost::compute::transform( + vector.begin(), + vector.end(), + imags.begin(), + boost::compute::imag<float>(), + queue + ); + queue.finish(); + BOOST_CHECK_EQUAL(float(imags[0]), float(3.0f)); + BOOST_CHECK_EQUAL(float(imags[1]), float(1.0f)); + BOOST_CHECK_EQUAL(float(imags[2]), float(-1.0f)); + BOOST_CHECK_EQUAL(float(imags[3]), float(-3.0f)); + BOOST_CHECK_EQUAL(float(imags[4]), float(-5.0f)); +} + +// compute the complex conjugate of a vector of complex<float>'s +BOOST_AUTO_TEST_CASE(complex_conj) +{ + boost::compute::vector<std::complex<float> > input(context); + input.push_back(std::complex<float>(1.0f, 3.0f), queue); + input.push_back(std::complex<float>(3.0f, 1.0f), queue); + input.push_back(std::complex<float>(5.0f, -1.0f), queue); + input.push_back(std::complex<float>(7.0f, -3.0f), queue); + input.push_back(std::complex<float>(9.0f, -5.0f), queue); + BOOST_CHECK_EQUAL(input.size(), size_t(5)); + + boost::compute::vector<std::complex<float> > output(5, context); + boost::compute::transform( + input.begin(), + input.end(), + output.begin(), + boost::compute::conj<float>(), + queue + ); + queue.finish(); + BOOST_CHECK_EQUAL(std::complex<float>(output[0]), std::complex<float>(1.0f, -3.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(output[1]), std::complex<float>(3.0f, -1.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(output[2]), std::complex<float>(5.0f, 1.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(output[3]), std::complex<float>(7.0f, 3.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(output[4]), std::complex<float>(9.0f, 5.0f)); +} + +// check type_name() for std::complex +BOOST_AUTO_TEST_CASE(complex_type_name) +{ + BOOST_CHECK( + std::strcmp( + boost::compute::type_name<std::complex<float> >(), + "float2" + ) == 0 + ); +} + +BOOST_AUTO_TEST_CASE(transform_multiply) +{ + boost::compute::vector<std::complex<float> > x(context); + x.push_back(std::complex<float>(1.0f, 2.0f), queue); + x.push_back(std::complex<float>(-2.0f, 5.0f), queue); + + boost::compute::vector<std::complex<float> > y(context); + y.push_back(std::complex<float>(3.0f, 4.0f), queue); + y.push_back(std::complex<float>(2.0f, -1.0f), queue); + + boost::compute::vector<std::complex<float> > z(2, context); + + // z = x * y + boost::compute::transform( + x.begin(), + x.end(), + y.begin(), + z.begin(), + boost::compute::multiplies<std::complex<float> >(), + queue + ); + queue.finish(); + + BOOST_CHECK_EQUAL(std::complex<float>(z[0]), std::complex<float>(-5.0f, 10.0f)); + BOOST_CHECK_EQUAL(std::complex<float>(z[1]), std::complex<float>(1.0f, 12.0f)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_constant_iterator.cpp b/src/boost/libs/compute/test/test_constant_iterator.cpp new file mode 100644 index 00000000..96cf29db --- /dev/null +++ b/src/boost/libs/compute/test/test_constant_iterator.cpp @@ -0,0 +1,96 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestConstantIterator +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/constant_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(value_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::constant_iterator<int>::value_type, + int + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::constant_iterator<float>::value_type, + float + >::value + )); +} + +BOOST_AUTO_TEST_CASE(distance) +{ + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_constant_iterator(128, 0), + boost::compute::make_constant_iterator(128, 10) + ), + std::ptrdiff_t(10) + ); + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_constant_iterator(256, 5), + boost::compute::make_constant_iterator(256, 10) + ), + std::ptrdiff_t(5) + ); +} + +BOOST_AUTO_TEST_CASE(copy) +{ + boost::compute::vector<int> vector(10, context); + + boost::compute::copy( + boost::compute::make_constant_iterator(42, 0), + boost::compute::make_constant_iterator(42, 10), + vector.begin(), + queue + ); + CHECK_RANGE_EQUAL( + int, 10, vector, + (42, 42, 42, 42, 42, 42, 42, 42, 42, 42) + ); +} + +BOOST_AUTO_TEST_CASE(fill_with_copy_doctest) +{ +//! [fill_with_copy] +using boost::compute::make_constant_iterator; + +boost::compute::vector<int> result(5, context); + +boost::compute::copy( + make_constant_iterator(42, 0), + make_constant_iterator(42, result.size()), + result.begin(), + queue +); + +// result == { 42, 42, 42, 42, 42 } +//! [fill_with_copy] + + CHECK_RANGE_EQUAL(int, 5, result, (42, 42, 42, 42, 42)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_context.cpp b/src/boost/libs/compute/test/test_context.cpp new file mode 100644 index 00000000..8155dd2e --- /dev/null +++ b/src/boost/libs/compute/test/test_context.cpp @@ -0,0 +1,67 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestContext +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/context.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(construct_from_cl_context) +{ + cl_device_id id = device.id(); + + // create cl_context + cl_context ctx = clCreateContext(0, 1, &id, 0, 0, 0); + BOOST_VERIFY(ctx); + + // create boost::compute::context + boost::compute::context context(ctx); + + // check context + BOOST_CHECK(cl_context(context) == ctx); + + // cleanup cl_context + clReleaseContext(ctx); +} + +#ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES +BOOST_AUTO_TEST_CASE(move_constructor) +{ + boost::compute::device device = boost::compute::system::default_device(); + boost::compute::context context1(device); + BOOST_VERIFY(cl_context(context1) != cl_context()); + + boost::compute::context context2(std::move(context1)); + BOOST_VERIFY(cl_context(context2) != cl_context()); + BOOST_VERIFY(cl_context(context1) == cl_context()); +} +#endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES + +BOOST_AUTO_TEST_CASE(multiple_devices) +{ + const std::vector<compute::platform> &platforms = compute::system::platforms(); + for(size_t i = 0; i < platforms.size(); i++){ + const compute::platform &platform = platforms[i]; + + // create a context for containing all devices in the platform + compute::context ctx(platform.devices()); + + // check device count + BOOST_CHECK_EQUAL(ctx.get_devices().size(), platform.device_count()); + } +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_context_error.cpp b/src/boost/libs/compute/test/test_context_error.cpp new file mode 100644 index 00000000..29186479 --- /dev/null +++ b/src/boost/libs/compute/test/test_context_error.cpp @@ -0,0 +1,25 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Fabian Köhler <fabian2804@googlemail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestContextError +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/exception/context_error.hpp> + +BOOST_AUTO_TEST_CASE(what) +{ + boost::compute::context context = boost::compute::system::default_context(); + boost::compute::context_error error(&context, "Test", 0, 0); + BOOST_CHECK_EQUAL(std::string(error.what()), std::string("Test")); + BOOST_CHECK(*error.get_context_ptr() == context); + BOOST_CHECK(error.get_private_info_ptr() == 0); + BOOST_CHECK(error.get_private_info_size() == 0); +} diff --git a/src/boost/libs/compute/test/test_copy.cpp b/src/boost/libs/compute/test/test_copy.cpp new file mode 100644 index 00000000..1ceb7853 --- /dev/null +++ b/src/boost/libs/compute/test/test_copy.cpp @@ -0,0 +1,411 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestCopy +#include <boost/test/unit_test.hpp> + +#include <list> +#include <vector> +#include <string> +#include <sstream> +#include <iterator> +#include <iostream> + +#include <boost/compute/svm.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/async/future.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/detail/device_ptr.hpp> +#include <boost/compute/iterator/detail/swizzle_iterator.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(copy_on_device) +{ + float data[] = { 6.1f, 10.2f, 19.3f, 25.4f }; + bc::vector<float> a(4, context); + bc::copy(data, data + 4, a.begin(), queue); + CHECK_RANGE_EQUAL(float, 4, a, (6.1f, 10.2f, 19.3f, 25.4f)); + + bc::vector<float> b(4, context); + bc::fill(b.begin(), b.end(), 0, queue); + CHECK_RANGE_EQUAL(float, 4, b, (0.0f, 0.0f, 0.0f, 0.0f)); + + bc::copy(a.begin(), a.end(), b.begin(), queue); + CHECK_RANGE_EQUAL(float, 4, b, (6.1f, 10.2f, 19.3f, 25.4f)); + + bc::vector<float> c(context); + bc::copy(c.begin(), c.end(), b.begin(), queue); + CHECK_RANGE_EQUAL(float, 4, b, (6.1f, 10.2f, 19.3f, 25.4f)); +} + +BOOST_AUTO_TEST_CASE(copy_on_device_device_ptr) +{ + float data[] = { 6.1f, 10.2f, 19.3f, 25.4f }; + bc::vector<float> a(4, context); + bc::copy(data, data + 4, a.begin(), queue); + CHECK_RANGE_EQUAL(float, 4, a, (6.1f, 10.2f, 19.3f, 25.4f)); + + bc::vector<float> b(4, context); + bc::detail::device_ptr<float> b_ptr(b.get_buffer(), size_t(0)); + + // buffer_iterator -> device_ptr + bc::copy(a.begin(), a.end(), b_ptr, queue); + CHECK_RANGE_EQUAL(float, 4, b, (6.1f, 10.2f, 19.3f, 25.4f)); + + bc::vector<float> c(4, context); + bc::fill(c.begin(), c.end(), 0.0f, queue); + bc::detail::device_ptr<float> c_ptr(c.get_buffer(), size_t(2)); + + // device_ptr -> device_ptr + bc::copy(b_ptr, b_ptr + 2, c_ptr, queue); + CHECK_RANGE_EQUAL(float, 4, c, (0.0f, 0.0f, 6.1f, 10.2f)); + + // device_ptr -> buffer_iterator + bc::copy(c_ptr, c_ptr + 2, a.begin() + 2, queue); + CHECK_RANGE_EQUAL(float, 4, a, (6.1f, 10.2f, 6.1f, 10.2f)); +} + +BOOST_AUTO_TEST_CASE(copy_on_host) +{ + int data[] = { 2, 4, 6, 8 }; + std::vector<int> vector(4); + compute::copy(data, data + 4, vector.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, vector, (2, 4, 6, 8)); +} + +BOOST_AUTO_TEST_CASE(copy) +{ + int data[] = { 1, 2, 5, 6 }; + bc::vector<int> vector(4, context); + bc::copy(data, data + 4, vector.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, vector, (1, 2, 5, 6)); + + std::vector<int> host_vector(4); + bc::copy(vector.begin(), vector.end(), host_vector.begin(), queue); + BOOST_CHECK_EQUAL(host_vector[0], 1); + BOOST_CHECK_EQUAL(host_vector[1], 2); + BOOST_CHECK_EQUAL(host_vector[2], 5); + BOOST_CHECK_EQUAL(host_vector[3], 6); +} + +BOOST_AUTO_TEST_CASE(empty_copy) +{ + int data[] = { 1, 2, 5, 6 }; + bc::vector<int> a(4, context); + bc::vector<int> b(context); + std::vector<int> c; + + bc::copy(data, data + 4, a.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, a, (1, 2, 5, 6)); + + bc::copy(b.begin(), b.end(), a.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, a, (1, 2, 5, 6)); + + bc::copy(c.begin(), c.end(), a.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, a, (1, 2, 5, 6)); + + bc::future<bc::vector<int>::iterator> future = + bc::copy_async(c.begin(), c.end(), a.begin(), queue); + if(future.valid()) + future.wait(); + CHECK_RANGE_EQUAL(int, 4, a, (1, 2, 5, 6)); +} + +// Test copying from a std::list to a bc::vector. This differs from +// the test copying from std::vector because std::list has non-contigous +// storage for its data values. +BOOST_AUTO_TEST_CASE(copy_from_host_list) +{ + int data[] = { -4, 12, 9, 0 }; + std::list<int> host_list(data, data + 4); + + bc::vector<int> vector(4, context); + bc::copy(host_list.begin(), host_list.end(), vector.begin(), queue); + CHECK_RANGE_EQUAL(int, 4, vector, (-4, 12, 9, 0)); +} + +BOOST_AUTO_TEST_CASE(copy_n_int) +{ + int data[] = { 1, 2, 3, 4, 5 }; + bc::vector<int> a(data, data + 5, queue); + + bc::vector<int> b(5, context); + bc::fill(b.begin(), b.end(), 0, queue); + bc::copy_n(a.begin(), 3, b.begin(), queue); + CHECK_RANGE_EQUAL(int, 5, b, (1, 2, 3, 0, 0)); + + bc::copy_n(b.begin(), 4, a.begin(), queue); + CHECK_RANGE_EQUAL(int, 5, a, (1, 2, 3, 0, 5)); +} + +BOOST_AUTO_TEST_CASE(copy_swizzle_iterator) +{ + using bc::int2_; + using bc::int4_; + + int data[] = { 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 1, 2, 3, + 4, 5, 6, 7 }; + + bc::vector<int4_> input(reinterpret_cast<int4_*>(data), + reinterpret_cast<int4_*>(data) + 4, + queue); + BOOST_CHECK_EQUAL(input.size(), size_t(4)); + CHECK_RANGE_EQUAL(int4_, 4, input, + (int4_(1, 2, 3, 4), + int4_(5, 6, 7, 8), + int4_(9, 1, 2, 3), + int4_(4, 5, 6, 7)) + ); + + bc::vector<int4_> output4(4, context); + bc::copy( + bc::detail::make_swizzle_iterator<4>(input.begin(), "wzyx"), + bc::detail::make_swizzle_iterator<4>(input.end(), "wzyx"), + output4.begin(), + queue + ); + CHECK_RANGE_EQUAL(int4_, 4, output4, + (int4_(4, 3, 2, 1), + int4_(8, 7, 6, 5), + int4_(3, 2, 1, 9), + int4_(7, 6, 5, 4)) + ); + + bc::vector<int2_> output2(4, context); + bc::copy( + bc::detail::make_swizzle_iterator<2>(input.begin(), "xz"), + bc::detail::make_swizzle_iterator<2>(input.end(), "xz"), + output2.begin(), + queue + ); + CHECK_RANGE_EQUAL(int2_, 4, output2, + (int2_(1, 3), + int2_(5, 7), + int2_(9, 2), + int2_(4, 6)) + ); + + bc::vector<int> output1(4, context); + bc::copy( + bc::detail::make_swizzle_iterator<1>(input.begin(), "y"), + bc::detail::make_swizzle_iterator<1>(input.end(), "y"), + output1.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 4, output1, (2, 6, 1, 5)); +} + +BOOST_AUTO_TEST_CASE(copy_int_async) +{ + // setup host data + int host_data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + typedef int* host_iterator; + + // setup device data + bc::vector<int> device_data(8, context); + typedef bc::vector<int>::iterator device_iterator; + + // copy data to device + bc::future<device_iterator> host_to_device_future = + bc::copy_async(host_data, host_data + 8, device_data.begin(), queue); + + // wait for copy to complete + host_to_device_future.wait(); + + // check results + CHECK_RANGE_EQUAL(int, 8, device_data, (1, 2, 3, 4, 5, 6, 7, 8)); + BOOST_VERIFY(host_to_device_future.get() == device_data.end()); + + // fill host data with zeros + std::fill(host_data, host_data + 8, int(0)); + + // copy data back to host + bc::future<host_iterator> device_to_host_future = + bc::copy_async(device_data.begin(), device_data.end(), host_data, queue); + + // wait for copy to complete + device_to_host_future.wait(); + + // check results + BOOST_CHECK_EQUAL(host_data[0], int(1)); + BOOST_CHECK_EQUAL(host_data[1], int(2)); + BOOST_CHECK_EQUAL(host_data[2], int(3)); + BOOST_CHECK_EQUAL(host_data[3], int(4)); + BOOST_CHECK_EQUAL(host_data[4], int(5)); + BOOST_CHECK_EQUAL(host_data[5], int(6)); + BOOST_CHECK_EQUAL(host_data[6], int(7)); + BOOST_CHECK_EQUAL(host_data[7], int(8)); + BOOST_VERIFY(device_to_host_future.get() == host_data + 8); +} + +BOOST_AUTO_TEST_CASE(copy_to_back_inserter) +{ + compute::vector<int> device_vector(5, context); + compute::iota(device_vector.begin(), device_vector.end(), 10, queue); + + std::vector<int> host_vector; + compute::copy( + device_vector.begin(), + device_vector.end(), + std::back_inserter(host_vector), + queue + ); + + BOOST_CHECK_EQUAL(host_vector.size(), size_t(5)); + BOOST_CHECK_EQUAL(host_vector[0], 10); + BOOST_CHECK_EQUAL(host_vector[1], 11); + BOOST_CHECK_EQUAL(host_vector[2], 12); + BOOST_CHECK_EQUAL(host_vector[3], 13); + BOOST_CHECK_EQUAL(host_vector[4], 14); +} + +BOOST_AUTO_TEST_CASE(copy_to_stringstream) +{ + std::stringstream stream; + + int data[] = { 2, 3, 4, 5, 6, 7, 8, 9 }; + compute::vector<int> vector(data, data + 8, queue); + + compute::copy( + vector.begin(), + vector.end(), + std::ostream_iterator<int>(stream, " "), + queue + ); + BOOST_CHECK_EQUAL(stream.str(), std::string("2 3 4 5 6 7 8 9 ")); +} + +BOOST_AUTO_TEST_CASE(check_copy_type) +{ + // copy from host to device and ensure clEnqueueWriteBuffer() is used + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<int> a(8, context); + compute::future<void> future = + compute::copy_async(data, data + 8, a.begin(), queue); + BOOST_CHECK( + future.get_event().get_command_type() == CL_COMMAND_WRITE_BUFFER + ); + future.wait(); + CHECK_RANGE_EQUAL(int, 8, a, (1, 2, 3, 4, 5, 6, 7, 8)); + + // copy on the device and ensure clEnqueueCopyBuffer() is used + compute::vector<int> b(8, context); + future = compute::copy_async(a.begin(), a.end(), b.begin(), queue); + BOOST_CHECK( + future.get_event().get_command_type() == CL_COMMAND_COPY_BUFFER + ); + future.wait(); + CHECK_RANGE_EQUAL(int, 8, b, (1, 2, 3, 4, 5, 6, 7, 8)); + + // copy between vectors of different types on the device and ensure + // that the copy kernel is used + compute::vector<short> c(8, context); + future = compute::copy_async(a.begin(), a.end(), c.begin(), queue); + BOOST_CHECK( + future.get_event().get_command_type() == CL_COMMAND_NDRANGE_KERNEL + ); + future.wait(); + CHECK_RANGE_EQUAL(short, 8, c, (1, 2, 3, 4, 5, 6, 7, 8)); + + // copy from device to host and ensure clEnqueueReadBuffer() is used + future = compute::copy_async(b.begin(), b.end(), data, queue); + BOOST_CHECK( + future.get_event().get_command_type() == CL_COMMAND_READ_BUFFER + ); + future.wait(); + CHECK_HOST_RANGE_EQUAL(int, 8, data, (1, 2, 3, 4, 5, 6, 7, 8)); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_2_0 +BOOST_AUTO_TEST_CASE(copy_svm_ptr) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using boost::compute::int_; + + if(bug_in_svmmemcpy(device)){ + std::cerr << "skipping copy_svm_ptr test case" << std::endl; + return; + } + + int_ data[] = { 1, 3, 2, 4 }; + + compute::svm_ptr<int_> ptr = compute::svm_alloc<int_>(context, 4); + compute::copy(data, data + 4, ptr, queue); + + int_ output[] = { 0, 0, 0, 0 }; + compute::copy(ptr, ptr + 4, output, queue); + CHECK_HOST_RANGE_EQUAL(int_, 4, output, (1, 3, 2, 4)); + + compute::svm_free(context, ptr); +} + +BOOST_AUTO_TEST_CASE(copy_async_svm_ptr) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using boost::compute::int_; + + if(bug_in_svmmemcpy(device)){ + std::cerr << "skipping copy_svm_ptr test case" << std::endl; + return; + } + + int_ data[] = { 1, 3, 2, 4 }; + + compute::svm_ptr<int_> ptr = compute::svm_alloc<int_>(context, 4); + boost::compute::future<void> future = + compute::copy_async(data, data + 4, ptr, queue); + future.wait(); + + int_ output[] = { 0, 0, 0, 0 }; + future = + compute::copy_async(ptr, ptr + 4, output, queue); + future.wait(); + CHECK_HOST_RANGE_EQUAL(int_, 4, output, (1, 3, 2, 4)); + + compute::svm_free(context, ptr); +} +#endif // BOOST_COMPUTE_CL_VERSION_2_0 + +BOOST_AUTO_TEST_CASE(copy_to_vector_bool) +{ + using compute::uchar_; + + compute::vector<uchar_> vec(2, context); + + // copy to device + bool data[] = {true, false}; + compute::copy(data, data + 2, vec.begin(), queue); + BOOST_CHECK(static_cast<bool>(vec[0]) == true); + BOOST_CHECK(static_cast<bool>(vec[1]) == false); + + // copy to host + std::vector<bool> host_vec(vec.size()); + compute::copy(vec.begin(), vec.end(), host_vec.begin(), queue); + BOOST_CHECK(host_vec[0] == true); + BOOST_CHECK(host_vec[1] == false); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_copy_if.cpp b/src/boost/libs/compute/test/test_copy_if.cpp new file mode 100644 index 00000000..2a65bb08 --- /dev/null +++ b/src/boost/libs/compute/test/test_copy_if.cpp @@ -0,0 +1,119 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestCopyIf +#include <boost/test/unit_test.hpp> + +#include <boost/compute/lambda.hpp> +#include <boost/compute/algorithm/copy_if.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(copy_if_int) +{ + int data[] = { 1, 6, 3, 5, 8, 2, 4 }; + bc::vector<int> input(data, data + 7, queue); + + bc::vector<int> output(input.size(), context); + bc::fill(output.begin(), output.end(), -1, queue); + + using ::boost::compute::_1; + + bc::vector<int>::iterator iter = + bc::copy_if(input.begin(), input.end(), + output.begin(), _1 < 5, queue); + BOOST_VERIFY(iter == output.begin() + 4); + CHECK_RANGE_EQUAL(int, 7, output, (1, 3, 2, 4, -1, -1, -1)); + + bc::fill(output.begin(), output.end(), 42, queue); + iter = + bc::copy_if(input.begin(), input.end(), + output.begin(), _1 * 2 >= 10, queue); + BOOST_VERIFY(iter == output.begin() + 3); + CHECK_RANGE_EQUAL(int, 7, output, (6, 5, 8, 42, 42, 42, 42)); +} + +BOOST_AUTO_TEST_CASE(copy_if_odd) +{ + int data[] = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5 }; + bc::vector<int> input(data, data + 10, queue); + + using ::boost::compute::_1; + + bc::vector<int> odds(input.size(), context); + bc::vector<int>::iterator odds_end = + bc::copy_if(input.begin(), input.end(), + odds.begin(), _1 % 2 == 1, queue); + BOOST_CHECK(odds_end == odds.begin() + 6); + CHECK_RANGE_EQUAL(int, 6, odds, (1, 3, 5, 1, 3, 5)); + + bc::vector<int> evens(input.size(), context); + bc::vector<int>::iterator evens_end = + bc::copy_if(input.begin(), input.end(), + evens.begin(), _1 % 2 == 0, queue); + BOOST_CHECK(evens_end == evens.begin() + 4); + CHECK_RANGE_EQUAL(int, 4, evens, (2, 4, 2, 4)); +} + +BOOST_AUTO_TEST_CASE(clip_points_below_plane) +{ + float data[] = { 1.0f, 2.0f, 3.0f, 0.0f, + -1.0f, 2.0f, 3.0f, 0.0f, + -2.0f, -3.0f, 4.0f, 0.0f, + 4.0f, -3.0f, 2.0f, 0.0f }; + bc::vector<bc::float4_> points(reinterpret_cast<bc::float4_ *>(data), + reinterpret_cast<bc::float4_ *>(data) + 4, + queue); + + // create output vector filled with (0, 0, 0, 0) + bc::vector<bc::float4_> output(points.size(), context); + bc::fill(output.begin(), output.end(), + bc::float4_(0.0f, 0.0f, 0.0f, 0.0f), queue); + + // define the plane (at origin, +X normal) + bc::float4_ plane_origin(0.0f, 0.0f, 0.0f, 0.0f); + bc::float4_ plane_normal(1.0f, 0.0f, 0.0f, 0.0f); + + using ::boost::compute::_1; + using ::boost::compute::lambda::dot; + + bc::vector<bc::float4_>::const_iterator iter = + bc::copy_if(points.begin(), + points.end(), + output.begin(), + dot(_1 - plane_origin, plane_normal) > 0.0f, + queue); + BOOST_CHECK(iter == output.begin() + 2); +} + +BOOST_AUTO_TEST_CASE(copy_index_if_int) +{ + int data[] = { 1, 6, 3, 5, 8, 2, 4 }; + compute::vector<int> input(data, data + 7, queue); + + compute::vector<int> output(input.size(), context); + compute::fill(output.begin(), output.end(), -1, queue); + + using ::boost::compute::_1; + using ::boost::compute::detail::copy_index_if; + + compute::vector<int>::iterator iter = + copy_index_if(input.begin(), input.end(), output.begin(), + _1 < 5, queue); + BOOST_VERIFY(iter == output.begin() + 4); + CHECK_RANGE_EQUAL(int, 7, output, (0, 2, 5, 6, -1, -1, -1)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_copy_type_mismatch.cpp b/src/boost/libs/compute/test/test_copy_type_mismatch.cpp new file mode 100644 index 00000000..49305a6d --- /dev/null +++ b/src/boost/libs/compute/test/test_copy_type_mismatch.cpp @@ -0,0 +1,1380 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2016 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +// Undefining BOOST_COMPUTE_USE_OFFLINE_CACHE macro as we want to modify cached +// parameters for copy algorithm without any undesirable consequences (like +// saving modified values of those parameters). +#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE + #undef BOOST_COMPUTE_USE_OFFLINE_CACHE +#endif + +#define BOOST_TEST_MODULE TestCopyTypeMismatch +#include <boost/test/unit_test.hpp> + +#include <list> +#include <vector> +#include <string> +#include <sstream> +#include <iterator> +#include <iostream> + +#include <boost/compute/svm.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/async/future.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/detail/device_ptr.hpp> +#include <boost/compute/memory/svm_ptr.hpp> +#include <boost/compute/detail/parameter_cache.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(is_same_ignore_const) +{ + BOOST_STATIC_ASSERT(( + boost::compute::detail::is_same_value_type< + std::vector<int>::iterator, + compute::buffer_iterator<int> + >::value + )); + BOOST_STATIC_ASSERT(( + boost::compute::detail::is_same_value_type< + std::vector<int>::const_iterator, + compute::buffer_iterator<int> + >::value + )); + BOOST_STATIC_ASSERT(( + boost::compute::detail::is_same_value_type< + std::vector<int>::iterator, + compute::buffer_iterator<const int> + >::value + )); + BOOST_STATIC_ASSERT(( + boost::compute::detail::is_same_value_type< + std::vector<int>::const_iterator, + compute::buffer_iterator<const int> + >::value + )); +} + +BOOST_AUTO_TEST_CASE(copy_to_device_float_to_double) +{ + if(!device.supports_extension("cl_khr_fp64")) { + std::cout << "skipping test: device does not support double" << std::endl; + return; + } + + using compute::double_; + using compute::float_; + + float_ host[] = { 6.1f, 10.2f, 19.3f, 25.4f }; + bc::vector<double_> device_vector(4, context); + + // copy host float data to double device vector + bc::copy(host, host + 4, device_vector.begin(), queue); + CHECK_RANGE_EQUAL(double_, 4, device_vector, (6.1f, 10.2f, 19.3f, 25.4f)); +} + +BOOST_AUTO_TEST_CASE(copy_to_device_float_to_int) +{ + using compute::int_; + using compute::float_; + + float_ host[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<int_> device_vector(4, context); + + // copy host float data to int device vector + bc::copy(host, host + 4, device_vector.begin(), queue); + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); +} + +// HOST -> DEVICE + +BOOST_AUTO_TEST_CASE(copy_to_device_float_to_int_mapping_device_vector) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + float_ host[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<int_> device_vector(4, context); + + std::string cache_key = + std::string("__boost_compute_copy_to_device_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + + // force copy_to_device_map (mapping device vector to the host) + parameters->set(cache_key, "map_copy_threshold", 1024); + + // copy host float data to int device vector + bc::copy(host, host + 4, device_vector.begin(), queue); + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_to_device_float_to_int_convert_on_host) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_device_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by casting input data on host and performing + // normal copy host->device (since types match now) + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 1024); + + float_ host[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<int_> device_vector(4, context); + + // copy host float data to int device vector + bc::copy(host, host + 4, device_vector.begin(), queue); + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_to_device_float_to_int_with_transform) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_device_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by mapping input data to the device memory + // and using transform operation for casting & copying + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 0); + + float_ host[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<int_> device_vector(4, context); + + // copy host float data to int device vector + bc::copy(host, host + 4, device_vector.begin(), queue); + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_async_to_device_float_to_int) +{ + using compute::int_; + using compute::float_; + + float_ host[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<int_> device_vector(4, context); + + // copy host float data to int device vector + compute::future<void> future = + bc::copy_async(host, host + 4, device_vector.begin(), queue); + future.wait(); + + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); +} + +BOOST_AUTO_TEST_CASE(copy_async_to_device_float_to_int_empty) +{ + using compute::int_; + using compute::float_; + + float_ host[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<int_> device_vector(size_t(4), int_(1), queue); + + // copy nothing to int device vector + compute::future<bc::vector<int_>::iterator > future = + bc::copy_async(host, host, device_vector.begin(), queue); + if(future.valid()) { + future.wait(); + } + + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + int_(1), + int_(1), + int_(1), + int_(1) + ) + ); +} + +// Test copying from a std::list to a bc::vector. This differs from +// the test copying from std::vector because std::list has non-contiguous +// storage for its data values. +BOOST_AUTO_TEST_CASE(copy_to_device_float_to_int_list_device_map) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_device_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + + // force copy_to_device_map (mapping device vector to the host) + parameters->set(cache_key, "map_copy_threshold", 1024); + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + std::list<float_> host(data, data + 4); + bc::vector<int_> device_vector(4, context); + + // copy host float data to int device vector + bc::copy(host.begin(), host.end(), device_vector.begin(), queue); + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); +} + +// Test copying from a std::list to a bc::vector. This differs from +// the test copying from std::vector because std::list has non-contiguous +// storage for its data values. +BOOST_AUTO_TEST_CASE(copy_to_device_float_to_int_list_convert_on_host) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_device_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by casting input data on host and performing + // normal copy host->device (since types match now) + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 1024); + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + std::list<float_> host(data, data + 4); + bc::vector<int_> device_vector(4, context); + + // copy host float data to int device vector + bc::copy(host.begin(), host.end(), device_vector.begin(), queue); + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +// SVM requires OpenCL 2.0 +#if defined(BOOST_COMPUTE_CL_VERSION_2_0) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED) +BOOST_AUTO_TEST_CASE(copy_to_device_svm_float_to_int_map) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_device_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + + // force copy_to_device_map (mapping device vector to the host) + parameters->set(cache_key, "map_copy_threshold", 1024); + + float_ host[] = { 5.1f, -10.3f, 19.4f, 26.7f }; + compute::svm_ptr<int_> ptr = compute::svm_alloc<int_>(context, 4); + + // copy host float data to int device vector + bc::copy(host, host + 4, ptr, queue); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_READ); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + static_cast<int_*>(ptr.get()), + ( + static_cast<int_>(5.1f), + static_cast<int_>(-10.3f), + static_cast<int_>(19.4f), + static_cast<int_>(26.7f) + ) + ); + queue.enqueue_svm_unmap(ptr.get()).wait(); + + compute::svm_free(context, ptr); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_to_device_svm_float_to_int_convert_on_host) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + if(bug_in_svmmemcpy(device)){ + std::cerr << "skipping svmmemcpy test case" << std::endl; + return; + } + + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_device_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by casting input data on host and performing + // normal copy host->device (since types match now) + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 1024); + + float_ host[] = { 0.1f, 10.3f, 9.4f, -26.7f }; + compute::svm_ptr<int_> ptr = compute::svm_alloc<int_>(context, 4); + + // copy host float data to int device vector + bc::copy(host, host + 4, ptr, queue); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_READ); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + static_cast<int_*>(ptr.get()), + ( + static_cast<int_>(0.1f), + static_cast<int_>(10.3f), + static_cast<int_>(9.4f), + static_cast<int_>(-26.7f) + ) + ); + queue.enqueue_svm_unmap(ptr.get()).wait(); + + compute::svm_free(context, ptr); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_to_device_svm_float_to_int_with_transform) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_device_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by mapping input data to the device memory + // and using transform operation (copy kernel) for casting & copying + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 0); + + float_ host[] = { 4.1f, -11.3f, 219.4f, -26.7f }; + compute::svm_ptr<int_> ptr = compute::svm_alloc<int_>(context, 4); + + // copy host float data to int device vector + bc::copy(host, host + 4, ptr, queue); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_READ); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + static_cast<int_*>(ptr.get()), + ( + static_cast<int_>(4.1f), + static_cast<int_>(-11.3f), + static_cast<int_>(219.4f), + static_cast<int_>(-26.7f) + ) + ); + queue.enqueue_svm_unmap(ptr.get()).wait(); + + compute::svm_free(context, ptr); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_async_to_device_svm_float_to_int) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::uint_; + using compute::float_; + + float_ host[] = { 44.1f, -14.3f, 319.4f, -26.7f }; + compute::svm_ptr<int_> ptr = compute::svm_alloc<int_>(context, 4); + + // copy host float data to int device vector + compute::future<void> future = + bc::copy_async(host, host + 4, ptr, queue); + future.wait(); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_READ); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + static_cast<int_*>(ptr.get()), + ( + static_cast<int_>(44.1f), + static_cast<int_>(-14.3f), + static_cast<int_>(319.4f), + static_cast<int_>(-26.7f) + ) + ); + queue.enqueue_svm_unmap(ptr.get()).wait(); + + compute::svm_free(context, ptr); +} +#endif + +// DEVICE -> DEVICE + +BOOST_AUTO_TEST_CASE(copy_on_device_float_to_int) +{ + using compute::int_; + using compute::float_; + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_fvector(data, data + 4, queue); + bc::vector<int_> device_ivector(4, context); + + // copy device float vector to device int vector + bc::copy( + device_fvector.begin(), + device_fvector.end(), + device_ivector.begin(), + queue + ); + + CHECK_RANGE_EQUAL( + int_, + 4, + device_ivector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); +} + +BOOST_AUTO_TEST_CASE(copy_async_on_device_float_to_int) +{ + using compute::int_; + using compute::float_; + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_fvector(data, data + 4, queue); + bc::vector<int_> device_ivector(4, context); + + // copy device float vector to device int vector + compute::future<void> future = + bc::copy_async( + device_fvector.begin(), + device_fvector.end(), + device_ivector.begin(), + queue + ); + future.wait(); + + CHECK_RANGE_EQUAL( + int_, + 4, + device_ivector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); +} + +BOOST_AUTO_TEST_CASE(copy_async_on_device_float_to_int_empty) +{ + using compute::int_; + using compute::float_; + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_fvector(data, data + 4, queue); + bc::vector<int_> device_ivector(size_t(4), int_(1), queue); + + // copy device float vector to device int vector + compute::future<void> future = + bc::copy_async( + device_fvector.begin(), + device_fvector.begin(), + device_ivector.begin(), + queue + ); + if(future.valid()) { + future.wait(); + } + + CHECK_RANGE_EQUAL( + int_, + 4, + device_ivector, + ( + int_(1), + int_(1), + int_(1), + int_(1) + ) + ); +} + +// SVM requires OpenCL 2.0 +#if defined(BOOST_COMPUTE_CL_VERSION_2_0) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED) +BOOST_AUTO_TEST_CASE(copy_on_device_buffer_to_svm_float_to_int) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::float_; + + float_ data[] = { 65.1f, -110.2f, -19.3f, 26.7f }; + bc::vector<float_> device_vector(data, data + 4, queue); + compute::svm_ptr<int_> ptr = compute::svm_alloc<int_>(context, 4); + + // copy host float data to int svm memory + bc::copy(device_vector.begin(), device_vector.end(), ptr, queue); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_READ); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + static_cast<int_*>(ptr.get()), + ( + static_cast<int_>(65.1f), + static_cast<int_>(-110.2f), + static_cast<int_>(-19.3f), + static_cast<int_>(26.7f) + ) + ); + queue.enqueue_svm_unmap(ptr.get()).wait(); + + compute::svm_free(context, ptr); +} + +BOOST_AUTO_TEST_CASE(copy_on_device_svm_to_buffer_float_to_int) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::float_; + + float_ data[] = { 6.1f, 11.2f, 19.3f, 6.7f }; + bc::vector<int_> device_vector(4, context); + compute::svm_ptr<float_> ptr = compute::svm_alloc<float_>(context, 4); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_WRITE); + for(size_t i = 0; i < 4; i++) { + static_cast<float_*>(ptr.get())[i] = data[i]; + } + queue.enqueue_svm_unmap(ptr.get()).wait(); + + // copy host float svm data to int device vector + bc::copy(ptr, ptr + 4, device_vector.begin(), queue); + + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(6.1f), + static_cast<int_>(11.2f), + static_cast<int_>(19.3f), + static_cast<int_>(6.7f) + ) + ); + + compute::svm_free(context, ptr); +} + +BOOST_AUTO_TEST_CASE(copy_on_device_svm_to_svm_float_to_int) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::float_; + + float_ data[] = { 0.1f, -10.2f, -1.3f, 2.7f }; + compute::svm_ptr<float_> ptr = compute::svm_alloc<float_>(context, 4); + compute::svm_ptr<int_> ptr2 = compute::svm_alloc<int_>(context, 4); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_WRITE); + for(size_t i = 0; i < 4; i++) { + static_cast<float_*>(ptr.get())[i] = data[i]; + } + queue.enqueue_svm_unmap(ptr.get()).wait(); + + // copy host float svm to int svm + bc::copy(ptr, ptr + 4, ptr2, queue); + + queue.enqueue_svm_map(ptr2.get(), 4 * sizeof(cl_int), CL_MAP_READ); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + static_cast<int_*>(ptr2.get()), + ( + static_cast<int_>(0.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(-1.3f), + static_cast<int_>(2.7f) + ) + ); + queue.enqueue_svm_unmap(ptr2.get()).wait(); + + compute::svm_free(context, ptr); + compute::svm_free(context, ptr2); +} + +BOOST_AUTO_TEST_CASE(copy_async_on_device_buffer_to_svm_float_to_int) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::float_; + + float_ data[] = { 65.1f, -110.2f, -19.3f, 26.7f }; + bc::vector<float_> device_vector(data, data + 4, queue); + compute::svm_ptr<int_> ptr = compute::svm_alloc<int_>(context, 4); + + // copy host float data to int svm memory + compute::future<bc::svm_ptr<int_> > future = + bc::copy_async(device_vector.begin(), device_vector.end(), ptr, queue); + future.wait(); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_READ); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + static_cast<int_*>(ptr.get()), + ( + static_cast<int_>(65.1f), + static_cast<int_>(-110.2f), + static_cast<int_>(-19.3f), + static_cast<int_>(26.7f) + ) + ); + queue.enqueue_svm_unmap(ptr.get()).wait(); + + compute::svm_free(context, ptr); +} + +BOOST_AUTO_TEST_CASE(copy_async_on_device_svm_to_buffer_float_to_int) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::float_; + + float_ data[] = { 65.1f, -110.2f, -19.3f, 26.7f }; + bc::vector<int_> device_vector(4, context); + compute::svm_ptr<float_> ptr = compute::svm_alloc<float_>(context, 4); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_WRITE); + for(size_t i = 0; i < 4; i++) { + static_cast<float_*>(ptr.get())[i] = data[i]; + } + queue.enqueue_svm_unmap(ptr.get()).wait(); + + // copy host float svm data to int device vector + compute::future<bc::vector<int_>::iterator > future = + bc::copy_async(ptr, ptr + 4, device_vector.begin(), queue); + future.wait(); + + CHECK_RANGE_EQUAL( + int_, + 4, + device_vector, + ( + static_cast<int_>(65.1f), + static_cast<int_>(-110.2f), + static_cast<int_>(-19.3f), + static_cast<int_>(26.7f) + ) + ); + + compute::svm_free(context, ptr); +} + +BOOST_AUTO_TEST_CASE(copy_async_on_device_svm_to_svm_float_to_int) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::float_; + + float_ data[] = { 0.1f, -10.2f, -1.3f, 2.7f }; + compute::svm_ptr<float_> ptr = compute::svm_alloc<float_>(context, 4); + compute::svm_ptr<int_> ptr2 = compute::svm_alloc<int_>(context, 4); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_WRITE); + for(size_t i = 0; i < 4; i++) { + static_cast<float_*>(ptr.get())[i] = data[i]; + } + queue.enqueue_svm_unmap(ptr.get()).wait(); + + // copy host float svm to int svm + compute::future<bc::svm_ptr<int_> > future = + bc::copy_async(ptr, ptr + 4, ptr2, queue); + future.wait(); + + queue.enqueue_svm_map(ptr2.get(), 4 * sizeof(cl_int), CL_MAP_READ); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + static_cast<int_*>(ptr2.get()), + ( + static_cast<int_>(0.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(-1.3f), + static_cast<int_>(2.7f) + ) + ); + queue.enqueue_svm_unmap(ptr2.get()).wait(); + + compute::svm_free(context, ptr); + compute::svm_free(context, ptr2); +} +#endif + +// DEVICE -> HOST + +BOOST_AUTO_TEST_CASE(copy_to_host_float_to_int) +{ + using compute::int_; + using compute::float_; + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_vector(data, data + 4, queue); + + std::vector<int_> host_vector(4); + // copy device float vector to int host vector + bc::copy(device_vector.begin(), device_vector.end(), host_vector.begin(), queue); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); +} + +BOOST_AUTO_TEST_CASE(copy_to_host_float_to_int_map) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_host_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + + // force copy_to_host_map (mapping device vector to the host) + parameters->set(cache_key, "map_copy_threshold", 1024); + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_vector(data, data + 4, queue); + + std::vector<int_> host_vector(4); + // copy device float vector to int host vector + bc::copy(device_vector.begin(), device_vector.end(), host_vector.begin(), queue); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_to_host_float_to_int_convert_on_host) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_host_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by copying input device vector to temporary + // host vector of the same type and then copying from that temporary + // vector to result using std::copy() + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 1024); + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_vector(data, data + 4, queue); + + std::vector<int_> host_vector(4); + // copy device float vector to int host vector + bc::copy(device_vector.begin(), device_vector.end(), host_vector.begin(), queue); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_to_host_float_to_int_convert_on_device) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_host_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by mapping output data to the device memory + // and using transform operation for casting & copying + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 0); + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_vector(data, data + 4, queue); + + std::vector<int_> host_vector(4); + // copy device float vector to int host vector + bc::copy(device_vector.begin(), device_vector.end(), host_vector.begin(), queue); + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +// Test copying from a bc::vector to a std::list . This differs from +// the test copying to std::vector because std::list has non-contiguous +// storage for its data values. +BOOST_AUTO_TEST_CASE(copy_to_host_list_float_to_int_map) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_host_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + + // force copy_to_host_map (mapping device vector to the host) + parameters->set(cache_key, "map_copy_threshold", 1024); + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_vector(data, data + 4, queue); + + std::list<int_> host_list(4); + // copy device float vector to int host vector + bc::copy(device_vector.begin(), device_vector.end(), host_list.begin(), queue); + + int_ expected[4] = { + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + }; + BOOST_CHECK_EQUAL_COLLECTIONS( + host_list.begin(), host_list.end(), + expected, expected + 4 + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); +} + +// Test copying from a bc::vector to a std::list . This differs from +// the test copying to std::vector because std::list has non-contiguous +// storage for its data values. +BOOST_AUTO_TEST_CASE(copy_to_host_list_float_to_int_covert_on_host) +{ + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_host_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by copying input device vector to temporary + // host vector of the same type and then copying from that temporary + // vector to result using std::copy() + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 1024); + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_vector(data, data + 4, queue); + + std::list<int_> host_list(4); + // copy device float vector to int host vector + bc::copy(device_vector.begin(), device_vector.end(), host_list.begin(), queue); + int_ expected[4] = { + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + }; + BOOST_CHECK_EQUAL_COLLECTIONS( + host_list.begin(), host_list.end(), + expected, expected + 4 + ); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_async_to_host_float_to_int) +{ + using compute::int_; + using compute::float_; + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_vector(data, data + 4, queue); + std::vector<int_> host_vector(device_vector.size()); + + // copy device float vector to host int vector + compute::future<void> future = + bc::copy_async( + device_vector.begin(), + device_vector.end(), + host_vector.begin(), + queue + ); + future.wait(); + + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + static_cast<int_>(6.1f), + static_cast<int_>(-10.2f), + static_cast<int_>(19.3f), + static_cast<int_>(25.4f) + ) + ); +} + +BOOST_AUTO_TEST_CASE(copy_async_to_host_float_to_int_empty) +{ + using compute::int_; + using compute::float_; + + float_ data[] = { 6.1f, -10.2f, 19.3f, 25.4f }; + bc::vector<float_> device_vector(data, data + 4, queue); + std::vector<int_> host_vector(device_vector.size(), int_(1)); + + // copy device float vector to host int vector + compute::future<void> future = + bc::copy_async( + device_vector.begin(), + device_vector.begin(), + host_vector.begin(), + queue + ); + if(future.valid()) { + future.wait(); + } + + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + int_(1), + int_(1), + int_(1), + int_(1) + ) + ); +} + +// SVM requires OpenCL 2.0 +#if defined(BOOST_COMPUTE_CL_VERSION_2_0) || defined(BOOST_COMPUTE_DOXYGEN_INVOKED) +BOOST_AUTO_TEST_CASE(copy_to_host_svm_float_to_int_map) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_host_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + + // force copy_to_host_map (mapping device vector to the host) + parameters->set(cache_key, "map_copy_threshold", 1024); + + float_ data[] = { 6.1f, 1.2f, 1.3f, -66.7f }; + std::vector<int_> host_vector(4, 0); + compute::svm_ptr<float_> ptr = compute::svm_alloc<float_>(context, 4); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_WRITE); + for(size_t i = 0; i < 4; i++) { + static_cast<float_*>(ptr.get())[i] = data[i]; + } + queue.enqueue_svm_unmap(ptr.get()).wait(); + + // copy host float svm data to int host vector + bc::copy(ptr, ptr + 4, host_vector.begin(), queue); + + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + static_cast<int_>(6.1f), + static_cast<int_>(1.2f), + static_cast<int_>(1.3f), + static_cast<int_>(-66.7f) + ) + ); + + compute::svm_free(context, ptr); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_to_host_svm_float_to_int_convert_on_host) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + if(bug_in_svmmemcpy(device)){ + std::cerr << "skipping svmmemcpy test case" << std::endl; + return; + } + + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_host_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by copying input device vector to temporary + // host vector of the same type and then copying from that temporary + // vector to result using std::copy() + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 1024); + + float_ data[] = { 6.1f, 1.2f, 1.3f, 766.7f }; + std::vector<int_> host_vector(4, 0); + compute::svm_ptr<float_> ptr = compute::svm_alloc<float_>(context, 4); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_WRITE); + for(size_t i = 0; i < 4; i++) { + static_cast<float_*>(ptr.get())[i] = data[i]; + } + queue.enqueue_svm_unmap(ptr.get()).wait(); + + // copy host float svm data to int host vector + bc::copy(ptr, ptr + 4, host_vector.begin(), queue); + + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + static_cast<int_>(6.1f), + static_cast<int_>(1.2f), + static_cast<int_>(1.3f), + static_cast<int_>(766.7f) + ) + ); + + compute::svm_free(context, ptr); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(copy_to_host_svm_float_to_int_transform) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + using compute::int_; + using compute::uint_; + using compute::float_; + + std::string cache_key = + std::string("__boost_compute_copy_to_host_float_int"); + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "map_copy_threshold", 0); + uint_ direct_copy_threshold = + parameters->get(cache_key, "direct_copy_threshold", 0); + + // force copying by copying input device vector to temporary + // host vector of the same type and then copying from that temporary + // vector to result using std::copy() + parameters->set(cache_key, "map_copy_threshold", 0); + parameters->set(cache_key, "direct_copy_threshold", 0); + + float_ data[] = { 0.1f, 11.2f, 1.3f, -66.7f }; + std::vector<int_> host_vector(4, 0); + compute::svm_ptr<float_> ptr = compute::svm_alloc<float_>(context, 4); + + queue.enqueue_svm_map(ptr.get(), 4 * sizeof(cl_int), CL_MAP_WRITE); + for(size_t i = 0; i < 4; i++) { + static_cast<float_*>(ptr.get())[i] = data[i]; + } + queue.enqueue_svm_unmap(ptr.get()).wait(); + + // copy host float svm data to int host vector + bc::copy(ptr, ptr + 4, host_vector.begin(), queue); + + CHECK_HOST_RANGE_EQUAL( + int_, + 4, + host_vector.begin(), + ( + static_cast<int_>(0.1f), + static_cast<int_>(11.2f), + static_cast<int_>(1.3f), + static_cast<int_>(-66.7f) + ) + ); + + compute::svm_free(context, ptr); + + // restore + parameters->set(cache_key, "map_copy_threshold", map_copy_threshold); + parameters->set(cache_key, "direct_copy_threshold", direct_copy_threshold); +} +#endif + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_count.cpp b/src/boost/libs/compute/test/test_count.cpp new file mode 100644 index 00000000..d1fb3aea --- /dev/null +++ b/src/boost/libs/compute/test/test_count.cpp @@ -0,0 +1,221 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestCount +#include <boost/test/unit_test.hpp> + +#include <string> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/function.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/count.hpp> +#include <boost/compute/algorithm/count_if.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/constant_iterator.hpp> + +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(count_int) +{ + int data[] = { 1, 2, 1, 2, 3 }; + bc::vector<int> vector(data, data + 5, queue); + BOOST_CHECK_EQUAL(bc::count(vector.begin(), vector.end(), 1, queue), size_t(2)); + BOOST_CHECK_EQUAL(bc::count(vector.begin(), vector.end(), 2, queue), size_t(2)); + BOOST_CHECK_EQUAL(bc::count(vector.begin(), vector.end(), 3, queue), size_t(1)); + BOOST_CHECK_EQUAL(bc::count(vector.begin() + 1, vector.end(), 1, queue), size_t(1)); + BOOST_CHECK_EQUAL(bc::count(vector.begin() + 1, vector.end() - 1, 3, queue), size_t(0)); + BOOST_CHECK_EQUAL(bc::count(vector.begin() + 1, vector.end() - 1, 2, queue), size_t(2)); +} + +BOOST_AUTO_TEST_CASE(count_constant_int_range) +{ + BOOST_CHECK_EQUAL( + bc::count(bc::make_constant_iterator(18, 0), + bc::make_constant_iterator(18, 5), + 18, + queue), + size_t(5) + ); + + BOOST_CHECK_EQUAL( + bc::count(bc::make_constant_iterator(19, 0), + bc::make_constant_iterator(19, 5), + 18, + queue), + size_t(0) + ); +} + +BOOST_AUTO_TEST_CASE(count_if_greater_than_two) +{ + float data[] = { 1.0f, 2.5f, -1.0f, 3.0f, 5.0f, -8.0f }; + bc::vector<float> vector(data, data + 5, queue); + + BOOST_CHECK_EQUAL( + bc::count_if(vector.begin(), vector.end(), bc::_1 > 2.0f, queue), + size_t(3) + ); +} + +BOOST_AUTO_TEST_CASE(count_int4) +{ + int data[] = { 1, 2, 3, 4, + 4, 5, 6, 7, + 7, 8, 9, 1, + 1, 2, 3, 4, + 4, 5, 6, 7, + 0, 3, 2, 2 }; + bc::vector<bc::int4_> vector(reinterpret_cast<bc::int4_ *>(data), + reinterpret_cast<bc::int4_ *>(data) + 6, + queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(6)); + + BOOST_CHECK_EQUAL( + bc::count(vector.begin(), vector.end(), bc::int4_(1, 2, 3, 4), queue), + size_t(2) + ); + BOOST_CHECK_EQUAL( + bc::count(vector.begin(), vector.end(), bc::int4_(4, 5, 6, 7), queue), + size_t(2) + ); + BOOST_CHECK_EQUAL( + bc::count(vector.begin(), vector.end(), bc::int4_(7, 8, 9, 1), queue), + size_t(1) + ); + BOOST_CHECK_EQUAL( + bc::count(vector.begin(), vector.end(), bc::int4_(0, 3, 2, 2), queue), + size_t(1) + ); + BOOST_CHECK_EQUAL( + bc::count(vector.begin(), vector.end(), bc::int4_(3, 4, 4, 5), queue), + size_t(0) + ); + BOOST_CHECK_EQUAL( + bc::count(vector.begin(), vector.end(), bc::int4_(1, 2, 3, 0), queue), + size_t(0) + ); + BOOST_CHECK_EQUAL( + bc::count(vector.begin(), vector.end(), bc::int4_(1, 9, 8, 7), queue), + size_t(0) + ); +} + +BOOST_AUTO_TEST_CASE(count_newlines) +{ + std::string string = "abcdefg\nhijklmn\nopqrs\ntuv\nwxyz\n"; + compute::vector<char> data(string.size(), context); + compute::copy(string.begin(), string.end(), data.begin(), queue); + + BOOST_CHECK_EQUAL( + compute::count(data.begin(), data.end(), '\n', queue), + size_t(5) + ); +} + +BOOST_AUTO_TEST_CASE(count_uchar) +{ + using boost::compute::uchar_; + + unsigned char data[] = { 0x00, 0x10, 0x2F, 0x10, 0x01, 0x00, 0x01, 0x00 }; + compute::vector<uchar_> vector(8, context); + compute::copy(data, data + 8, vector.begin(), queue); + + BOOST_CHECK_EQUAL( + compute::count(vector.begin(), vector.end(), 0x00, queue), + size_t(3) + ); + BOOST_CHECK_EQUAL( + compute::count(vector.begin(), vector.end(), 0x10, queue), + size_t(2) + ); + BOOST_CHECK_EQUAL( + compute::count(vector.begin(), vector.end(), 0x2F, queue), + size_t(1) + ); + BOOST_CHECK_EQUAL( + compute::count(vector.begin(), vector.end(), 0x01, queue), + size_t(2) + ); + BOOST_CHECK_EQUAL( + compute::count(vector.begin(), vector.end(), 0xFF, queue), + size_t(0) + ); +} + +BOOST_AUTO_TEST_CASE(count_vector_component) +{ + int data[] = { + 1, 2, + 3, 4, + 5, 6, + 7, 8 + }; + + using boost::compute::int2_; + + compute::vector<int2_> vector(4, context); + compute::copy( + reinterpret_cast<int2_ *>(data), + reinterpret_cast<int2_ *>(data) + 4, + vector.begin(), + queue + ); + + using boost::compute::lambda::_1; + using boost::compute::lambda::get; + + BOOST_CHECK_EQUAL( + compute::count_if(vector.begin(), vector.end(), get<0>(_1) < 4, queue), + size_t(2) + ); + BOOST_CHECK_EQUAL( + compute::count_if(vector.begin(), vector.end(), get<1>(_1) > 3, queue), + size_t(3) + ); +} + +BOOST_AUTO_TEST_CASE(count_if_odd) +{ + compute::vector<int> vec(2048, context); + compute::iota(vec.begin(), vec.end(), 0, queue); + + BOOST_COMPUTE_FUNCTION(bool, is_odd, (int x), + { + return x & 1; + }); + + BOOST_CHECK_EQUAL( + compute::count_if(vec.begin(), vec.end(), is_odd, queue), vec.size() / 2 + ); +} + +BOOST_AUTO_TEST_CASE(count_if_with_reduce) +{ + compute::vector<int> vec(2048, context); + compute::iota(vec.begin(), vec.end(), 0, queue); + + using boost::compute::lambda::_1; + + BOOST_CHECK_EQUAL( + compute::detail::count_if_with_reduce( + vec.begin(), vec.end(), _1 > 1024, queue + ), + size_t(1023) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_counting_iterator.cpp b/src/boost/libs/compute/test/test_counting_iterator.cpp new file mode 100644 index 00000000..46c24ad4 --- /dev/null +++ b/src/boost/libs/compute/test/test_counting_iterator.cpp @@ -0,0 +1,100 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestCountingIterator +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(value_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::counting_iterator<int>::value_type, + int + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::counting_iterator<float>::value_type, + float + >::value + )); +} + +BOOST_AUTO_TEST_CASE(distance) +{ + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_counting_iterator(0), + boost::compute::make_counting_iterator(10) + ), + std::ptrdiff_t(10) + ); + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_counting_iterator(5), + boost::compute::make_counting_iterator(10) + ), + std::ptrdiff_t(5) + ); + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_counting_iterator(-5), + boost::compute::make_counting_iterator(5) + ), + std::ptrdiff_t(10) + ); +} + +BOOST_AUTO_TEST_CASE(copy) +{ + boost::compute::vector<int> vector(10, context); + + boost::compute::copy( + boost::compute::make_counting_iterator(1), + boost::compute::make_counting_iterator(11), + vector.begin(), + queue + ); + CHECK_RANGE_EQUAL( + int, 10, vector, + (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) + ); +} + +BOOST_AUTO_TEST_CASE(iota_with_copy_doctest) +{ +//! [iota_with_copy] +using boost::compute::make_counting_iterator; + +boost::compute::vector<int> result(5, context); + +boost::compute::copy( + make_counting_iterator(1), make_counting_iterator(6), result.begin(), queue +); + +// result == { 1, 2, 3, 4, 5 } +//! [iota_with_copy] + + CHECK_RANGE_EQUAL(int, 5, result, (1, 2, 3, 4, 5)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_device.cpp b/src/boost/libs/compute/test/test_device.cpp new file mode 100644 index 00000000..bc370c1e --- /dev/null +++ b/src/boost/libs/compute/test/test_device.cpp @@ -0,0 +1,293 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestDevice +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/device.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/detail/nvidia_compute_capability.hpp> + +#include "opencl_version_check.hpp" + +BOOST_AUTO_TEST_CASE(null_device) +{ + boost::compute::device null; + BOOST_CHECK(null.id() == cl_device_id()); + BOOST_CHECK(null.get() == cl_device_id()); +} + +BOOST_AUTO_TEST_CASE(default_device_doctest) +{ +//! [default_gpu] +boost::compute::device gpu = boost::compute::system::default_device(); +//! [default_gpu] + + BOOST_CHECK(gpu.id()); +} + +BOOST_AUTO_TEST_CASE(device_platform) +{ + boost::compute::platform p = boost::compute::system::platforms().at(0); + BOOST_CHECK(p == p.devices().at(0).platform()); +} + +BOOST_AUTO_TEST_CASE(get_device_name) +{ + boost::compute::device gpu = boost::compute::system::default_device(); + if(gpu.id()){ + BOOST_CHECK(!gpu.name().empty()); + } +} + +BOOST_AUTO_TEST_CASE(equality_operator) +{ + boost::compute::device device1 = boost::compute::system::default_device(); + BOOST_CHECK(device1 == device1); + + boost::compute::device device2 = device1; + BOOST_CHECK(device1 == device2); +} + +BOOST_AUTO_TEST_CASE(get_max_work_item_sizes) +{ + boost::compute::device device = boost::compute::system::default_device(); + + std::vector<size_t> max_work_item_sizes = + device.get_info<std::vector<size_t> >(CL_DEVICE_MAX_WORK_ITEM_SIZES); + BOOST_CHECK_GE(max_work_item_sizes.size(), size_t(3)); + BOOST_CHECK_GE(max_work_item_sizes[0], size_t(1)); + BOOST_CHECK_GE(max_work_item_sizes[1], size_t(1)); + BOOST_CHECK_GE(max_work_item_sizes[2], size_t(1)); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_1_2 + +// returns true if the device supports the partitioning type +bool supports_partition_type(const boost::compute::device &device, + cl_device_partition_property type) +{ + const std::vector<cl_device_partition_property> properties = + device.get_info<std::vector<cl_device_partition_property> >( + CL_DEVICE_PARTITION_PROPERTIES + ); + + return std::find(properties.begin(), + properties.end(), + type) != properties.end(); +} + +BOOST_AUTO_TEST_CASE(partition_device_equally) +{ + // get default device and ensure it has at least two compute units + boost::compute::device device = boost::compute::system::default_device(); + + REQUIRES_OPENCL_VERSION(1,2); + + if(device.compute_units() < 2){ + std::cout << "skipping test: " + << "device does not have enough compute units" + << std::endl; + return; + } + + // check that the device supports partitioning equally + if(!supports_partition_type(device, CL_DEVICE_PARTITION_EQUALLY)){ + std::cout << "skipping test: " + << "device does not support CL_DEVICE_PARTITION_EQUALLY" + << std::endl; + return; + } + + // ensure device is not a sub-device + BOOST_CHECK(device.is_subdevice() == false); + + // partition default device into sub-devices with one compute unit each + std::vector<boost::compute::device> + sub_devices = device.partition_equally(1); + BOOST_CHECK_EQUAL(sub_devices.size(), size_t(device.compute_units())); + + // verify each of the sub-devices + for(size_t i = 0; i < sub_devices.size(); i++){ + const boost::compute::device &sub_device = sub_devices[i]; + + // ensure parent device id is correct + cl_device_id parent_id = + sub_device.get_info<cl_device_id>(CL_DEVICE_PARENT_DEVICE); + BOOST_CHECK(parent_id == device.id()); + + // ensure device is a sub-device + BOOST_CHECK(sub_device.is_subdevice() == true); + + // check number of compute units + BOOST_CHECK_EQUAL(sub_device.compute_units(), size_t(1)); + } +} + +// used to sort devices by number of compute units +bool compare_compute_units(const boost::compute::device &a, + const boost::compute::device &b) +{ + return a.compute_units() < b.compute_units(); +} + +BOOST_AUTO_TEST_CASE(partition_by_counts) +{ + // get default device and ensure it has at least four compute units + boost::compute::device device = boost::compute::system::default_device(); + + REQUIRES_OPENCL_VERSION(1,2); + + if(device.compute_units() < 4){ + std::cout << "skipping test: " + << "device does not have enough compute units" + << std::endl; + return; + } + + // check that the device supports partitioning by counts + if(!supports_partition_type(device, CL_DEVICE_PARTITION_BY_COUNTS)){ + std::cout << "skipping test: " + << "device does not support CL_DEVICE_PARTITION_BY_COUNTS" + << std::endl; + return; + } + + // ensure device is not a sub-device + BOOST_CHECK(device.is_subdevice() == false); + + // create vector of sub-device compute unit counts + std::vector<size_t> counts; + counts.push_back(2); + counts.push_back(1); + counts.push_back(1); + + // partition default device into sub-devices according to counts + std::vector<boost::compute::device> + sub_devices = device.partition_by_counts(counts); + BOOST_CHECK_EQUAL(sub_devices.size(), size_t(3)); + + // sort sub-devices by number of compute units (see issue #185) + std::sort(sub_devices.begin(), sub_devices.end(), compare_compute_units); + + // verify each of the sub-devices + BOOST_CHECK_EQUAL(sub_devices[0].compute_units(), size_t(1)); + BOOST_CHECK_EQUAL(sub_devices[1].compute_units(), size_t(1)); + BOOST_CHECK_EQUAL(sub_devices[2].compute_units(), size_t(2)); +} + +BOOST_AUTO_TEST_CASE(partition_by_affinity_domain) +{ + // get default device and ensure it has at least two compute units + boost::compute::device device = boost::compute::system::default_device(); + + REQUIRES_OPENCL_VERSION(1,2); + + if(device.compute_units() < 2){ + std::cout << "skipping test: " + << "device does not have enough compute units" + << std::endl; + return; + } + + // check that the device supports splitting by affinity domains + if(!supports_partition_type(device, CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE)){ + std::cout << "skipping test: " + << "device does not support partitioning by affinity domain" + << std::endl; + return; + } + + // ensure device is not a sub-device + BOOST_CHECK(device.is_subdevice() == false); + + std::vector<boost::compute::device> sub_devices = + device.partition_by_affinity_domain( + CL_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE); + BOOST_CHECK(sub_devices.size() > 0); + BOOST_CHECK(sub_devices[0].is_subdevice() == true); +} +#endif // BOOST_COMPUTE_CL_VERSION_1_2 + +BOOST_AUTO_TEST_CASE(nvidia_compute_capability) +{ + boost::compute::device device = boost::compute::system::default_device(); + int major, minor; + boost::compute::detail::get_nvidia_compute_capability(device, major, minor); + boost::compute::detail::check_nvidia_compute_capability(device, 3, 0); +} + +BOOST_AUTO_TEST_CASE(get_info_specializations) +{ + boost::compute::device device = boost::compute::system::default_device(); + + std::cout << device.get_info<CL_DEVICE_NAME>() << std::endl; +} + +#ifdef BOOST_COMPUTE_CL_VERSION_2_1 +BOOST_AUTO_TEST_CASE(get_host_timer) +{ + boost::compute::device device = boost::compute::system::default_device(); + + REQUIRES_OPENCL_VERSION(2, 1); + + BOOST_CHECK(device.get_host_timer() != 0); + + #ifndef BOOST_COMPUTE_NO_HDR_CHRONO + typedef std::chrono::milliseconds stdms; + BOOST_CHECK(device.get_host_timer<stdms>().count() != 0); + #endif + + #ifndef BOOST_COMPUTE_NO_BOOST_CHRONO + typedef boost::chrono::milliseconds bms; + BOOST_CHECK(device.get_host_timer<bms>().count() != 0); + #endif +} + +BOOST_AUTO_TEST_CASE(get_device_and_host_timer) +{ + boost::compute::device device = boost::compute::system::default_device(); + + REQUIRES_OPENCL_VERSION(2, 1); + + typedef std::pair<boost::compute::ulong_, boost::compute::ulong_> dah_timer; + dah_timer timer; + BOOST_CHECK_NO_THROW(timer = device.get_device_and_host_timer()); + BOOST_CHECK(timer.first != 0); + BOOST_CHECK(timer.second != 0); + + #ifndef BOOST_COMPUTE_NO_HDR_CHRONO + typedef std::chrono::milliseconds stdms; + BOOST_CHECK(device.get_device_and_host_timer<stdms>().first.count() != 0); + BOOST_CHECK(device.get_device_and_host_timer<stdms>().second.count() != 0); + #endif + + #ifndef BOOST_COMPUTE_NO_BOOST_CHRONO + typedef boost::chrono::milliseconds bms; + BOOST_CHECK(device.get_device_and_host_timer<bms>().first.count() != 0); + BOOST_CHECK(device.get_device_and_host_timer<bms>().second.count() != 0); + #endif +} + +BOOST_AUTO_TEST_CASE(get_info_opencl21_queries) +{ + boost::compute::device device = boost::compute::system::default_device(); + + REQUIRES_OPENCL_VERSION(2, 1); + + BOOST_CHECK(!device.get_info<CL_DEVICE_IL_VERSION>().empty()); + BOOST_CHECK(device.get_info<CL_DEVICE_MAX_NUM_SUB_GROUPS>() > 0); + BOOST_CHECK_NO_THROW( + device.get_info<CL_DEVICE_SUB_GROUP_INDEPENDENT_FORWARD_PROGRESS>() + ); +} +#endif // BOOST_COMPUTE_CL_VERSION_2_1 diff --git a/src/boost/libs/compute/test/test_discard_iterator.cpp b/src/boost/libs/compute/test/test_discard_iterator.cpp new file mode 100644 index 00000000..94a3d700 --- /dev/null +++ b/src/boost/libs/compute/test/test_discard_iterator.cpp @@ -0,0 +1,94 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestDiscardIterator +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/copy_if.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/discard_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(value_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::discard_iterator::value_type, void + >::value + )); +} + +BOOST_AUTO_TEST_CASE(distance) +{ + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_discard_iterator(0), + boost::compute::make_discard_iterator(10) + ), + std::ptrdiff_t(10) + ); + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_discard_iterator(5), + boost::compute::make_discard_iterator(10) + ), + std::ptrdiff_t(5) + ); +} + +BOOST_AUTO_TEST_CASE(discard_copy) +{ + boost::compute::vector<int> vector(10, context); + boost::compute::fill(vector.begin(), vector.end(), 42, queue); + + boost::compute::copy( + vector.begin(), vector.end(), + boost::compute::make_discard_iterator(), + queue + ); +} + +BOOST_AUTO_TEST_CASE(discard_copy_if) +{ + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + boost::compute::vector<int> vector(data, data + 8, queue); + + using boost::compute::lambda::_1; + + boost::compute::discard_iterator end = boost::compute::copy_if( + vector.begin(), vector.end(), + boost::compute::make_discard_iterator(), + _1 > 4, + queue + ); + BOOST_CHECK(std::distance(boost::compute::discard_iterator(), end) == 4); +} + +BOOST_AUTO_TEST_CASE(discard_fill) +{ + boost::compute::fill( + boost::compute::make_discard_iterator(0), + boost::compute::make_discard_iterator(100), + 42, + queue + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_discrete_distribution.cpp b/src/boost/libs/compute/test/test_discrete_distribution.cpp new file mode 100644 index 00000000..6c4b8d71 --- /dev/null +++ b/src/boost/libs/compute/test/test_discrete_distribution.cpp @@ -0,0 +1,237 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestDiscreteDistribution +#include <boost/test/unit_test.hpp> + +#include <vector> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/count_if.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/discrete_distribution.hpp> +#include <boost/compute/lambda.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(discrete_distribution_doctest) +{ + using boost::compute::uint_; + using boost::compute::lambda::_1; + + boost::compute::vector<uint_> vec(100, context); + +//! [generate] +// initialize the default random engine +boost::compute::default_random_engine engine(queue); + +// initialize weights +int weights[] = {2, 2}; + +// setup the discrete distribution to produce integers 0 and 1 +// with equal weights +boost::compute::discrete_distribution<uint_> distribution(weights, weights+2); + +// generate the random values and store them to 'vec' +distribution.generate(vec.begin(), vec.end(), engine, queue); +// ! [generate] + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + vec.begin(), vec.end(), _1 > 1, queue + ), + size_t(0) + ); +} + +BOOST_AUTO_TEST_CASE(discrete_distribution) +{ + using boost::compute::uint_; + using boost::compute::lambda::_1; + + size_t size = 100; + boost::compute::vector<uint_> vec(size, context); + + // initialize the default random engine + boost::compute::default_random_engine engine(queue); + + // initialize weights + int weights[] = {10, 40, 40, 10}; + + // setup the discrete distribution + boost::compute::discrete_distribution<uint_> distribution( + weights, weights + 4 + ); + + std::vector<double> p = distribution.probabilities(); + BOOST_CHECK_CLOSE(p[0], double(0.1), 0.001); + BOOST_CHECK_CLOSE(p[1], double(0.4), 0.001); + BOOST_CHECK_CLOSE(p[2], double(0.4), 0.001); + BOOST_CHECK_CLOSE(p[3], double(0.1), 0.001); + + BOOST_CHECK_EQUAL((distribution.min)(), uint_(0)); + BOOST_CHECK_EQUAL((distribution.max)(), uint_(3)); + + // generate the random values and store them to 'vec' + distribution.generate(vec.begin(), vec.end(), engine, queue); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + vec.begin(), vec.end(), _1 < 4, queue + ), + size + ); +} + +BOOST_AUTO_TEST_CASE(discrete_distribution_default_ctor) +{ + using boost::compute::uint_; + using boost::compute::lambda::_1; + + size_t size = 100; + boost::compute::vector<uint_> vec(size, context); + + // initialize the default random engine + boost::compute::default_random_engine engine(queue); + + // call default constructor + boost::compute::discrete_distribution<uint_> distribution; + + std::vector<double> p = distribution.probabilities(); + BOOST_CHECK_CLOSE(p[0], double(1), 0.001); + + // generate the random values and store them to 'vec' + distribution.generate(vec.begin(), vec.end(), engine, queue); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + vec.begin(), vec.end(), _1 == 0, queue + ), + size + ); +} + +BOOST_AUTO_TEST_CASE(discrete_distribution_one_weight) +{ + using boost::compute::uint_; + using boost::compute::lambda::_1; + + size_t size = 100; + boost::compute::vector<uint_> vec(size, context); + + // initialize the default random engine + boost::compute::default_random_engine engine(queue); + + std::vector<int> weights(1, 1); + // call default constructor + boost::compute::discrete_distribution<uint_> distribution( + weights.begin(), weights.end() + ); + + std::vector<double> p = distribution.probabilities(); + BOOST_CHECK_CLOSE(p[0], double(1), 0.001); + + BOOST_CHECK_EQUAL((distribution.min)(), uint_(0)); + BOOST_CHECK_EQUAL((distribution.max)(), uint_(0)); + + // generate the random values and store them to 'vec' + distribution.generate(vec.begin(), vec.end(), engine, queue); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + vec.begin(), vec.end(), _1 == 0, queue + ), + size + ); +} + +BOOST_AUTO_TEST_CASE(discrete_distribution_empty_weights) +{ + using boost::compute::uint_; + using boost::compute::lambda::_1; + + size_t size = 100; + boost::compute::vector<uint_> vec(size, context); + + // initialize the default random engine + boost::compute::default_random_engine engine(queue); + + std::vector<int> weights; + // weights.begin() == weights.end() + boost::compute::discrete_distribution<uint_> distribution( + weights.begin(), weights.end() + ); + + std::vector<double> p = distribution.probabilities(); + BOOST_CHECK_CLOSE(p[0], double(1), 0.001); + + BOOST_CHECK_EQUAL((distribution.min)(), uint_(0)); + BOOST_CHECK_EQUAL((distribution.max)(), uint_(0)); + + // generate the random values and store them to 'vec' + distribution.generate(vec.begin(), vec.end(), engine, queue); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + vec.begin(), vec.end(), _1 == 0, queue + ), + size + ); +} + +BOOST_AUTO_TEST_CASE(discrete_distribution_uchar) +{ + using boost::compute::uchar_; + using boost::compute::uint_; + using boost::compute::lambda::_1; + + size_t size = 100; + boost::compute::vector<uchar_> uchar_vec(size, context); + boost::compute::vector<uint_> uint_vec(size, context); + + // initialize the default random engine + boost::compute::default_random_engine engine(queue); + + // initialize weights + std::vector<int> weights(258, 0); + weights[257] = 1; + + // setup the discrete distribution + boost::compute::discrete_distribution<uchar_> distribution( + weights.begin(), weights.end() + ); + + BOOST_CHECK_EQUAL((distribution.min)(), uchar_(0)); + BOOST_CHECK_EQUAL((distribution.max)(), uchar_(255)); + + // generate the random uchar_ values to the uchar_ vector + distribution.generate(uchar_vec.begin(), uchar_vec.end(), engine, queue); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + uchar_vec.begin(), uchar_vec.end(), _1 == uchar_(1), queue + ), + size + ); + + // generate the random uchar_ values to the uint_ vector + distribution.generate(uint_vec.begin(), uint_vec.end(), engine, queue); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + uint_vec.begin(), uint_vec.end(), _1 == uint_(1), queue + ), + size + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_dynamic_bitset.cpp b/src/boost/libs/compute/test/test_dynamic_bitset.cpp new file mode 100644 index 00000000..1afb905b --- /dev/null +++ b/src/boost/libs/compute/test/test_dynamic_bitset.cpp @@ -0,0 +1,96 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestDynamicBitset +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/dynamic_bitset.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(set_and_test) +{ + compute::dynamic_bitset<> bits(1024, queue); + + bits.set(1, queue); + BOOST_CHECK(bits.test(1, queue) == true); + BOOST_CHECK(bits.test(2, queue) == false); + + bits.set(1, false, queue); + BOOST_CHECK(bits.test(1, queue) == false); + BOOST_CHECK(bits.test(2, queue) == false); +} + +BOOST_AUTO_TEST_CASE(count) +{ + compute::dynamic_bitset<> bits(1024, queue); + BOOST_CHECK_EQUAL(bits.count(queue), size_t(0)); + + bits.set(1, queue); + bits.set(8, queue); + bits.set(129, queue); + BOOST_CHECK_EQUAL(bits.count(queue), size_t(3)); + + bits.set(8, false, queue); + BOOST_CHECK_EQUAL(bits.count(queue), size_t(2)); + + bits.reset(queue); + BOOST_CHECK_EQUAL(bits.count(queue), size_t(0)); +} + +BOOST_AUTO_TEST_CASE(resize) +{ + compute::dynamic_bitset<> bits(0, queue); + BOOST_CHECK_EQUAL(bits.size(), size_t(0)); + BOOST_CHECK_EQUAL(bits.empty(), true); + BOOST_CHECK_EQUAL(bits.count(queue), size_t(0)); + + bits.resize(100, queue); + BOOST_CHECK_EQUAL(bits.size(), size_t(100)); + BOOST_CHECK_EQUAL(bits.empty(), false); + BOOST_CHECK_EQUAL(bits.count(queue), size_t(0)); + + bits.set(42, true, queue); + BOOST_CHECK_EQUAL(bits.count(queue), size_t(1)); + + bits.resize(0, queue); + BOOST_CHECK_EQUAL(bits.size(), size_t(0)); + BOOST_CHECK_EQUAL(bits.empty(), true); + BOOST_CHECK_EQUAL(bits.count(queue), size_t(0)); +} + +BOOST_AUTO_TEST_CASE(none_and_any) +{ + compute::dynamic_bitset<> bits(1024, queue); + BOOST_CHECK(bits.any(queue) == false); + BOOST_CHECK(bits.none(queue) == true); + + bits.set(1023, queue); + BOOST_CHECK(bits.any(queue) == true); + BOOST_CHECK(bits.none(queue) == false); + + bits.set(1023, false, queue); + BOOST_CHECK(bits.any(queue) == false); + BOOST_CHECK(bits.none(queue) == true); + + bits.set(1, queue); + BOOST_CHECK(bits.any(queue) == true); + BOOST_CHECK(bits.none(queue) == false); + + bits.reset(queue); + BOOST_CHECK(bits.any(queue) == false); + BOOST_CHECK(bits.none(queue) == true); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_equal.cpp b/src/boost/libs/compute/test/test_equal.cpp new file mode 100644 index 00000000..0b568c91 --- /dev/null +++ b/src/boost/libs/compute/test/test_equal.cpp @@ -0,0 +1,61 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestEqual +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/equal.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/container/string.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(equal_int) +{ + int data1[] = { 1, 2, 3, 4, 5, 6 }; + int data2[] = { 1, 2, 3, 7, 5, 6 }; + + boost::compute::vector<int> vector1(data1, data1 + 6, queue); + boost::compute::vector<int> vector2(data2, data2 + 6, queue); + + BOOST_CHECK(boost::compute::equal(vector1.begin(), vector1.end(), + vector2.begin(), queue) == false); + BOOST_CHECK(boost::compute::equal(vector1.begin(), vector1.begin() + 2, + vector2.begin(), queue) == true); + BOOST_CHECK(boost::compute::equal(vector1.begin() + 4, vector1.end(), + vector2.begin() + 4, queue) == true); +} + +BOOST_AUTO_TEST_CASE(equal_string) +{ + boost::compute::string a = "abcdefghijk"; + boost::compute::string b = "abcdefghijk"; + boost::compute::string c = "abcdezghijk"; + + BOOST_CHECK(boost::compute::equal(a.begin(), a.end(), b.begin(), queue) == true); + BOOST_CHECK(boost::compute::equal(a.begin(), a.end(), c.begin(), queue) == false); +} + +BOOST_AUTO_TEST_CASE(equal_different_range_sizes) +{ + boost::compute::vector<int> a(10, context); + boost::compute::vector<int> b(20, context); + + boost::compute::fill(a.begin(), a.end(), 3, queue); + boost::compute::fill(b.begin(), b.end(), 3, queue); + + BOOST_CHECK(boost::compute::equal(a.begin(), a.end(), b.begin(), b.end(), queue) == false); + BOOST_CHECK(boost::compute::equal(a.begin(), a.end(), a.begin(), a.end(), queue) == true); + BOOST_CHECK(boost::compute::equal(b.begin(), b.end(), a.begin(), a.end(), queue) == false); + BOOST_CHECK(boost::compute::equal(b.begin(), b.end(), b.begin(), b.end(), queue) == true); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_equal_range.cpp b/src/boost/libs/compute/test/test_equal_range.cpp new file mode 100644 index 00000000..981d22ca --- /dev/null +++ b/src/boost/libs/compute/test/test_equal_range.cpp @@ -0,0 +1,73 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestEqualRange +#include <boost/test/unit_test.hpp> + +#include <utility> +#include <iterator> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/equal_range.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(equal_range_int) +{ + int data[] = { 1, 2, 2, 2, 3, 3, 4, 5 }; + boost::compute::vector<int> vector(data, data + 8, queue); + + typedef boost::compute::vector<int>::iterator iterator; + + std::pair<iterator, iterator> range0 = + boost::compute::equal_range(vector.begin(), vector.end(), int(0), queue); + BOOST_CHECK(range0.first == vector.begin()); + BOOST_CHECK(range0.second == vector.begin()); + BOOST_CHECK_EQUAL(std::distance(range0.first, range0.second), ptrdiff_t(0)); + + std::pair<iterator, iterator> range1 = + boost::compute::equal_range(vector.begin(), vector.end(), int(1), queue); + BOOST_CHECK(range1.first == vector.begin()); + BOOST_CHECK(range1.second == vector.begin() + 1); + BOOST_CHECK_EQUAL(std::distance(range1.first, range1.second), ptrdiff_t(1)); + + std::pair<iterator, iterator> range2 = + boost::compute::equal_range(vector.begin(), vector.end(), int(2), queue); + BOOST_CHECK(range2.first == vector.begin() + 1); + BOOST_CHECK(range2.second == vector.begin() + 4); + BOOST_CHECK_EQUAL(std::distance(range2.first, range2.second), ptrdiff_t(3)); + + std::pair<iterator, iterator> range3 = + boost::compute::equal_range(vector.begin(), vector.end(), int(3), queue); + BOOST_CHECK(range3.first == vector.begin() + 4); + BOOST_CHECK(range3.second == vector.begin() + 6); + BOOST_CHECK_EQUAL(std::distance(range3.first, range3.second), ptrdiff_t(2)); + + std::pair<iterator, iterator> range4 = + boost::compute::equal_range(vector.begin(), vector.end(), int(4), queue); + BOOST_CHECK(range4.first == vector.begin() + 6); + BOOST_CHECK(range4.second == vector.begin() + 7); + BOOST_CHECK_EQUAL(std::distance(range4.first, range4.second), ptrdiff_t(1)); + + std::pair<iterator, iterator> range5 = + boost::compute::equal_range(vector.begin(), vector.end(), int(5), queue); + BOOST_CHECK(range5.first == vector.begin() + 7); + BOOST_CHECK(range5.second == vector.end()); + BOOST_CHECK_EQUAL(std::distance(range5.first, range5.second), ptrdiff_t(1)); + + std::pair<iterator, iterator> range6 = + boost::compute::equal_range(vector.begin(), vector.end(), int(6), queue); + BOOST_CHECK(range6.first == vector.end()); + BOOST_CHECK(range6.second == vector.end()); + BOOST_CHECK_EQUAL(std::distance(range6.first, range6.second), ptrdiff_t(0)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_event.cpp b/src/boost/libs/compute/test/test_event.cpp new file mode 100644 index 00000000..9077c2a2 --- /dev/null +++ b/src/boost/libs/compute/test/test_event.cpp @@ -0,0 +1,143 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestEvent +#include <boost/test/unit_test.hpp> + +#include <vector> + +#ifdef BOOST_COMPUTE_USE_CPP11 +#include <mutex> +#include <future> +#endif // BOOST_COMPUTE_USE_CPP11 + +#include <boost/compute/async/future.hpp> +#include <boost/compute/event.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(null_event) +{ + boost::compute::event null; + BOOST_CHECK(null.get() == cl_event()); +} + +#if defined(BOOST_COMPUTE_CL_VERSION_1_1) && defined(BOOST_COMPUTE_USE_CPP11) +std::mutex callback_mutex; +std::condition_variable callback_condition_variable; +static bool callback_invoked = false; + +static void BOOST_COMPUTE_CL_CALLBACK +callback(cl_event event, cl_int status, void *user_data) +{ + std::lock_guard<std::mutex> lock(callback_mutex); + callback_invoked = true; + callback_condition_variable.notify_one(); +} + +BOOST_AUTO_TEST_CASE(event_callback) +{ + REQUIRES_OPENCL_VERSION(1,2); + + // ensure callback has not yet been executed + BOOST_CHECK_EQUAL(callback_invoked, false); + + // enqueue marker and set callback to be invoked + boost::compute::event marker = queue.enqueue_marker(); + marker.set_callback(callback); + marker.wait(); + + // wait up to one second for the callback to be executed + std::unique_lock<std::mutex> lock(callback_mutex); + callback_condition_variable.wait_for( + lock, std::chrono::seconds(1), [&](){ return callback_invoked; } + ); + + // ensure callback has been executed + BOOST_CHECK_EQUAL(callback_invoked, true); +} + +BOOST_AUTO_TEST_CASE(lambda_callback) +{ + REQUIRES_OPENCL_VERSION(1,2); + + bool lambda_invoked = false; + + boost::compute::event marker = queue.enqueue_marker(); + marker.set_callback([&](){ + std::lock_guard<std::mutex> lock(callback_mutex); + lambda_invoked = true; + callback_condition_variable.notify_one(); + }); + marker.wait(); + + // wait up to one second for the callback to be executed + std::unique_lock<std::mutex> lock(callback_mutex); + callback_condition_variable.wait_for( + lock, std::chrono::seconds(1), [&](){ return lambda_invoked; } + ); + BOOST_CHECK_EQUAL(lambda_invoked, true); +} + +BOOST_AUTO_TEST_CASE(future_then_callback) +{ + REQUIRES_OPENCL_VERSION(1,2); + + bool callback_invoked = false; + + boost::compute::future<void> future(queue.enqueue_marker()); + future.then([&](){ + std::lock_guard<std::mutex> lock(callback_mutex); + callback_invoked = true; + callback_condition_variable.notify_one(); + }); + future.wait(); + + // wait up to one second for the callback to be executed + std::unique_lock<std::mutex> lock(callback_mutex); + callback_condition_variable.wait_for( + lock, std::chrono::seconds(1), [&](){ return callback_invoked; } + ); + BOOST_CHECK_EQUAL(callback_invoked, true); +} + +void BOOST_COMPUTE_CL_CALLBACK +event_promise_fulfiller_callback(cl_event event, cl_int status, void *user_data) +{ + auto *promise = static_cast<std::promise<void> *>(user_data); + promise->set_value(); + delete promise; +} + +BOOST_AUTO_TEST_CASE(event_to_std_future) +{ + REQUIRES_OPENCL_VERSION(1,2); + + // enqueue an asynchronous copy to the device + std::vector<float> vector(1000, 3.14f); + boost::compute::buffer buffer(context, 1000 * sizeof(float)); + auto event = queue.enqueue_write_buffer_async( + buffer, 0, 1000 * sizeof(float), vector.data() + ); + + // create a promise and future to be set by the callback + auto *promise = new std::promise<void>; + std::future<void> future = promise->get_future(); + event.set_callback(event_promise_fulfiller_callback, CL_COMPLETE, promise); + + // ensure commands are submitted to the device before waiting + queue.flush(); + + // wait for future to become ready + future.wait(); +} +#endif // BOOST_COMPUTE_CL_VERSION_1_1 + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_extents.cpp b/src/boost/libs/compute/test/test_extents.cpp new file mode 100644 index 00000000..38ab092f --- /dev/null +++ b/src/boost/libs/compute/test/test_extents.cpp @@ -0,0 +1,100 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestExtents +#include <boost/test/unit_test.hpp> + +#include <algorithm> +#include <vector> + +#include <boost/compute/utility/dim.hpp> +#include <boost/compute/utility/extents.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +#ifndef BOOST_COMPUTE_NO_HDR_INITIALIZER_LIST +BOOST_AUTO_TEST_CASE(initialize) +{ + compute::extents<1> one(1); + BOOST_CHECK_EQUAL(one[0], size_t(1)); + + compute::extents<3> xyz = compute::dim(1, 2, 3); + BOOST_CHECK_EQUAL(xyz[0], size_t(1)); + BOOST_CHECK_EQUAL(xyz[1], size_t(2)); + BOOST_CHECK_EQUAL(xyz[2], size_t(3)); +} +#endif + +BOOST_AUTO_TEST_CASE(size) +{ + BOOST_CHECK_EQUAL(compute::extents<1>().size(), size_t(1)); + BOOST_CHECK_EQUAL(compute::extents<2>().size(), size_t(2)); + BOOST_CHECK_EQUAL(compute::extents<3>().size(), size_t(3)); +} + +BOOST_AUTO_TEST_CASE(subscript_operator) +{ + compute::extents<3> xyz; + BOOST_CHECK_EQUAL(xyz[0], size_t(0)); + BOOST_CHECK_EQUAL(xyz[1], size_t(0)); + BOOST_CHECK_EQUAL(xyz[2], size_t(0)); + + xyz[0] = size_t(10); + xyz[1] = size_t(20); + xyz[2] = size_t(30); + BOOST_CHECK_EQUAL(xyz[0], size_t(10)); + BOOST_CHECK_EQUAL(xyz[1], size_t(20)); + BOOST_CHECK_EQUAL(xyz[2], size_t(30)); +} + +#ifndef BOOST_COMPUTE_NO_HDR_INITIALIZER_LIST +BOOST_AUTO_TEST_CASE(data) +{ + compute::extents<3> xyz = compute::dim(5, 6, 7); + BOOST_CHECK_EQUAL(xyz.data()[0], size_t(5)); + BOOST_CHECK_EQUAL(xyz.data()[1], size_t(6)); + BOOST_CHECK_EQUAL(xyz.data()[2], size_t(7)); +} + +BOOST_AUTO_TEST_CASE(linear) +{ + compute::extents<2> uv = compute::dim(16, 16); + BOOST_CHECK_EQUAL(uv.linear(), size_t(256)); +} + +BOOST_AUTO_TEST_CASE(equality_operator) +{ + BOOST_CHECK(compute::dim(10, 20) == compute::dim(10, 20)); + BOOST_CHECK(compute::dim(20, 10) != compute::dim(10, 20)); +} + +BOOST_AUTO_TEST_CASE(empty_dim) +{ + BOOST_CHECK(compute::dim<0>() == compute::dim()); + BOOST_CHECK(compute::dim<1>() == compute::dim(0)); + BOOST_CHECK(compute::dim<2>() == compute::dim(0, 0)); + BOOST_CHECK(compute::dim<3>() == compute::dim(0, 0, 0)); +} + +BOOST_AUTO_TEST_CASE(copy_to_vector) +{ + compute::extents<3> exts = compute::dim(4, 5, 6); + + std::vector<size_t> vec(3); + std::copy(exts.begin(), exts.end(), vec.begin()); + BOOST_CHECK_EQUAL(vec[0], size_t(4)); + BOOST_CHECK_EQUAL(vec[1], size_t(5)); + BOOST_CHECK_EQUAL(vec[2], size_t(6)); +} +#endif + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_extrema.cpp b/src/boost/libs/compute/test/test_extrema.cpp new file mode 100644 index 00000000..7f339d66 --- /dev/null +++ b/src/boost/libs/compute/test/test_extrema.cpp @@ -0,0 +1,396 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +// Undefining BOOST_COMPUTE_USE_OFFLINE_CACHE macro as we want to modify cached +// parameters for copy algorithm without any undesirable consequences (like +// saving modified values of those parameters). +#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE + #undef BOOST_COMPUTE_USE_OFFLINE_CACHE +#endif + +#define BOOST_TEST_MODULE TestExtrema +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/max_element.hpp> +#include <boost/compute/algorithm/min_element.hpp> +#include <boost/compute/algorithm/minmax_element.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/transform_iterator.hpp> +#include <boost/compute/detail/parameter_cache.hpp> + +#include "quirks.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(empyt_min) +{ + using boost::compute::int_; + + boost::compute::vector<int_> vector(size_t(16), int_(0), queue); + boost::compute::vector<int_>::iterator min_iter = + boost::compute::min_element(vector.begin(), vector.begin(), queue); + BOOST_CHECK(min_iter == vector.begin()); + + min_iter = + boost::compute::min_element(vector.begin(), vector.begin() + 1, queue); + BOOST_CHECK(min_iter == vector.begin()); +} + +BOOST_AUTO_TEST_CASE(int_min_max) +{ + using boost::compute::int_; + using boost::compute::uint_; + + boost::compute::vector<int_> vector(size_t(4096), int_(0), queue); + boost::compute::iota(vector.begin(), (vector.begin() + 512), 1, queue); + boost::compute::fill((vector.end() - 512), vector.end(), 513, queue); + + boost::compute::vector<int_>::iterator min_iter = + boost::compute::min_element(vector.begin(), vector.end(), queue); + BOOST_CHECK(min_iter == vector.begin() + 512); + BOOST_CHECK_EQUAL((vector.begin() + 512).read(queue), 0); + BOOST_CHECK_EQUAL(min_iter.read(queue), 0); + + boost::compute::vector<int_>::iterator max_iter = + boost::compute::max_element(vector.begin(), vector.end(), queue); + BOOST_CHECK(max_iter == vector.end() - 512); + BOOST_CHECK_EQUAL((vector.end() - 512).read(queue), 513); + BOOST_CHECK_EQUAL(max_iter.read(queue), 513); + + // compare function + boost::compute::less<int_> lessint; + + // test minmax_element + std::pair< + boost::compute::vector<int_>::iterator, + boost::compute::vector<int_>::iterator + > minmax_iter = + boost::compute::minmax_element(vector.begin(), vector.end(), queue); + BOOST_CHECK_EQUAL((minmax_iter.first).read(queue), 0); + BOOST_CHECK_EQUAL((minmax_iter.second).read(queue), 513); + + minmax_iter = + boost::compute::minmax_element(vector.begin(), vector.end(), lessint, queue); + BOOST_CHECK_EQUAL((minmax_iter.first).read(queue), 0); + BOOST_CHECK_EQUAL((minmax_iter.second).read(queue), 513); + + // find_extrama_on_cpu + + // make sure find_extrama_on_cpu is used, no serial_find_extrema + std::string cache_key = + "__boost_find_extrema_cpu_4"; + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "serial_find_extrema_threshold", 0); + // force find_extrama_on_cpu + parameters->set(cache_key, "serial_find_extrema_threshold", 16); + + min_iter = boost::compute::detail::find_extrema_on_cpu( + vector.begin(), vector.end(), lessint, true /* find minimum */, queue + ); + BOOST_CHECK(min_iter == vector.begin() + 512); + BOOST_CHECK_EQUAL((vector.begin() + 512).read(queue), 0); + BOOST_CHECK_EQUAL(min_iter.read(queue), 0); + + max_iter = boost::compute::detail::find_extrema_on_cpu( + vector.begin(), vector.end(), lessint, false /* find minimum */, queue + ); + BOOST_CHECK(max_iter == vector.end() - 512); + BOOST_CHECK_EQUAL((vector.end() - 512).read(queue), 513); + BOOST_CHECK_EQUAL(max_iter.read(queue), 513); + + // restore + parameters->set(cache_key, "serial_find_extrema_threshold", map_copy_threshold); + + if(is_apple_cpu_device(device)) { + std::cerr + << "skipping all further tests due to Apple platform" + << " behavior when local memory is used on a CPU device" + << std::endl; + return; + } + + // find_extrama_with_reduce + min_iter = boost::compute::detail::find_extrema_with_reduce( + vector.begin(), vector.end(), lessint, true /* find minimum */, queue + ); + BOOST_CHECK(min_iter == vector.begin() + 512); + BOOST_CHECK_EQUAL((vector.begin() + 512).read(queue), 0); + BOOST_CHECK_EQUAL(min_iter.read(queue), 0); + + max_iter = boost::compute::detail::find_extrema_with_reduce( + vector.begin(), vector.end(), lessint, false /* find minimum */, queue + ); + BOOST_CHECK(max_iter == vector.end() - 512); + BOOST_CHECK_EQUAL((vector.end() - 512).read(queue), 513); + BOOST_CHECK_EQUAL(max_iter.read(queue), 513); + + // find_extram_with_atomics + min_iter = boost::compute::detail::find_extrema_with_atomics( + vector.begin(), vector.end(), lessint, true /* find minimum */, queue + ); + BOOST_CHECK(min_iter == vector.begin() + 512); + BOOST_CHECK_EQUAL((vector.begin() + 512).read(queue), 0); + BOOST_CHECK_EQUAL(min_iter.read(queue), 0); + + max_iter = boost::compute::detail::find_extrema_with_atomics( + vector.begin(), vector.end(), lessint, false /* find minimum */, queue + ); + BOOST_CHECK(max_iter == vector.end() - 512); + BOOST_CHECK_EQUAL((vector.end() - 512).read(queue), 513); + BOOST_CHECK_EQUAL(max_iter.read(queue), 513); +} + +BOOST_AUTO_TEST_CASE(int2_min_max_custom_comparision_function) +{ + using boost::compute::int2_; + using boost::compute::uint_; + + boost::compute::vector<int2_> vector(context); + vector.push_back(int2_(1, 10), queue); + vector.push_back(int2_(2, -100), queue); + vector.push_back(int2_(3, 30), queue); + vector.push_back(int2_(4, 20), queue); + vector.push_back(int2_(5, 5), queue); + vector.push_back(int2_(6, -80), queue); + vector.push_back(int2_(7, 21), queue); + vector.push_back(int2_(8, -5), queue); + + BOOST_COMPUTE_FUNCTION(bool, compare_second, (const int2_ a, const int2_ b), + { + return a.y < b.y; + }); + + boost::compute::vector<int2_>::iterator min_iter = + boost::compute::min_element( + vector.begin(), vector.end(), compare_second, queue + ); + BOOST_CHECK(min_iter == vector.begin() + 1); + BOOST_CHECK_EQUAL(*min_iter, int2_(2, -100)); + + boost::compute::vector<int2_>::iterator max_iter = + boost::compute::max_element( + vector.begin(), vector.end(), compare_second, queue + ); + BOOST_CHECK(max_iter == vector.begin() + 2); + BOOST_CHECK_EQUAL(*max_iter, int2_(3, 30)); + + // find_extrama_on_cpu + + // make sure find_extrama_on_cpu is used, no serial_find_extrema + std::string cache_key = + "__boost_find_extrema_cpu_8"; + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "serial_find_extrema_threshold", 0); + // force find_extrama_on_cpu + parameters->set(cache_key, "serial_find_extrema_threshold", 16); + + min_iter = boost::compute::detail::find_extrema_on_cpu( + vector.begin(), vector.end(), compare_second, true /* find minimum */, queue + ); + BOOST_CHECK(min_iter == vector.begin() + 1); + BOOST_CHECK_EQUAL(*min_iter, int2_(2, -100)); + + max_iter = boost::compute::detail::find_extrema_on_cpu( + vector.begin(), vector.end(), compare_second, false /* find minimum */, queue + ); + BOOST_CHECK(max_iter == vector.begin() + 2); + BOOST_CHECK_EQUAL(*max_iter, int2_(3, 30)); + + // restore + parameters->set(cache_key, "serial_find_extrema_threshold", map_copy_threshold); + + if(is_apple_cpu_device(device)) { + std::cerr + << "skipping all further tests due to Apple platform" + << " behavior when local memory is used on a CPU device" + << std::endl; + return; + } + + // find_extrama_with_reduce + min_iter = boost::compute::detail::find_extrema_with_reduce( + vector.begin(), vector.end(), compare_second, true /* find minimum */, queue + ); + BOOST_CHECK(min_iter == vector.begin() + 1); + BOOST_CHECK_EQUAL(*min_iter, int2_(2, -100)); + + max_iter = boost::compute::detail::find_extrema_with_reduce( + vector.begin(), vector.end(), compare_second, false /* find minimum */, queue + ); + BOOST_CHECK(max_iter == vector.begin() + 2); + BOOST_CHECK_EQUAL(*max_iter, int2_(3, 30)); + + // find_extram_with_atomics + min_iter = boost::compute::detail::find_extrema_with_atomics( + vector.begin(), vector.end(), compare_second, true /* find minimum */, queue + ); + BOOST_CHECK(min_iter == vector.begin() + 1); + BOOST_CHECK_EQUAL(*min_iter, int2_(2, -100)); + + max_iter = boost::compute::detail::find_extrema_with_atomics( + vector.begin(), vector.end(), compare_second, false /* find minimum */, queue + ); + BOOST_CHECK(max_iter == vector.begin() + 2); + BOOST_CHECK_EQUAL(*max_iter, int2_(3, 30)); +} + +BOOST_AUTO_TEST_CASE(iota_min_max) +{ + boost::compute::vector<int> vector(5000, context); + + // fill with 0 -> 4999 + boost::compute::iota(vector.begin(), vector.end(), 0, queue); + + boost::compute::vector<int>::iterator min_iter = + boost::compute::min_element(vector.begin(), vector.end(), queue); + BOOST_CHECK(min_iter == vector.begin()); + BOOST_CHECK_EQUAL(*min_iter, 0); + + boost::compute::vector<int>::iterator max_iter = + boost::compute::max_element(vector.begin(), vector.end(), queue); + BOOST_CHECK(max_iter == vector.end() - 1); + BOOST_CHECK_EQUAL(*max_iter, 4999); + + min_iter = + boost::compute::min_element( + vector.begin() + 1000, + vector.end() - 1000, + queue + ); + BOOST_CHECK(min_iter == vector.begin() + 1000); + BOOST_CHECK_EQUAL(*min_iter, 1000); + + max_iter = + boost::compute::max_element( + vector.begin() + 1000, + vector.end() - 1000, + queue + ); + BOOST_CHECK(max_iter == vector.begin() + 3999); + BOOST_CHECK_EQUAL(*max_iter, 3999); + + // fill with -2500 -> 2499 + boost::compute::iota(vector.begin(), vector.end(), -2500, queue); + min_iter = + boost::compute::min_element(vector.begin(), vector.end(), queue); + BOOST_CHECK(min_iter == vector.begin()); + BOOST_CHECK_EQUAL(*min_iter, -2500); + + max_iter = + boost::compute::max_element(vector.begin(), vector.end(), queue); + BOOST_CHECK(max_iter == vector.end() - 1); + BOOST_CHECK_EQUAL(*max_iter, 2499); +} + +// uses max_element() and length() to find the longest 2d vector +BOOST_AUTO_TEST_CASE(max_vector_length) +{ + float data[] = { -1.5f, 3.2f, + 10.0f, 0.0f, + -4.2f, 2.0f, + 0.0f, 0.5f, + 1.9f, 1.9f }; + boost::compute::vector<boost::compute::float2_> vector( + reinterpret_cast<boost::compute::float2_ *>(data), + reinterpret_cast<boost::compute::float2_ *>(data) + 5, + queue + ); + + // find length of the longest vector + typedef boost::compute::transform_iterator< + boost::compute::vector<boost::compute::float2_>::iterator, + boost::compute::length<boost::compute::float2_> + > length_transform_iter; + + length_transform_iter max_iter = + boost::compute::max_element( + boost::compute::make_transform_iterator( + vector.begin(), + boost::compute::length<boost::compute::float2_>() + ), + boost::compute::make_transform_iterator( + vector.end(), + boost::compute::length<boost::compute::float2_>() + ), + queue + ); + BOOST_CHECK( + max_iter == boost::compute::make_transform_iterator( + vector.begin() + 1, + boost::compute::length<boost::compute::float2_>() + ) + ); + BOOST_CHECK(max_iter.base() == vector.begin() + 1); + BOOST_CHECK_EQUAL(*max_iter, float(10.0)); + + // find length of the shortest vector + length_transform_iter min_iter = + boost::compute::min_element( + boost::compute::make_transform_iterator( + vector.begin(), + boost::compute::length<boost::compute::float2_>() + ), + boost::compute::make_transform_iterator( + vector.end(), + boost::compute::length<boost::compute::float2_>() + ), + queue + ); + BOOST_CHECK( + min_iter == boost::compute::make_transform_iterator( + vector.begin() + 3, + boost::compute::length<boost::compute::float2_>() + ) + ); + BOOST_CHECK(min_iter.base() == vector.begin() + 3); + BOOST_CHECK_EQUAL(*min_iter, float(0.5)); +} + +// uses max_element() and popcount() to find the value with the most 1 bits +BOOST_AUTO_TEST_CASE(max_bits_set) +{ + using boost::compute::uint_; + + uint_ data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + boost::compute::vector<uint_> vector(data, data + 10, queue); + + boost::compute::vector<uint_>::iterator iter = + boost::compute::max_element( + boost::compute::make_transform_iterator( + vector.begin(), + boost::compute::popcount<uint_>() + ), + boost::compute::make_transform_iterator( + vector.end(), + boost::compute::popcount<uint_>() + ), + queue + ).base(); + + BOOST_CHECK(iter == vector.begin() + 7); + BOOST_CHECK_EQUAL(uint_(*iter), uint_(7)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_fill.cpp b/src/boost/libs/compute/test/test_fill.cpp new file mode 100644 index 00000000..bc58e6cb --- /dev/null +++ b/src/boost/libs/compute/test/test_fill.cpp @@ -0,0 +1,333 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFill +#include <boost/test/unit_test.hpp> +#include <boost/test/test_case_template.hpp> +#include <boost/mpl/list.hpp> + +#include <iostream> + +#include <boost/compute/algorithm/equal.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/fill_n.hpp> +#include <boost/compute/async/future.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/svm.hpp> +#include <boost/compute/type_traits.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +typedef boost::mpl::list + <bc::char_, bc::uchar_, bc::int_, bc::uint_, + bc::long_, bc::ulong_, bc::float_, bc::double_> + scalar_types; + +template<class T> +inline void test_fill(T v1, T v2, T v3, bc::command_queue queue) { + if(boost::is_same<typename bc::scalar_type<T>::type, bc::double_>::value && + !queue.get_device().supports_extension("cl_khr_fp64")) { + std::cerr << "Skipping test_fill<" << bc::type_name<T>() << ">() " + "on device which doesn't support cl_khr_fp64" << std::endl; + return; + } + + bc::vector<T> vector(4, queue.get_context()); + bc::fill(vector.begin(), vector.end(), v1, queue); + queue.finish(); + CHECK_RANGE_EQUAL(T, 4, vector, (v1, v1, v1, v1)); + + vector.resize(1000, queue); + bc::fill(vector.begin(), vector.end(), v2, queue); + queue.finish(); + BOOST_CHECK_EQUAL(vector.front(), v2); + BOOST_CHECK_EQUAL(vector.back(), v2); + + bc::fill(vector.begin() + 500, vector.end(), v3, queue); + queue.finish(); + BOOST_CHECK_EQUAL(vector.front(), v2); + BOOST_CHECK_EQUAL(vector[499], v2); + BOOST_CHECK_EQUAL(vector[500], v3); + BOOST_CHECK_EQUAL(vector.back(), v3); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_scalar, S, scalar_types ) +{ + S v1 = S(1.5f); + S v2 = S(2.5f); + S v3 = S(42.0f); + test_fill(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_vec2, S, scalar_types ) +{ + typedef typename bc::make_vector_type<S, 2>::type T; + S s1 = S(1.5f); + S s2 = S(2.5f); + S s3 = S(42.0f); + S s4 = S(84.0f); + + T v1 = T(s1, s2); + T v2 = T(s3, s4); + T v3 = T(s2, s1); + test_fill(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_vec4, S, scalar_types ) +{ + typedef typename bc::make_vector_type<S, 4>::type T; + S s1 = S(1.5f); + S s2 = S(2.5f); + S s3 = S(42.0f); + S s4 = S(84.0f); + + T v1 = T(s1, s2, s3, s4); + T v2 = T(s3, s4, s1, s2); + T v3 = T(s4, s3, s2, s1); + test_fill(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_vec8, S, scalar_types ) +{ + typedef typename bc::make_vector_type<S, 8>::type T; + S s1 = S(1.5f); + S s2 = S(2.5f); + S s3 = S(42.0f); + S s4 = S(84.0f); + S s5 = S(122.5f); + S s6 = S(131.5f); + S s7 = S(142.0f); + S s8 = S(254.0f); + + T v1 = T(s1, s2, s3, s4, s5, s6, s7, s8); + T v2 = T(s3, s4, s1, s2, s7, s8, s5, s6); + T v3 = T(s4, s3, s2, s1, s8, s7, s6, s5); + test_fill(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_vec16, S, scalar_types ) +{ + typedef typename bc::make_vector_type<S, 16>::type T; + S s1 = S(1.5f); + S s2 = S(2.5f); + S s3 = S(42.0f); + S s4 = S(84.0f); + S s5 = S(122.5f); + S s6 = S(131.5f); + S s7 = S(142.0f); + S s8 = S(254.0f); + + T v1 = T(s1, s2, s3, s4, s5, s6, s7, s8, s1, s2, s3, s4, s5, s6, s7, s8); + T v2 = T(s3, s4, s1, s2, s7, s8, s5, s6, s4, s3, s2, s1, s8, s7, s6, s5); + T v3 = T(s4, s3, s2, s1, s8, s7, s6, s5, s8, s7, s6, s5, s4, s3, s2, s1); + test_fill(v1, v2, v3, queue); +} + +template<class T> +inline void test_fill_n(T v1, T v2, T v3, bc::command_queue queue) { + if(boost::is_same<typename bc::scalar_type<T>::type, bc::double_>::value && + !queue.get_device().supports_extension("cl_khr_fp64")) { + std::cerr << "Skipping test_fill_n<" << bc::type_name<T>() << ">() " + "on device which doesn't support cl_khr_fp64" << std::endl; + return; + } + + bc::vector<T> vector(4, queue.get_context()); + bc::fill_n(vector.begin(), 4, v1, queue); + queue.finish(); + CHECK_RANGE_EQUAL(T, 4, vector, (v1, v1, v1, v1)); + + bc::fill_n(vector.begin(), 3, v2, queue); + queue.finish(); + CHECK_RANGE_EQUAL(T, 4, vector, (v2, v2, v2, v1)); + + bc::fill_n(vector.begin() + 1, 2, v3, queue); + queue.finish(); + CHECK_RANGE_EQUAL(T, 4, vector, (v2, v3, v3, v1)); + + bc::fill_n(vector.begin(), 4, v2, queue); + queue.finish(); + CHECK_RANGE_EQUAL(T, 4, vector, (v2, v2, v2, v2)); + + // fill last element + bc::fill_n(vector.end() - 1, 1, v3, queue); + queue.finish(); + CHECK_RANGE_EQUAL(T, 4, vector, (v2, v2, v2, v3)); + + // fill first element + bc::fill_n(vector.begin(), 1, v1, queue); + queue.finish(); + CHECK_RANGE_EQUAL(T, 4, vector, (v1, v2, v2, v3)); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_n_scalar, S, scalar_types ) +{ + S v1 = S(1.5f); + S v2 = S(2.5f); + S v3 = S(42.0f); + test_fill_n(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_n_vec2, S, scalar_types ) +{ + typedef typename bc::make_vector_type<S, 2>::type T; + S s1 = S(1.5f); + S s2 = S(2.5f); + S s3 = S(42.0f); + S s4 = S(84.0f); + + T v1 = T(s1, s2); + T v2 = T(s3, s4); + T v3 = T(s2, s1); + test_fill_n(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_n_vec4, S, scalar_types ) +{ + typedef typename bc::make_vector_type<S, 4>::type T; + S s1 = S(1.5f); + S s2 = S(2.5f); + S s3 = S(42.0f); + S s4 = S(84.0f); + + T v1 = T(s1, s2, s3, s4); + T v2 = T(s3, s4, s1, s2); + T v3 = T(s4, s3, s2, s1); + test_fill_n(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_n_vec8, S, scalar_types ) +{ + typedef typename bc::make_vector_type<S, 8>::type T; + S s1 = S(1.5f); + S s2 = S(2.5f); + S s3 = S(42.0f); + S s4 = S(84.0f); + S s5 = S(122.5f); + S s6 = S(131.5f); + S s7 = S(142.0f); + S s8 = S(254.0f); + + T v1 = T(s1, s2, s3, s4, s5, s6, s7, s8); + T v2 = T(s3, s4, s1, s2, s7, s8, s5, s6); + T v3 = T(s4, s3, s2, s1, s8, s7, s6, s5); + test_fill_n(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE_TEMPLATE( fill_n_vec16, S, scalar_types ) +{ + typedef typename bc::make_vector_type<S, 16>::type T; + S s1 = S(1.5f); + S s2 = S(2.5f); + S s3 = S(42.0f); + S s4 = S(84.0f); + S s5 = S(122.5f); + S s6 = S(131.5f); + S s7 = S(142.0f); + S s8 = S(254.0f); + + T v1 = T(s1, s2, s3, s4, s5, s6, s7, s8, s1, s2, s3, s4, s5, s6, s7, s8); + T v2 = T(s3, s4, s1, s2, s7, s8, s5, s6, s4, s3, s2, s1, s8, s7, s6, s5); + T v3 = T(s4, s3, s2, s1, s8, s7, s6, s5, s8, s7, s6, s5, s4, s3, s2, s1); + test_fill_n(v1, v2, v3, queue); +} + +BOOST_AUTO_TEST_CASE(check_fill_type) +{ + bc::vector<int> vector(5, context); + bc::future<void> future = + bc::fill_async(vector.begin(), vector.end(), 42, queue); + future.wait(); + + #ifdef BOOST_COMPUTE_CL_VERSION_1_2 + BOOST_CHECK_EQUAL( + future.get_event().get_command_type(), + device.check_version(1,2) ? CL_COMMAND_FILL_BUFFER : CL_COMMAND_NDRANGE_KERNEL + ); + #else + BOOST_CHECK( + future.get_event().get_command_type() == CL_COMMAND_NDRANGE_KERNEL + ); + #endif +} + +BOOST_AUTO_TEST_CASE(fill_clone_buffer) +{ + int data[] = { 1, 2, 3, 4 }; + bc::vector<int> vec(data, data + 4, queue); + CHECK_RANGE_EQUAL(int, 4, vec, (1, 2, 3, 4)); + + bc::buffer cloned_buffer = vec.get_buffer().clone(queue); + BOOST_CHECK( + bc::equal( + vec.begin(), + vec.end(), + bc::make_buffer_iterator<int>(cloned_buffer, 0), + queue + ) + ); + + bc::fill(vec.begin(), vec.end(), 5, queue); + BOOST_CHECK( + !bc::equal( + vec.begin(), + vec.end(), + bc::make_buffer_iterator<int>(cloned_buffer, 0), + queue + ) + ); + + bc::fill( + bc::make_buffer_iterator<int>(cloned_buffer, 0), + bc::make_buffer_iterator<int>(cloned_buffer, 4), + 5, + queue + ); + BOOST_CHECK( + bc::equal( + vec.begin(), + vec.end(), + bc::make_buffer_iterator<int>(cloned_buffer, 0), + queue + ) + ); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_2_0 +BOOST_AUTO_TEST_CASE(fill_svm_buffer) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + size_t size = 4; + bc::svm_ptr<cl_int> ptr = + bc::svm_alloc<cl_int>(context, size * sizeof(cl_int)); + bc::fill_n(ptr, size * sizeof(cl_int), 42, queue); + + queue.enqueue_svm_map(ptr.get(), size * sizeof(cl_int), CL_MAP_READ); + for(size_t i = 0; i < size; i++) { + BOOST_CHECK_EQUAL(static_cast<cl_int*>(ptr.get())[i], 42); + } + queue.enqueue_svm_unmap(ptr.get()); + + bc::svm_free(context, ptr); +} +#endif // BOOST_COMPUTE_CL_VERSION_2_0 + +BOOST_AUTO_TEST_CASE(empty_fill) +{ + bc::vector<int> vec(0, context); + bc::fill(vec.begin(), vec.end(), 42, queue); + bc::fill_async(vec.begin(), vec.end(), 42, queue); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_find.cpp b/src/boost/libs/compute/test/test_find.cpp new file mode 100644 index 00000000..d17823f8 --- /dev/null +++ b/src/boost/libs/compute/test/test_find.cpp @@ -0,0 +1,107 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFind +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/find.hpp> +#include <boost/compute/algorithm/find_if.hpp> +#include <boost/compute/algorithm/find_if_not.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/constant_buffer_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(find_int) +{ + int data[] = { 9, 15, 1, 4, 9, 9, 4, 15, 12, 1 }; + bc::vector<int> vector(data, data + 10, queue); + + bc::vector<int>::iterator iter = + bc::find(vector.begin(), vector.end(), 4, queue); + BOOST_CHECK(iter == vector.begin() + 3); + BOOST_CHECK_EQUAL(*iter, 4); + + iter = bc::find(vector.begin(), vector.end(), 12, queue); + BOOST_CHECK(iter == vector.begin() + 8); + BOOST_CHECK_EQUAL(*iter, 12); + + iter = bc::find(vector.begin(), vector.end(), 1, queue); + BOOST_CHECK(iter == vector.begin() + 2); + BOOST_CHECK_EQUAL(*iter, 1); + + iter = bc::find(vector.begin(), vector.end(), 9, queue); + BOOST_CHECK(iter == vector.begin()); + BOOST_CHECK_EQUAL(*iter, 9); + + iter = bc::find(vector.begin(), vector.end(), 100, queue); + BOOST_CHECK(iter == vector.end()); +} + +BOOST_AUTO_TEST_CASE(find_int2) +{ + using bc::int2_; + + int data[] = { 1, 2, 4, 5, 7, 8 }; + bc::vector<int2_> vector( + reinterpret_cast<int2_ *>(data), + reinterpret_cast<int2_ *>(data) + 3, + queue + ); + CHECK_RANGE_EQUAL(int2_, 3, vector, (int2_(1, 2), int2_(4, 5), int2_(7, 8))); + + bc::vector<int2_>::iterator iter = + bc::find(vector.begin(), vector.end(), int2_(4, 5), queue); + BOOST_CHECK(iter == vector.begin() + 1); + BOOST_CHECK_EQUAL(*iter, int2_(4, 5)); + + iter = bc::find(vector.begin(), vector.end(), int2_(10, 11), queue); + BOOST_CHECK(iter == vector.end()); +} + +BOOST_AUTO_TEST_CASE(find_if_not_int) +{ + int data[] = { 2, 4, 6, 8, 1, 3, 5, 7, 9 }; + bc::vector<int> vector(data, data + 9, queue); + + bc::vector<int>::iterator iter = + bc::find_if_not(vector.begin(), vector.end(), bc::_1 == 2, queue); + BOOST_CHECK(iter == vector.begin() + 1); + BOOST_CHECK_EQUAL(*iter, 4); +} + +BOOST_AUTO_TEST_CASE(find_point_by_distance) +{ + using boost::compute::float2_; + using boost::compute::lambda::_1; + using boost::compute::lambda::distance; + + float2_ points[] = { + float2_(0, 0), float2_(2, 2), float2_(4, 4), float2_(8, 8) + }; + compute::vector<float2_> vec(points, points + 4, queue); + + compute::vector<float2_>::iterator iter = + compute::find_if(vec.begin(), vec.end(), distance(_1, float2_(5, 5)) < 1.5f, queue); + BOOST_CHECK(iter == vec.begin() + 2); + + float2_ value; + compute::copy_n(iter, 1, &value, queue); + BOOST_CHECK_EQUAL(value, float2_(4, 4)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_find_end.cpp b/src/boost/libs/compute/test/test_find_end.cpp new file mode 100644 index 00000000..6ef050d0 --- /dev/null +++ b/src/boost/libs/compute/test/test_find_end.cpp @@ -0,0 +1,63 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFindEnd +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/find_end.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(find_end_int) +{ + bc::int_ data[] = {1, 4, 2, 6, 3, 2, 6, 3, 4, 6}; + bc::vector<bc::int_> vectort(data, data + 10, queue); + + bc::int_ datap[] = {2, 6}; + bc::vector<bc::int_> vectorp(datap, datap + 2, queue); + + bc::vector<bc::int_>::iterator iter = + bc::find_end(vectort.begin(), vectort.end(), + vectorp.begin(), vectorp.end(), queue); + + BOOST_CHECK(iter == vectort.begin() + 5); + + vectorp.insert(vectorp.begin() + 1, bc::int_(9), queue); + + iter = + bc::find_end(vectort.begin(), vectort.end(), + vectorp.begin(), vectorp.end(), queue); + + BOOST_CHECK(iter == vectort.end()); +} + +BOOST_AUTO_TEST_CASE(find_end_string) +{ + bc::char_ text[] = "sdabababacabskjabacab"; + bc::vector<bc::char_> vectort(text, text + 21, queue); + + bc::char_ pattern[] = "aba"; + bc::vector<bc::char_> vectorp(pattern, pattern + 3, queue); + + bc::vector<bc::char_>::iterator iter = + bc::find_end(vectort.begin(), vectort.end(), + vectorp.begin(), vectorp.end(), queue); + + BOOST_CHECK(iter == (vectort.begin() + 15)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_flat_map.cpp b/src/boost/libs/compute/test/test_flat_map.cpp new file mode 100644 index 00000000..c1f96aa8 --- /dev/null +++ b/src/boost/libs/compute/test/test_flat_map.cpp @@ -0,0 +1,147 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFlatMap +#include <boost/test/unit_test.hpp> + +#include <utility> + +#include <boost/concept_check.hpp> + +#include <boost/compute/source.hpp> +#include <boost/compute/container/flat_map.hpp> +#include <boost/compute/type_traits/type_name.hpp> +#include <boost/compute/type_traits/type_definition.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(concept_check) +{ + BOOST_CONCEPT_ASSERT((boost::Container<boost::compute::flat_map<int, float> >)); +// BOOST_CONCEPT_ASSERT((boost::SimpleAssociativeContainer<boost::compute::flat_map<int, float> >)); +// BOOST_CONCEPT_ASSERT((boost::UniqueAssociativeContainer<boost::compute::flat_map<int, float> >)); + BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<boost::compute::flat_map<int, float>::iterator>)); + BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<boost::compute::flat_map<int, float>::const_iterator>)); +} + +BOOST_AUTO_TEST_CASE(insert) +{ + boost::compute::flat_map<int, float> map(context); + map.insert(std::make_pair(1, 1.1f), queue); + map.insert(std::make_pair(-1, -1.1f), queue); + map.insert(std::make_pair(3, 3.3f), queue); + map.insert(std::make_pair(2, 2.2f), queue); + BOOST_CHECK_EQUAL(map.size(), size_t(4)); + BOOST_CHECK(map.find(-1) == map.begin() + 0); + BOOST_CHECK(map.find(1) == map.begin() + 1); + BOOST_CHECK(map.find(2) == map.begin() + 2); + BOOST_CHECK(map.find(3) == map.begin() + 3); + + map.insert(std::make_pair(2, -2.2f), queue); + BOOST_CHECK_EQUAL(map.size(), size_t(4)); +} + +BOOST_AUTO_TEST_CASE(at) +{ + boost::compute::flat_map<int, float> map(context); + map.insert(std::make_pair(1, 1.1f), queue); + map.insert(std::make_pair(4, 4.4f), queue); + map.insert(std::make_pair(3, 3.3f), queue); + map.insert(std::make_pair(2, 2.2f), queue); + BOOST_CHECK_EQUAL(float(map.at(1)), float(1.1f)); + BOOST_CHECK_EQUAL(float(map.at(2)), float(2.2f)); + BOOST_CHECK_EQUAL(float(map.at(3)), float(3.3f)); + BOOST_CHECK_EQUAL(float(map.at(4)), float(4.4f)); +} + +BOOST_AUTO_TEST_CASE(index_operator) +{ + boost::compute::flat_map<int, float> map; + map[1] = 1.1f; + map[2] = 2.2f; + map[3] = 3.3f; + map[4] = 4.4f; + BOOST_CHECK_EQUAL(float(map[1]), float(1.1f)); + BOOST_CHECK_EQUAL(float(map[2]), float(2.2f)); + BOOST_CHECK_EQUAL(float(map[3]), float(3.3f)); + BOOST_CHECK_EQUAL(float(map[4]), float(4.4f)); +} + +BOOST_AUTO_TEST_CASE(custom_kernel) +{ + typedef boost::compute::flat_map<int, float> MapType; + + // map from int->float on device + MapType map(context); + map.insert(std::make_pair(1, 1.2f), queue); + map.insert(std::make_pair(3, 3.4f), queue); + map.insert(std::make_pair(5, 5.6f), queue); + map.insert(std::make_pair(7, 7.8f), queue); + + // simple linear search for key in map + const char lookup_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void lookup(__global const MapType *map, + const int map_size, + const KeyType key, + __global ValueType *result) + { + for(int i = 0; i < map_size; i++){ + if(map[i].first == key){ + *result = map[i].second; + break; + } + } + } + ); + + // create program source + std::stringstream source; + + // add type definition for map type + source << boost::compute::type_definition<MapType::value_type>(); + + // add lookup function source + source << lookup_source; + + // create lookup program + boost::compute::program lookup_program = + boost::compute::program::create_with_source(source.str(), context); + + // program build options + std::stringstream options; + options << "-DMapType=" << boost::compute::type_name<MapType::value_type>() + << " -DKeyType=" << boost::compute::type_name<MapType::key_type>() + << " -DValueType=" << boost::compute::type_name<MapType::mapped_type>(); + + // build lookup program with options + lookup_program.build(options.str()); + + // create buffer for result value + boost::compute::vector<float> result(1, context); + + // create lookup kernel + boost::compute::kernel lookup_kernel = lookup_program.create_kernel("lookup"); + + // set kernel arguments + lookup_kernel.set_arg(0, map.begin().get_buffer()); // map buffer + lookup_kernel.set_arg<boost::compute::int_>( + 1, static_cast<boost::compute::int_>(map.size()) + ); // map size + lookup_kernel.set_arg<MapType::key_type>(2, 5); // key + lookup_kernel.set_arg(3, result.get_buffer()); // result buffer + + // run kernel with a single work-item + queue.enqueue_task(lookup_kernel); + + // check result from buffer + BOOST_CHECK_EQUAL(result.begin().read(queue), 5.6f); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_flat_set.cpp b/src/boost/libs/compute/test/test_flat_set.cpp new file mode 100644 index 00000000..798bf4ce --- /dev/null +++ b/src/boost/libs/compute/test/test_flat_set.cpp @@ -0,0 +1,136 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFlatSet +#include <boost/test/unit_test.hpp> + +#include <utility> + +#include <boost/concept_check.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/container/flat_set.hpp> + +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(concept_check) +{ + BOOST_CONCEPT_ASSERT((boost::Container<bc::flat_set<int> >)); +// BOOST_CONCEPT_ASSERT((boost::SimpleAssociativeContainer<bc::flat_set<int> >)); +// BOOST_CONCEPT_ASSERT((boost::UniqueAssociativeContainer<bc::flat_set<int> >)); + BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<bc::flat_set<int>::iterator>)); + BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<bc::flat_set<int>::const_iterator>)); +} + +BOOST_AUTO_TEST_CASE(insert) +{ + bc::flat_set<int> set(context); + typedef bc::flat_set<int>::iterator iterator; + std::pair<iterator, bool> location = set.insert(12, queue); + queue.finish(); + BOOST_CHECK(location.first == set.begin()); + BOOST_CHECK(location.second == true); + BOOST_CHECK_EQUAL(*location.first, 12); + BOOST_CHECK_EQUAL(set.size(), size_t(1)); + + location = set.insert(12, queue); + queue.finish(); + BOOST_CHECK(location.first == set.begin()); + BOOST_CHECK(location.second == false); + BOOST_CHECK_EQUAL(set.size(), size_t(1)); + + location = set.insert(4, queue); + queue.finish(); + BOOST_CHECK(location.first == set.begin()); + BOOST_CHECK(location.second == true); + BOOST_CHECK_EQUAL(set.size(), size_t(2)); + + location = set.insert(12, queue); + queue.finish(); + BOOST_CHECK(location.first == set.begin() + 1); + BOOST_CHECK(location.second == false); + BOOST_CHECK_EQUAL(set.size(), size_t(2)); + + location = set.insert(9, queue); + queue.finish(); + BOOST_CHECK(location.first == set.begin() + 1); + BOOST_CHECK(location.second == true); + BOOST_CHECK_EQUAL(set.size(), size_t(3)); +} + +BOOST_AUTO_TEST_CASE(erase) +{ + bc::flat_set<int> set(context); + typedef bc::flat_set<int>::iterator iterator; + set.insert(1, queue); + set.insert(2, queue); + set.insert(3, queue); + set.insert(4, queue); + set.insert(5, queue); + queue.finish(); + BOOST_CHECK_EQUAL(set.size(), size_t(5)); + + iterator i = set.erase(set.begin(), queue); + queue.finish(); + BOOST_CHECK(i == set.begin() + 1); + BOOST_CHECK_EQUAL(set.size(), size_t(4)); + BOOST_CHECK_EQUAL(*set.begin(), 2); + + size_t count = set.erase(3, queue); + queue.finish(); + BOOST_CHECK_EQUAL(count, size_t(1)); + BOOST_CHECK_EQUAL(set.size(), size_t(3)); + BOOST_CHECK_EQUAL(*set.begin(), 2); + + count = set.erase(9, queue); + queue.finish(); + BOOST_CHECK_EQUAL(count, size_t(0)); + BOOST_CHECK_EQUAL(set.size(), size_t(3)); + BOOST_CHECK_EQUAL(*set.begin(), 2); + + i = set.erase(set.begin() + 1, queue); + queue.finish(); + BOOST_CHECK(i == set.begin() + 2); + BOOST_CHECK_EQUAL(set.size(), size_t(2)); + BOOST_CHECK_EQUAL(*set.begin(), 2); + BOOST_CHECK_EQUAL(*(set.end() - 1), 5); + + set.erase(set.begin(), set.end(), queue); + queue.finish(); + BOOST_CHECK_EQUAL(set.size(), size_t(0)); +} + +BOOST_AUTO_TEST_CASE(clear) +{ + bc::flat_set<float> set; + BOOST_CHECK(set.empty() == true); + BOOST_CHECK_EQUAL(set.size(), size_t(0)); + + set.clear(); + BOOST_CHECK(set.empty() == true); + BOOST_CHECK_EQUAL(set.size(), size_t(0)); + + set.insert(3.14f); + BOOST_CHECK(set.empty() == false); + BOOST_CHECK_EQUAL(set.size(), size_t(1)); + + set.insert(4.184f); + BOOST_CHECK(set.empty() == false); + BOOST_CHECK_EQUAL(set.size(), size_t(2)); + + set.clear(); + BOOST_CHECK(set.empty() == true); + BOOST_CHECK_EQUAL(set.size(), size_t(0)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_for_each.cpp b/src/boost/libs/compute/test/test_for_each.cpp new file mode 100644 index 00000000..d695738e --- /dev/null +++ b/src/boost/libs/compute/test/test_for_each.cpp @@ -0,0 +1,46 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestForEach +#include <boost/test/unit_test.hpp> + +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/algorithm/for_each.hpp> +#include <boost/compute/algorithm/for_each_n.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(for_each_nop) +{ + bc::vector<int> vector(4, context); + bc::iota(vector.begin(), vector.end(), 0, queue); + + BOOST_COMPUTE_FUNCTION(void, nop, (int ignored), {}); + + bc::for_each(vector.begin(), vector.end(), nop, queue); + queue.finish(); +} + +BOOST_AUTO_TEST_CASE(for_each_n_nop) +{ + bc::vector<int> vector(4, context); + bc::iota(vector.begin(), vector.end(), 0, queue); + + BOOST_COMPUTE_FUNCTION(void, nop, (int ignored), {}); + + bc::for_each_n(vector.begin(), vector.size(), nop, queue); + queue.finish(); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_function.cpp b/src/boost/libs/compute/test/test_function.cpp new file mode 100644 index 00000000..63889dcb --- /dev/null +++ b/src/boost/libs/compute/test/test_function.cpp @@ -0,0 +1,209 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunction +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/accumulate.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/generate.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/zip_iterator.hpp> +#include <boost/compute/types/pair.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(add_three) +{ + BOOST_COMPUTE_FUNCTION(int, add_three, (int x), + { + return x + 3; + }); + + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vector(data, data + 4, queue); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), add_three, queue + ); + CHECK_RANGE_EQUAL(int, 4, vector, (4, 5, 6, 7)); +} + +BOOST_AUTO_TEST_CASE(sum_odd_values) +{ + BOOST_COMPUTE_FUNCTION(int, add_odd_value, (int sum, int value), + { + if(value & 1){ + return sum + value; + } + else { + return sum + 0; + } + }); + + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<int> vector(data, data + 8, queue); + + int result = compute::accumulate( + vector.begin(), vector.end(), 0, add_odd_value, queue + ); + BOOST_CHECK_EQUAL(result, 16); +} + +BOOST_AUTO_TEST_CASE(sort_pairs) +{ + if(device.vendor() == "NVIDIA" && device.platform().name() == "Apple"){ + // FIXME: this test currently segfaults on NVIDIA GPUs on Apple + std::cerr << "skipping sort_pairs test on NVIDIA GPU on Apple platform" << std::endl; + return; + } + + std::vector<std::pair<int, float> > data; + data.push_back(std::make_pair(1, 2.3f)); + data.push_back(std::make_pair(0, 4.2f)); + data.push_back(std::make_pair(2, 1.0f)); + + compute::vector<std::pair<int, float> > vector(data.begin(), data.end(), queue); + + // sort by first component + BOOST_COMPUTE_FUNCTION(bool, compare_first, (std::pair<int, float> a, std::pair<int, float> b), + { + return a.first < b.first; + }); + + compute::sort(vector.begin(), vector.end(), compare_first, queue); + compute::copy(vector.begin(), vector.end(), data.begin(), queue); + BOOST_CHECK(data[0] == std::make_pair(0, 4.2f)); + BOOST_CHECK(data[1] == std::make_pair(1, 2.3f)); + BOOST_CHECK(data[2] == std::make_pair(2, 1.0f)); + + // sort by second component + BOOST_COMPUTE_FUNCTION(bool, compare_second, (std::pair<int, float> a, std::pair<int, float> b), + { + return a.second < b.second; + }); + + compute::sort(vector.begin(), vector.end(), compare_second, queue); + compute::copy(vector.begin(), vector.end(), data.begin(), queue); + BOOST_CHECK(data[0] == std::make_pair(2, 1.0f)); + BOOST_CHECK(data[1] == std::make_pair(1, 2.3f)); + BOOST_CHECK(data[2] == std::make_pair(0, 4.2f)); +} + +BOOST_AUTO_TEST_CASE(transform_zip_iterator) +{ + float float_data[] = { 1.f, 2.f, 3.f, 4.f }; + compute::vector<float> input_floats(float_data, float_data + 4, queue); + + int int_data[] = { 2, 4, 6, 8 }; + compute::vector<int> input_ints(int_data, int_data + 4, queue); + + compute::vector<float> results(4, context); + + BOOST_COMPUTE_FUNCTION(float, tuple_pown, (boost::tuple<float, int> x), + { + return pown(boost_tuple_get(x, 0), boost_tuple_get(x, 1)); + }); + + compute::transform( + compute::make_zip_iterator( + boost::make_tuple(input_floats.begin(), input_ints.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(input_floats.end(), input_ints.end()) + ), + results.begin(), + tuple_pown, + queue + ); + + float results_data[4]; + compute::copy(results.begin(), results.end(), results_data, queue); + BOOST_CHECK_CLOSE(results_data[0], 1.f, 1e-4); + BOOST_CHECK_CLOSE(results_data[1], 16.f, 1e-4); + BOOST_CHECK_CLOSE(results_data[2], 729.f, 1e-4); + BOOST_CHECK_CLOSE(results_data[3], 65536.f, 1e-4); +} + +static BOOST_COMPUTE_FUNCTION(int, static_function, (int x), +{ + return x + 5; +}); + +BOOST_AUTO_TEST_CASE(test_static_function) +{ + int data[] = { 1, 2, 3, 4}; + compute::vector<int> vec(data, data + 4, queue); + + compute::transform( + vec.begin(), vec.end(), vec.begin(), static_function, queue + ); + CHECK_RANGE_EQUAL(int, 4, vec, (6, 7, 8, 9)); +} + +template<class T> +inline compute::function<T(T)> make_negate_function() +{ + BOOST_COMPUTE_FUNCTION(T, negate, (const T x), + { + return -x; + }); + + return negate; +} + +BOOST_AUTO_TEST_CASE(test_templated_function) +{ + int int_data[] = { 1, 2, 3, 4 }; + compute::vector<int> int_vec(int_data, int_data + 4, queue); + + compute::function<int(int)> negate_int = make_negate_function<int>(); + compute::transform( + int_vec.begin(), int_vec.end(), int_vec.begin(), negate_int, queue + ); + CHECK_RANGE_EQUAL(int, 4, int_vec, (-1, -2, -3, -4)); + + float float_data[] = { 1.1f, 2.2f, 3.3f, 4.4f }; + compute::vector<float> float_vec(float_data, float_data + 4, queue); + + compute::function<float(float)> negate_float = make_negate_function<float>(); + compute::transform( + float_vec.begin(), float_vec.end(), float_vec.begin(), negate_float, queue + ); + CHECK_RANGE_EQUAL(float, 4, float_vec, (-1.1f, -2.2f, -3.3f, -4.4f)); +} + +BOOST_AUTO_TEST_CASE(define) +{ + BOOST_COMPUTE_FUNCTION(int, return_number, (), + { + return NUMBER; + }); + return_number.define("NUMBER", "4"); + + compute::vector<int> vec(1, context); + compute::generate(vec.begin(), vec.end(), return_number, queue); + CHECK_RANGE_EQUAL(int, 1, vec, (4)); + + return_number.define("NUMBER", "2"); + compute::generate(vec.begin(), vec.end(), return_number, queue); + CHECK_RANGE_EQUAL(int, 1, vec, (2)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_function_input_iterator.cpp b/src/boost/libs/compute/test/test_function_input_iterator.cpp new file mode 100644 index 00000000..b5c315f7 --- /dev/null +++ b/src/boost/libs/compute/test/test_function_input_iterator.cpp @@ -0,0 +1,50 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionInputIterator +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/function_input_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(generate_42_doctest) +{ + boost::compute::vector<int> result(4, context); + +//! [generate_42] +BOOST_COMPUTE_FUNCTION(int, ret42, (), +{ + return 42; +}); + +boost::compute::copy( + boost::compute::make_function_input_iterator(ret42, 0), + boost::compute::make_function_input_iterator(ret42, result.size()), + result.begin(), + queue +); + +// result == { 42, 42, 42, 42 } +//! [generate_42] + + CHECK_RANGE_EQUAL(int, 4, result, (42, 42, 42, 42)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_functional_as.cpp b/src/boost/libs/compute/test/test_functional_as.cpp new file mode 100644 index 00000000..f1318b0a --- /dev/null +++ b/src/boost/libs/compute/test/test_functional_as.cpp @@ -0,0 +1,59 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionalAs +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/as.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(roundtrip_int_float) +{ + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<int> input(8, context); + compute::copy_n(data, 8, input.begin(), queue); + + // convert int -> float + compute::vector<float> output(8, context); + compute::transform( + input.begin(), + input.end(), + output.begin(), + compute::as<float>(), + queue + ); + + // zero out input + compute::fill(input.begin(), input.end(), 0, queue); + + // convert float -> int + compute::transform( + output.begin(), + output.end(), + input.begin(), + compute::as<int>(), + queue + ); + + // check values + CHECK_RANGE_EQUAL( + int, 8, input, (1, 2, 3, 4, 5, 6, 7, 8) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_functional_bind.cpp b/src/boost/libs/compute/test/test_functional_bind.cpp new file mode 100644 index 00000000..327232d8 --- /dev/null +++ b/src/boost/libs/compute/test/test_functional_bind.cpp @@ -0,0 +1,237 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionalBind +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/count_if.hpp> +#include <boost/compute/algorithm/find_if.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/bind.hpp> +#include <boost/compute/functional/common.hpp> +#include <boost/compute/functional/operator.hpp> +#include <boost/compute/types/struct.hpp> + +// simple test struct +struct data_struct +{ + int int_value; + float float_value; +}; + +BOOST_COMPUTE_ADAPT_STRUCT(data_struct, data_struct, (int_value, float_value)) + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +using compute::placeholders::_1; +using compute::placeholders::_2; + +BOOST_AUTO_TEST_CASE(transform_plus_two) +{ + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vector(4, context); + compute::copy_n(data, 4, vector.begin(), queue); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), + compute::bind(compute::plus<int>(), _1, 2), + queue + ); + + CHECK_RANGE_EQUAL(int, 4, vector, (3, 4, 5, 6)); +} + +BOOST_AUTO_TEST_CASE(transform_pow_two) +{ + float data[] = { 2, 3, 4, 5 }; + compute::vector<float> vector(4, context); + compute::copy_n(data, 4, vector.begin(), queue); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), + compute::bind(compute::pow<float>(), 2.0f, _1), + queue + ); + + compute::copy(vector.begin(), vector.end(), data, queue); + BOOST_CHECK_CLOSE(data[0], 4.0f, 1e-4); + BOOST_CHECK_CLOSE(data[1], 8.0f, 1e-4); + BOOST_CHECK_CLOSE(data[2], 16.0f, 1e-4); + BOOST_CHECK_CLOSE(data[3], 32.0f, 1e-4); +} + +BOOST_AUTO_TEST_CASE(find_if_equal) +{ + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vector(4, context); + compute::copy_n(data, 4, vector.begin(), queue); + + BOOST_CHECK( + compute::find_if( + vector.begin(), vector.end(), + compute::bind(compute::equal_to<int>(), _1, 3), + queue + ) == vector.begin() + 2 + ); +} + +BOOST_AUTO_TEST_CASE(compare_less_than) +{ + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vector(data, data + 4, queue); + + int count = boost::compute::count_if( + vector.begin(), vector.end(), + compute::bind(compute::less<int>(), _1, int(3)), + queue + ); + BOOST_CHECK_EQUAL(count, 2); + + count = boost::compute::count_if( + vector.begin(), vector.end(), + compute::bind(compute::less<int>(), int(3), _1), + queue + ); + BOOST_CHECK_EQUAL(count, 1); +} + +BOOST_AUTO_TEST_CASE(subtract_ranges) +{ + int data1[] = { 1, 2, 3, 4 }; + int data2[] = { 4, 3, 2, 1 }; + + compute::vector<int> vector1(data1, data1 + 4, queue); + compute::vector<int> vector2(data2, data2 + 4, queue); + + compute::vector<int> result(4, context); + + compute::transform( + vector1.begin(), + vector1.end(), + vector2.begin(), + result.begin(), + compute::bind(compute::minus<int>(), _1, _2), + queue + ); + CHECK_RANGE_EQUAL(int, 4, result, (-3, -1, 1, 3)); + + compute::transform( + vector1.begin(), + vector1.end(), + vector2.begin(), + result.begin(), + compute::bind(compute::minus<int>(), _2, _1), + queue + ); + CHECK_RANGE_EQUAL(int, 4, result, (3, 1, -1, -3)); + + compute::transform( + vector1.begin(), + vector1.end(), + vector2.begin(), + result.begin(), + compute::bind(compute::minus<int>(), 5, _1), + queue + ); + CHECK_RANGE_EQUAL(int, 4, result, (4, 3, 2, 1)); + + compute::transform( + vector1.begin(), + vector1.end(), + vector2.begin(), + result.begin(), + compute::bind(compute::minus<int>(), 5, _2), + queue + ); + CHECK_RANGE_EQUAL(int, 4, result, (1, 2, 3, 4)); +} + +BOOST_AUTO_TEST_CASE(clamp_values) +{ + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vector(data, data + 4, queue); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), + compute::bind(compute::clamp<int>(), _1, 2, 3), + queue + ); + CHECK_RANGE_EQUAL(int, 4, vector, (2, 2, 3, 3)); +} + +BOOST_AUTO_TEST_CASE(bind_custom_function) +{ + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vector(data, data + 4, queue); + + BOOST_COMPUTE_FUNCTION(int, x_if_odd_else_y, (int x, int y), + { + if(x & 1) + return x; + else + return y; + }); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), + compute::bind(x_if_odd_else_y, _1, 9), + queue + ); + CHECK_RANGE_EQUAL(int, 4, vector, (1, 9, 3, 9)); + + compute::copy( + data, data + 4, vector.begin(), queue + ); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), + compute::bind(x_if_odd_else_y, 2, _1), + queue + ); + CHECK_RANGE_EQUAL(int, 4, vector, (1, 2, 3, 4)); +} + +BOOST_AUTO_TEST_CASE(bind_struct) +{ + if(bug_in_struct_assignment(device)){ + std::cerr << "skipping bind_struct test" << std::endl; + return; + } + + BOOST_COMPUTE_FUNCTION(int, add_struct_value, (int x, data_struct s), + { + return s.int_value + x; + }); + + data_struct data; + data.int_value = 3; + data.float_value = 4.56f; + + int input[] = { 1, 2, 3, 4 }; + compute::vector<int> vec(input, input + 4, queue); + + compute::transform( + vec.begin(), vec.end(), vec.begin(), + compute::bind(add_struct_value, _1, data), + queue + ); + CHECK_RANGE_EQUAL(int, 4, vec, (4, 5, 6, 7)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_functional_convert.cpp b/src/boost/libs/compute/test/test_functional_convert.cpp new file mode 100644 index 00000000..b3303af3 --- /dev/null +++ b/src/boost/libs/compute/test/test_functional_convert.cpp @@ -0,0 +1,44 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionalConvert +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/convert.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(convert_int_float) +{ + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<int> input(8, context); + compute::copy_n(data, 8, input.begin(), queue); + + compute::vector<float> output(8, context); + compute::transform( + input.begin(), + input.end(), + output.begin(), + compute::convert<float>(), + queue + ); + CHECK_RANGE_EQUAL( + float, 8, output, (1.f, 2.f, 3.f, 4.f, 5.f, 6.f, 7.f, 8.f) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_functional_get.cpp b/src/boost/libs/compute/test/test_functional_get.cpp new file mode 100644 index 00000000..9536145e --- /dev/null +++ b/src/boost/libs/compute/test/test_functional_get.cpp @@ -0,0 +1,83 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionalGet +#include <boost/test/unit_test.hpp> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/types/pair.hpp> +#include <boost/compute/types/tuple.hpp> +#include <boost/compute/types/fundamental.hpp> +#include <boost/compute/functional/get.hpp> +#include <boost/compute/type_traits/result_of.hpp> + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(get_vector_result_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::result_of< + compute::get<0>(compute::float4_) + >::type, + float + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::result_of< + compute::get<1>(compute::int2_) + >::type, + int + >::value + )); +} + +BOOST_AUTO_TEST_CASE(get_pair_result_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::result_of< + compute::get<0>(std::pair<int, float>) + >::type, + int + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::result_of< + compute::get<1>(std::pair<compute::float2_, compute::char4_>) + >::type, + compute::char4_ + >::value + )); +} + +BOOST_AUTO_TEST_CASE(get_tuple_result_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::result_of< + compute::get<0>(boost::tuple<int, int, double>) + >::type, + int + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::result_of< + compute::get<2>(boost::tuple<char, int, float>) + >::type, + float + >::value + )); +} diff --git a/src/boost/libs/compute/test/test_functional_hash.cpp b/src/boost/libs/compute/test/test_functional_hash.cpp new file mode 100644 index 00000000..e6e1c112 --- /dev/null +++ b/src/boost/libs/compute/test/test_functional_hash.cpp @@ -0,0 +1,42 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionalHash +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/hash.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(hash_int) +{ + using compute::ulong_; + + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> input_values(data, data + 4, queue); + compute::vector<ulong_> hash_values(4, context); + + compute::transform( + input_values.begin(), + input_values.end(), + hash_values.begin(), + compute::hash<int>(), + queue + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_functional_identity.cpp b/src/boost/libs/compute/test/test_functional_identity.cpp new file mode 100644 index 00000000..93534c05 --- /dev/null +++ b/src/boost/libs/compute/test/test_functional_identity.cpp @@ -0,0 +1,39 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionalIdentity +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/identity.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(copy_with_identity_transform) +{ + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<int> input(data, data + 8, queue); + compute::vector<int> output(8, context); + + compute::transform( + input.begin(), input.end(), output.begin(), compute::identity<int>(), queue + ); + + CHECK_RANGE_EQUAL( + int, 8, output, (1, 2, 3, 4, 5, 6, 7, 8) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_functional_popcount.cpp b/src/boost/libs/compute/test/test_functional_popcount.cpp new file mode 100644 index 00000000..4a15a508 --- /dev/null +++ b/src/boost/libs/compute/test/test_functional_popcount.cpp @@ -0,0 +1,42 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionalPopcount +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/popcount.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +typedef boost::mpl::list< + compute::uchar_, compute::ushort_, compute::uint_, compute::ulong_ +> popcount_test_types; + +BOOST_AUTO_TEST_CASE_TEMPLATE(popcount, T, popcount_test_types) +{ + compute::vector<T> vec(context); + vec.push_back(0x00, queue); + vec.push_back(0x01, queue); + vec.push_back(0x03, queue); + vec.push_back(0xff, queue); + + compute::vector<int> popcounts(vec.size(), context); + compute::transform( + vec.begin(), vec.end(), popcounts.begin(), compute::popcount<T>(), queue + ); + CHECK_RANGE_EQUAL(int, 4, popcounts, (0, 1, 2, 8)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_functional_unpack.cpp b/src/boost/libs/compute/test/test_functional_unpack.cpp new file mode 100644 index 00000000..98460071 --- /dev/null +++ b/src/boost/libs/compute/test/test_functional_unpack.cpp @@ -0,0 +1,99 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestFunctionalUnpack +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/zip_iterator.hpp> +#include <boost/compute/functional/detail/unpack.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(plus_int) +{ + int data1[] = { 1, 3, 5, 7 }; + int data2[] = { 2, 4, 6, 8 }; + + compute::vector<int> input1(4, context); + compute::vector<int> input2(4, context); + + compute::copy_n(data1, 4, input1.begin(), queue); + compute::copy_n(data2, 4, input2.begin(), queue); + + compute::vector<int> output(4, context); + compute::transform( + compute::make_zip_iterator( + boost::make_tuple(input1.begin(), input2.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(input1.end(), input2.end()) + ), + output.begin(), + compute::detail::unpack(compute::plus<int>()), + queue + ); + CHECK_RANGE_EQUAL(int, 4, output, (3, 7, 11, 15)); +} + +BOOST_AUTO_TEST_CASE(fma_float) +{ + float data1[] = { 1, 3, 5, 7 }; + float data2[] = { 2, 4, 6, 8 }; + float data3[] = { 0, 9, 1, 2 }; + + compute::vector<float> input1(4, context); + compute::vector<float> input2(4, context); + compute::vector<float> input3(4, context); + + compute::copy_n(data1, 4, input1.begin(), queue); + compute::copy_n(data2, 4, input2.begin(), queue); + compute::copy_n(data3, 4, input3.begin(), queue); + + compute::vector<int> output(4, context); + compute::transform( + compute::make_zip_iterator( + boost::make_tuple(input1.begin(), input2.begin(), input3.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(input1.end(), input2.end(), input3.begin()) + ), + output.begin(), + compute::detail::unpack(compute::fma<float>()), + queue + ); +} + +BOOST_AUTO_TEST_CASE(subtract_int2) +{ + using compute::int2_; + + int data[] = { 4, 2, 5, 1, 6, 3, 7, 0 }; + compute::vector<int2_> input(4, context); + compute::copy_n(reinterpret_cast<int2_ *>(data), 4, input.begin(), queue); + + compute::vector<int> output(4, context); + compute::transform( + input.begin(), + input.end(), + output.begin(), + compute::detail::unpack(compute::minus<int>()), + queue + ); + CHECK_RANGE_EQUAL(int, 4, output, (2, 4, 3, 7)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_gather.cpp b/src/boost/libs/compute/test/test_gather.cpp new file mode 100644 index 00000000..2d6af2c8 --- /dev/null +++ b/src/boost/libs/compute/test/test_gather.cpp @@ -0,0 +1,71 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestGather +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy_if.hpp> +#include <boost/compute/algorithm/gather.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(gather_int) +{ + int input_data[] = { 1, 2, 3, 4, 5 }; + compute::vector<int> input(input_data, input_data + 5, queue); + + int indices_data[] = { 0, 4, 1, 3, 2 }; + compute::vector<int> indices(indices_data, indices_data + 5, queue); + + compute::vector<int> output(5, context); + compute::gather( + indices.begin(), indices.end(), input.begin(), output.begin(), queue + ); + CHECK_RANGE_EQUAL(int, 5, output, (1, 5, 2, 4, 3)); + + compute::gather( + indices.begin() + 1, indices.end(), input.begin(), output.begin(), queue + ); + CHECK_RANGE_EQUAL(int, 5, output, (5, 2, 4, 3, 3)); +} + +BOOST_AUTO_TEST_CASE(copy_index_then_gather) +{ + // input data + int data[] = { 1, 4, 3, 2, 5, 9, 8, 7 }; + compute::vector<int> input(data, data + 8, queue); + + // function returning true if the input is odd + BOOST_COMPUTE_FUNCTION(bool, is_odd, (int x), + { + return x % 2 != 0; + }); + + // copy indices of all odd values + compute::vector<int> odds(5, context); + compute::detail::copy_index_if( + input.begin(), input.end(), odds.begin(), is_odd, queue + ); + CHECK_RANGE_EQUAL(int, 5, odds, (0, 2, 4, 5, 7)); + + // gather all odd values + compute::vector<int> odd_values(5, context); + compute::gather( + odds.begin(), odds.end(), input.begin(), odd_values.begin(), queue + ); + CHECK_RANGE_EQUAL(int, 5, odd_values, (1, 3, 5, 9, 7)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_generate.cpp b/src/boost/libs/compute/test/test_generate.cpp new file mode 100644 index 00000000..aeec0a72 --- /dev/null +++ b/src/boost/libs/compute/test/test_generate.cpp @@ -0,0 +1,71 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestGenerate +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/generate.hpp> +#include <boost/compute/algorithm/generate_n.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/pair.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(generate4) +{ + bc::vector<int> vector(4, context); + bc::fill(vector.begin(), vector.end(), 2, queue); + CHECK_RANGE_EQUAL(int, 4, vector, (2, 2, 2, 2)); + + BOOST_COMPUTE_FUNCTION(int, ret4, (void), + { + return 4; + }); + + bc::generate(vector.begin(), vector.end(), ret4, queue); + CHECK_RANGE_EQUAL(int, 4, vector, (4, 4, 4, 4)); +} + +BOOST_AUTO_TEST_CASE(generate_pair) +{ + if(bug_in_struct_assignment(device)){ + std::cerr << "skipping generate_pair test" << std::endl; + return; + } + + // in order to use std::pair<T1, T2> with BOOST_COMPUTE_FUNCTION() macro we + // need a typedef. otherwise the commas in the type declaration screw it up. + typedef std::pair<int, float> pair_type; + + bc::vector<pair_type> vector(3, context); + + BOOST_COMPUTE_FUNCTION(pair_type, generate_pair, (void), + { + return boost_make_pair(int, 2, float, 3.14f); + }); + + bc::generate(vector.begin(), vector.end(), generate_pair, queue); + + // check results + std::vector<pair_type> host_vector(3); + bc::copy(vector.begin(), vector.end(), host_vector.begin(), queue); + BOOST_CHECK(host_vector[0] == std::make_pair(2, 3.14f)); + BOOST_CHECK(host_vector[1] == std::make_pair(2, 3.14f)); + BOOST_CHECK(host_vector[2] == std::make_pair(2, 3.14f)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_image1d.cpp b/src/boost/libs/compute/test/test_image1d.cpp new file mode 100644 index 00000000..364d19ed --- /dev/null +++ b/src/boost/libs/compute/test/test_image1d.cpp @@ -0,0 +1,70 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestImage1D +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/image/image1d.hpp> +#include <boost/compute/utility/dim.hpp> + +#include "quirks.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(image1d_get_supported_formats) +{ + const std::vector<compute::image_format> formats = + compute::image1d::get_supported_formats(context); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_1_2 +BOOST_AUTO_TEST_CASE(fill_image1d) +{ + REQUIRES_OPENCL_VERSION(1, 2); // device OpenCL version check + + // single-channel unsigned char + compute::image_format format(CL_R, CL_UNSIGNED_INT8); + + if(!compute::image1d::is_supported_format(format, context)){ + std::cerr << "skipping fill_image1d test, image format not supported" << std::endl; + return; + } + + compute::image1d img(context, 64, format); + + BOOST_CHECK_EQUAL(img.width(), size_t(64)); + BOOST_CHECK(img.size() == compute::dim(64)); + BOOST_CHECK(img.format() == format); + + // fill image with '128' + compute::uint4_ fill_color(128, 0, 0, 0); + queue.enqueue_fill_image(img, &fill_color, img.origin(), img.size()); + + // read value of first pixel + compute::uchar_ first_pixel = 0; + queue.enqueue_read_image(img, compute::dim(0), compute::dim(1), &first_pixel); + BOOST_CHECK_EQUAL(first_pixel, compute::uchar_(128)); +} +#endif // BOOST_COMPUTE_CL_VERSION_1_2 + +// check type_name() for image1d +BOOST_AUTO_TEST_CASE(image1d_type_name) +{ + BOOST_CHECK( + std::strcmp( + boost::compute::type_name<boost::compute::image1d>(), "image1d_t" + ) == 0 + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_image2d.cpp b/src/boost/libs/compute/test/test_image2d.cpp new file mode 100644 index 00000000..2ae56c47 --- /dev/null +++ b/src/boost/libs/compute/test/test_image2d.cpp @@ -0,0 +1,226 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestImage2D +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/image/image2d.hpp> +#include <boost/compute/utility/dim.hpp> + +#include "quirks.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(image2d_get_supported_formats) +{ + const std::vector<compute::image_format> formats = + compute::image2d::get_supported_formats(context); +} + +BOOST_AUTO_TEST_CASE(create_image_doctest) +{ + try { +//! [create_image] +// create 8-bit RGBA image format +boost::compute::image_format rgba8(CL_RGBA, CL_UNSIGNED_INT8); + +// create 640x480 image object +boost::compute::image2d img(context, 640, 480, rgba8); +//! [create_image] + + // verify image has been created and format is correct + BOOST_CHECK(img.get() != cl_mem()); + BOOST_CHECK(img.format() == rgba8); + BOOST_CHECK_EQUAL(img.width(), size_t(640)); + BOOST_CHECK_EQUAL(img.height(), size_t(480)); + } + catch(compute::opencl_error &e){ + if(e.error_code() == CL_IMAGE_FORMAT_NOT_SUPPORTED){ + // image format not supported by device + return; + } + + // some other error, rethrow + throw; + } +} + +BOOST_AUTO_TEST_CASE(get_info) +{ + compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8); + + if(!compute::image2d::is_supported_format(format, context)){ + std::cerr << "skipping get_info test, image format not supported" << std::endl; + return; + } + + compute::image2d image( + context, 48, 64, format, compute::image2d::read_only + ); + + BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_WIDTH), size_t(48)); + BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_HEIGHT), size_t(64)); + BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_DEPTH), size_t(0)); + BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_ROW_PITCH), size_t(48*4)); + BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_SLICE_PITCH), size_t(0)); + BOOST_CHECK_EQUAL(image.get_info<size_t>(CL_IMAGE_ELEMENT_SIZE), size_t(4)); + + BOOST_CHECK(image.format() == format); + BOOST_CHECK_EQUAL(image.width(), size_t(48)); + BOOST_CHECK_EQUAL(image.height(), size_t(64)); +} + +BOOST_AUTO_TEST_CASE(clone_image) +{ + compute::image_format format(CL_RGBA, CL_UNORM_INT8); + + if(!compute::image2d::is_supported_format(format, context)){ + std::cerr << "skipping clone_image test, image format not supported" << std::endl; + return; + } + + // image data + unsigned int data[] = { 0x0000ffff, 0xff00ffff, + 0x00ff00ff, 0xffffffff }; + + // create image on the device + compute::image2d image(context, 2, 2, format); + + // ensure we have a valid image object + BOOST_REQUIRE(image.get() != cl_mem()); + + // copy image data to the device + queue.enqueue_write_image(image, image.origin(), image.size(), data); + + // clone image + compute::image2d copy = image.clone(queue); + + // ensure image format is the same + BOOST_CHECK(copy.format() == image.format()); + + // read cloned image data back to the host + unsigned int cloned_data[4]; + queue.enqueue_read_image(copy, image.origin(), image.size(), cloned_data); + + // ensure original data and cloned data are the same + BOOST_CHECK_EQUAL(cloned_data[0], data[0]); + BOOST_CHECK_EQUAL(cloned_data[1], data[1]); + BOOST_CHECK_EQUAL(cloned_data[2], data[2]); + BOOST_CHECK_EQUAL(cloned_data[3], data[3]); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_1_2 +BOOST_AUTO_TEST_CASE(fill_image) +{ + REQUIRES_OPENCL_VERSION(1, 2); // device OpenCL version check + + compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8); + + if(!compute::image2d::is_supported_format(format, context)){ + std::cerr << "skipping fill_image test, image format not supported" << std::endl; + return; + } + + compute::image2d img(context, 640, 480, format); + + // fill image with black + compute::uint4_ black(0, 0, 0, 255); + queue.enqueue_fill_image(img, &black, img.origin(), img.size()); + + // read value of first pixel + compute::uchar4_ first_pixel; + queue.enqueue_read_image(img, compute::dim(0), compute::dim(1), &first_pixel); + BOOST_CHECK_EQUAL(first_pixel, compute::uchar4_(0, 0, 0, 255)); + + // fill image with white + compute::uint4_ white(255, 255, 255, 255); + queue.enqueue_fill_image(img, &white, img.origin(), img.size()); + + // read value of first pixel + queue.enqueue_read_image(img, compute::dim(0), compute::dim(1), &first_pixel); + BOOST_CHECK_EQUAL(first_pixel, compute::uchar4_(255, 255, 255, 255)); +} +#endif + +// check type_name() for image2d +BOOST_AUTO_TEST_CASE(image2d_type_name) +{ + BOOST_CHECK( + std::strcmp( + boost::compute::type_name<boost::compute::image2d>(), "image2d_t" + ) == 0 + ); +} + +BOOST_AUTO_TEST_CASE(map_image) +{ + compute::image_format format(CL_RGBA, CL_UNSIGNED_INT8); + + if(!compute::image2d::is_supported_format(format, context)){ + std::cerr << "skipping clone_image test, image format not supported" << std::endl; + return; + } + + // create image on the device + compute::image2d image(context, 2, 2, format); + + // ensure we have a valid image object + BOOST_REQUIRE(image.get() != cl_mem()); + + size_t row_pitch = 0; + size_t slice_pitch = 0; + + // write map image + compute::uint_* ptr = static_cast<compute::uint_*>( + queue.enqueue_map_image(image, CL_MAP_WRITE, image.origin(), + image.size(), row_pitch, slice_pitch) + ); + + BOOST_CHECK_EQUAL(row_pitch, size_t(2*4)); + + // image data + compute::uint_ data[] = { 0x0000ffff, 0xff00ffff, + 0x00ff00ff, 0xffffffff }; + + // copy data to image + for(size_t i = 0; i < 4; i++){ + *(ptr+i) = data[i]; + } + + // unmap + queue.enqueue_unmap_image(image, static_cast<void*>(ptr)); + + // read map image + compute::event map_event; + ptr = static_cast<compute::uint_*>( + queue.enqueue_map_image_async(image, CL_MAP_READ, image.origin(), + image.size(), row_pitch, slice_pitch, + map_event) + ); + + map_event.wait(); + + BOOST_CHECK(map_event.get_status() == CL_COMPLETE); + BOOST_CHECK_EQUAL(row_pitch, size_t(2*4)); + + // checking + for(size_t i = 0; i < 4; i++){ + BOOST_CHECK_EQUAL(*(ptr+i), data[i]); + } + + // unmap + queue.enqueue_unmap_image(image, static_cast<void*>(ptr)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_image3d.cpp b/src/boost/libs/compute/test/test_image3d.cpp new file mode 100644 index 00000000..ee1cc15d --- /dev/null +++ b/src/boost/libs/compute/test/test_image3d.cpp @@ -0,0 +1,37 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestImage3D +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/image/image3d.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(image3d_get_supported_formats) +{ + const std::vector<compute::image_format> formats = + compute::image3d::get_supported_formats(context); +} + +// check type_name() for image3d +BOOST_AUTO_TEST_CASE(image3d_type_name) +{ + BOOST_CHECK( + std::strcmp( + boost::compute::type_name<boost::compute::image3d>(), "image3d_t" + ) == 0 + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_image_sampler.cpp b/src/boost/libs/compute/test/test_image_sampler.cpp new file mode 100644 index 00000000..14b01381 --- /dev/null +++ b/src/boost/libs/compute/test/test_image_sampler.cpp @@ -0,0 +1,65 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestImageSampler +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/image/image_sampler.hpp> + +#include "quirks.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(get_context) +{ + if(!supports_image_samplers(device)){ + std::cerr << "skipping get_context test" << std::endl; + return; + } + + compute::image_sampler sampler(context, true, CL_ADDRESS_NONE, CL_FILTER_NEAREST); + BOOST_CHECK(sampler.get_context() == context); +} + +BOOST_AUTO_TEST_CASE(get_info) +{ + if(!supports_image_samplers(device)){ + std::cerr << "skipping get_info test" << std::endl; + return; + } + + compute::image_sampler sampler(context, true, CL_ADDRESS_NONE, CL_FILTER_NEAREST); + BOOST_CHECK_EQUAL(sampler.get_info<bool>(CL_SAMPLER_NORMALIZED_COORDS), true); + BOOST_CHECK_EQUAL( + sampler.get_info<cl_addressing_mode>(CL_SAMPLER_ADDRESSING_MODE), + cl_addressing_mode(CL_ADDRESS_NONE) + ); + BOOST_CHECK_EQUAL( + sampler.get_info<cl_filter_mode>(CL_SAMPLER_FILTER_MODE), + cl_filter_mode(CL_FILTER_NEAREST) + ); + + sampler = compute::image_sampler(context, false, CL_ADDRESS_CLAMP, CL_FILTER_LINEAR); + BOOST_CHECK_EQUAL(sampler.get_info<bool>(CL_SAMPLER_NORMALIZED_COORDS), false); + BOOST_CHECK_EQUAL( + sampler.get_info<cl_addressing_mode>(CL_SAMPLER_ADDRESSING_MODE), + cl_addressing_mode(CL_ADDRESS_CLAMP) + ); + BOOST_CHECK_EQUAL( + sampler.get_info<cl_filter_mode>(CL_SAMPLER_FILTER_MODE), + cl_filter_mode(CL_FILTER_LINEAR) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_includes.cpp b/src/boost/libs/compute/test/test_includes.cpp new file mode 100644 index 00000000..9ecc42d0 --- /dev/null +++ b/src/boost/libs/compute/test/test_includes.cpp @@ -0,0 +1,60 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestIncludes +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/includes.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(includes_int) +{ + int dataset1[] = {1, 1, 2, 2, 2, 2, 3, 3, 4, 5, 6, 10}; + bc::vector<bc::int_> set1(dataset1, dataset1 + 12, queue); + + int dataset2[] = {2, 4, 5, 6}; + bc::vector<bc::int_> set2(dataset2, dataset2 + 4, queue); + + bool includes = bc::includes(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 4, queue); + BOOST_VERIFY(includes == true); + + set2[3] = 7; + includes = bc::includes(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 4, queue); + BOOST_VERIFY(includes == false); +} + +BOOST_AUTO_TEST_CASE(includes_string) +{ + char string1[] = "abcccdddeeff"; + bc::vector<bc::char_> set1(string1, string1 + 12, queue); + + char string2[] = "bccdf"; + bc::vector<bc::char_> set2(string2, string2 + 5, queue); + + bool includes = bc::includes(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 5, queue); + BOOST_VERIFY(includes == true); + + set2[0] = 'g'; + includes = bc::includes(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 4, queue); + BOOST_VERIFY(includes == false); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_inner_product.cpp b/src/boost/libs/compute/test/test_inner_product.cpp new file mode 100644 index 00000000..0c2d82c6 --- /dev/null +++ b/src/boost/libs/compute/test/test_inner_product.cpp @@ -0,0 +1,53 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInnerProduct +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/inner_product.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> + +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(inner_product_int) +{ + int data1[] = { 1, 2, 3, 4 }; + bc::vector<int> input1(data1, data1 + 4, queue); + + int data2[] = { 10, 20, 30, 40 }; + bc::vector<int> input2(data2, data2 + 4, queue); + + int product = bc::inner_product(input1.begin(), + input1.end(), + input2.begin(), + 0, + queue); + BOOST_CHECK_EQUAL(product, 300); +} + +BOOST_AUTO_TEST_CASE(inner_product_counting_iterator) +{ + BOOST_CHECK_EQUAL( + boost::compute::inner_product( + boost::compute::make_counting_iterator<int>(0), + boost::compute::make_counting_iterator<int>(100), + boost::compute::make_counting_iterator<int>(0), + 0, + queue + ), + 328350 + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_inplace_merge.cpp b/src/boost/libs/compute/test/test_inplace_merge.cpp new file mode 100644 index 00000000..f328ec15 --- /dev/null +++ b/src/boost/libs/compute/test/test_inplace_merge.cpp @@ -0,0 +1,47 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInplaceMerge +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/inplace_merge.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(simple_merge_int) +{ + int data[] = { 1, 3, 5, 7, 2, 4, 6, 8 }; + compute::vector<int> vector(data, data + 8, queue); + + // merge each half in-place + compute::inplace_merge( + vector.begin(), + vector.begin() + 4, + vector.end(), + queue + ); + CHECK_RANGE_EQUAL(int, 8, vector, (1, 2, 3, 4, 5, 6, 7, 8)); + + // run again on already sorted list + compute::inplace_merge( + vector.begin(), + vector.begin() + 4, + vector.end(), + queue + ); + CHECK_RANGE_EQUAL(int, 8, vector, (1, 2, 3, 4, 5, 6, 7, 8)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_inplace_reduce.cpp b/src/boost/libs/compute/test/test_inplace_reduce.cpp new file mode 100644 index 00000000..a0706e3a --- /dev/null +++ b/src/boost/libs/compute/test/test_inplace_reduce.cpp @@ -0,0 +1,138 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInplaceReduce +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/algorithm/detail/inplace_reduce.hpp> +#include <boost/compute/container/vector.hpp> + +#include "quirks.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(sum_int) +{ + if(is_apple_cpu_device(device)) { + std::cerr + << "skipping all inplace_reduce tests due to Apple platform" + << " behavior when local memory is used on a CPU device" + << std::endl; + return; + } + + int data[] = { 1, 5, 3, 4, 9, 3, 5, 3 }; + boost::compute::vector<int> vector(data, data + 8, queue); + + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::plus<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(33)); + + vector.assign(data, data + 8); + vector.push_back(3); + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::plus<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(36)); +} + +BOOST_AUTO_TEST_CASE(multiply_int) +{ + if(is_apple_cpu_device(device)) { + return; + } + + int data[] = { 1, 5, 3, 4, 9, 3, 5, 3 }; + boost::compute::vector<int> vector(data, data + 8, queue); + + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::multiplies<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(24300)); + + vector.assign(data, data + 8); + vector.push_back(3); + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::multiplies<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(72900)); +} + +BOOST_AUTO_TEST_CASE(reduce_iota) +{ + if(is_apple_cpu_device(device)) { + return; + } + + // 1 value + boost::compute::vector<int> vector(1, context); + boost::compute::iota(vector.begin(), vector.end(), int(0), queue); + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::plus<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(0)); + + // 1000 values + vector.resize(1000); + boost::compute::iota(vector.begin(), vector.end(), int(0), queue); + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::plus<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(499500)); + + // 2499 values + vector.resize(2499); + boost::compute::iota(vector.begin(), vector.end(), int(0), queue); + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::plus<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(3121251)); + + // 4096 values + vector.resize(4096); + boost::compute::iota(vector.begin(), vector.end(), int(0), queue); + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::plus<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(8386560)); + + // 5000 values + vector.resize(5000); + boost::compute::iota(vector.begin(), vector.end(), int(0), queue); + boost::compute::detail::inplace_reduce(vector.begin(), + vector.end(), + boost::compute::plus<int>(), + queue); + queue.finish(); + BOOST_CHECK_EQUAL(int(vector[0]), int(12497500)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_insertion_sort.cpp b/src/boost/libs/compute/test/test_insertion_sort.cpp new file mode 100644 index 00000000..a9088b5a --- /dev/null +++ b/src/boost/libs/compute/test/test_insertion_sort.cpp @@ -0,0 +1,171 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInsertionSort +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/algorithm/detail/insertion_sort.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(sort_char_vector) +{ + using boost::compute::char_; + + char_ data[] = { 'c', 'a', '0', '7', 'B', 'F', '\0', '$' }; + boost::compute::vector<char_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(char_, 8, vector, ('\0', '$', '0', '7', 'B', 'F', 'a', 'c')); +} + +BOOST_AUTO_TEST_CASE(sort_uchar_vector) +{ + using boost::compute::uchar_; + + uchar_ data[] = { 0x12, 0x00, 0xFF, 0xB4, 0x80, 0x32, 0x64, 0xA2 }; + boost::compute::vector<uchar_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(uchar_, 8, vector, (0x00, 0x12, 0x32, 0x64, 0x80, 0xA2, 0xB4, 0xFF)); +} + +BOOST_AUTO_TEST_CASE(sort_short_vector) +{ + using boost::compute::short_; + + short_ data[] = { -4, 152, -94, 963, 31002, -456, 0, -2113 }; + boost::compute::vector<short_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(short_, 8, vector, (-2113, -456, -94, -4, 0, 152, 963, 31002)); +} + +BOOST_AUTO_TEST_CASE(sort_ushort_vector) +{ + using boost::compute::ushort_; + + ushort_ data[] = { 4, 152, 94, 963, 63202, 34560, 0, 2113 }; + boost::compute::vector<ushort_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(ushort_, 8, vector, (0, 4, 94, 152, 963, 2113, 34560, 63202)); +} + +BOOST_AUTO_TEST_CASE(sort_int_vector) +{ + int data[] = { -4, 152, -5000, 963, 75321, -456, 0, 1112 }; + boost::compute::vector<int> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(int, 8, vector, (-5000, -456, -4, 0, 152, 963, 1112, 75321)); +} + +BOOST_AUTO_TEST_CASE(sort_uint_vector) +{ + using boost::compute::uint_; + + uint_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<uint_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(uint_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_long_vector) +{ + using boost::compute::long_; + + long_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<long_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(long_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_ulong_vector) +{ + using boost::compute::ulong_; + + ulong_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<ulong_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(ulong_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_float_vector) +{ + float data[] = { -6023.0f, 152.5f, -63.0f, 1234567.0f, 11.2f, + -5000.1f, 0.0f, 14.0f, -8.25f, -0.0f }; + boost::compute::vector<float> vector(data, data + 10, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(10)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL( + float, 10, vector, + (-6023.0f, -5000.1f, -63.0f, -8.25f, -0.0f, 0.0f, 11.2f, 14.0f, 152.5f, 1234567.0f) + ); +} + +BOOST_AUTO_TEST_CASE(sort_double_vector) +{ + if(!device.supports_extension("cl_khr_fp64")){ + std::cout << "skipping test: device does not support double" << std::endl; + return; + } + + double data[] = { -6023.0, 152.5, -63.0, 1234567.0, 11.2, + -5000.1, 0.0, 14.0, -8.25, -0.0 }; + boost::compute::vector<double> vector(data, data + 10, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(10)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::serial_insertion_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL( + double, 10, vector, + (-6023.0, -5000.1, -63.0, -8.25, -0.0, 0.0, 11.2, 14.0, 152.5, 1234567.0) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_invoke.cpp b/src/boost/libs/compute/test/test_invoke.cpp new file mode 100644 index 00000000..87f3f265 --- /dev/null +++ b/src/boost/libs/compute/test/test_invoke.cpp @@ -0,0 +1,59 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://kylelutz.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestInvoke +#include <boost/test/unit_test.hpp> + +#include <boost/compute/function.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/functional/integer.hpp> +#include <boost/compute/functional/math.hpp> +#include <boost/compute/utility/invoke.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(invoke_builtin) +{ + BOOST_CHECK_EQUAL(compute::invoke(compute::abs<int>(), queue, -3), 3); + BOOST_CHECK_CLOSE(compute::invoke(compute::pow<float>(), queue, 2.f, 8.f), 256.f, 1e-4); +} + +BOOST_AUTO_TEST_CASE(invoke_function) +{ + BOOST_COMPUTE_FUNCTION(int, plus_two, (int x), + { + return x + 2; + }); + + BOOST_CHECK_EQUAL(compute::invoke(plus_two, queue, 2), 4); + + BOOST_COMPUTE_FUNCTION(float, get_max, (float x, float y), + { + if(x > y) + return x; + else + return y; + }); + + BOOST_CHECK_EQUAL(compute::invoke(get_max, queue, 10.f, 20.f), 20.f); +} + +BOOST_AUTO_TEST_CASE(invoke_lambda) +{ + using boost::compute::lambda::_1; + using boost::compute::lambda::_2; + + BOOST_CHECK_EQUAL(compute::invoke(_1 / 2, queue, 4), 2); + BOOST_CHECK_EQUAL(compute::invoke(_1 * _2 + 1, queue, 3, 3), 10); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_iota.cpp b/src/boost/libs/compute/test/test_iota.cpp new file mode 100644 index 00000000..345decec --- /dev/null +++ b/src/boost/libs/compute/test/test_iota.cpp @@ -0,0 +1,90 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestIota +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/context.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/permutation_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(iota_int) +{ + bc::vector<int> vector(4, context); + bc::iota(vector.begin(), vector.end(), 0, queue); + CHECK_RANGE_EQUAL(int, 4, vector, (0, 1, 2, 3)); + + bc::iota(vector.begin(), vector.end(), 10, queue); + CHECK_RANGE_EQUAL(int, 4, vector, (10, 11, 12, 13)); + + bc::iota(vector.begin() + 2, vector.end(), -5, queue); + CHECK_RANGE_EQUAL(int, 4, vector, (10, 11, -5, -4)); + + bc::iota(vector.begin(), vector.end() - 2, 4, queue); + CHECK_RANGE_EQUAL(int, 4, vector, (4, 5, -5, -4)); +} + +BOOST_AUTO_TEST_CASE(iota_doctest) +{ + boost::compute::vector<int> vec(3, context); + +//! [iota] +boost::compute::iota(vec.begin(), vec.end(), 0, queue); +//! [iota] + + CHECK_RANGE_EQUAL(int, 3, vec, (0, 1, 2)); +} + +BOOST_AUTO_TEST_CASE(iota_permutation_iterator) +{ + bc::vector<int> output(5, context); + bc::fill(output.begin(), output.end(), 0, queue); + + int map_data[] = { 2, 0, 1, 4, 3 }; + bc::vector<int> map(map_data, map_data + 5, queue); + + bc::iota( + bc::make_permutation_iterator(output.begin(), map.begin()), + bc::make_permutation_iterator(output.end(), map.end()), + 1, + queue + ); + CHECK_RANGE_EQUAL(int, 5, output, (2, 3, 1, 5, 4)); +} + +BOOST_AUTO_TEST_CASE(iota_uint) +{ + bc::vector<bc::uint_> vector(4, context); + bc::iota(vector.begin(), vector.end(), bc::uint_(0), queue); + CHECK_RANGE_EQUAL(bc::uint_, 4, vector, (0, 1, 2, 3)); +} + +BOOST_AUTO_TEST_CASE(iota_char) +{ + bc::vector<bc::char_> vector(4, context); + bc::iota(vector.begin(), vector.end(), bc::uint_(0), queue); + CHECK_RANGE_EQUAL(bc::char_, 4, vector, (0, 1, 2, 3)); +} + +BOOST_AUTO_TEST_CASE(iota_uchar) +{ + bc::vector<bc::uchar_> vector(4, context); + bc::iota(vector.begin(), vector.end(), bc::uint_(0), queue); + CHECK_RANGE_EQUAL(bc::uchar_, 4, vector, (0, 1, 2, 3)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_is_permutation.cpp b/src/boost/libs/compute/test/test_is_permutation.cpp new file mode 100644 index 00000000..542a5d0b --- /dev/null +++ b/src/boost/libs/compute/test/test_is_permutation.cpp @@ -0,0 +1,71 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestIsPermutation +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/is_permutation.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(is_permutation_int) +{ + bc::int_ dataset1[] = {1, 3, 1, 2, 5}; + bc::vector<bc::int_> vector1(dataset1, dataset1 + 5, queue); + + bc::int_ dataset2[] = {3, 1, 5, 1, 2}; + bc::vector<bc::int_> vector2(dataset2, dataset2 + 5, queue); + + bool result = + bc::is_permutation(vector1.begin(), vector1.begin() + 5, + vector2.begin(), vector2.begin() + 5, queue); + + BOOST_VERIFY(result == true); + + vector2.begin().write(bc::int_(1), queue); + + result = bc::is_permutation(vector1.begin(), vector1.begin() + 5, + vector2.begin(), vector2.begin() + 5, + queue); + + BOOST_VERIFY(result == false); +} + +BOOST_AUTO_TEST_CASE(is_permutation_string) +{ + bc::char_ dataset1[] = "abade"; + bc::vector<bc::char_> vector1(dataset1, dataset1 + 5, queue); + + bc::char_ dataset2[] = "aadeb"; + bc::vector<bc::char_> vector2(dataset2, dataset2 + 5, queue); + + bool result = + bc::is_permutation(vector1.begin(), vector1.begin() + 5, + vector2.begin(), vector2.begin() + 5, queue); + + BOOST_VERIFY(result == true); + + vector2.begin().write(bc::char_('b'), queue); + + result = bc::is_permutation(vector1.begin(), vector1.begin() + 5, + vector2.begin(), vector2.begin() + 5, + queue); + + BOOST_VERIFY(result == false); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_is_sorted.cpp b/src/boost/libs/compute/test/test_is_sorted.cpp new file mode 100644 index 00000000..55e75ac1 --- /dev/null +++ b/src/boost/libs/compute/test/test_is_sorted.cpp @@ -0,0 +1,71 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestIsSorted +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/algorithm/reverse.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(is_sorted_int) +{ + compute::vector<int> vec(context); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue)); + + vec.push_back(1, queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue)); + + vec.push_back(2, queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue)); + + vec.push_back(0, queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue) == false); + + vec.push_back(-2, queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue) == false); + + compute::sort(vec.begin(), vec.end(), queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue)); +} + +BOOST_AUTO_TEST_CASE(is_sorted_ones) +{ + compute::vector<int> vec(2048, context); + compute::fill(vec.begin(), vec.end(), 1, queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue)); +} + +BOOST_AUTO_TEST_CASE(is_sorted_iota) +{ + // create vector with values from 1..1000 + compute::vector<int> vec(1000, context); + compute::iota(vec.begin(), vec.end(), 1, queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue)); + + // reverse the range + compute::reverse(vec.begin(), vec.end(), queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue) == false); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), compute::greater<int>(), queue)); + + // reverse it back + compute::reverse(vec.begin(), vec.end(), queue); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), queue)); + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), compute::greater<int>(), queue) == false); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_kernel.cpp b/src/boost/libs/compute/test/test_kernel.cpp new file mode 100644 index 00000000..2ab13b8a --- /dev/null +++ b/src/boost/libs/compute/test/test_kernel.cpp @@ -0,0 +1,335 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestKernel +#include <boost/test/unit_test.hpp> + +#include <boost/compute/buffer.hpp> +#include <boost/compute/kernel.hpp> +#include <boost/compute/types.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/utility/source.hpp> + +#include "context_setup.hpp" +#include "check_macros.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(name) +{ + compute::kernel foo = compute::kernel::create_with_source( + "__kernel void foo(int x) { }", "foo", context + ); + BOOST_CHECK_EQUAL(foo.name(), "foo"); + + compute::kernel bar = compute::kernel::create_with_source( + "__kernel void bar(float x) { }", "bar", context + ); + BOOST_CHECK_EQUAL(bar.name(), "bar"); +} + +BOOST_AUTO_TEST_CASE(arity) +{ + compute::kernel foo = compute::kernel::create_with_source( + "__kernel void foo(int x) { }", "foo", context + ); + BOOST_CHECK_EQUAL(foo.arity(), size_t(1)); + + compute::kernel bar = compute::kernel::create_with_source( + "__kernel void bar(float x, float y) { }", "bar", context + ); + BOOST_CHECK_EQUAL(bar.arity(), size_t(2)); + + compute::kernel baz = compute::kernel::create_with_source( + "__kernel void baz(char x, char y, char z) { }", "baz", context + ); + BOOST_CHECK_EQUAL(baz.arity(), size_t(3)); +} + +BOOST_AUTO_TEST_CASE(set_buffer_arg) +{ + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void foo(__global int *x, __global int *y) + { + x[get_global_id(0)] = -y[get_global_id(0)]; + } + ); + + compute::kernel foo = + compute::kernel::create_with_source(source, "foo", context); + + compute::buffer x(context, 16); + compute::buffer y(context, 16); + + foo.set_arg(0, x); + foo.set_arg(1, y.get()); +} + +BOOST_AUTO_TEST_CASE(get_work_group_info) +{ + const char source[] = + "__kernel void sum(__global const float *input,\n" + " __global float *output)\n" + "{\n" + " __local float scratch[16];\n" + " const uint gid = get_global_id(0);\n" + " const uint lid = get_local_id(0);\n" + " if(lid < 16)\n" + " scratch[lid] = input[gid];\n" + "}\n"; + + compute::program program = + compute::program::create_with_source(source, context); + + program.build(); + + compute::kernel kernel = program.create_kernel("sum"); + + using compute::ulong_; + + // get local memory size + kernel.get_work_group_info<ulong_>(device, CL_KERNEL_LOCAL_MEM_SIZE); + + // check work group size + size_t work_group_size = + kernel.get_work_group_info<size_t>(device, CL_KERNEL_WORK_GROUP_SIZE); + BOOST_CHECK(work_group_size >= 1); +} + +#ifndef BOOST_COMPUTE_NO_VARIADIC_TEMPLATES +BOOST_AUTO_TEST_CASE(kernel_set_args) +{ + compute::kernel k = compute::kernel::create_with_source( + "__kernel void test(int x, float y, char z) { }", "test", context + ); + + k.set_args(4, 2.4f, 'a'); +} +#endif // BOOST_COMPUTE_NO_VARIADIC_TEMPLATES + +// Originally failed to compile on macOS (several types are resolved differently) +BOOST_AUTO_TEST_CASE(kernel_set_args_mac) +{ + compute::kernel k = compute::kernel::create_with_source( + "__kernel void test(unsigned int a, unsigned long b) { }", "test", context + ); + + compute::uint_ a; + compute::ulong_ b; + + k.set_arg(0, a); + k.set_arg(1, b); +} + + +#ifdef BOOST_COMPUTE_CL_VERSION_1_2 +BOOST_AUTO_TEST_CASE(get_arg_info) +{ + REQUIRES_OPENCL_VERSION(1, 2); + + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void sum_kernel(__global const int *input, + const uint size, + __global int *result) + { + int sum = 0; + for(uint i = 0; i < size; i++){ + sum += input[i]; + } + *result = sum; + } + ); + + compute::program program = + compute::program::create_with_source(source, context); + + program.build("-cl-kernel-arg-info"); + + compute::kernel kernel = program.create_kernel("sum_kernel"); + + BOOST_CHECK_EQUAL(kernel.get_info<CL_KERNEL_NUM_ARGS>(), compute::uint_(3)); + + BOOST_CHECK_EQUAL(kernel.get_arg_info<std::string>(0, CL_KERNEL_ARG_TYPE_NAME), "int*"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<std::string>(0, CL_KERNEL_ARG_NAME), "input"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<std::string>(1, CL_KERNEL_ARG_TYPE_NAME), "uint"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<std::string>(1, CL_KERNEL_ARG_NAME), "size"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<std::string>(2, CL_KERNEL_ARG_TYPE_NAME), "int*"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<std::string>(2, CL_KERNEL_ARG_NAME), "result"); + + BOOST_CHECK_EQUAL(kernel.get_arg_info<CL_KERNEL_ARG_TYPE_NAME>(0), "int*"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<CL_KERNEL_ARG_NAME>(0), "input"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<CL_KERNEL_ARG_TYPE_NAME>(1), "uint"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<CL_KERNEL_ARG_NAME>(1), "size"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<CL_KERNEL_ARG_TYPE_NAME>(2), "int*"); + BOOST_CHECK_EQUAL(kernel.get_arg_info<CL_KERNEL_ARG_NAME>(2), "result"); +} +#endif // BOOST_COMPUTE_CL_VERSION_1_2 + +#ifdef BOOST_COMPUTE_CL_VERSION_2_0 +#ifndef CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR + #define CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE +#endif +#ifndef CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR + #define CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE +#endif +BOOST_AUTO_TEST_CASE(get_sub_group_info_ext) +{ + compute::kernel k = compute::kernel::create_with_source( + "__kernel void test(float x) { }", "test", context + ); + + // get_sub_group_info(const device&, cl_kernel_sub_group_info, const std::vector<size_t>) + std::vector<size_t> local_work_size(2, size_t(64)); + boost::optional<size_t> count = k.get_sub_group_info<size_t>( + device, + CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR, + local_work_size + ); + + #ifdef BOOST_COMPUTE_CL_VERSION_2_1 + if(device.check_version(2, 1)) + { + BOOST_CHECK(count); + } + else + #endif // BOOST_COMPUTE_CL_VERSION_2_1 + if(device.check_version(2, 0) && device.supports_extension("cl_khr_subgroups")) + { + // for device with cl_khr_subgroups it should return some value + BOOST_CHECK(count); + } + else + { + // for device without cl_khr_subgroups ext it should return null optional + BOOST_CHECK(count == boost::none); + } + + // get_sub_group_info(const device&, cl_kernel_sub_group_info, const size_t, const void *) + count = k.get_sub_group_info<size_t>( + device, + CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR, + 2 * sizeof(size_t), + &local_work_size[0] + ); + + #ifdef BOOST_COMPUTE_CL_VERSION_2_1 + if(device.check_version(2, 1)) + { + BOOST_CHECK(count); + } + else + #endif // BOOST_COMPUTE_CL_VERSION_2_1 + if(device.check_version(2, 0) && device.supports_extension("cl_khr_subgroups")) + { + // for device with cl_khr_subgroups it should return some value + BOOST_CHECK(count); + } + else + { + // for device without cl_khr_subgroups ext it should return null optional + BOOST_CHECK(count == boost::none); + } +} +#endif // BOOST_COMPUTE_CL_VERSION_2_0 + +#ifdef BOOST_COMPUTE_CL_VERSION_2_1 +BOOST_AUTO_TEST_CASE(get_sub_group_info_core) +{ + compute::kernel k = compute::kernel::create_with_source( + "__kernel void test(float x) { }", "test", context + ); + + // get_sub_group_info(const device&, cl_kernel_sub_group_info, const size_t) + boost::optional<std::vector<size_t>> local_size = + k.get_sub_group_info<std::vector<size_t> >( + device, + CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT, + size_t(1) + ); + + if(device.check_version(2, 1)) + { + // for 2.1 devices it should return some value + BOOST_CHECK(local_size); + BOOST_CHECK(local_size.value().size() == 3); + } + else + { + // for 1.x and 2.0 devices it should return null optional, + // because CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT is not + // supported by cl_khr_subgroups (2.0 ext) + BOOST_CHECK(local_size == boost::none); + } + + // get_sub_group_info(const device&, cl_kernel_sub_group_info, const size_t) + boost::optional<size_t> local_size_simple = + k.get_sub_group_info<size_t>( + device, + CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT, + size_t(1) + ); + + if(device.check_version(2, 1)) + { + // for 2.1 devices it should return some value + BOOST_CHECK(local_size_simple); + } + else + { + // for 1.x and 2.0 devices it should return null optional, + // because CL_KERNEL_LOCAL_SIZE_FOR_SUB_GROUP_COUNT is not + // supported by cl_khr_subgroups (2.0 ext) + BOOST_CHECK(local_size_simple == boost::none); + } + + // get_sub_group_info(const device&, cl_kernel_sub_group_info) + boost::optional<size_t> max = + k.get_sub_group_info<size_t>( + device, + CL_KERNEL_MAX_NUM_SUB_GROUPS + ); + + if(device.check_version(2, 1)) + { + // for 2.1 devices it should return some value + BOOST_CHECK(max); + } + else + { + // for 1.x and 2.0 devices it should return null optional, + // because CL_KERNEL_MAX_NUM_SUB_GROUPS is not + // supported by cl_khr_subgroups (2.0 ext) + BOOST_CHECK(max == boost::none); + } +} +#endif // BOOST_COMPUTE_CL_VERSION_2_1 + +#ifdef BOOST_COMPUTE_CL_VERSION_2_1 +BOOST_AUTO_TEST_CASE(clone_kernel) +{ + REQUIRES_OPENCL_PLATFORM_VERSION(2, 1); + + compute::kernel k1 = compute::kernel::create_with_source( + "__kernel void test(__global int * x) { x[get_global_id(0)] = get_global_id(0); }", + "test", context + ); + + compute::buffer x(context, 5 * sizeof(compute::int_)); + k1.set_arg(0, x); + + // Clone k1 kernel + compute::kernel k2 = k1.clone(); + // After clone k2 0th argument (__global float * x) should be set, + // so we should be able to enqueue k2 kernel without problems + queue.enqueue_1d_range_kernel(k2, 0, x.size() / sizeof(compute::int_), 0).wait(); +} +#endif // BOOST_COMPUTE_CL_VERSION_2_1 + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_lambda.cpp b/src/boost/libs/compute/test/test_lambda.cpp new file mode 100644 index 00000000..5fa72ac3 --- /dev/null +++ b/src/boost/libs/compute/test/test_lambda.cpp @@ -0,0 +1,617 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestLambda +#include <boost/test/unit_test.hpp> + +#include <boost/tuple/tuple_io.hpp> +#include <boost/tuple/tuple_comparison.hpp> + +#include <boost/compute/function.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/for_each.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/bind.hpp> +#include <boost/compute/iterator/zip_iterator.hpp> +#include <boost/compute/types/pair.hpp> +#include <boost/compute/types/tuple.hpp> + +#include "check_macros.hpp" +#include "quirks.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(squared_plus_one) +{ + bc::vector<int> vector(context); + vector.push_back(1, queue); + vector.push_back(2, queue); + vector.push_back(3, queue); + vector.push_back(4, queue); + vector.push_back(5, queue); + + // multiply each value by itself and add one + bc::transform(vector.begin(), + vector.end(), + vector.begin(), + (bc::_1 * bc::_1) + 1, + queue); + CHECK_RANGE_EQUAL(int, 5, vector, (2, 5, 10, 17, 26)); +} + +BOOST_AUTO_TEST_CASE(abs_int) +{ + bc::vector<int> vector(context); + vector.push_back(-1, queue); + vector.push_back(-2, queue); + vector.push_back(3, queue); + vector.push_back(-4, queue); + vector.push_back(5, queue); + + bc::transform(vector.begin(), + vector.end(), + vector.begin(), + abs(bc::_1), + queue); + CHECK_RANGE_EQUAL(int, 5, vector, (1, 2, 3, 4, 5)); +} + +template<class Result, class Expr> +void check_lambda_result(const Expr &) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + typename ::boost::compute::lambda::result_of<Expr>::type, + Result + >::value + )); +} + +template<class Result, class Expr, class Arg1> +void check_lambda_result(const Expr &, const Arg1 &) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + typename ::boost::compute::lambda::result_of< + Expr, + typename boost::tuple<Arg1> + >::type, + Result + >::value + )); +} + +template<class Result, class Expr, class Arg1, class Arg2> +void check_lambda_result(const Expr &, const Arg1 &, const Arg2 &) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + typename ::boost::compute::lambda::result_of< + Expr, + typename boost::tuple<Arg1, Arg2> + >::type, + Result + >::value + )); +} + +template<class Result, class Expr, class Arg1, class Arg2, class Arg3> +void check_lambda_result(const Expr &, const Arg1 &, const Arg2 &, const Arg3 &) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + typename ::boost::compute::lambda::result_of< + Expr, + typename boost::tuple<Arg1, Arg2, Arg3> + >::type, + Result + >::value + )); +} + +BOOST_AUTO_TEST_CASE(result_of) +{ + using ::boost::compute::lambda::_1; + using ::boost::compute::lambda::_2; + using ::boost::compute::lambda::_3; + + namespace proto = ::boost::proto; + + using boost::compute::int_; + + check_lambda_result<int_>(proto::lit(1)); + check_lambda_result<int_>(proto::lit(1) + 2); + check_lambda_result<float>(proto::lit(1.2f)); + check_lambda_result<float>(proto::lit(1) + 1.2f); + check_lambda_result<float>(proto::lit(1) / 2 + 1.2f); + + using boost::compute::float4_; + using boost::compute::int4_; + + check_lambda_result<int_>(_1, int_(1)); + check_lambda_result<float>(_1, float(1.2f)); + check_lambda_result<float4_>(_1, float4_(1, 2, 3, 4)); + check_lambda_result<float4_>(2.0f * _1, float4_(1, 2, 3, 4)); + check_lambda_result<float4_>(_1 * 2.0f, float4_(1, 2, 3, 4)); + + check_lambda_result<float>(dot(_1, _2), float4_(0, 1, 2, 3), float4_(3, 2, 1, 0)); + check_lambda_result<float>(dot(_1, float4_(3, 2, 1, 0)), float4_(0, 1, 2, 3)); + check_lambda_result<float>(distance(_1, _2), float4_(0, 1, 2, 3), float4_(3, 2, 1, 0)); + check_lambda_result<float>(distance(_1, float4_(3, 2, 1, 0)), float4_(0, 1, 2, 3)); + + check_lambda_result<float>(length(_1), float4_(3, 2, 1, 0)); + + check_lambda_result<float4_>(cross(_1, _2), float4_(0, 1, 2, 3), float4_(3, 2, 1, 0)); + check_lambda_result<float4_>(cross(_1, float4_(3, 2, 1, 0)), float4_(0, 1, 2, 3)); + + check_lambda_result<float4_>(max(_1, _2), float4_(3, 2, 1, 0), float4_(0, 1, 2, 3)); + check_lambda_result<float4_>(max(_1, float(1.0f)), float4_(0, 1, 2, 3)); + check_lambda_result<int4_>(max(_1, int4_(3, 2, 1, 0)), int4_(0, 1, 2, 3)); + check_lambda_result<int4_>(max(_1, int_(1)), int4_(0, 1, 2, 3)); + check_lambda_result<float4_>(min(_1, float4_(3, 2, 1, 0)), float4_(0, 1, 2, 3)); + + check_lambda_result<float4_>(step(_1, _2), float4_(3, 2, 1, 0), float4_(0, 1, 2, 3)); + check_lambda_result<int4_>(step(_1, _2), float(3.0f), int4_(0, 1, 2, 3)); + + check_lambda_result<float4_>( + smoothstep(_1, _2, _3), + float4_(3, 2, 1, 0), float4_(3, 2, 1, 0), float4_(0, 1, 2, 3) + ); + check_lambda_result<int4_>( + smoothstep(_1, _2, _3), + float(2.0f), float(3.0f), int4_(0, 1, 2, 3) + ); + + check_lambda_result<int4_>(bc::lambda::isinf(_1), float4_(0, 1, 2, 3)); + + check_lambda_result<int>(_1 + 2, int(2)); + check_lambda_result<float>(_1 + 2, float(2.2f)); + + check_lambda_result<int>(_1 + _2, int(1), int(2)); + check_lambda_result<float>(_1 + _2, int(1), float(2.2f)); + + check_lambda_result<int>(_1 + _1, int(1)); + check_lambda_result<float>(_1 * _1, float(1)); + + using boost::compute::lambda::get; + + check_lambda_result<float>(get<0>(_1), float4_(1, 2, 3, 4)); + check_lambda_result<bool>(get<0>(_1) < 1.f, float4_(1, 2, 3, 4)); + check_lambda_result<bool>(_1 < 1.f, float(2)); + + using boost::compute::lambda::make_pair; + + check_lambda_result<int>(get<0>(make_pair(_1, _2)), int(1), float(1.2f)); + check_lambda_result<float>(get<1>(make_pair(_1, _2)), int(1), float(1.2f)); + check_lambda_result<std::pair<int, float> >(make_pair(_1, _2), int(1), float(1.2f)); + + using boost::compute::lambda::make_tuple; + + check_lambda_result<boost::tuple<int> >(make_tuple(_1), int(1)); + check_lambda_result<boost::tuple<int, float> >(make_tuple(_1, _2), int(1), float(1.2f)); + check_lambda_result<boost::tuple<int, int> >(make_tuple(_1, _1), int(1)); + check_lambda_result<boost::tuple<int, float> >(make_tuple(_1, _2), int(1), float(1.4f)); + check_lambda_result<boost::tuple<char, int, float> >( + make_tuple(_1, _2, _3), char('a'), int(2), float(3.4f) + ); + check_lambda_result<boost::tuple<int, int, int> >( + make_tuple(_1, _1, _1), int(1), float(1.4f) + ); + check_lambda_result<boost::tuple<int, float, int, float, int> >( + make_tuple(_1, _2, _1, _2, _1), int(1), float(1.4f) + ); +} + +BOOST_AUTO_TEST_CASE(make_function_from_lamdba) +{ + using boost::compute::lambda::_1; + + int data[] = { 2, 4, 6, 8, 10 }; + compute::vector<int> vector(data, data + 5, queue); + + compute::function<int(int)> f = _1 * 2 + 3; + + compute::transform( + vector.begin(), vector.end(), vector.begin(), f, queue + ); + CHECK_RANGE_EQUAL(int, 5, vector, (7, 11, 15, 19, 23)); +} + +BOOST_AUTO_TEST_CASE(make_function_from_binary_lamdba) +{ + using boost::compute::lambda::_1; + using boost::compute::lambda::_2; + using boost::compute::lambda::abs; + + int data1[] = { 2, 4, 6, 8, 10 }; + int data2[] = { 10, 8, 6, 4, 2 }; + compute::vector<int> vec1(data1, data1 + 5, queue); + compute::vector<int> vec2(data2, data2 + 5, queue); + compute::vector<int> result(5, context); + + compute::function<int(int, int)> f = abs(_1 - _2); + + compute::transform( + vec1.begin(), vec1.end(), vec2.begin(), result.begin(), f, queue + ); + CHECK_RANGE_EQUAL(int, 5, result, (8, 4, 0, 4, 8)); +} + +BOOST_AUTO_TEST_CASE(lambda_binary_function_with_pointer_modf) +{ + using boost::compute::lambda::_1; + using boost::compute::lambda::_2; + using boost::compute::lambda::abs; + + bc::float_ data1[] = { 2.2f, 4.2f, 6.3f, 8.3f, 10.2f }; + compute::vector<bc::float_> vec1(data1, data1 + 5, queue); + compute::vector<bc::float_> vec2(size_t(5), context); + compute::vector<bc::float_> result(5, context); + + compute::transform( + bc::make_transform_iterator(vec1.begin(), _1 + 0.01f), + bc::make_transform_iterator(vec1.end(), _1 + 0.01f), + vec2.begin(), + result.begin(), + bc::lambda::modf(_1, _2), + queue + ); + CHECK_RANGE_CLOSE(bc::float_, 5, result, (0.21f, 0.21f, 0.31f, 0.31f, 0.21f), 0.01f); + CHECK_RANGE_CLOSE(bc::float_, 5, vec2, (2, 4, 6, 8, 10), 0.01f); +} + +BOOST_AUTO_TEST_CASE(lambda_tenary_function_with_pointer_remquo) +{ + if(!has_remquo_func(device)) + { + return; + } + + using boost::compute::lambda::_1; + using boost::compute::lambda::_2; + using boost::compute::lambda::get; + + bc::float_ data1[] = { 2.2f, 4.2f, 6.3f, 8.3f, 10.2f }; + bc::float_ data2[] = { 4.4f, 4.2f, 6.3f, 16.6f, 10.2f }; + compute::vector<bc::float_> vec1(data1, data1 + 5, queue); + compute::vector<bc::float_> vec2(data2, data2 + 5, queue); + compute::vector<bc::int_> vec3(size_t(5), context); + compute::vector<bc::float_> result(5, context); + + compute::transform( + compute::make_zip_iterator( + boost::make_tuple(vec1.begin(), vec2.begin(), vec3.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(vec1.end(), vec2.end(), vec3.end()) + ), + result.begin(), + bc::lambda::remquo(get<0>(_1), get<1>(_1), get<2>(_1)), + queue + ); + CHECK_RANGE_CLOSE(bc::float_, 5, result, (2.2f, 0.0f, 0.0f, 8.3f, 0.0f), 0.01f); + CHECK_RANGE_EQUAL(bc::int_, 5, vec3, (0, 1, 1, 0, 1)); +} + +BOOST_AUTO_TEST_CASE(lambda_get_vector) +{ + using boost::compute::_1; + using boost::compute::int2_; + using boost::compute::lambda::get; + + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<int2_> vector(4, context); + + compute::copy( + reinterpret_cast<int2_ *>(data), + reinterpret_cast<int2_ *>(data) + 4, + vector.begin(), + queue + ); + + // extract first component of each vector + compute::vector<int> first_component(4, context); + compute::transform( + vector.begin(), + vector.end(), + first_component.begin(), + get<0>(_1), + queue + ); + CHECK_RANGE_EQUAL(int, 4, first_component, (1, 3, 5, 7)); + + // extract second component of each vector + compute::vector<int> second_component(4, context); + compute::transform( + vector.begin(), + vector.end(), + first_component.begin(), + get<1>(_1), + queue + ); + CHECK_RANGE_EQUAL(int, 4, first_component, (2, 4, 6, 8)); +} + +BOOST_AUTO_TEST_CASE(lambda_get_pair) +{ + using boost::compute::_1; + using boost::compute::lambda::get; + + compute::vector<std::pair<int, float> > vector(context); + vector.push_back(std::make_pair(1, 1.2f), queue); + vector.push_back(std::make_pair(3, 3.4f), queue); + vector.push_back(std::make_pair(5, 5.6f), queue); + vector.push_back(std::make_pair(7, 7.8f), queue); + + // extract first compoenent of each pair + compute::vector<int> first_component(4, context); + compute::transform( + vector.begin(), + vector.end(), + first_component.begin(), + get<0>(_1), + queue + ); + CHECK_RANGE_EQUAL(int, 4, first_component, (1, 3, 5, 7)); + + // extract second compoenent of each pair + compute::vector<float> second_component(4, context); + compute::transform( + vector.begin(), + vector.end(), + second_component.begin(), + get<1>(_1), + queue + ); + CHECK_RANGE_EQUAL(float, 4, second_component, (1.2f, 3.4f, 5.6f, 7.8f)); +} + +BOOST_AUTO_TEST_CASE(lambda_get_tuple) +{ + using boost::compute::_1; + using boost::compute::lambda::get; + + compute::vector<boost::tuple<int, char, float> > vector(context); + + vector.push_back(boost::make_tuple(1, 'a', 1.2f), queue); + vector.push_back(boost::make_tuple(3, 'b', 3.4f), queue); + vector.push_back(boost::make_tuple(5, 'c', 5.6f), queue); + vector.push_back(boost::make_tuple(7, 'd', 7.8f), queue); + + // extract first component of each tuple + compute::vector<int> first_component(4, context); + compute::transform( + vector.begin(), + vector.end(), + first_component.begin(), + get<0>(_1), + queue + ); + CHECK_RANGE_EQUAL(int, 4, first_component, (1, 3, 5, 7)); + + // extract second component of each tuple + compute::vector<char> second_component(4, context); + compute::transform( + vector.begin(), + vector.end(), + second_component.begin(), + get<1>(_1), + queue + ); + CHECK_RANGE_EQUAL(char, 4, second_component, ('a', 'b', 'c', 'd')); + + // extract third component of each tuple + compute::vector<float> third_component(4, context); + compute::transform( + vector.begin(), + vector.end(), + third_component.begin(), + get<2>(_1), + queue + ); + CHECK_RANGE_EQUAL(float, 4, third_component, (1.2f, 3.4f, 5.6f, 7.8f)); +} + +BOOST_AUTO_TEST_CASE(lambda_get_zip_iterator) +{ + using boost::compute::_1; + using boost::compute::lambda::get; + + float data[] = { 1.2f, 2.3f, 3.4f, 4.5f, 5.6f, 6.7f, 7.8f, 9.0f }; + compute::vector<float> input(8, context); + compute::copy(data, data + 8, input.begin(), queue); + + compute::vector<float> output(8, context); + + compute::for_each( + compute::make_zip_iterator( + boost::make_tuple(input.begin(), output.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(input.end(), output.end()) + ), + get<1>(_1) = get<0>(_1), + queue + ); + CHECK_RANGE_EQUAL(float, 8, output, + (1.2f, 2.3f, 3.4f, 4.5f, 5.6f, 6.7f, 7.8f, 9.0f) + ); +} + +BOOST_AUTO_TEST_CASE(lambda_make_pair) +{ + using boost::compute::_1; + using boost::compute::_2; + using boost::compute::lambda::make_pair; + + int int_data[] = { 1, 3, 5, 7 }; + float float_data[] = { 1.2f, 2.3f, 3.4f, 4.5f }; + + compute::vector<int> int_vector(int_data, int_data + 4, queue); + compute::vector<float> float_vector(float_data, float_data + 4, queue); + compute::vector<std::pair<int, float> > output_vector(4, context); + + compute::transform( + int_vector.begin(), + int_vector.end(), + float_vector.begin(), + output_vector.begin(), + make_pair(_1 - 1, 0 - _2), + queue + ); + + std::vector<std::pair<int, float> > host_vector(4); + compute::copy_n(output_vector.begin(), 4, host_vector.begin(), queue); + BOOST_CHECK(host_vector[0] == std::make_pair(0, -1.2f)); + BOOST_CHECK(host_vector[1] == std::make_pair(2, -2.3f)); + BOOST_CHECK(host_vector[2] == std::make_pair(4, -3.4f)); + BOOST_CHECK(host_vector[3] == std::make_pair(6, -4.5f)); +} + +BOOST_AUTO_TEST_CASE(lambda_make_tuple) +{ + using boost::compute::_1; + using boost::compute::lambda::get; + using boost::compute::lambda::make_tuple; + + std::vector<boost::tuple<int, float> > data; + data.push_back(boost::make_tuple(2, 1.2f)); + data.push_back(boost::make_tuple(4, 2.4f)); + data.push_back(boost::make_tuple(6, 4.6f)); + data.push_back(boost::make_tuple(8, 6.8f)); + + compute::vector<boost::tuple<int, float> > input_vector(4, context); + compute::copy(data.begin(), data.end(), input_vector.begin(), queue); + + // reverse the elements in the tuple + compute::vector<boost::tuple<float, int> > output_vector(4, context); + + compute::transform( + input_vector.begin(), + input_vector.end(), + output_vector.begin(), + make_tuple(get<1>(_1), get<0>(_1)), + queue + ); + + std::vector<boost::tuple<float, int> > host_vector(4); + compute::copy_n(output_vector.begin(), 4, host_vector.begin(), queue); + BOOST_CHECK_EQUAL(host_vector[0], boost::make_tuple(1.2f, 2)); + BOOST_CHECK_EQUAL(host_vector[1], boost::make_tuple(2.4f, 4)); + BOOST_CHECK_EQUAL(host_vector[2], boost::make_tuple(4.6f, 6)); + BOOST_CHECK_EQUAL(host_vector[3], boost::make_tuple(6.8f, 8)); + + // duplicate each element in the tuple + compute::vector<boost::tuple<int, int, float, float> > doubled_vector(4, context); + compute::transform( + input_vector.begin(), + input_vector.end(), + doubled_vector.begin(), + make_tuple(get<0>(_1), get<0>(_1), get<1>(_1), get<1>(_1)), + queue + ); + + std::vector<boost::tuple<int, int, float, float> > doubled_host_vector(4); + compute::copy_n(doubled_vector.begin(), 4, doubled_host_vector.begin(), queue); + BOOST_CHECK_EQUAL(doubled_host_vector[0], boost::make_tuple(2, 2, 1.2f, 1.2f)); + BOOST_CHECK_EQUAL(doubled_host_vector[1], boost::make_tuple(4, 4, 2.4f, 2.4f)); + BOOST_CHECK_EQUAL(doubled_host_vector[2], boost::make_tuple(6, 6, 4.6f, 4.6f)); + BOOST_CHECK_EQUAL(doubled_host_vector[3], boost::make_tuple(8, 8, 6.8f, 6.8f)); +} + +BOOST_AUTO_TEST_CASE(bind_lambda_function) +{ + using compute::placeholders::_1; + namespace lambda = compute::lambda; + + int data[] = { 1, 2, 3, 4 }; + compute::vector<int> vector(data, data + 4, queue); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), + compute::bind(lambda::_1 * lambda::_2, _1, 2), + queue + ); + CHECK_RANGE_EQUAL(int, 4, vector, (2, 4, 6, 8)); +} + +BOOST_AUTO_TEST_CASE(lambda_function_with_uint_args) +{ + compute::uint_ host_data[] = { 1, 3, 5, 7, 9 }; + compute::vector<compute::uint_> device_vector(host_data, host_data + 5, queue); + + using boost::compute::lambda::clamp; + using compute::lambda::_1; + + compute::transform( + device_vector.begin(), device_vector.end(), + device_vector.begin(), + clamp(_1, compute::uint_(4), compute::uint_(6)), + queue + ); + CHECK_RANGE_EQUAL(compute::uint_, 5, device_vector, (4, 4, 5, 6, 6)); +} + +BOOST_AUTO_TEST_CASE(lambda_function_with_short_args) +{ + compute::short_ host_data[] = { 1, 3, 5, 7, 9 }; + compute::vector<compute::short_> device_vector(host_data, host_data + 5, queue); + + using boost::compute::lambda::clamp; + using compute::lambda::_1; + + compute::transform( + device_vector.begin(), device_vector.end(), + device_vector.begin(), + clamp(_1, compute::short_(4), compute::short_(6)), + queue + ); + CHECK_RANGE_EQUAL(compute::short_, 5, device_vector, (4, 4, 5, 6, 6)); +} + +BOOST_AUTO_TEST_CASE(lambda_function_with_uchar_args) +{ + compute::uchar_ host_data[] = { 1, 3, 5, 7, 9 }; + compute::vector<compute::uchar_> device_vector(host_data, host_data + 5, queue); + + using boost::compute::lambda::clamp; + using compute::lambda::_1; + + compute::transform( + device_vector.begin(), device_vector.end(), + device_vector.begin(), + clamp(_1, compute::uchar_(4), compute::uchar_(6)), + queue + ); + CHECK_RANGE_EQUAL(compute::uchar_, 5, device_vector, (4, 4, 5, 6, 6)); +} + +BOOST_AUTO_TEST_CASE(lambda_function_with_char_args) +{ + compute::char_ host_data[] = { 1, 3, 5, 7, 9 }; + compute::vector<compute::char_> device_vector(host_data, host_data + 5, queue); + + using boost::compute::lambda::clamp; + using compute::lambda::_1; + + compute::transform( + device_vector.begin(), device_vector.end(), + device_vector.begin(), + clamp(_1, compute::char_(4), compute::char_(6)), + queue + ); + CHECK_RANGE_EQUAL(compute::char_, 5, device_vector, (4, 4, 5, 6, 6)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_lexicographical_compare.cpp b/src/boost/libs/compute/test/test_lexicographical_compare.cpp new file mode 100644 index 00000000..45daa92a --- /dev/null +++ b/src/boost/libs/compute/test/test_lexicographical_compare.cpp @@ -0,0 +1,75 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Mageswaran.D <mageswaran1989@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestLexicographicalCompare +#include <boost/test/unit_test.hpp> + +#include <boost/compute/container/string.hpp> +#include <boost/compute/container/basic_string.hpp> +#include <boost/compute/algorithm/lexicographical_compare.hpp> + +#include "context_setup.hpp" +#include "check_macros.hpp" + +BOOST_AUTO_TEST_CASE(lexicographical_compare_string) +{ + boost::compute::string a = "abcdefghijk"; + boost::compute::string b = "abcdefghijk"; + boost::compute::string c = "abcdefghija"; + boost::compute::string d = "zabcdefghij"; + + BOOST_CHECK(boost::compute::lexicographical_compare(a.begin(), + a.end(), + b.begin(), + b.end()) == false); + + BOOST_CHECK(boost::compute::lexicographical_compare(c.begin(), + c.end(), + a.begin(), + a.end()) == true); + + BOOST_CHECK(boost::compute::lexicographical_compare(c.begin(), + c.end(), + d.begin(), + d.end()) == true); +} + +BOOST_AUTO_TEST_CASE(lexicographical_compare_number) +{ + int data1[] = { 1, 2, 3, 4, 5, 6 }; + int data2[] = { 9, 2, 3, 4, 5, 6 }; + int data3[] = { 1, 2, 3, 4, 5 }; + int data4[] = { 9, 2, 3, 4, 5, 100 }; + + boost::compute::vector<int> vector1(data1, data1 + 6, queue); + boost::compute::vector<int> vector2(data2, data2 + 6, queue); + boost::compute::vector<int> vector3(data3, data3 + 5, queue); + boost::compute::vector<int> vector4(data4, data4 + 6, queue); + + BOOST_CHECK(boost::compute::lexicographical_compare(vector1.begin(), + vector1.end(), + vector2.begin(), + vector2.end(), + queue) == true); + + BOOST_CHECK(boost::compute::lexicographical_compare(vector1.begin(), + vector1.end(), + vector3.begin(), + vector3.end(), + queue) == false); + + BOOST_CHECK(boost::compute::lexicographical_compare(vector3.begin(), + vector3.end(), + vector4.begin(), + vector4.end(), + queue) == true); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_linear_congruential_engine.cpp b/src/boost/libs/compute/test/test_linear_congruential_engine.cpp new file mode 100644 index 00000000..25438c7f --- /dev/null +++ b/src/boost/libs/compute/test/test_linear_congruential_engine.cpp @@ -0,0 +1,120 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestLinearCongruentialEngine +#include <boost/test/unit_test.hpp> + +#include <boost/compute/random/linear_congruential_engine.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(generate_uint) +{ + using boost::compute::uint_; + + boost::compute::linear_congruential_engine<uint_> rng(queue); + + boost::compute::vector<uint_> vector(10, context); + + rng.generate(vector.begin(), vector.end(), queue); + + CHECK_RANGE_EQUAL( + uint_, 10, vector, + (uint_(1099087573), + uint_(2291457337), + uint_(4026424941), + uint_(420705969), + uint_(2250972997), + uint_(153107049), + uint_(3581708125), + uint_(1733142113), + uint_(3008982197), + uint_(3237988505)) + ); +} + +BOOST_AUTO_TEST_CASE(discard_uint) +{ + using boost::compute::uint_; + + boost::compute::linear_congruential_engine<uint_> rng(queue); + + boost::compute::vector<uint_> vector(5, context); + + rng.discard(5, queue); + rng.generate(vector.begin(), vector.end(), queue); + + CHECK_RANGE_EQUAL( + uint_, 5, vector, + (uint_(153107049), + uint_(3581708125), + uint_(1733142113), + uint_(3008982197), + uint_(3237988505)) + ); +} + +BOOST_AUTO_TEST_CASE(copy_ctor) +{ + using boost::compute::uint_; + + boost::compute::linear_congruential_engine<uint_> rng(queue); + boost::compute::linear_congruential_engine<uint_> rng_copy(rng); + + boost::compute::vector<uint_> vector(10, context); + + rng_copy.generate(vector.begin(), vector.end(), queue); + + CHECK_RANGE_EQUAL( + uint_, 10, vector, + (uint_(1099087573), + uint_(2291457337), + uint_(4026424941), + uint_(420705969), + uint_(2250972997), + uint_(153107049), + uint_(3581708125), + uint_(1733142113), + uint_(3008982197), + uint_(3237988505)) + ); +} + +BOOST_AUTO_TEST_CASE(assign_op) +{ + using boost::compute::uint_; + + boost::compute::linear_congruential_engine<uint_> rng(queue); + boost::compute::linear_congruential_engine<uint_> rng_copy(queue); + + boost::compute::vector<uint_> vector(10, context); + + rng_copy.discard(5, queue); + rng_copy = rng; + rng_copy.generate(vector.begin(), vector.end(), queue); + + CHECK_RANGE_EQUAL( + uint_, 10, vector, + (uint_(1099087573), + uint_(2291457337), + uint_(4026424941), + uint_(420705969), + uint_(2250972997), + uint_(153107049), + uint_(3581708125), + uint_(1733142113), + uint_(3008982197), + uint_(3237988505)) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_literal_conversion.cpp b/src/boost/libs/compute/test/test_literal_conversion.cpp new file mode 100644 index 00000000..09898d44 --- /dev/null +++ b/src/boost/libs/compute/test/test_literal_conversion.cpp @@ -0,0 +1,72 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2016 Jason Rhinelander <jason@imaginary.ca> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestLiteralConversion +#include <boost/test/unit_test.hpp> + +#include <string> +#include <sstream> +#include <vector> + +#include <boost/compute/detail/literal.hpp> + +BOOST_AUTO_TEST_CASE(literal_conversion_float) +{ + std::vector<float> values, roundtrip; + values.push_back(1.2345679f); + values.push_back(1.2345680f); + values.push_back(1.2345681f); + for (size_t i = 0; i < values.size(); i++) { + std::string literal = boost::compute::detail::make_literal(values[i]); + // Check that we got something in the literal, and that at least the first + // 6 characters (5 digits) look good + BOOST_CHECK_EQUAL(literal.substr(0, 6), "1.2345"); + + // libc++ stream extraction fails on a value such as "1.2f" rather than extracting 1.2 + // and leaving the f; so check the "f", then slice it off for the extraction below: + BOOST_CHECK_EQUAL(literal.substr(literal.length()-1), "f"); + + std::istringstream iss(literal.substr(0, literal.length()-1)); + float x; + iss >> x; + roundtrip.push_back(x); + } + BOOST_CHECK_EQUAL(values[0], roundtrip[0]); + BOOST_CHECK_EQUAL(values[1], roundtrip[1]); + BOOST_CHECK_EQUAL(values[2], roundtrip[2]); +} + +BOOST_AUTO_TEST_CASE(literal_conversion_double) +{ + std::vector<double> values, roundtrip; + values.push_back(1.2345678901234567); + values.push_back(1.2345678901234569); + values.push_back(1.2345678901234571); + for (size_t i = 0; i < values.size(); i++) { + std::string literal = boost::compute::detail::make_literal(values[i]); + // Check that we got something in the literal, and that at least the first + // 11 characters (10 digits) look good + BOOST_CHECK_EQUAL(literal.substr(0, 11), "1.234567890"); + + // Stuff the literal into a stream then extract it, and make sure we get a numerically + // identical result. (Since there is no suffix, we don't have to worry about removing the + // suffix like we have to above, for float--but we also check to make sure there is no + // (unextracted) suffix). + std::istringstream iss(literal); + double x; + std::string suffix; + iss >> x >> suffix; + BOOST_CHECK_EQUAL(suffix, ""); + roundtrip.push_back(x); + } + BOOST_CHECK_EQUAL(values[0], roundtrip[0]); + BOOST_CHECK_EQUAL(values[1], roundtrip[1]); + BOOST_CHECK_EQUAL(values[2], roundtrip[2]); +} diff --git a/src/boost/libs/compute/test/test_local_buffer.cpp b/src/boost/libs/compute/test/test_local_buffer.cpp new file mode 100644 index 00000000..69e5389a --- /dev/null +++ b/src/boost/libs/compute/test/test_local_buffer.cpp @@ -0,0 +1,80 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestLocalBuffer +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/core.hpp> +#include <boost/compute/memory/local_buffer.hpp> +#include <boost/compute/utility/source.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(local_buffer_arg) +{ + if(device.get_info<CL_DEVICE_LOCAL_MEM_TYPE>() != CL_LOCAL){ + std::cerr << "skipping local buffer arg test: " + << "device does not support local memory" << std::endl; + return; + } + + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void foo(__local float *local_buffer, + __global float *global_buffer) + { + const uint gid = get_global_id(0); + const uint lid = get_local_id(0); + + local_buffer[lid] = gid; + + global_buffer[gid] = local_buffer[lid]; + } + ); + + // create and build program + compute::program program = + compute::program::build_with_source(source, context); + + // create kernel + compute::kernel kernel = program.create_kernel("foo"); + + // setup kernel arguments + compute::buffer global_buf(context, 128 * sizeof(float)); + kernel.set_arg(0, compute::local_buffer<float>(32)); + kernel.set_arg(1, global_buf); + + // some implementations don't correctly report dynamically-set local buffer sizes + if(kernel.get_work_group_info<cl_ulong>(device, CL_KERNEL_LOCAL_MEM_SIZE) == 0){ + std::cerr << "skipping checks for local memory size, device reports " + << "zero after setting dynamically-sized local buffer size" + << std::endl; + return; + } + + // check actual memory size + BOOST_CHECK_GE( + kernel.get_work_group_info<cl_ulong>(device, CL_KERNEL_LOCAL_MEM_SIZE), + 32 * sizeof(float) + ); + + // increase local buffer size and check new actual local memory size + kernel.set_arg(0, compute::local_buffer<float>(64)); + + BOOST_CHECK_GE( + kernel.get_work_group_info<cl_ulong>(device, CL_KERNEL_LOCAL_MEM_SIZE), + 64 * sizeof(float) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_malloc.cpp b/src/boost/libs/compute/test/test_malloc.cpp new file mode 100644 index 00000000..212200d9 --- /dev/null +++ b/src/boost/libs/compute/test/test_malloc.cpp @@ -0,0 +1,40 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestMalloc +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/experimental/malloc.hpp> + +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(malloc_int) +{ + bc::experimental::device_ptr<int> ptr = bc::experimental::malloc<int>(5, context); + + int input_data[] = { 2, 5, 8, 3, 6 }; + bc::copy(input_data, input_data + 5, ptr, queue); + + int output_data[5]; + bc::copy(ptr, ptr + 5, output_data, queue); + + BOOST_CHECK_EQUAL(output_data[0], 2); + BOOST_CHECK_EQUAL(output_data[1], 5); + BOOST_CHECK_EQUAL(output_data[2], 8); + BOOST_CHECK_EQUAL(output_data[3], 3); + BOOST_CHECK_EQUAL(output_data[4], 6); + + bc::experimental::free(ptr); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_mapped_view.cpp b/src/boost/libs/compute/test/test_mapped_view.cpp new file mode 100644 index 00000000..c862a75e --- /dev/null +++ b/src/boost/libs/compute/test/test_mapped_view.cpp @@ -0,0 +1,70 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestMappedView +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/algorithm/reduce.hpp> +#include <boost/compute/container/mapped_view.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(fill) +{ + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + for(int i = 0; i < 8; i++){ + BOOST_CHECK_EQUAL(data[i], i+1); + } + + compute::mapped_view<int> view(data, 8, context); + compute::fill(view.begin(), view.end(), 4, queue); + + view.map(CL_MAP_READ, queue); + for(int i = 0; i < 8; i++){ + BOOST_CHECK_EQUAL(data[i], 4); + } + view.unmap(queue); +} + +BOOST_AUTO_TEST_CASE(sort) +{ + int data[] = { 5, 2, 3, 1, 8, 7, 4, 9 }; + compute::mapped_view<int> view(data, 8, context); + + compute::sort(view.begin(), view.end(), queue); + + view.map(CL_MAP_READ, queue); + BOOST_CHECK_EQUAL(data[0], 1); + BOOST_CHECK_EQUAL(data[7], 9); + view.unmap(queue); +} + +BOOST_AUTO_TEST_CASE(mapped_view_reduce_doctest) +{ +//! [reduce] +// create data array on the host +int data[] = { 5, 2, 3, 1, 8, 7, 4, 9 }; +boost::compute::mapped_view<int> view(data, 8, context); + +// use reduce() to calculate the sum on the device +int sum = 0; +boost::compute::reduce(view.begin(), view.end(), &sum, queue); +//! [reduce] + + BOOST_CHECK_EQUAL(sum, 39); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_merge.cpp b/src/boost/libs/compute/test/test_merge.cpp new file mode 100644 index 00000000..df3b12dc --- /dev/null +++ b/src/boost/libs/compute/test/test_merge.cpp @@ -0,0 +1,167 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestMerge +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/types/pair.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/merge.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/lambda.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(simple_merge_int) +{ + int data1[] = { 1, 3, 5, 7 }; + int data2[] = { 2, 4, 6, 8 }; + + boost::compute::vector<int> v1(4, context); + boost::compute::vector<int> v2(4, context); + boost::compute::vector<int> v3(8, context); + + boost::compute::copy_n(data1, 4, v1.begin(), queue); + boost::compute::copy_n(data2, 4, v2.begin(), queue); + boost::compute::fill(v3.begin(), v3.end(), 0, queue); + + // merge v1 with v2 into v3 + boost::compute::merge( + v1.begin(), v1.end(), + v2.begin(), v2.end(), + v3.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 8, v3, (1, 2, 3, 4, 5, 6, 7, 8)); + + // merge v2 with v1 into v3 + boost::compute::merge( + v2.begin(), v2.end(), + v1.begin(), v1.end(), + v3.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 8, v3, (1, 2, 3, 4, 5, 6, 7, 8)); + + // merge v1 with v1 into v3 + boost::compute::merge( + v1.begin(), v1.end(), + v1.begin(), v1.end(), + v3.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 8, v3, (1, 1, 3, 3, 5, 5, 7, 7)); + + // merge v2 with v2 into v3 + boost::compute::merge( + v2.begin(), v2.end(), + v2.begin(), v2.end(), + v3.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 8, v3, (2, 2, 4, 4, 6, 6, 8, 8)); + + // merge v1 with empty range into v3 + boost::compute::merge( + v1.begin(), v1.end(), + v1.begin(), v1.begin(), + v3.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 4, v3, (1, 3, 5, 7)); + + // merge v2 with empty range into v3 + boost::compute::merge( + v1.begin(), v1.begin(), + v2.begin(), v2.end(), + v3.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 4, v3, (2, 4, 6, 8)); +} + +BOOST_AUTO_TEST_CASE(merge_pairs) +{ + std::vector<std::pair<int, float> > data1; + std::vector<std::pair<int, float> > data2; + + data1.push_back(std::make_pair(0, 0.1f)); + data1.push_back(std::make_pair(2, 2.1f)); + data1.push_back(std::make_pair(4, 4.1f)); + data1.push_back(std::make_pair(6, 6.1f)); + data2.push_back(std::make_pair(1, 1.1f)); + data2.push_back(std::make_pair(3, 3.1f)); + data2.push_back(std::make_pair(5, 5.1f)); + data2.push_back(std::make_pair(7, 7.1f)); + + std::vector<std::pair<int, float> > data3(data1.size() + data2.size()); + std::fill(data3.begin(), data3.end(), std::make_pair(-1, -1.f)); + + boost::compute::vector<std::pair<int, float> > v1(data1.size(), context); + boost::compute::vector<std::pair<int, float> > v2(data2.size(), context); + boost::compute::vector<std::pair<int, float> > v3(data3.size(), context); + + boost::compute::copy(data1.begin(), data1.end(), v1.begin(), queue); + boost::compute::copy(data2.begin(), data2.end(), v2.begin(), queue); + + using ::boost::compute::lambda::_1; + using ::boost::compute::lambda::_2; + using ::boost::compute::lambda::get; + + boost::compute::merge( + v1.begin(), v1.end(), + v2.begin(), v2.end(), + v3.begin(), + get<0>(_1) < get<0>(_2), + queue + ); + + boost::compute::copy(v3.begin(), v3.end(), data3.begin(), queue); + + BOOST_CHECK(v3[0] == std::make_pair(0, 0.1f)); + BOOST_CHECK(v3[1] == std::make_pair(1, 1.1f)); + BOOST_CHECK(v3[2] == std::make_pair(2, 2.1f)); + BOOST_CHECK(v3[3] == std::make_pair(3, 3.1f)); + BOOST_CHECK(v3[4] == std::make_pair(4, 4.1f)); + BOOST_CHECK(v3[5] == std::make_pair(5, 5.1f)); + BOOST_CHECK(v3[6] == std::make_pair(6, 6.1f)); + BOOST_CHECK(v3[7] == std::make_pair(7, 7.1f)); +} + +BOOST_AUTO_TEST_CASE(merge_floats) +{ + float data1[] = { 1.1f, 2.2f, 3.3f, 4.4f, + 5.5f, 6.6f, 7.7f, 8.8f }; + float data2[] = { 1.0f, 2.0f, 3.9f, 4.9f, + 6.8f, 6.9f, 7.0f, 7.1f }; + + boost::compute::vector<float> v1(8, context); + boost::compute::vector<float> v2(8, context); + boost::compute::vector<float> v3(v1.size() + v2.size(), context); + + boost::compute::copy_n(data1, 8, v1.begin(), queue); + boost::compute::copy_n(data2, 8, v2.begin(), queue); + boost::compute::fill(v3.begin(), v3.end(), 0.f, queue); + + boost::compute::merge( + v1.begin(), v1.end(), + v2.begin(), v2.end(), + v3.begin(), + queue + ); + CHECK_RANGE_EQUAL(float, 16, v3, + (1.0f, 1.1f, 2.0f, 2.2f, 3.3f, 3.9f, 4.4f, 4.9f, + 5.5f, 6.6f, 6.8f, 6.9f, 7.0f, 7.1f, 7.7f, 8.8f) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_merge_sort_gpu.cpp b/src/boost/libs/compute/test/test_merge_sort_gpu.cpp new file mode 100644 index 00000000..5b857aca --- /dev/null +++ b/src/boost/libs/compute/test/test_merge_sort_gpu.cpp @@ -0,0 +1,374 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2016 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestMergeSortOnGPU +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/algorithm/detail/merge_sort_on_gpu.hpp> +#include <boost/compute/container/vector.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(sort_small_vector_char) +{ + if(is_apple_cpu_device(device)) { + std::cerr + << "skipping all merge_sort_on_gpu tests due to Apple platform" + << " behavior when local memory is used on a CPU device" + << std::endl; + return; + } + + using boost::compute::char_; + ::boost::compute::greater<char_> greater; + ::boost::compute::less<char_> less; + + char_ data[] = { 'c', 'a', '0', '7', 'B', 'F', '\0', '$' }; + boost::compute::vector<char_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + // < + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), less, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), less, queue) + ); + CHECK_RANGE_EQUAL(char_, 8, vector, ('\0', '$', '0', '7', 'B', 'F', 'a', 'c')); + + // > + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), greater, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), greater, queue) + ); + CHECK_RANGE_EQUAL(char_, 8, vector, ('c', 'a', 'F', 'B', '7', '0', '$', '\0')); +} + +BOOST_AUTO_TEST_CASE(sort_mid_vector_int) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::int_; + ::boost::compute::greater<int_> greater; + ::boost::compute::less<int_> less; + + const int_ size = 748; + std::vector<int_> data(size); + for(int_ i = 0; i < size; i++){ + data[i] = i%2 ? i : -i; + } + + boost::compute::vector<int_> vector(data.begin(), data.end(), queue); + BOOST_CHECK_EQUAL(vector.size(), size); + BOOST_CHECK(!boost::compute::is_sorted(vector.begin(), vector.end(), queue)); + + // < + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), less, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), less, queue) + ); + + // > + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), greater, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), greater, queue) + ); +} + +BOOST_AUTO_TEST_CASE(sort_mid_vector_ulong) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::ulong_; + ::boost::compute::greater<ulong_> greater; + ::boost::compute::less<ulong_> less; + + const ulong_ size = 260; + std::vector<ulong_> data(size); + for(ulong_ i = 0; i < size; i++){ + data[i] = i%2 ? i : i * i; + } + + boost::compute::vector<ulong_> vector(data.begin(), data.end(), queue); + BOOST_CHECK_EQUAL(vector.size(), size); + BOOST_CHECK(!boost::compute::is_sorted(vector.begin(), vector.end(), queue)); + + // < + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), less, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), less, queue) + ); + + // > + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), greater, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), greater, queue) + ); +} + + +BOOST_AUTO_TEST_CASE(sort_mid_vector_float) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::float_; + ::boost::compute::greater<float_> greater; + ::boost::compute::less<float_> less; + + const int size = 513; + std::vector<float_> data(size); + for(int i = 0; i < size; i++){ + data[i] = float_(i%2 ? i : -i); + } + + boost::compute::vector<float_> vector(data.begin(), data.end(), queue); + BOOST_CHECK_EQUAL(vector.size(), size); + BOOST_CHECK(!boost::compute::is_sorted(vector.begin(), vector.end(), queue)); + + // < + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), less, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), less, queue) + ); + + // > + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), greater, queue + ); + queue.finish(); + + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), greater, queue) + ); +} + +BOOST_AUTO_TEST_CASE(sort_mid_vector_double) +{ + if(is_apple_cpu_device(device)) { + return; + } + + if(!device.supports_extension("cl_khr_fp64")){ + std::cout << "skipping test: device does not support double" << std::endl; + return; + } + + using boost::compute::double_; + ::boost::compute::greater<double_> greater; + ::boost::compute::less<double_> less; + + const int size = 1023; + std::vector<double_> data(size); + for(int i = 0; i < size; i++){ + data[i] = double_(i%2 ? i : -i); + } + + boost::compute::vector<double_> vector(data.begin(), data.end(), queue); + BOOST_CHECK_EQUAL(vector.size(), size); + BOOST_CHECK(!boost::compute::is_sorted(vector.begin(), vector.end(), queue)); + + // < + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), less, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), less, queue) + ); + + // > + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), greater, queue + ); + queue.finish(); + + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), greater, queue) + ); +} + +BOOST_AUTO_TEST_CASE(sort_mid_vector_int_custom_comparison_func) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::int_; + ::boost::compute::greater<int_> greater; + ::boost::compute::less<int_> less; + + const int_ size = 1024; + std::vector<int_> data(size); + for(int_ i = 0; i < size; i++){ + data[i] = i%2 ? size - i : i - size; + } + + BOOST_COMPUTE_FUNCTION(bool, abs_sort, (int_ a, int_ b), + { + return abs(a) < abs(b); + }); + + boost::compute::vector<int_> vector(data.begin(), data.end(), queue); + BOOST_CHECK_EQUAL(vector.size(), size); + BOOST_CHECK( + !boost::compute::is_sorted(vector.begin(), vector.end(), abs_sort, queue) + ); + + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), abs_sort, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), abs_sort, queue) + ); +} + +BOOST_AUTO_TEST_CASE(sort_mid_vector_int2) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::int2_; + using boost::compute::int_; + ::boost::compute::greater<int2_> greater; + ::boost::compute::less<int2_> less; + + const int_ size = 1024; + std::vector<int2_> data(size); + for(int_ i = 0; i < size; i++){ + data[i] = i%2 ? int2_(i, i) : int2_(i - size, i - size); + } + + BOOST_COMPUTE_FUNCTION(bool, abs_sort, (int2_ a, int2_ b), + { + return abs(a.x + a.y) < abs(b.x + b.y); + }); + + boost::compute::vector<int2_> vector(data.begin(), data.end(), queue); + BOOST_CHECK_EQUAL(vector.size(), size); + BOOST_CHECK( + !boost::compute::is_sorted(vector.begin(), vector.end(), abs_sort, queue) + ); + + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), abs_sort, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), abs_sort, queue) + ); +} + +BOOST_AUTO_TEST_CASE(sort_mid_vector_long8) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::long8_; + using boost::compute::long_; + ::boost::compute::greater<long8_> greater; + ::boost::compute::less<long8_> less; + + const long_ size = 256; + std::vector<long8_> data(size); + for(long_ i = 0; i < size; i++){ + data[i] = i%2 ? long8_(i) : long8_(i * i); + } + + BOOST_COMPUTE_FUNCTION(bool, comp, (long8_ a, long8_ b), + { + return a.s0 < b.s3; + }); + + boost::compute::vector<long8_> vector(data.begin(), data.end(), queue); + BOOST_CHECK_EQUAL(vector.size(), size); + BOOST_CHECK( + !boost::compute::is_sorted(vector.begin(), vector.end(), comp, queue) + ); + + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), comp, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), comp, queue) + ); +} + +BOOST_AUTO_TEST_CASE(stable_sort_vector_int2) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::int2_; + + int2_ data[] = { + int2_(8, 3), int2_(5, 1), + int2_(2, 1), int2_(6, 1), + int2_(8, 1), int2_(7, 1), + int2_(4, 1), int2_(8, 2) + }; + + BOOST_COMPUTE_FUNCTION(bool, comp, (int2_ a, int2_ b), + { + return a.x < b.x; + }); + + boost::compute::vector<int2_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), 8); + BOOST_CHECK( + !boost::compute::is_sorted(vector.begin(), vector.end(), comp, queue) + ); + + // + boost::compute::detail::merge_sort_on_gpu( + vector.begin(), vector.end(), comp, true /*stable*/, queue + ); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), comp, queue) + ); + CHECK_RANGE_EQUAL( + int2_, 8, vector, + ( + int2_(2, 1), int2_(4, 1), + int2_(5, 1), int2_(6, 1), + int2_(7, 1), int2_(8, 3), + int2_(8, 1), int2_(8, 2) + ) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_mersenne_twister_engine.cpp b/src/boost/libs/compute/test/test_mersenne_twister_engine.cpp new file mode 100644 index 00000000..c286c257 --- /dev/null +++ b/src/boost/libs/compute/test/test_mersenne_twister_engine.cpp @@ -0,0 +1,120 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestMersenneTwisterEngine +#include <boost/test/unit_test.hpp> + +#include <boost/compute/random/mersenne_twister_engine.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(generate_uint) +{ + using boost::compute::uint_; + + boost::compute::mt19937 rng(queue); + + boost::compute::vector<uint_> vector(10, context); + + rng.generate(vector.begin(), vector.end(), queue); + + CHECK_RANGE_EQUAL( + uint_, 10, vector, + (uint_(3499211612), + uint_(581869302), + uint_(3890346734), + uint_(3586334585), + uint_(545404204), + uint_(4161255391), + uint_(3922919429), + uint_(949333985), + uint_(2715962298), + uint_(1323567403)) + ); +} + +BOOST_AUTO_TEST_CASE(discard_uint) +{ + using boost::compute::uint_; + + boost::compute::mt19937 rng(queue); + + boost::compute::vector<uint_> vector(5, context); + + rng.discard(5, queue); + rng.generate(vector.begin(), vector.end(), queue); + + CHECK_RANGE_EQUAL( + uint_, 5, vector, + (uint_(4161255391), + uint_(3922919429), + uint_(949333985), + uint_(2715962298), + uint_(1323567403)) + ); +} + +BOOST_AUTO_TEST_CASE(copy_ctor) +{ + using boost::compute::uint_; + + boost::compute::mt19937 rng(queue); + boost::compute::mt19937 rng_copy(rng); + + boost::compute::vector<uint_> vector(10, context); + + rng_copy.generate(vector.begin(), vector.end(), queue); + + CHECK_RANGE_EQUAL( + uint_, 10, vector, + (uint_(3499211612), + uint_(581869302), + uint_(3890346734), + uint_(3586334585), + uint_(545404204), + uint_(4161255391), + uint_(3922919429), + uint_(949333985), + uint_(2715962298), + uint_(1323567403)) + ); +} + +BOOST_AUTO_TEST_CASE(assign_op) +{ + using boost::compute::uint_; + + boost::compute::mt19937 rng(queue); + boost::compute::mt19937 rng_copy(queue); + + boost::compute::vector<uint_> vector(10, context); + + rng_copy.discard(5, queue); + rng_copy = rng; + rng_copy.generate(vector.begin(), vector.end(), queue); + + CHECK_RANGE_EQUAL( + uint_, 10, vector, + (uint_(3499211612), + uint_(581869302), + uint_(3890346734), + uint_(3586334585), + uint_(545404204), + uint_(4161255391), + uint_(3922919429), + uint_(949333985), + uint_(2715962298), + uint_(1323567403)) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_mismatch.cpp b/src/boost/libs/compute/test/test_mismatch.cpp new file mode 100644 index 00000000..32d900c6 --- /dev/null +++ b/src/boost/libs/compute/test/test_mismatch.cpp @@ -0,0 +1,64 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestMismatch +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/mismatch.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(mismatch_int) +{ + int data1[] = { 1, 2, 3, 4, 5, 6 }; + int data2[] = { 1, 2, 3, 7, 5, 6 }; + + boost::compute::vector<int> vector1(data1, data1 + 6, queue); + boost::compute::vector<int> vector2(data2, data2 + 6, queue); + + typedef boost::compute::vector<int>::iterator iter; + + std::pair<iter, iter> location = + boost::compute::mismatch(vector1.begin(), vector1.end(), + vector2.begin(), queue); + BOOST_CHECK(location.first == vector1.begin() + 3); + BOOST_CHECK_EQUAL(int(*location.first), int(4)); + BOOST_CHECK(location.second == vector2.begin() + 3); + BOOST_CHECK_EQUAL(int(*location.second), int(7)); +} + +BOOST_AUTO_TEST_CASE(mismatch_different_range_sizes) +{ + boost::compute::vector<int> a(10, context); + boost::compute::vector<int> b(20, context); + + boost::compute::fill(a.begin(), a.end(), 3, queue); + boost::compute::fill(b.begin(), b.end(), 3, queue); + + typedef boost::compute::vector<int>::iterator iter; + + std::pair<iter, iter> location; + + location = boost::compute::mismatch( + a.begin(), a.end(), b.begin(), b.end(), queue + ); + BOOST_CHECK(location.first == a.end()); + BOOST_CHECK(location.second == b.begin() + 10); + + location = boost::compute::mismatch( + b.begin(), b.end(), a.begin(), a.end(), queue + ); + BOOST_CHECK(location.first == b.begin() + 10); + BOOST_CHECK(location.second == a.end()); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_next_permutation.cpp b/src/boost/libs/compute/test/test_next_permutation.cpp new file mode 100644 index 00000000..b76c3811 --- /dev/null +++ b/src/boost/libs/compute/test/test_next_permutation.cpp @@ -0,0 +1,71 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestNextPermutation +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/next_permutation.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(next_permutation_int) +{ + int dataset[] = {1, 3, 4, 2, 5}; + bc::vector<bc::int_> vector(dataset, dataset + 5, queue); + + bool result = + bc::next_permutation(vector.begin(), vector.begin() + 5, queue); + + CHECK_RANGE_EQUAL(int, 5, vector, (1, 3, 4, 5, 2)); + BOOST_VERIFY(result == true); + + vector[0] = 10; vector[1] = 9; vector[2] = 6; + + result = bc::next_permutation(vector.begin(), vector.begin() + 5, queue); + + CHECK_RANGE_EQUAL(int, 5, vector, (2, 5, 6, 9, 10)); + BOOST_VERIFY(result == false); +} + +BOOST_AUTO_TEST_CASE(next_permutation_string) +{ + char dataset[] = "aaab"; + bc::vector<bc::char_> vector(dataset, dataset + 4, queue); + + bool result = + bc::next_permutation(vector.begin(), vector.begin() + 4, queue); + + CHECK_RANGE_EQUAL(char, 4, vector, ('a', 'a', 'b', 'a')); + BOOST_VERIFY(result == true); + + result = bc::next_permutation(vector.begin(), vector.begin() + 4, queue); + + CHECK_RANGE_EQUAL(char, 4, vector, ('a', 'b', 'a', 'a')); + BOOST_VERIFY(result == true); + + result = bc::next_permutation(vector.begin(), vector.begin() + 4, queue); + + CHECK_RANGE_EQUAL(char, 4, vector, ('b', 'a', 'a', 'a')); + BOOST_VERIFY(result == true); + + result = bc::next_permutation(vector.begin(), vector.begin() + 4, queue); + + CHECK_RANGE_EQUAL(char, 4, vector, ('a', 'a', 'a', 'b')); + BOOST_VERIFY(result == false); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_no_device_found.cpp b/src/boost/libs/compute/test/test_no_device_found.cpp new file mode 100644 index 00000000..91a48870 --- /dev/null +++ b/src/boost/libs/compute/test/test_no_device_found.cpp @@ -0,0 +1,31 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2015 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestNoDeviceFound +#include <boost/test/unit_test.hpp> + +#include <boost/compute/exception/no_device_found.hpp> + +void throw_no_device_found() +{ + throw boost::compute::no_device_found(); +} + +BOOST_AUTO_TEST_CASE(what) +{ + try { + throw_no_device_found(); + + BOOST_REQUIRE(false); // should not get here + } + catch(boost::compute::no_device_found& e){ + BOOST_CHECK_EQUAL(std::string(e.what()), "No OpenCL device found"); + } +} diff --git a/src/boost/libs/compute/test/test_normal_distribution.cpp b/src/boost/libs/compute/test/test_normal_distribution.cpp new file mode 100644 index 00000000..bb8a93ca --- /dev/null +++ b/src/boost/libs/compute/test/test_normal_distribution.cpp @@ -0,0 +1,84 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestNormalDistribution +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/count_if.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/normal_distribution.hpp> +#include <boost/compute/lambda.hpp> + +#include <boost/accumulators/accumulators.hpp> +#include <boost/accumulators/statistics/mean.hpp> +#include <boost/accumulators/statistics/stats.hpp> +#include <boost/accumulators/statistics/variance.hpp> + +#include "context_setup.hpp" + +template<class Stats, class T> +boost::accumulators::accumulator_set<T, Stats> +accumulate_statistics(const boost::compute::vector<T>& vector, + boost::compute::command_queue& queue) { + // copy vector to the host + std::vector<T> host_vector(vector.size()); + boost::compute::copy( + vector.begin(), vector.end(), host_vector.begin(), queue + ); + + // compute desired statistics and return accumulator object + return std::for_each( + host_vector.begin(), + host_vector.end(), + boost::accumulators::accumulator_set<T, Stats>() + ); +} + +BOOST_AUTO_TEST_CASE(normal_distribution_doctest) +{ + using boost::compute::lambda::_1; + + boost::compute::vector<float> vec(10, context); + +//! [generate] +// initialize the default random engine +boost::compute::default_random_engine engine(queue); + +// setup the normal distribution to produce floats centered at 5 +boost::compute::normal_distribution<float> distribution(5.0f, 1.0f); + +// generate the random values and store them to 'vec' +distribution.generate(vec.begin(), vec.end(), engine, queue); +//! [generate] +} + +BOOST_AUTO_TEST_CASE(normal_distribution_statistics) +{ + // generate normally distributed random numbers + const size_t n = 10000; + boost::compute::vector<float> vec(n, context); + boost::compute::default_random_engine engine(queue); + boost::compute::normal_distribution<float> distribution(10.0f, 2.0f); + distribution.generate(vec.begin(), vec.end(), engine, queue); + + // compute mean and standard deviation + using namespace boost::accumulators; + accumulator_set<float, stats<tag::variance> > acc = + accumulate_statistics<stats<tag::variance> >(vec, queue); + + // check mean and standard deviation are what we expect + BOOST_CHECK_CLOSE(mean(acc), 10.f, 0.5f); + BOOST_CHECK_CLOSE(std::sqrt(variance(acc)), 2.f, 0.5f); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_nth_element.cpp b/src/boost/libs/compute/test/test_nth_element.cpp new file mode 100644 index 00000000..ac072732 --- /dev/null +++ b/src/boost/libs/compute/test/test_nth_element.cpp @@ -0,0 +1,113 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestNthElement +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/is_partitioned.hpp> +#include <boost/compute/algorithm/nth_element.hpp> +#include <boost/compute/algorithm/partition_point.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(nth_element_int) +{ + int data[] = { 9, 15, 1, 4, 9, 9, 4, 15, 12, 1 }; + boost::compute::vector<int> vector(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::nth_element( + vector.begin(), vector.begin() + 5, vector.end(), queue + ); + + BOOST_CHECK_EQUAL(vector[5], 9); + BOOST_VERIFY(boost::compute::is_partitioned( + vector.begin(), vector.end(), boost::compute::_1 <= 9, queue + )); + BOOST_VERIFY(boost::compute::partition_point( + vector.begin(), vector.end(), boost::compute::_1 <= 9, queue + ) > vector.begin() + 5); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::nth_element( + vector.begin(), vector.end(), vector.end(), queue + ); + CHECK_RANGE_EQUAL(int, 10, vector, (9, 15, 1, 4, 9, 9, 4, 15, 12, 1)); +} + +BOOST_AUTO_TEST_CASE(nth_element_median) +{ + int data[] = { 5, 6, 4, 3, 2, 6, 7, 9, 3 }; + boost::compute::vector<int> v(9, context); + boost::compute::copy_n(data, 9, v.begin(), queue); + + boost::compute::nth_element(v.begin(), v.begin() + 4, v.end(), queue); + + BOOST_CHECK_EQUAL(v[4], 5); + BOOST_VERIFY(boost::compute::is_partitioned( + v.begin(), v.end(), boost::compute::_1 <= 5, queue + )); + BOOST_VERIFY(boost::compute::partition_point( + v.begin(), v.end(), boost::compute::_1 <= 5, queue + ) > v.begin() + 4); +} + +BOOST_AUTO_TEST_CASE(nth_element_second_largest) +{ + int data[] = { 5, 6, 4, 3, 2, 6, 7, 9, 3 }; + boost::compute::vector<int> v(9, context); + boost::compute::copy_n(data, 9, v.begin(), queue); + + boost::compute::nth_element(v.begin(), v.begin() + 1, v.end(), queue); + + BOOST_CHECK_EQUAL(v[1], 3); + BOOST_VERIFY(boost::compute::is_partitioned( + v.begin(), v.end(), boost::compute::_1 <= 3, queue + )); + BOOST_VERIFY(boost::compute::partition_point( + v.begin(), v.end(), boost::compute::_1 <= 3, queue + ) > v.begin() + 1); +} + +BOOST_AUTO_TEST_CASE(nth_element_comparator) +{ + int data[] = { 9, 15, 1, 4, 9, 9, 4, 15, 12, 1 }; + boost::compute::vector<int> vector(10, context); + + boost::compute::less<int> less_than; + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::nth_element( + vector.begin(), vector.begin() + 5, vector.end(), less_than, queue + ); + BOOST_CHECK_EQUAL(vector[5], 9); + BOOST_VERIFY(boost::compute::is_partitioned( + vector.begin(), vector.end(), boost::compute::_1 <= 9, queue + )); + BOOST_VERIFY(boost::compute::partition_point( + vector.begin(), vector.end(), boost::compute::_1 <= 9, queue + ) > vector.begin() + 5); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::nth_element( + vector.begin(), vector.end(), vector.end(), less_than, queue + ); + CHECK_RANGE_EQUAL(int, 10, vector, (9, 15, 1, 4, 9, 9, 4, 15, 12, 1)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_opencl_error.cpp b/src/boost/libs/compute/test/test_opencl_error.cpp new file mode 100644 index 00000000..6735b44a --- /dev/null +++ b/src/boost/libs/compute/test/test_opencl_error.cpp @@ -0,0 +1,35 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestOpenCLError +#include <boost/test/unit_test.hpp> + +#include <boost/compute/exception/opencl_error.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(error_to_string) +{ + using boost::compute::opencl_error; + + BOOST_CHECK_EQUAL(opencl_error::to_string(CL_SUCCESS), "Success"); + BOOST_CHECK_EQUAL(opencl_error::to_string(CL_INVALID_VALUE), "Invalid Value"); + BOOST_CHECK_EQUAL(opencl_error::to_string(-123456), "Unknown OpenCL Error (-123456)"); +} + +BOOST_AUTO_TEST_CASE(error_code) +{ + boost::compute::opencl_error e(CL_INVALID_DEVICE); + BOOST_CHECK_EQUAL(e.error_code(), CL_INVALID_DEVICE); + BOOST_CHECK_EQUAL(e.error_string(), "Invalid Device"); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_pair.cpp b/src/boost/libs/compute/test/test_pair.cpp new file mode 100644 index 00000000..055ed920 --- /dev/null +++ b/src/boost/libs/compute/test/test_pair.cpp @@ -0,0 +1,194 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPair +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/find.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/get.hpp> +#include <boost/compute/functional/field.hpp> +#include <boost/compute/types/pair.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(vector_pair_int_float) +{ + boost::compute::vector<std::pair<int, float> > vector(context); + vector.push_back(std::make_pair(1, 1.1f), queue); + vector.push_back(std::make_pair(2, 2.2f), queue); + vector.push_back(std::make_pair(3, 3.3f), queue); + queue.finish(); + BOOST_CHECK_EQUAL(vector.size(), size_t(3)); + BOOST_CHECK(vector[0] == std::make_pair(1, 1.1f)); + BOOST_CHECK(vector[1] == std::make_pair(2, 2.2f)); + BOOST_CHECK(vector[2] == std::make_pair(3, 3.3f)); +} + +BOOST_AUTO_TEST_CASE(copy_pair_vector) +{ + boost::compute::vector<std::pair<int, float> > input(context); + input.push_back(std::make_pair(1, 2.0f), queue); + input.push_back(std::make_pair(3, 4.0f), queue); + input.push_back(std::make_pair(5, 6.0f), queue); + input.push_back(std::make_pair(7, 8.0f), queue); + queue.finish(); + BOOST_CHECK_EQUAL(input.size(), size_t(4)); + + boost::compute::vector<std::pair<int, float> > output(4, context); + boost::compute::copy(input.begin(), input.end(), output.begin(), queue); + queue.finish(); + BOOST_CHECK(output[0] == std::make_pair(1, 2.0f)); + BOOST_CHECK(output[1] == std::make_pair(3, 4.0f)); + BOOST_CHECK(output[2] == std::make_pair(5, 6.0f)); + BOOST_CHECK(output[3] == std::make_pair(7, 8.0f)); +} + +BOOST_AUTO_TEST_CASE(fill_pair_vector) +{ + if(bug_in_struct_assignment(device)){ + std::cerr << "skipping fill_pair_vector test" << std::endl; + return; + } + + boost::compute::vector<std::pair<int, float> > vector(5, context); + boost::compute::fill(vector.begin(), vector.end(), std::make_pair(4, 2.0f), queue); + queue.finish(); + BOOST_CHECK(vector[0] == std::make_pair(4, 2.0f)); + BOOST_CHECK(vector[1] == std::make_pair(4, 2.0f)); + BOOST_CHECK(vector[2] == std::make_pair(4, 2.0f)); + BOOST_CHECK(vector[3] == std::make_pair(4, 2.0f)); + BOOST_CHECK(vector[4] == std::make_pair(4, 2.0f)); +} + +BOOST_AUTO_TEST_CASE(fill_char_pair_vector) +{ + if(bug_in_struct_assignment(device)){ + std::cerr << "skipping fill_char_pair_vector test" << std::endl; + return; + } + + std::pair<char, unsigned char> value('c', static_cast<unsigned char>(127)); + boost::compute::vector<std::pair<char, unsigned char> > vector(5, context); + boost::compute::fill(vector.begin(), vector.end(), value, queue); + queue.finish(); + BOOST_CHECK(vector[0] == value); + BOOST_CHECK(vector[1] == value); + BOOST_CHECK(vector[2] == value); + BOOST_CHECK(vector[3] == value); + BOOST_CHECK(vector[4] == value); +} + +BOOST_AUTO_TEST_CASE(transform_pair_get) +{ + boost::compute::vector<std::pair<int, float> > input(context); + input.push_back(std::make_pair(1, 2.0f), queue); + input.push_back(std::make_pair(3, 4.0f), queue); + input.push_back(std::make_pair(5, 6.0f), queue); + input.push_back(std::make_pair(7, 8.0f), queue); + queue.finish(); + + boost::compute::vector<int> first_output(4, context); + boost::compute::transform( + input.begin(), + input.end(), + first_output.begin(), + ::boost::compute::get<0>(), + queue + ); + CHECK_RANGE_EQUAL(int, 4, first_output, (1, 3, 5, 7)); + + boost::compute::vector<float> second_output(4, context); + boost::compute::transform( + input.begin(), + input.end(), + second_output.begin(), + ::boost::compute::get<1>(), + queue + ); + CHECK_RANGE_EQUAL(float, 4, second_output, (2.0f, 4.0f, 6.0f, 8.0f)); +} + +BOOST_AUTO_TEST_CASE(transform_pair_field) +{ + boost::compute::vector<std::pair<int, float> > input(context); + input.push_back(std::make_pair(1, 2.0f), queue); + input.push_back(std::make_pair(3, 4.0f), queue); + input.push_back(std::make_pair(5, 6.0f), queue); + input.push_back(std::make_pair(7, 8.0f), queue); + + boost::compute::vector<int> first_output(4, context); + boost::compute::transform( + input.begin(), + input.end(), + first_output.begin(), + boost::compute::field<int>("first"), + queue + ); + CHECK_RANGE_EQUAL(int, 4, first_output, (1, 3, 5, 7)); + + boost::compute::vector<float> second_output(4, context); + boost::compute::transform( + input.begin(), + input.end(), + second_output.begin(), + boost::compute::field<float>("second"), + queue + ); + CHECK_RANGE_EQUAL(float, 4, second_output, (2.0f, 4.0f, 6.0f, 8.0f)); +} + +BOOST_AUTO_TEST_CASE(find_vector_pair) +{ + boost::compute::vector<std::pair<int, float> > vector(context); + vector.push_back(std::make_pair(1, 1.1f), queue); + vector.push_back(std::make_pair(2, 2.2f), queue); + vector.push_back(std::make_pair(3, 3.3f), queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(3)); + + BOOST_CHECK( + boost::compute::find( + boost::compute::make_transform_iterator( + vector.begin(), + boost::compute::get<0>() + ), + boost::compute::make_transform_iterator( + vector.end(), + boost::compute::get<0>() + ), + int(2), + queue + ).base() == vector.begin() + 1 + ); + + BOOST_CHECK( + boost::compute::find( + boost::compute::make_transform_iterator( + vector.begin(), + boost::compute::get<1>() + ), + boost::compute::make_transform_iterator( + vector.end(), + boost::compute::get<1>() + ), + float(3.3f), + queue + ).base() == vector.begin() + 2 + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_partial_sum.cpp b/src/boost/libs/compute/test/test_partial_sum.cpp new file mode 100644 index 00000000..f8d82922 --- /dev/null +++ b/src/boost/libs/compute/test/test_partial_sum.cpp @@ -0,0 +1,41 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPartialSum +#include <boost/test/unit_test.hpp> + +#include <vector> +#include <numeric> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/partial_sum.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(partial_sum_int) +{ + int data[] = { 1, 2, 5, 3, 9, 1, 4, 2 }; + bc::vector<int> a(8, context); + bc::copy(data, data + 8, a.begin(), queue); + + bc::vector<int> b(a.size(), context); + bc::vector<int>::iterator iter = + bc::partial_sum(a.begin(), a.end(), b.begin(), queue); + BOOST_CHECK(iter == b.end()); + CHECK_RANGE_EQUAL(int, 8, b, (1, 3, 8, 11, 20, 21, 25, 27)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_partition.cpp b/src/boost/libs/compute/test/test_partition.cpp new file mode 100644 index 00000000..b6faac8d --- /dev/null +++ b/src/boost/libs/compute/test/test_partition.cpp @@ -0,0 +1,82 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPartition +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/partition.hpp> +#include <boost/compute/algorithm/partition_copy.hpp> +#include <boost/compute/algorithm/is_partitioned.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(partition_float_vector) +{ + bc::vector<float> vector(context); + vector.push_back(1.0f, queue); + vector.push_back(2.0f, queue); + vector.push_back(-1.0f, queue); + vector.push_back(-2.0f, queue); + vector.push_back(3.0f, queue); + vector.push_back(4.0f, queue); + vector.push_back(-3.0f, queue); + vector.push_back(-4.0f, queue); + + // verify is_partitioned() + BOOST_VERIFY(bc::is_partitioned(vector.begin(), + vector.end(), + bc::signbit_<float>(), + queue) == false); + + // partition by signbit + bc::vector<float>::iterator iter = bc::partition(vector.begin(), + vector.end(), + bc::signbit_<float>(), + queue); + queue.finish(); + BOOST_VERIFY(iter == vector.begin() + 4); + BOOST_CHECK_LT(vector[0], 0.0f); + BOOST_CHECK_LT(vector[1], 0.0f); + BOOST_CHECK_LT(vector[2], 0.0f); + BOOST_CHECK_LT(vector[3], 0.0f); + BOOST_CHECK_GT(vector[4], 0.0f); + BOOST_CHECK_GT(vector[5], 0.0f); + BOOST_CHECK_GT(vector[6], 0.0f); + BOOST_CHECK_GT(vector[7], 0.0f); + + // verify is_partitioned() + BOOST_VERIFY(bc::is_partitioned(vector.begin(), + vector.end(), + bc::signbit_<float>(), + queue) == true); +} + +BOOST_AUTO_TEST_CASE(partition_small_vector) +{ + bc::vector<float> vector(context); + bc::partition(vector.begin(), vector.end(), bc::signbit_<float>(), queue); + + vector.push_back(1.0f, queue); + bc::partition(vector.begin(), vector.end(), bc::signbit_<float>(), queue); + CHECK_RANGE_EQUAL(float, 1, vector, (1.0f)); + + vector.push_back(-1.0f, queue); + bc::partition(vector.begin(), vector.end(), bc::signbit_<float>(), queue); + CHECK_RANGE_EQUAL(float, 2, vector, (-1.0f, 1.0f)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_partition_point.cpp b/src/boost/libs/compute/test/test_partition_point.cpp new file mode 100644 index 00000000..5cee7e9f --- /dev/null +++ b/src/boost/libs/compute/test/test_partition_point.cpp @@ -0,0 +1,38 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPartitionPoint +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/partition_point.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/system.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(partition_point_int) +{ + int dataset[] = {1, 1, 5, 2, 4, -2, 0, -1, 0, -1}; + bc::vector<bc::int_> vector(dataset, dataset + 10, queue); + + bc::vector<bc::int_>::iterator iter = + bc::partition_point(vector.begin(), vector.begin() + 10, + bc::_1 > 0, queue); + + BOOST_VERIFY(iter == vector.begin()+5); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_permutation_iterator.cpp b/src/boost/libs/compute/test/test_permutation_iterator.cpp new file mode 100644 index 00000000..ee6488c3 --- /dev/null +++ b/src/boost/libs/compute/test/test_permutation_iterator.cpp @@ -0,0 +1,110 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPermutationIterator +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/types.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/buffer_iterator.hpp> +#include <boost/compute/iterator/permutation_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(value_type) +{ + using boost::compute::float4_; + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::permutation_iterator< + boost::compute::buffer_iterator<float>, + boost::compute::buffer_iterator<int> + >::value_type, + float + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::permutation_iterator< + boost::compute::buffer_iterator<float4_>, + boost::compute::buffer_iterator<short> + >::value_type, + float4_ + >::value + )); +} + +BOOST_AUTO_TEST_CASE(base_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::permutation_iterator< + boost::compute::buffer_iterator<int>, + boost::compute::buffer_iterator<int> + >::base_type, + boost::compute::buffer_iterator<int> + >::value + )); +} + +BOOST_AUTO_TEST_CASE(copy) +{ + int input_data[] = { 3, 4, 2, 1, 5 }; + boost::compute::vector<int> input(input_data, input_data + 5, queue); + + int map_data[] = { 3, 2, 0, 1, 4 }; + boost::compute::vector<int> map(map_data, map_data + 5, queue); + + boost::compute::vector<int> output(5, context); + boost::compute::copy( + boost::compute::make_permutation_iterator(input.begin(), map.begin()), + boost::compute::make_permutation_iterator(input.end(), map.end()), + output.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 5, output, (1, 2, 3, 4, 5)); +} + +BOOST_AUTO_TEST_CASE(reverse_range_doctest) +{ + int values_data[] = { 10, 20, 30, 40 }; + int indices_data[] = { 3, 2, 1, 0 }; + + boost::compute::vector<int> values(values_data, values_data + 4, queue); + boost::compute::vector<int> indices(indices_data, indices_data + 4, queue); + + boost::compute::vector<int> result(4, context); + +//! [reverse_range] +// values = { 10, 20, 30, 40 } +// indices = { 3, 2, 1, 0 } + +boost::compute::copy( + boost::compute::make_permutation_iterator(values.begin(), indices.begin()), + boost::compute::make_permutation_iterator(values.end(), indices.end()), + result.begin(), + queue +); + +// result == { 40, 30, 20, 10 } +//! [reverse_range] + + CHECK_RANGE_EQUAL(int, 4, result, (40, 30, 20, 10)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_pinned_allocator.cpp b/src/boost/libs/compute/test/test_pinned_allocator.cpp new file mode 100644 index 00000000..ca34c034 --- /dev/null +++ b/src/boost/libs/compute/test/test_pinned_allocator.cpp @@ -0,0 +1,27 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPinnedAllocator +#include <boost/test/unit_test.hpp> + +#include <boost/compute/allocator/pinned_allocator.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(vector_with_pinned_allocator) +{ + compute::vector<int, compute::pinned_allocator<int> > vector(context); + vector.push_back(12, queue); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_pipe.cpp b/src/boost/libs/compute/test/test_pipe.cpp new file mode 100644 index 00000000..25e61c8d --- /dev/null +++ b/src/boost/libs/compute/test/test_pipe.cpp @@ -0,0 +1,36 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPipe +#include <boost/test/unit_test.hpp> + +#include <boost/compute/core.hpp> +#include <boost/compute/pipe.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(empty) +{ +} + +#ifdef BOOST_COMPUTE_CL_VERSION_2_0 +BOOST_AUTO_TEST_CASE(create_pipe) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + compute::pipe pipe(context, 16 * sizeof(float), 128); + BOOST_CHECK_EQUAL(pipe.get_info<CL_PIPE_PACKET_SIZE>(), 64); + BOOST_CHECK_EQUAL(pipe.get_info<CL_PIPE_MAX_PACKETS>(), 128); +} +#endif // BOOST_COMPUTE_CL_VERSION_2_0 + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_platform.cpp b/src/boost/libs/compute/test/test_platform.cpp new file mode 100644 index 00000000..76cfaecb --- /dev/null +++ b/src/boost/libs/compute/test/test_platform.cpp @@ -0,0 +1,45 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPlatform +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/platform.hpp> +#include <boost/compute/system.hpp> + +BOOST_AUTO_TEST_CASE(platform_id) +{ + boost::compute::platform platform = + boost::compute::system::platforms().front(); + + boost::compute::platform platform_copy(platform.id()); + + BOOST_CHECK(platform == platform_copy); + BOOST_CHECK(platform.id() == platform_copy.id()); +} + +BOOST_AUTO_TEST_CASE(platform_supports_extension) +{ + boost::compute::platform platform = + boost::compute::system::platforms().front(); + + std::string extensions = platform.get_info<CL_PLATFORM_EXTENSIONS>(); + if(extensions.empty()){ + std::cerr << "platform doesn't support any extensions" << std::endl; + return; + } + + size_t space = extensions.find(' '); + std::string first_extension = extensions.substr(0, space); + BOOST_CHECK(platform.supports_extension(first_extension) == true); + BOOST_CHECK(platform.supports_extension("invalid_extension_name") == false); +} diff --git a/src/boost/libs/compute/test/test_prev_permutation.cpp b/src/boost/libs/compute/test/test_prev_permutation.cpp new file mode 100644 index 00000000..b6edf4cf --- /dev/null +++ b/src/boost/libs/compute/test/test_prev_permutation.cpp @@ -0,0 +1,71 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestPrevPermutation +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/prev_permutation.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(prev_permutation_int) +{ + int dataset[] = {1, 3, 4, 2, 5}; + bc::vector<bc::int_> vector(dataset, dataset + 5, queue); + + bool result = + bc::prev_permutation(vector.begin(), vector.begin() + 5, queue); + + CHECK_RANGE_EQUAL(int, 5, vector, (1, 3, 2, 5, 4)); + BOOST_VERIFY(result == true); + + vector[1] = 1; vector[4] = 6; + + result = bc::prev_permutation(vector.begin(), vector.begin() + 5, queue); + + CHECK_RANGE_EQUAL(int, 5, vector, (6, 5, 2, 1, 1)); + BOOST_VERIFY(result == false); +} + +BOOST_AUTO_TEST_CASE(prev_permutation_string) +{ + char dataset[] = "baaa"; + bc::vector<bc::char_> vector(dataset, dataset + 4, queue); + + bool result = + bc::prev_permutation(vector.begin(), vector.begin() + 4, queue); + + CHECK_RANGE_EQUAL(char, 4, vector, ('a', 'b', 'a', 'a')); + BOOST_VERIFY(result == true); + + result = bc::prev_permutation(vector.begin(), vector.begin() + 4, queue); + + CHECK_RANGE_EQUAL(char, 4, vector, ('a', 'a', 'b', 'a')); + BOOST_VERIFY(result == true); + + result = bc::prev_permutation(vector.begin(), vector.begin() + 4, queue); + + CHECK_RANGE_EQUAL(char, 4, vector, ('a', 'a', 'a', 'b')); + BOOST_VERIFY(result == true); + + result = bc::prev_permutation(vector.begin(), vector.begin() + 4, queue); + + CHECK_RANGE_EQUAL(char, 4, vector, ('b', 'a', 'a', 'a')); + BOOST_VERIFY(result == false); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_program.cpp b/src/boost/libs/compute/test/test_program.cpp new file mode 100644 index 00000000..7172c5e2 --- /dev/null +++ b/src/boost/libs/compute/test/test_program.cpp @@ -0,0 +1,401 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestProgram +#include <boost/test/unit_test.hpp> + +// disable the automatic kernel compilation debug messages. this allows the +// test for program to check that compilation error exceptions are properly +// thrown when invalid kernel code is passed to program::build(). +#undef BOOST_COMPUTE_DEBUG_KERNEL_COMPILATION + +#include <boost/compute/exception/program_build_failure.hpp> +#include <boost/compute/kernel.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/program.hpp> +#include <boost/compute/utility/source.hpp> + +#include "quirks.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +const char source[] = + "__kernel void foo(__global float *x, const uint n) { }\n" + "__kernel void bar(__global int *x, __global int *y) { }\n"; + + +BOOST_AUTO_TEST_CASE(get_program_info) +{ + // create program + boost::compute::program program = + boost::compute::program::create_with_source(source, context); + + // build program + program.build(); + + // check program info +#ifndef BOOST_COMPUTE_USE_OFFLINE_CACHE + BOOST_CHECK(program.source().empty() == false); +#endif + BOOST_CHECK(program.get_context() == context); +} + +BOOST_AUTO_TEST_CASE(program_source) +{ + // create program from source + boost::compute::program program = + boost::compute::program::create_with_source(source, context); + + BOOST_CHECK_EQUAL(std::string(source), program.source()); +} + +BOOST_AUTO_TEST_CASE(program_multiple_sources) +{ + std::vector<std::string> sources; + sources.push_back("__kernel void foo(__global int* x) { }\n"); + sources.push_back("__kernel void bar(__global float* y) { }\n"); + + // create program from sources + boost::compute::program program = + boost::compute::program::create_with_source(sources, context); + program.build(); + + boost::compute::kernel foo = program.create_kernel("foo"); + boost::compute::kernel bar = program.create_kernel("bar"); +} + +BOOST_AUTO_TEST_CASE(program_source_no_file) +{ + // create program from a non-existant source file + // and verifies it throws. + BOOST_CHECK_THROW(boost::compute::program program = + boost::compute::program::create_with_source_file + (std::string(), context), + std::ios_base::failure); +} + +BOOST_AUTO_TEST_CASE(create_kernel) +{ + boost::compute::program program = + boost::compute::program::create_with_source(source, context); + program.build(); + + boost::compute::kernel foo = program.create_kernel("foo"); + boost::compute::kernel bar = program.create_kernel("bar"); + + // try to create a kernel that doesn't exist + BOOST_CHECK_THROW(program.create_kernel("baz"), boost::compute::opencl_error); +} + +BOOST_AUTO_TEST_CASE(create_with_binary) +{ + // create program from source + boost::compute::program source_program = + boost::compute::program::create_with_source(source, context); + source_program.build(); + + // create kernels in source program + boost::compute::kernel source_foo_kernel = source_program.create_kernel("foo"); + boost::compute::kernel source_bar_kernel = source_program.create_kernel("bar"); + + // check source kernels + BOOST_CHECK_EQUAL(source_foo_kernel.name(), std::string("foo")); + BOOST_CHECK_EQUAL(source_bar_kernel.name(), std::string("bar")); + + // get binary + std::vector<unsigned char> binary = source_program.binary(); + + // create program from binary + boost::compute::program binary_program = + boost::compute::program::create_with_binary(binary, context); + binary_program.build(); + + // create kernels in binary program + boost::compute::kernel binary_foo_kernel = binary_program.create_kernel("foo"); + boost::compute::kernel binary_bar_kernel = binary_program.create_kernel("bar"); + + // check binary kernels + BOOST_CHECK_EQUAL(binary_foo_kernel.name(), std::string("foo")); + BOOST_CHECK_EQUAL(binary_bar_kernel.name(), std::string("bar")); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_2_1 +BOOST_AUTO_TEST_CASE(create_with_il) +{ + REQUIRES_OPENCL_VERSION(2, 1); + + size_t device_address_space_size = device.address_bits(); + std::string file_path(BOOST_COMPUTE_TEST_DATA_PATH); + if(device_address_space_size == 64) + { + file_path += "/program.spirv64"; + } + else + { + file_path += "/program.spirv32"; + } + + // create program from il + boost::compute::program il_program; + BOOST_CHECK_NO_THROW( + il_program = boost::compute::program::create_with_il_file( + file_path, context + ) + ); + BOOST_CHECK_NO_THROW(il_program.build()); + + // create kernel (to check if program was loaded correctly) + BOOST_CHECK_NO_THROW(il_program.create_kernel("foobar")); +} + +BOOST_AUTO_TEST_CASE(get_program_il_binary) +{ + REQUIRES_OPENCL_VERSION(2, 1); + + size_t device_address_space_size = device.address_bits(); + std::string file_path(BOOST_COMPUTE_TEST_DATA_PATH); + if(device_address_space_size == 64) + { + file_path += "/program.spirv64"; + } + else + { + file_path += "/program.spirv32"; + } + + // create program from il + boost::compute::program il_program; + BOOST_CHECK_NO_THROW( + il_program = boost::compute::program::create_with_il_file( + file_path, context + ) + ); + BOOST_CHECK_NO_THROW(il_program.build()); + + std::vector<unsigned char> il_binary; + BOOST_CHECK_NO_THROW(il_binary = il_program.il_binary()); + + // create program from loaded il binary + BOOST_CHECK_NO_THROW( + il_program = boost::compute::program::create_with_il(il_binary, context) + ); + BOOST_CHECK_NO_THROW(il_program.build()); + + // create kernel (to check if program was loaded correctly) + BOOST_CHECK_NO_THROW(il_program.create_kernel("foobar")); +} + +BOOST_AUTO_TEST_CASE(get_program_il_binary_empty) +{ + REQUIRES_OPENCL_VERSION(2, 1); + + boost::compute::program program; + BOOST_CHECK_NO_THROW( + program = boost::compute::program::create_with_source(source, context) + ); + BOOST_CHECK_NO_THROW(program.build()); + + std::vector<unsigned char> il_binary; + il_binary = program.il_binary(); + BOOST_CHECK(il_binary.empty()); +} +#endif // BOOST_COMPUTE_CL_VERSION_2_1 + +BOOST_AUTO_TEST_CASE(create_with_source_doctest) +{ +//! [create_with_source] +std::string source = "__kernel void foo(__global int *data) { }"; + +boost::compute::program foo_program = + boost::compute::program::create_with_source(source, context); +//! [create_with_source] + + foo_program.build(); +} + +#ifdef BOOST_COMPUTE_CL_VERSION_1_2 +BOOST_AUTO_TEST_CASE(compile_and_link) +{ + REQUIRES_OPENCL_VERSION(1,2); + + if(!supports_compile_program(device) || !supports_link_program(device)) { + return; + } + + // create the library program + const char library_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + // for some reason the apple opencl compilers complains if a prototype + // for the square() function is not available, so we add it here + T square(T); + + // generic square function definition + T square(T x) { return x * x; } + ); + + compute::program library_program = + compute::program::create_with_source(library_source, context); + + library_program.compile("-DT=int"); + + // create the kernel program + const char kernel_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + // forward declare square function + extern int square(int); + + // square kernel definition + __kernel void square_kernel(__global int *x) + { + x[0] = square(x[0]); + } + ); + + compute::program square_program = + compute::program::create_with_source(kernel_source, context); + + square_program.compile(); + + // link the programs + std::vector<compute::program> programs; + programs.push_back(library_program); + programs.push_back(square_program); + + compute::program linked_program = + compute::program::link(programs, context); + + // create the square kernel + compute::kernel square_kernel = + linked_program.create_kernel("square_kernel"); + BOOST_CHECK_EQUAL(square_kernel.name(), "square_kernel"); +} + +BOOST_AUTO_TEST_CASE(compile_and_link_with_headers) +{ + REQUIRES_OPENCL_VERSION(1,2); + + if(!supports_compile_program(device) || !supports_link_program(device)) { + return; + } + + // create the header programs + const char square_header_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + T square(T x) { return x * x; } + ); + const char div2_header_source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + T div2(T x) { return x / 2; } + ); + + compute::program square_header_program = + compute::program::create_with_source(square_header_source, context); + compute::program div2_header_program = + compute::program::create_with_source(div2_header_source, context); + + // create the kernel program + const char kernel_source[] = + "#include \"square.h\"\n" + "#include \"div2.h\"\n" + "__kernel void squareby2_kernel(__global int *x)" + "{" + " x[0] = div2(square(x[0]));" + "}"; + + compute::program square_program = + compute::program::create_with_source(kernel_source, context); + + std::vector<std::pair<std::string, compute::program> > header_programs; + header_programs.push_back(std::make_pair("square.h", square_header_program)); + header_programs.push_back(std::make_pair("div2.h", div2_header_program)); + + square_program.compile("-DT=int", header_programs); + + // link program + std::vector<compute::program> programs; + programs.push_back(square_program); + + compute::program linked_program = + compute::program::link(programs, context); + + // create the square kernel + compute::kernel square_kernel = + linked_program.create_kernel("squareby2_kernel"); + BOOST_CHECK_EQUAL(square_kernel.name(), "squareby2_kernel"); +} +#endif // BOOST_COMPUTE_CL_VERSION_1_2 + +BOOST_AUTO_TEST_CASE(build_log) +{ + const char invalid_source[] = + "__kernel void foo(__global int *input) { !@#$%^&*() }"; + + compute::program invalid_program = + compute::program::create_with_source(invalid_source, context); + + try { + invalid_program.build(); + + // should not get here + BOOST_CHECK(false); + } + catch(compute::opencl_error&){ + std::string log = invalid_program.build_log(); + BOOST_CHECK(!log.empty()); + } +} + +BOOST_AUTO_TEST_CASE(program_build_exception) +{ + const char invalid_source[] = + "__kernel void foo(__global int *input) { !@#$%^&*() }"; + + compute::program invalid_program = + compute::program::create_with_source(invalid_source, context); + + BOOST_CHECK_THROW(invalid_program.build(), + compute::program_build_failure); + + try { + // POCL bug: https://github.com/pocl/pocl/issues/577 + if(pocl_bug_issue_577(device)) + { + invalid_program = + compute::program::create_with_source(invalid_source, context); + } + invalid_program.build(); + + // should not get here + BOOST_CHECK(false); + } + catch(compute::program_build_failure& e){ + BOOST_CHECK(e.build_log() == invalid_program.build_log()); + } + catch(...) + { + // should not get here + BOOST_CHECK(false); + } +} + +BOOST_AUTO_TEST_CASE(build_with_source_exception) +{ + const char invalid_source[] = + "__kernel void foo(__global int *input) { !@#$%^&*() }"; + + BOOST_CHECK_THROW(compute::program::build_with_source(invalid_source, context), + compute::program_build_failure); +} + +BOOST_AUTO_TEST_CASE(build_with_source_file_exception) +{ + std::string file_path(BOOST_COMPUTE_TEST_DATA_PATH "/invalid_program.cl"); + BOOST_CHECK_THROW(compute::program::build_with_source_file(file_path, context), + compute::program_build_failure); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_program_cache.cpp b/src/boost/libs/compute/test/test_program_cache.cpp new file mode 100644 index 00000000..446e9a87 --- /dev/null +++ b/src/boost/libs/compute/test/test_program_cache.cpp @@ -0,0 +1,99 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestProgramCache +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/utility/program_cache.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(setup) +{ + // get default context + compute::context ctx = context; + + // get program cache + boost::shared_ptr<compute::program_cache> cache = + compute::program_cache::get_global_cache(ctx); + + // try to load a null string + BOOST_CHECK(cache->get(std::string()) == boost::none); + + // try to load a non-existant program + BOOST_CHECK(cache->get("nonexistant") == boost::none); + + // create and store a program + const char p1_source[] = + "__kernel void add(__global int *a, int x)\n" + "{\n" + " a[get_global_id(0)] += x;\n" + "}\n"; + compute::program p1 = + compute::program::create_with_source(p1_source, ctx); + p1.build(); + cache->insert("p1", p1); + + // try to load the program + BOOST_CHECK(cache->get("p1") == p1); + + // create a copy of the context + compute::context ctx_copy = ctx; + + // check that they both have the same cl_context + BOOST_CHECK(ctx_copy.get() == ctx.get()); + + // check that the cache is the same + boost::shared_ptr<compute::program_cache> cache_copy = + compute::program_cache::get_global_cache(ctx_copy); + BOOST_CHECK(cache_copy == cache); + + // try to load the program again + BOOST_CHECK(cache_copy->get("p1") == p1); +} + +BOOST_AUTO_TEST_CASE(evict) +{ + // create cache with capacity of four and insert four programs + compute::program_cache cache(4); + cache.insert("a", compute::program()); + cache.insert("b", compute::program()); + cache.insert("c", compute::program()); + cache.insert("d", compute::program()); + + // check that all four programs still reside in the cache + BOOST_CHECK(cache.get("a") != boost::none); + BOOST_CHECK(cache.get("b") != boost::none); + BOOST_CHECK(cache.get("c") != boost::none); + BOOST_CHECK(cache.get("d") != boost::none); + + // insert fifth program which should evict the oldest ("a") + cache.insert("e", compute::program()); + + // check that "a" has been evicted and that "e" is now present + BOOST_CHECK(cache.get("a") == boost::none); + BOOST_CHECK(cache.get("b") != boost::none); + BOOST_CHECK(cache.get("c") != boost::none); + BOOST_CHECK(cache.get("d") != boost::none); + BOOST_CHECK(cache.get("e") != boost::none); + + // clear cache and ensure no program objects are found + cache.clear(); + BOOST_CHECK(cache.get("a") == boost::none); + BOOST_CHECK(cache.get("b") == boost::none); + BOOST_CHECK(cache.get("c") == boost::none); + BOOST_CHECK(cache.get("d") == boost::none); + BOOST_CHECK(cache.get("e") == boost::none); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_radix_sort.cpp b/src/boost/libs/compute/test/test_radix_sort.cpp new file mode 100644 index 00000000..d43deae2 --- /dev/null +++ b/src/boost/libs/compute/test/test_radix_sort.cpp @@ -0,0 +1,543 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestRadixSort +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/algorithm/detail/radix_sort.hpp> +#include <boost/compute/container/vector.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +const bool descending = false; + +BOOST_AUTO_TEST_CASE(sort_char_vector) +{ + if(is_apple_cpu_device(device)) { + std::cerr + << "skipping all radix_sort tests due to Apple platform" + << " behavior when local memory is used on a CPU device" + << std::endl; + return; + } + + using boost::compute::char_; + + char_ data[] = { 'c', 'a', '0', '7', 'B', 'F', '\0', '$' }; + boost::compute::vector<char_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(char_, 8, vector, ('\0', '$', '0', '7', 'B', 'F', 'a', 'c')); +} + +BOOST_AUTO_TEST_CASE(sort_uchar_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::uchar_; + + uchar_ data[] = { 0x12, 0x00, 0xFF, 0xB4, 0x80, 0x32, 0x64, 0xA2 }; + boost::compute::vector<uchar_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(uchar_, 8, vector, (0x00, 0x12, 0x32, 0x64, 0x80, 0xA2, 0xB4, 0xFF)); +} + +BOOST_AUTO_TEST_CASE(sort_short_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::short_; + + short_ data[] = { -4, 152, -94, 963, 31002, -456, 0, -2113 }; + boost::compute::vector<short_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(short_, 8, vector, (-2113, -456, -94, -4, 0, 152, 963, 31002)); +} + +BOOST_AUTO_TEST_CASE(sort_ushort_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::ushort_; + + ushort_ data[] = { 4, 152, 94, 963, 63202, 34560, 0, 2113 }; + boost::compute::vector<ushort_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(ushort_, 8, vector, (0, 4, 94, 152, 963, 2113, 34560, 63202)); +} + +BOOST_AUTO_TEST_CASE(sort_int_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + int data[] = { -4, 152, -5000, 963, 75321, -456, 0, 1112 }; + boost::compute::vector<int> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(int, 8, vector, (-5000, -456, -4, 0, 152, 963, 1112, 75321)); +} + +BOOST_AUTO_TEST_CASE(sort_uint_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::uint_; + + uint_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<uint_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(uint_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_long_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::long_; + + long_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<long_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(long_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_ulong_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::ulong_; + + ulong_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<ulong_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(ulong_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_float_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + float data[] = { -6023.0f, 152.5f, -63.0f, 1234567.0f, 11.2f, + -5000.1f, 0.0f, 14.0f, -8.25f, -0.0f }; + boost::compute::vector<float> vector(data, data + 10, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(10)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL( + float, 10, vector, + (-6023.0f, -5000.1f, -63.0f, -8.25f, -0.0f, 0.0f, 11.2f, 14.0f, 152.5f, 1234567.0f) + ); + + // copy data, sort, and check again (to check program caching) + boost::compute::copy(data, data + 10, vector.begin(), queue); + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL( + float, 10, vector, + (-6023.0f, -5000.1f, -63.0f, -8.25f, -0.0f, 0.0f, 11.2f, 14.0f, 152.5f, 1234567.0f) + ); +} + +BOOST_AUTO_TEST_CASE(sort_double_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + if(!device.supports_extension("cl_khr_fp64")){ + std::cout << "skipping test: device does not support double" << std::endl; + return; + } + + double data[] = { -6023.0, 152.5, -63.0, 1234567.0, 11.2, + -5000.1, 0.0, 14.0, -8.25, -0.0 }; + boost::compute::vector<double> vector(data, data + 10, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(10)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::detail::radix_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL( + double, 10, vector, + (-6023.0, -5000.1, -63.0, -8.25, -0.0, 0.0, 11.2, 14.0, 152.5, 1234567.0) + ); +} + +BOOST_AUTO_TEST_CASE(sort_char_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::char_; + + char_ data[] = { 'c', 'a', '0', '7', 'B', 'F', '\0', '$' }; + boost::compute::vector<char_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<char_>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<char_>(), queue + )); + + CHECK_RANGE_EQUAL( + char_, 8, vector, + ('c', 'a', 'F', 'B', '7', '0', '$', '\0') + ); +} + +BOOST_AUTO_TEST_CASE(sort_uchar_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::uchar_; + + uchar_ data[] = { 0x12, 0x00, 0xFF, 0xB4, 0x80, 0x32, 0x64, 0xA2 }; + boost::compute::vector<uchar_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<uchar_>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<uchar_>(), queue + )); + + CHECK_RANGE_EQUAL( + uchar_, 8, vector, + (0xFF, 0xB4, 0xA2, 0x80, 0x64, 0x32, 0x12, 0x00) + ); +} + +BOOST_AUTO_TEST_CASE(sort_short_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::short_; + + short_ data[] = { -4, 152, -94, 963, 31002, -456, 0, -2113 }; + boost::compute::vector<short_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<short_>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<short_>(), queue + )); + + CHECK_RANGE_EQUAL( + short_, 8, vector, + (31002, 963, 152, 0, -4, -94, -456, -2113) + ); +} + +BOOST_AUTO_TEST_CASE(sort_ushort_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::ushort_; + + ushort_ data[] = { 4, 152, 94, 963, 63202, 34560, 0, 2113 }; + boost::compute::vector<ushort_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<ushort_>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<ushort_>(), queue + )); + + CHECK_RANGE_EQUAL( + ushort_, 8, vector, + (63202, 34560, 2113, 963, 152, 94, 4, 0) + ); +} + +BOOST_AUTO_TEST_CASE(sort_int_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::int_; + + int_ data[] = { -4, 152, -5000, 963, 75321, -456, 0, 1112 }; + boost::compute::vector<int_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<int_>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<int_>(), queue + )); + + CHECK_RANGE_EQUAL( + int_, 8, vector, + (75321, 1112, 963, 152, 0, -4, -456, -5000) + ); +} + +BOOST_AUTO_TEST_CASE(sort_uint_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::uint_; + + uint_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<uint_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<uint_>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<uint_>(), queue + )); + + CHECK_RANGE_EQUAL( + uint_, 8, vector, + (4000000, 123456, 102030, 9852, 1988, 562, 500, 0) + ); +} + +BOOST_AUTO_TEST_CASE(sort_long_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::long_; + + long_ data[] = { -500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<long_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<long_>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<long_>(), queue + )); + + CHECK_RANGE_EQUAL( + long_, 8, vector, + (4000000, 123456, 102030, 9852, 1988, 562, 0, -500) + ); +} + +BOOST_AUTO_TEST_CASE(sort_ulong_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + using boost::compute::ulong_; + + ulong_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<ulong_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<ulong_>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<ulong_>(), queue + )); + + CHECK_RANGE_EQUAL( + ulong_, 8, vector, + (4000000, 123456, 102030, 9852, 1988, 562, 500, 0) + ); +} + +BOOST_AUTO_TEST_CASE(sort_float_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + float data[] = { + -6023.0f, 152.5f, -63.0f, 1234567.0f, 11.2f, + -5000.1f, 0.0f, 14.0f, -8.25f, -0.0f + }; + + boost::compute::vector<float> vector(data, data + 10, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(10)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<float>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<float>(), queue + )); + + CHECK_RANGE_EQUAL( + float, 10, vector, + (1234567.0f, 152.5f, 14.0f, 11.2f, 0.0f, -0.0f, -8.25f, -63.0f, -5000.1f, -6023.0f) + ); + + // copy data, sort, and check again (to check program caching) + boost::compute::copy(data, data + 10, vector.begin(), queue); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<float>(), queue + )); + CHECK_RANGE_EQUAL( + float, 10, vector, + (1234567.0f, 152.5f, 14.0f, 11.2f, 0.0f, -0.0f, -8.25f, -63.0f, -5000.1f, -6023.0f) + ); +} + +BOOST_AUTO_TEST_CASE(sort_double_vector_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + if(!device.supports_extension("cl_khr_fp64")){ + std::cout << "skipping test: device does not support double" << std::endl; + return; + } + + double data[] = { + -6023.0, 152.5, -63.0, 1234567.0, 11.2, -5000.1, 0.0, 14.0, -8.25, -0.0 + }; + + boost::compute::vector<double> vector(data, data + 10, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(10)); + + BOOST_CHECK(!boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<double>(), queue + )); + boost::compute::detail::radix_sort( + vector.begin(), vector.end(), descending, queue + ); + BOOST_CHECK(boost::compute::is_sorted( + vector.begin(), vector.end(), boost::compute::greater<double>(), queue + )); + + CHECK_RANGE_EQUAL( + double, 10, vector, + (1234567.0, 152.5, 14.0, 11.2, 0.0, -0.0, -8.25, -63.0, -5000.1, -6023.0) + ); +} + +BOOST_AUTO_TEST_CASE(sort_partial_vector) +{ + if(is_apple_cpu_device(device)) { + return; + } + + int data[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; + boost::compute::vector<int> vec(data, data + 10, queue); + + boost::compute::detail::radix_sort(vec.begin() + 2, vec.end() - 2, queue); + CHECK_RANGE_EQUAL(int, 10, vec, (9, 8, 2, 3, 4, 5, 6, 7, 1, 0)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_radix_sort_by_key.cpp b/src/boost/libs/compute/test/test_radix_sort_by_key.cpp new file mode 100644 index 00000000..cc86d4ba --- /dev/null +++ b/src/boost/libs/compute/test/test_radix_sort_by_key.cpp @@ -0,0 +1,311 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2016 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestRadixSortByKey +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/algorithm/detail/radix_sort.hpp> +#include <boost/compute/container/vector.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +const bool descending = false; + +// radix_sort_by_key should be stable +BOOST_AUTO_TEST_CASE(stable_radix_sort_int_by_int) +{ + if(is_apple_cpu_device(device)) { + std::cerr + << "skipping all radix_sort_by_key tests due to Apple platform" + << " behavior when local memory is used on a CPU device" + << std::endl; + return; + } + + compute::int_ keys_data[] = { 10, 9, 2, 7, 6, -1, 4, 2, 2, 10 }; + compute::int_ values_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + + compute::vector<compute::int_> keys(keys_data, keys_data + 10, queue); + compute::vector<compute::int_> values(values_data, values_data + 10, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::detail::radix_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + + CHECK_RANGE_EQUAL( + compute::int_, 10, keys, + (-1, 2, 2, 2, 4, 6, 7, 9, 10, 10) // keys + // ( 6, 3, 8, 9, 7, 5, 4, 2, 1, 10) values + ); + CHECK_RANGE_EQUAL( + compute::int_, 10, values, + // (-1, 2, 2, 2, 4, 6, 7, 9, 10, 10) keys + ( 6, 3, 8, 9, 7, 5, 4, 2, 1, 10) // values + ); +} + +// radix_sort_by_key should be stable +BOOST_AUTO_TEST_CASE(stable_radix_sort_int_by_int_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + compute::int_ keys_data[] = { 10, 9, 2, 7, 6, -1, 4, 2, 2, 10 }; + compute::int_ values_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + + compute::vector<compute::int_> keys(keys_data, keys_data + 10, queue); + compute::vector<compute::int_> values(values_data, values_data + 10, queue); + + BOOST_CHECK( + !compute::is_sorted( + keys.begin(), keys.end(), compute::greater<compute::int_>(), queue + ) + ); + compute::detail::radix_sort_by_key( + keys.begin(), keys.end(), values.begin(), descending, queue + ); + BOOST_CHECK( + compute::is_sorted( + keys.begin(), keys.end(), compute::greater<compute::int_>(), queue + ) + ); + + CHECK_RANGE_EQUAL( + compute::int_, 10, keys, + (10, 10, 9, 7, 6, 4, 2, 2, 2, -1) // keys + // ( 1, 10, 2, 4, 5, 7, 3, 8, 9, 6) values + ); + CHECK_RANGE_EQUAL( + compute::int_, 10, values, + // (10, 10, 9, 7, 6, 4, 2, 2, 2, -1) // keys + ( 1, 10, 2, 4, 5, 7, 3, 8, 9, 6) // values + ); +} + +// radix_sort_by_key should be stable +BOOST_AUTO_TEST_CASE(stable_radix_sort_uint_by_uint) +{ + if(is_apple_cpu_device(device)) { + return; + } + + compute::uint_ keys_data[] = { 10, 9, 2, 7, 6, 1, 4, 2, 2, 10 }; + compute::uint_ values_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + + compute::vector<compute::uint_> keys(keys_data, keys_data + 10, queue); + compute::vector<compute::uint_> values(values_data, values_data + 10, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::detail::radix_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + + CHECK_RANGE_EQUAL( + compute::uint_, 10, keys, + (1, 2, 2, 2, 4, 6, 7, 9, 10, 10) // keys + // (6, 3, 8, 9, 7, 5, 4, 2, 1, 10) values + ); + CHECK_RANGE_EQUAL( + compute::uint_, 10, values, + // (1, 2, 2, 2, 4, 6, 7, 9, 10, 10) keys + (6, 3, 8, 9, 7, 5, 4, 2, 1, 10) // values + ); +} + +// radix_sort_by_key should be stable +BOOST_AUTO_TEST_CASE(stable_radix_sort_uint_by_uint_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + compute::uint_ keys_data[] = { 10, 9, 2, 7, 6, 1, 4, 2, 2, 10 }; + compute::uint_ values_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + + compute::vector<compute::uint_> keys(keys_data, keys_data + 10, queue); + compute::vector<compute::uint_> values(values_data, values_data + 10, queue); + + BOOST_CHECK( + !compute::is_sorted( + keys.begin(), keys.end(), compute::greater<compute::uint_>(), queue + ) + ); + compute::detail::radix_sort_by_key( + keys.begin(), keys.end(), values.begin(), descending, queue + ); + BOOST_CHECK( + compute::is_sorted( + keys.begin(), keys.end(), compute::greater<compute::uint_>(), queue + ) + ); + + CHECK_RANGE_EQUAL( + compute::uint_, 10, keys, + (10, 10, 9, 7, 6, 4, 2, 2, 2, 1) // keys + // ( 1, 10, 2, 4, 5, 7, 3, 8, 9, 6) values + ); + CHECK_RANGE_EQUAL( + compute::uint_, 10, values, + // (10, 10, 9, 7, 6, 4, 2, 2, 2, 1) // keys + ( 1, 10, 2, 4, 5, 7, 3, 8, 9, 6) // values + ); +} + + +// radix_sort_by_key should be stable +BOOST_AUTO_TEST_CASE(stable_radix_sort_int_by_float) +{ + if(is_apple_cpu_device(device)) { + return; + } + + compute::float_ keys_data[] = { 10., 5.5, 10., 7., 5.5}; + compute::int_ values_data[] = { 1, 200, -10, 2, 4 }; + + compute::vector<compute::float_> keys(keys_data, keys_data + 5, queue); + compute::vector<compute::uint_> values(values_data, values_data + 5, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::detail::radix_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + + CHECK_RANGE_EQUAL( + compute::float_, 5, keys, + (5.5, 5.5, 7., 10., 10.) // keys + // (200, 4, 2, 1, -10) values + ); + CHECK_RANGE_EQUAL( + compute::int_, 5, values, + // (5.5, 5.5, 7., 10., 10.) keys + (200, 4, 2, 1, -10) // values + ); +} + +// radix_sort_by_key should be stable +BOOST_AUTO_TEST_CASE(stable_radix_sort_int_by_float_desc) +{ + if(is_apple_cpu_device(device)) { + return; + } + + compute::float_ keys_data[] = { 10., 5.5, 10., 7., 5.5}; + compute::int_ values_data[] = { 1, 200, -10, 2, 4 }; + + compute::vector<compute::float_> keys(keys_data, keys_data + 5, queue); + compute::vector<compute::uint_> values(values_data, values_data + 5, queue); + + BOOST_CHECK( + !compute::is_sorted( + keys.begin(), keys.end(), compute::greater<compute::float_>(), queue + ) + ); + compute::detail::radix_sort_by_key( + keys.begin(), keys.end(), values.begin(), descending, queue + ); + BOOST_CHECK( + compute::is_sorted( + keys.begin(), keys.end(), compute::greater<compute::float_>(), queue + ) + ); + + CHECK_RANGE_EQUAL( + compute::float_, 5, keys, + (10., 10., 7., 5.5, 5.5) // keys + // ( 1, -10, 2, 200, 4) values + ); + CHECK_RANGE_EQUAL( + compute::int_, 5, values, + // (10., 10., 7., 5.5, 5.5) // keys + ( 1, -10, 2, 200, 4) // values + ); +} + + +// radix_sort_by_key should be stable +BOOST_AUTO_TEST_CASE(stable_radix_sort_char_by_int) +{ + if(is_apple_cpu_device(device)) { + return; + } + + compute::int_ keys_data[] = { 6, 1, 1, 3, 4, 7, 5, 1 }; + compute::char_ values_data[] = { 'g', 'c', 'b', 'd', 'e', 'h', 'f', 'a' }; + + compute::vector<compute::int_> keys(keys_data, keys_data + 8, queue); + compute::vector<compute::char_> values(values_data, values_data + 8, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::detail::radix_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + + CHECK_RANGE_EQUAL( + compute::int_, 8, keys, + (1, 1, 1, 3, 4, 5, 6, 7) + ); + CHECK_RANGE_EQUAL( + compute::char_, 8, values, + ('c', 'b', 'a', 'd', 'e', 'f', 'g', 'h') + ); +} + +// radix_sort_by_key should be stable +BOOST_AUTO_TEST_CASE(stable_radix_sort_int2_by_int) +{ + if(is_apple_cpu_device(device)) { + return; + } + + compute::int_ keys_data[] = { 6, 1, 1, 3, 4, 7, 5, 1 }; + compute::int2_ values_data[] = { + compute::int2_(1, 1), // 6 + compute::int2_(1, 2), // 1 + compute::int2_(1, 3), // 1 + compute::int2_(1, 4), // 3 + compute::int2_(1, 5), // 4 + compute::int2_(1, 6), // 7 + compute::int2_(1, 7), // 5 + compute::int2_(1, 8) // 1 + }; + + compute::vector<compute::int_> keys(keys_data, keys_data + 8, queue); + compute::vector<compute::int2_> values(values_data, values_data + 8, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::detail::radix_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + + CHECK_RANGE_EQUAL( + compute::int_, 8, keys, + (1, 1, 1, 3, 4, 5, 6, 7) + ); + CHECK_RANGE_EQUAL( + compute::int2_, 8, values, + ( + compute::int2_(1, 2), + compute::int2_(1, 3), + compute::int2_(1, 8), + compute::int2_(1, 4), + compute::int2_(1, 5), + compute::int2_(1, 7), + compute::int2_(1, 1), + compute::int2_(1, 6) + ) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_random_fill.cpp b/src/boost/libs/compute/test/test_random_fill.cpp new file mode 100644 index 00000000..8d890e7d --- /dev/null +++ b/src/boost/libs/compute/test/test_random_fill.cpp @@ -0,0 +1,76 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestRandomFill +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/count_if.hpp> +#include <boost/compute/algorithm/detail/random_fill.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/lambda.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(random_fill_float) +{ + using compute::lambda::_1; + + compute::vector<float> vector(10, context); + + // fill with values between 0 and 1 + compute::detail::random_fill( + vector.begin(), + vector.end(), + 0.0f, + 1.0f, + queue + ); + + BOOST_CHECK_EQUAL( + compute::count_if( + vector.begin(), vector.end(), _1 < 0.0f || _1 > 1.0f, queue + ), + size_t(0) + ); + + // fill with values between 5 and 10 + compute::detail::random_fill( + vector.begin(), + vector.end(), + 5.0f, + 10.0f, + queue + ); + + BOOST_CHECK_EQUAL( + compute::count_if( + vector.begin(), vector.end(), _1 < 5.0f || _1 > 10.0f, queue + ), + size_t(0) + ); + + // fill with values between -25 and 25 + compute::detail::random_fill( + vector.begin(), vector.end(), -25.0f, 25.0f, queue + ); + + BOOST_CHECK_EQUAL( + compute::count_if( + vector.begin(), vector.end(), _1 < -25.0f || _1 > 25.0f, queue + ), + size_t(0) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_random_shuffle.cpp b/src/boost/libs/compute/test/test_random_shuffle.cpp new file mode 100644 index 00000000..69885aba --- /dev/null +++ b/src/boost/libs/compute/test/test_random_shuffle.cpp @@ -0,0 +1,54 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestRandomShuffle +#include <boost/test/unit_test.hpp> + +#include <set> +#include <iterator> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/random_shuffle.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(shuffle_int_vector) +{ + bc::vector<int> vector(context); + vector.push_back(1, queue); + vector.push_back(9, queue); + vector.push_back(19, queue); + vector.push_back(29, queue); + queue.finish(); + + std::set<int> original_values; + for(size_t i = 0; i < vector.size(); i++){ + original_values.insert(vector[i]); + } + BOOST_CHECK_EQUAL(original_values.size(), size_t(4)); + + bc::random_shuffle(vector.begin(), vector.end(), queue); + + std::set<int> shuffled_values; + bc::copy( + vector.begin(), + vector.end(), + std::inserter(shuffled_values, shuffled_values.begin()), + queue + ); + BOOST_CHECK_EQUAL(shuffled_values.size(), size_t(4)); + BOOST_VERIFY(original_values == shuffled_values); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_reduce.cpp b/src/boost/libs/compute/test/test_reduce.cpp new file mode 100644 index 00000000..c3855061 --- /dev/null +++ b/src/boost/libs/compute/test/test_reduce.cpp @@ -0,0 +1,298 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestReduce +#include <boost/test/unit_test.hpp> + +#include <boost/compute/lambda.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/algorithm/reduce.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/constant_iterator.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> +#include <boost/compute/iterator/transform_iterator.hpp> +#include <boost/compute/types/complex.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(reduce_int) +{ + int data[] = { 1, 5, 9, 13, 17 }; + compute::vector<int> vector(data, data + 5, queue); + int sum; + compute::reduce(vector.begin(), vector.end(), &sum, compute::plus<int>(), queue); + BOOST_CHECK_EQUAL(sum, 45); + + int product; + compute::reduce(vector.begin(), vector.end(), &product, compute::multiplies<int>(), queue); + BOOST_CHECK_EQUAL(product, 9945); +} + +BOOST_AUTO_TEST_CASE(reduce_empty_vector) +{ + compute::vector<short> vector(context); + + short sum = 0; + compute::reduce(vector.begin(), vector.end(), &sum, queue); + BOOST_CHECK_EQUAL(sum, short(0)); +} + +BOOST_AUTO_TEST_CASE(reduce_doctest) +{ + int data[] = { 1, 2, 3, 4 }; + boost::compute::vector<int> vec(data, data + 4, queue); + +//! [sum_int] +int sum = 0; +boost::compute::reduce(vec.begin(), vec.end(), &sum, queue); +//! [sum_int] + + BOOST_CHECK_EQUAL(sum, 10); +} + +BOOST_AUTO_TEST_CASE(reduce_twos) +{ + using compute::uint_; + + compute::vector<uint_> vector(8, context); + compute::fill(vector.begin(), vector.end(), uint_(2), queue); + + uint_ sum; + compute::reduce(vector.begin(), vector.end(), &sum, compute::plus<uint_>(), queue); + BOOST_CHECK_EQUAL(sum, uint_(16)); + + uint_ product; + compute::reduce(vector.begin(), vector.end(), &product, compute::multiplies<uint_>(), queue); + BOOST_CHECK_EQUAL(product, uint_(256)); +} + +BOOST_AUTO_TEST_CASE(reduce_on_device) +{ + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<int> input(data, data + 8, queue); + compute::vector<int> result(2, context); + compute::reduce(input.begin(), input.begin() + 4, result.begin(), queue); + compute::reduce(input.begin() + 4, input.end(), result.end() - 1, queue); + CHECK_RANGE_EQUAL(int, 2, result, (10, 26)); +} + +BOOST_AUTO_TEST_CASE(reduce_int_min_max) +{ + int data[] = { 11, 5, 92, 13, 42 }; + compute::vector<int> vector(data, data + 5, queue); + int min_value; + compute::reduce( + vector.begin(), + vector.end(), + &min_value, + compute::min<int>(), + queue + ); + BOOST_CHECK_EQUAL(min_value, 5); + + int max_value; + compute::reduce( + vector.begin(), + vector.end(), + &max_value, + compute::max<int>(), + queue + ); + BOOST_CHECK_EQUAL(max_value, 92); +} + +BOOST_AUTO_TEST_CASE(reduce_int2) +{ + std::vector<compute::int2_> data; + for(int i = 0; i < 6; i++){ + compute::int2_ value; + value[0] = i + 1; + value[1] = 2 * i + 1; + data.push_back(value); + } + + compute::vector<compute::int2_> vector(data.begin(), data.end(), queue); + + compute::int2_ sum; + compute::reduce( + vector.begin(), + vector.end(), + &sum, + queue + ); + BOOST_CHECK_EQUAL(sum, compute::int2_(21, 36)); +} + +BOOST_AUTO_TEST_CASE(reduce_pinned_vector) +{ + int data[] = { 2, 5, 8, 11, 15 }; + std::vector<int> vector(data, data + 5); + + compute::buffer buffer(context, + vector.size() * sizeof(int), + compute::buffer::read_only | compute::buffer::use_host_ptr, + &vector[0]); + + int sum; + compute::reduce( + compute::make_buffer_iterator<int>(buffer, 0), + compute::make_buffer_iterator<int>(buffer, 5), + &sum, + compute::plus<int>() + ); + BOOST_CHECK_EQUAL(sum, 41); +} + +BOOST_AUTO_TEST_CASE(reduce_constant_iterator) +{ + int result; + compute::reduce( + compute::make_constant_iterator(1, 0), + compute::make_constant_iterator(1, 5), + &result, + queue + ); + BOOST_CHECK_EQUAL(result, 5); + + compute::reduce( + compute::make_constant_iterator(3, 0), + compute::make_constant_iterator(3, 5), + &result, + queue + ); + BOOST_CHECK_EQUAL(result, 15); + + compute::reduce( + compute::make_constant_iterator(2, 0), + compute::make_constant_iterator(2, 5), + &result, + compute::multiplies<int>(), + queue + ); + BOOST_CHECK_EQUAL(result, 32); +} + +BOOST_AUTO_TEST_CASE(reduce_counting_iterator) +{ + int result; + compute::reduce( + compute::make_counting_iterator(1), + compute::make_counting_iterator(10), + &result, + queue + ); + BOOST_CHECK_EQUAL(result, 45); + + compute::reduce( + compute::make_counting_iterator(1), + compute::make_counting_iterator(5), + &result, + compute::multiplies<int>(), + queue + ); + BOOST_CHECK_EQUAL(result, 24); +} + +BOOST_AUTO_TEST_CASE(reduce_transform_iterator) +{ + using ::boost::compute::_1; + + int data[] = { 1, 3, 5, 7, 9 }; + compute::vector<int> vector(data, data + 5, queue); + + int sum; + compute::reduce( + compute::make_transform_iterator(vector.begin(), _1 + 1), + compute::make_transform_iterator(vector.end(), _1 + 1), + &sum, + queue + ); + BOOST_CHECK_EQUAL(sum, 30); + + compute::reduce( + compute::make_transform_iterator(vector.begin(), _1 > 4), + compute::make_transform_iterator(vector.end(), _1 > 4), + &sum, + compute::plus<int>(), + queue + ); + BOOST_CHECK_EQUAL(sum, 3); + + compute::reduce( + compute::make_transform_iterator(vector.begin(), _1 * _1), + compute::make_transform_iterator(vector.end(), _1 * _1), + &sum, + queue + ); + BOOST_CHECK_EQUAL(sum, 165); +} + +BOOST_AUTO_TEST_CASE(reduce_complex) +{ + std::vector<std::complex<float> > data; + data.push_back(std::complex<float>(1, 2)); + data.push_back(std::complex<float>(2, 4)); + data.push_back(std::complex<float>(3, 6)); + data.push_back(std::complex<float>(4, 8)); + + compute::vector<std::complex<float> > vector(data.size(), context); + compute::copy(data.begin(), data.end(), vector.begin(), queue); + + std::complex<float> result; + compute::reduce( + vector.begin(), vector.end(), &result, queue + ); + BOOST_CHECK(result == std::complex<float>(10, 20)); + + compute::reduce( + vector.begin(), vector.end(), &result, compute::plus<std::complex<float> >(), queue + ); + BOOST_CHECK(result == std::complex<float>(10, 20)); + + compute::reduce( + vector.begin(), vector.end(), &result, compute::multiplies<std::complex<float> >(), queue + ); + BOOST_CHECK(result == std::complex<float>(-168, -576)); +} + +BOOST_AUTO_TEST_CASE(reduce_uchar_to_float) +{ + compute::vector<compute::uchar_> data(context); + data.push_back(250, queue); + data.push_back(250, queue); + float sum = 0; + compute::reduce(data.begin(), data.end(), &sum, compute::plus<float>(), queue); + BOOST_CHECK_EQUAL(sum, 500); +} + +// Test case for https://github.com/boostorg/compute/issues/746 +BOOST_AUTO_TEST_CASE(buffer_reference_count_test) +{ + using compute::uint_; + + compute::vector<uint_> vector(8, context); + const compute::buffer& b = vector.get_buffer(); + uint_ rc1 = b.get_info<CL_MEM_REFERENCE_COUNT>(); + { + compute::fill(vector.begin(), vector.end(), uint_(2), queue); + + uint_ product; + compute::reduce(vector.begin(), vector.end(), &product, compute::multiplies<uint_>(), queue); + BOOST_CHECK_EQUAL(product, uint_(256)); + } + uint_ rc2 = b.get_info<CL_MEM_REFERENCE_COUNT>(); + BOOST_CHECK_EQUAL(rc1, rc2); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_reduce_by_key.cpp b/src/boost/libs/compute/test/test_reduce_by_key.cpp new file mode 100644 index 00000000..df34250f --- /dev/null +++ b/src/boost/libs/compute/test/test_reduce_by_key.cpp @@ -0,0 +1,210 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestReduceByKey +#include <boost/test/unit_test.hpp> + +#include <boost/compute/lambda.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/algorithm/inclusive_scan.hpp> +#include <boost/compute/algorithm/reduce_by_key.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(reduce_by_key_int) +{ +//! [reduce_by_key_int] +// setup keys and values +int keys[] = { 0, 2, -3, -3, -3, -3, -3, 4 }; +int data[] = { 1, 1, 1, 1, 1, 2, 5, 1 }; + +boost::compute::vector<int> keys_input(keys, keys + 8, queue); +boost::compute::vector<int> values_input(data, data + 8, queue); + +boost::compute::vector<int> keys_output(8, context); +boost::compute::vector<int> values_output(8, context); +// reduce by key +boost::compute::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), queue); +// keys_output = { 0, 2, -3, 4 } +// values_output = { 1, 1, 10, 1 } +//! [reduce_by_key_int] + CHECK_RANGE_EQUAL(int, 4, keys_output, (0, 2, -3, 4)); + CHECK_RANGE_EQUAL(int, 4, values_output, (1, 1, 10, 1)); +} + +BOOST_AUTO_TEST_CASE(reduce_by_key_int_long_vector) +{ + size_t size = 1024; + bc::vector<int> keys_input(size, int(0), queue); + bc::vector<int> values_input(size, int(1), queue); + + bc::vector<int> keys_output(size, context); + bc::vector<int> values_output(size, context); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), queue); + + CHECK_RANGE_EQUAL(int, 1, keys_output, (0)); + CHECK_RANGE_EQUAL(int, 1, values_output, (static_cast<int>(size))); + + keys_input[137] = 1; + keys_input[677] = 1; + keys_input[1001] = 1; + bc::inclusive_scan(keys_input.begin(), keys_input.end(), keys_input.begin(), queue); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), queue); + + CHECK_RANGE_EQUAL(int, 4, keys_output, (0, 1, 2, 3)); + CHECK_RANGE_EQUAL(int, 4, values_output, (137, 540, 324, 23)); +} + +BOOST_AUTO_TEST_CASE(reduce_by_key_empty_vector) +{ + bc::vector<int> keys_input(context); + bc::vector<int> values_input(context); + + bc::vector<int> keys_output(context); + bc::vector<int> values_output(context); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), queue); + + BOOST_CHECK(keys_output.empty()); + BOOST_CHECK(values_output.empty()); +} + +BOOST_AUTO_TEST_CASE(reduce_by_key_int_one_key_value) +{ + int keys[] = { 22 }; + int data[] = { -9 }; + + bc::vector<int> keys_input(keys, keys + 1, queue); + bc::vector<int> values_input(data, data + 1, queue); + + bc::vector<int> keys_output(1, context); + bc::vector<int> values_output(1, context); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), queue); + + CHECK_RANGE_EQUAL(int, 1, keys_output, (22)); + CHECK_RANGE_EQUAL(int, 1, values_output, (-9)); +} + +BOOST_AUTO_TEST_CASE(reduce_by_key_int_min_max) +{ + int keys[] = { 0, 2, 2, 3, 3, 3, 3, 3, 4 }; + int data[] = { 1, 2, 1, -3, 1, 4, 2, 5, 77 }; + + bc::vector<int> keys_input(keys, keys + 9, queue); + bc::vector<int> values_input(data, data + 9, queue); + + bc::vector<int> keys_output(9, context); + bc::vector<int> values_output(9, context); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), bc::min<int>(), + bc::equal_to<int>(), queue); + + CHECK_RANGE_EQUAL(int, 4, keys_output, (0, 2, 3, 4)); + CHECK_RANGE_EQUAL(int, 4, values_output, (1, 1, -3, 77)); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), bc::max<int>(), + bc::equal_to<int>(), queue); + + CHECK_RANGE_EQUAL(int, 4, keys_output, (0, 2, 3, 4)); + CHECK_RANGE_EQUAL(int, 4, values_output, (1, 2, 5, 77)); +} + +BOOST_AUTO_TEST_CASE(reduce_by_key_float_max) +{ + int keys[] = { 0, 2, 2, 3, 3, 3, 3, 3, 4 }; + float data[] = { 1.0, 2.0, -1.5, -3.0, 1.0, -0.24, 2, 5, 77.1 }; + + bc::vector<int> keys_input(keys, keys + 9, queue); + bc::vector<float> values_input(data, data + 9, queue); + + bc::vector<int> keys_output(9, context); + bc::vector<float> values_output(9, context); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), bc::max<float>(), + queue); + + CHECK_RANGE_EQUAL(int, 4, keys_output, (0, 2, 3, 4)); + BOOST_CHECK_CLOSE(float(values_output[0]), 1.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(values_output[1]), 2.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(values_output[2]), 5.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(values_output[3]), 77.1f, 1e-4f); +} + +BOOST_AUTO_TEST_CASE(reduce_by_key_int2) +{ + using bc::int2_; + + int keys[] = { 0, 2, 3, 3, 3, 3, 4, 4 }; + int2_ data[] = { + int2_(0, 1), int2_(-3, 2), int2_(0, 1), int2_(0, 1), + int2_(-3, 0), int2_(0, 0), int2_(-3, 2), int2_(-7, -2) + }; + + bc::vector<int> keys_input(keys, keys + 8, queue); + bc::vector<int2_> values_input(data, data + 8, queue); + + bc::vector<int> keys_output(8, context); + bc::vector<int2_> values_output(8, context); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), queue); + + CHECK_RANGE_EQUAL(int, 4, keys_output, (0, 2, 3, 4)); + CHECK_RANGE_EQUAL(int2_, 4, values_output, + (int2_(0, 1), int2_(-3, 2), int2_(-3, 2), int2_(-10, 0))); +} + +BOOST_AUTO_TEST_CASE(reduce_by_key_int2_long_vector) +{ + using bc::int2_; + + size_t size = 1024; + bc::vector<int> keys_input(size, int(0), queue); + bc::vector<int2_> values_input(size, int2_(1, -1), queue); + + bc::vector<int> keys_output(size, context); + bc::vector<int2_> values_output(size, context); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), queue); + + CHECK_RANGE_EQUAL(int, 1, keys_output, (0)); + CHECK_RANGE_EQUAL(int2_, 1, values_output, (int2_(int(size), -int(size)))); + + keys_input[137] = 1; + keys_input[677] = 1; + keys_input[1001] = 1; + bc::inclusive_scan(keys_input.begin(), keys_input.end(), keys_input.begin(), queue); + + bc::reduce_by_key(keys_input.begin(), keys_input.end(), values_input.begin(), + keys_output.begin(), values_output.begin(), queue); + + CHECK_RANGE_EQUAL(int, 4, keys_output, (0, 1, 2, 3)); + CHECK_RANGE_EQUAL(int2_, 4, values_output, + (int2_(137, -137), int2_(540, -540), int2_(324, -324), int2_(23, -23))); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_remove.cpp b/src/boost/libs/compute/test/test_remove.cpp new file mode 100644 index 00000000..5cb980bd --- /dev/null +++ b/src/boost/libs/compute/test/test_remove.cpp @@ -0,0 +1,55 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestRemove +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/remove.hpp> +#include <boost/compute/algorithm/remove_if.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(remove_int) +{ + int data[] = { 1, 2, 1, 3, 2, 4, 3, 4, 5 }; + bc::vector<int> vector(data, data + 9, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(9)); + + // remove 2's + bc::vector<int>::const_iterator iter = + bc::remove(vector.begin(), vector.end(), 2, queue); + BOOST_VERIFY(iter == vector.begin() + 7); + CHECK_RANGE_EQUAL(int, 7, vector, (1, 1, 3, 4, 3, 4, 5)); + + // remove 4's + iter = bc::remove(vector.begin(), vector.begin() + 7, 4, queue); + BOOST_VERIFY(iter == vector.begin() + 5); + CHECK_RANGE_EQUAL(int, 5, vector, (1, 1, 3, 3, 5)); + + // remove 1's + iter = bc::remove(vector.begin(), vector.begin() + 5, 1, queue); + BOOST_VERIFY(iter == vector.begin() + 3); + CHECK_RANGE_EQUAL(int, 3, vector, (3, 3, 5)); + + // remove 5's + iter = bc::remove(vector.begin(), vector.begin() + 3, 5, queue); + BOOST_VERIFY(iter == vector.begin() + 2); + CHECK_RANGE_EQUAL(int, 2, vector, (3, 3)); + + // remove 3's + iter = bc::remove(vector.begin(), vector.begin() + 2, 3, queue); + BOOST_VERIFY(iter == vector.begin()); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_replace.cpp b/src/boost/libs/compute/test/test_replace.cpp new file mode 100644 index 00000000..6ce5ffd6 --- /dev/null +++ b/src/boost/libs/compute/test/test_replace.cpp @@ -0,0 +1,53 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestReplace +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/algorithm/replace.hpp> +#include <boost/compute/algorithm/replace_copy.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(replace_int) +{ + bc::vector<int> vector(5, context); + bc::iota(vector.begin(), vector.end(), 0, queue); + CHECK_RANGE_EQUAL(int, 5, vector, (0, 1, 2, 3, 4)); + + bc::replace(vector.begin(), vector.end(), 2, 6, queue); + CHECK_RANGE_EQUAL(int, 5, vector, (0, 1, 6, 3, 4)); +} + +BOOST_AUTO_TEST_CASE(replace_copy_int) +{ + bc::vector<int> a(5, context); + bc::iota(a.begin(), a.end(), 0, queue); + CHECK_RANGE_EQUAL(int, 5, a, (0, 1, 2, 3, 4)); + + bc::vector<int> b(5, context); + bc::vector<int>::iterator iter = + bc::replace_copy(a.begin(), a.end(), b.begin(), 3, 9, queue); + BOOST_CHECK(iter == b.end()); + CHECK_RANGE_EQUAL(int, 5, b, (0, 1, 2, 9, 4)); + + // ensure 'a' was not modified + CHECK_RANGE_EQUAL(int, 5, a, (0, 1, 2, 3, 4)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_result_of.cpp b/src/boost/libs/compute/test/test_result_of.cpp new file mode 100644 index 00000000..e964c4de --- /dev/null +++ b/src/boost/libs/compute/test/test_result_of.cpp @@ -0,0 +1,40 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestResultOf +#include <boost/test/unit_test.hpp> + +#include <boost/compute/function.hpp> +#include <boost/compute/functional/operator.hpp> +#include <boost/compute/type_traits/result_of.hpp> + +BOOST_AUTO_TEST_CASE(result_of_function) +{ + using boost::compute::function; + using boost::compute::result_of; + + BOOST_STATIC_ASSERT(( + boost::is_same<result_of<function<int()>()>::type, int>::value + )); +} + +BOOST_AUTO_TEST_CASE(result_of_operators) +{ + using boost::compute::plus; + using boost::compute::minus; + using boost::compute::result_of; + + BOOST_STATIC_ASSERT(( + boost::is_same<result_of<plus<int>(int, int)>::type, int>::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same<result_of<minus<int>(int, int)>::type, int>::value + )); +} diff --git a/src/boost/libs/compute/test/test_reverse.cpp b/src/boost/libs/compute/test/test_reverse.cpp new file mode 100644 index 00000000..03ffe639 --- /dev/null +++ b/src/boost/libs/compute/test/test_reverse.cpp @@ -0,0 +1,93 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestReverse +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/algorithm/reverse.hpp> +#include <boost/compute/algorithm/reverse_copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(reverse_int) +{ + bc::vector<int> vector(5, context); + bc::iota(vector.begin(), vector.end(), 0, queue); + CHECK_RANGE_EQUAL(int, 5, vector, (0, 1, 2, 3, 4)); + + bc::reverse(vector.begin(), vector.end(), queue); + CHECK_RANGE_EQUAL(int, 5, vector, (4, 3, 2, 1, 0)); + + bc::reverse(vector.begin() + 1, vector.end(), queue); + CHECK_RANGE_EQUAL(int, 5, vector, (4, 0, 1, 2, 3)); + + bc::reverse(vector.begin() + 1, vector.end() - 1, queue); + CHECK_RANGE_EQUAL(int, 5, vector, (4, 2, 1, 0, 3)); + + bc::reverse(vector.begin(), vector.end() - 2, queue); + CHECK_RANGE_EQUAL(int, 5, vector, (1, 2, 4, 0, 3)); + + vector.resize(6, queue); + bc::iota(vector.begin(), vector.end(), 10, queue); + CHECK_RANGE_EQUAL(int, 6, vector, (10, 11, 12, 13, 14, 15)); + + bc::reverse(vector.begin(), vector.end(), queue); + CHECK_RANGE_EQUAL(int, 6, vector, (15, 14, 13, 12, 11, 10)); + + bc::reverse(vector.begin() + 3, vector.end(), queue); + CHECK_RANGE_EQUAL(int, 6, vector, (15, 14, 13, 10, 11, 12)); + + bc::reverse(vector.begin() + 1, vector.end() - 2, queue); + CHECK_RANGE_EQUAL(int, 6, vector, (15, 10, 13, 14, 11, 12)); +} + +BOOST_AUTO_TEST_CASE(reverse_copy_int) +{ + bc::vector<int> a(5, context); + bc::iota(a.begin(), a.end(), 0, queue); + CHECK_RANGE_EQUAL(int, 5, a, (0, 1, 2, 3, 4)); + + bc::vector<int> b(5, context); + bc::vector<int>::iterator iter = + bc::reverse_copy(a.begin(), a.end(), b.begin(), queue); + BOOST_CHECK(iter == b.end()); + CHECK_RANGE_EQUAL(int, 5, b, (4, 3, 2, 1, 0)); + + iter = bc::reverse_copy(b.begin() + 1, b.end(), a.begin() + 1, queue); + BOOST_CHECK(iter == a.end()); + CHECK_RANGE_EQUAL(int, 5, a, (0, 0, 1, 2, 3)); + + iter = bc::reverse_copy(a.begin(), a.end() - 1, b.begin(), queue); + BOOST_CHECK(iter == (b.end() - 1)); + CHECK_RANGE_EQUAL(int, 5, b, (2, 1, 0, 0, 0)); +} + +BOOST_AUTO_TEST_CASE(reverse_copy_counting_iterator) +{ + bc::vector<int> vector(5, context); + bc::reverse_copy( + bc::make_counting_iterator(1), + bc::make_counting_iterator(6), + vector.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 5, vector, (5, 4, 3, 2, 1)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_rotate.cpp b/src/boost/libs/compute/test/test_rotate.cpp new file mode 100644 index 00000000..cedec5d0 --- /dev/null +++ b/src/boost/libs/compute/test/test_rotate.cpp @@ -0,0 +1,69 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestRotate +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/rotate.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(rotate_trivial) +{ + int data[] = {1, 4, 2, 6, 3, 2, 5, 3, 4, 6}; + boost::compute::vector<int> vector(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::rotate(vector.begin(), vector.begin(), vector.end(), queue); + CHECK_RANGE_EQUAL(int, 10, vector, (1, 4, 2, 6, 3, 2, 5, 3, 4, 6)); + + boost::compute::rotate(vector.begin(), vector.end(), vector.end(), queue); + CHECK_RANGE_EQUAL(int, 10, vector, (1, 4, 2, 6, 3, 2, 5, 3, 4, 6)); +} + +BOOST_AUTO_TEST_CASE(rotate_1) +{ + int data[] = {1, 4, 2, 6, 3, 2, 5, 3, 4, 6}; + boost::compute::vector<int> vector(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::rotate(vector.begin(), vector.begin()+1, vector.end(), queue); + CHECK_RANGE_EQUAL(int, 10, vector, (4, 2, 6, 3, 2, 5, 3, 4, 6, 1)); +} + +BOOST_AUTO_TEST_CASE(rotate_4) +{ + int data[] = {1, 4, 2, 6, 3, 2, 5, 3, 4, 6}; + boost::compute::vector<int> vector(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::rotate(vector.begin(), vector.begin()+4, vector.end(), queue); + CHECK_RANGE_EQUAL(int, 10, vector, (3, 2, 5, 3, 4, 6, 1, 4, 2, 6)); +} + +BOOST_AUTO_TEST_CASE(rotate_9) +{ + int data[] = {1, 4, 2, 6, 3, 2, 5, 3, 4, 6}; + boost::compute::vector<int> vector(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::rotate(vector.begin(), vector.begin()+9, vector.end(), queue); + CHECK_RANGE_EQUAL(int, 10, vector, (6, 1, 4, 2, 6, 3, 2, 5, 3, 4)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_rotate_copy.cpp b/src/boost/libs/compute/test/test_rotate_copy.cpp new file mode 100644 index 00000000..14f67d7f --- /dev/null +++ b/src/boost/libs/compute/test/test_rotate_copy.cpp @@ -0,0 +1,73 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestRotateCopy +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/rotate_copy.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(rotate_copy_trivial) +{ + int data[] = {1, 4, 2, 6, 3, 2, 5, 3, 4, 6}; + boost::compute::vector<int> vector(10, context); + boost::compute::vector<int> result(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::rotate_copy(vector.begin(), vector.begin(), vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int, 10, result, (1, 4, 2, 6, 3, 2, 5, 3, 4, 6)); + + boost::compute::rotate_copy(vector.begin(), vector.end(), vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int, 10, result, (1, 4, 2, 6, 3, 2, 5, 3, 4, 6)); +} + +BOOST_AUTO_TEST_CASE(rotate_copy_1) +{ + int data[] = {1, 4, 2, 6, 3, 2, 5, 3, 4, 6}; + boost::compute::vector<int> vector(10, context); + boost::compute::vector<int> result(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::rotate_copy(vector.begin(), vector.begin()+1, vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int, 10, result, (4, 2, 6, 3, 2, 5, 3, 4, 6, 1)); +} + +BOOST_AUTO_TEST_CASE(rotate_copy_4) +{ + int data[] = {1, 4, 2, 6, 3, 2, 5, 3, 4, 6}; + boost::compute::vector<int> vector(10, context); + boost::compute::vector<int> result(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::rotate_copy(vector.begin(), vector.begin()+4, vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int, 10, result, (3, 2, 5, 3, 4, 6, 1, 4, 2, 6)); +} + +BOOST_AUTO_TEST_CASE(rotate_copy_9) +{ + int data[] = {1, 4, 2, 6, 3, 2, 5, 3, 4, 6}; + boost::compute::vector<int> vector(10, context); + boost::compute::vector<int> result(10, context); + + boost::compute::copy_n(data, 10, vector.begin(), queue); + + boost::compute::rotate_copy(vector.begin(), vector.begin()+9, vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int, 10, result, (6, 1, 4, 2, 6, 3, 2, 5, 3, 4)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_scan.cpp b/src/boost/libs/compute/test/test_scan.cpp new file mode 100644 index 00000000..1504ea06 --- /dev/null +++ b/src/boost/libs/compute/test/test_scan.cpp @@ -0,0 +1,490 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +// Undefining BOOST_COMPUTE_USE_OFFLINE_CACHE macro as we want to modify cached +// parameters for copy algorithm without any undesirable consequences (like +// saving modified values of those parameters). +#ifdef BOOST_COMPUTE_USE_OFFLINE_CACHE + #undef BOOST_COMPUTE_USE_OFFLINE_CACHE +#endif + +#define BOOST_TEST_MODULE TestScan +#include <boost/test/unit_test.hpp> + +#include <numeric> +#include <functional> +#include <vector> + +#include <boost/compute/functional.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/exclusive_scan.hpp> +#include <boost/compute/algorithm/inclusive_scan.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> +#include <boost/compute/iterator/transform_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(inclusive_scan_int) +{ + using boost::compute::uint_; + using boost::compute::int_; + + int_ data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; + bc::vector<int_> vector(data, data + 12, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(12)); + + bc::vector<int_> result(12, context); + BOOST_CHECK_EQUAL(result.size(), size_t(12)); + + // inclusive scan + bc::inclusive_scan(vector.begin(), vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int_, 12, result, (0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66)); + + // in-place inclusive scan + CHECK_RANGE_EQUAL(int_, 12, vector, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)); + bc::inclusive_scan(vector.begin(), vector.end(), vector.begin(), queue); + CHECK_RANGE_EQUAL(int_, 12, vector, (0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66)); + + // scan_on_cpu + + bc::copy(data, data + 12, vector.begin(), queue); + + // make sure parallel scan_on_cpu is used, no serial_scan + std::string cache_key = + "__boost_scan_cpu_4"; + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "serial_scan_threshold", 0); + // force parallel scan_on_cpu + parameters->set(cache_key, "serial_scan_threshold", 0); + + // inclusive scan + bc::inclusive_scan(vector.begin(), vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int_, 12, result, (0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66)); + + // in-place inclusive scan + CHECK_RANGE_EQUAL(int_, 12, vector, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)); + bc::inclusive_scan(vector.begin(), vector.end(), vector.begin(), queue); + CHECK_RANGE_EQUAL(int_, 12, vector, (0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66)); + + // restore + parameters->set(cache_key, "serial_scan_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(exclusive_scan_int) +{ + using boost::compute::uint_; + using boost::compute::int_; + + int_ data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; + bc::vector<int_> vector(data, data + 12, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(12)); + + bc::vector<int_> result(size_t(12), int_(0), queue); + BOOST_CHECK_EQUAL(result.size(), size_t(12)); + + // exclusive scan + bc::exclusive_scan(vector.begin(), vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int_, 12, result, (0, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)); + + // in-place exclusive scan + CHECK_RANGE_EQUAL(int_, 12, vector, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)); + bc::exclusive_scan(vector.begin(), vector.end(), vector.begin(), queue); + CHECK_RANGE_EQUAL(int_, 12, vector, (0, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)); + + // scan_on_cpu + bc::copy(data, data + 12, vector.begin(), queue); + + // make sure parallel scan_on_cpu is used, no serial_scan + std::string cache_key = + "__boost_scan_cpu_4"; + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "serial_scan_threshold", 0); + // force parallel scan_on_cpu + parameters->set(cache_key, "serial_scan_threshold", 0); + + // exclusive scan + bc::exclusive_scan(vector.begin(), vector.end(), result.begin(), queue); + CHECK_RANGE_EQUAL(int_, 12, result, (0, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)); + + // in-place exclusive scan + CHECK_RANGE_EQUAL(int_, 12, vector, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)); + bc::exclusive_scan(vector.begin(), vector.end(), vector.begin(), queue); + CHECK_RANGE_EQUAL(int_, 12, vector, (0, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55)); + + // restore + parameters->set(cache_key, "serial_scan_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(inclusive_scan_int2) +{ + using boost::compute::int_; + using boost::compute::uint_; + using boost::compute::int2_; + + int_ data[] = { 1, 2, + 3, 4, + 5, 6, + 7, 8, + 9, 0 }; + + boost::compute::vector<int2_> input(reinterpret_cast<int2_*>(data), + reinterpret_cast<int2_*>(data) + 5, + queue); + BOOST_CHECK_EQUAL(input.size(), size_t(5)); + + boost::compute::vector<int2_> output(5, context); + boost::compute::inclusive_scan(input.begin(), input.end(), output.begin(), + queue); + CHECK_RANGE_EQUAL( + int2_, 5, output, + (int2_(1, 2), int2_(4, 6), int2_(9, 12), int2_(16, 20), int2_(25, 20)) + ); + + // scan_on_cpu + + // make sure parallel scan_on_cpu is used, no serial_scan + std::string cache_key = + "__boost_scan_cpu_8"; + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "serial_scan_threshold", 0); + // force parallel scan_on_cpu + parameters->set(cache_key, "serial_scan_threshold", 0); + + boost::compute::inclusive_scan(input.begin(), input.end(), output.begin(), + queue); + CHECK_RANGE_EQUAL( + int2_, 5, output, + (int2_(1, 2), int2_(4, 6), int2_(9, 12), int2_(16, 20), int2_(25, 20)) + ); + + // restore + parameters->set(cache_key, "serial_scan_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(inclusive_scan_counting_iterator) +{ + using boost::compute::int_; + using boost::compute::uint_; + + bc::vector<int_> result(10, context); + bc::inclusive_scan(bc::make_counting_iterator(1), + bc::make_counting_iterator(11), + result.begin(), queue); + CHECK_RANGE_EQUAL(int_, 10, result, (1, 3, 6, 10, 15, 21, 28, 36, 45, 55)); + + // scan_on_cpu + + // make sure parallel scan_on_cpu is used, no serial_scan + std::string cache_key = + "__boost_scan_cpu_4"; + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "serial_scan_threshold", 0); + // force parallel scan_on_cpu + parameters->set(cache_key, "serial_scan_threshold", 0); + + bc::inclusive_scan(bc::make_counting_iterator(1), + bc::make_counting_iterator(11), + result.begin(), queue); + CHECK_RANGE_EQUAL(int_, 10, result, (1, 3, 6, 10, 15, 21, 28, 36, 45, 55)); + + // restore + parameters->set(cache_key, "serial_scan_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(exclusive_scan_counting_iterator) +{ + using boost::compute::int_; + using boost::compute::uint_; + + bc::vector<int_> result(10, context); + bc::exclusive_scan(bc::make_counting_iterator(1), + bc::make_counting_iterator(11), + result.begin(), queue); + CHECK_RANGE_EQUAL(int_, 10, result, (0, 1, 3, 6, 10, 15, 21, 28, 36, 45)); + + // scan_on_cpu + + // make sure parallel scan_on_cpu is used, no serial_scan + std::string cache_key = + "__boost_scan_cpu_4"; + boost::shared_ptr<bc::detail::parameter_cache> parameters = + bc::detail::parameter_cache::get_global_cache(device); + + // save + uint_ map_copy_threshold = + parameters->get(cache_key, "serial_scan_threshold", 0); + // force parallel scan_on_cpu + parameters->set(cache_key, "serial_scan_threshold", 0); + + bc::exclusive_scan(bc::make_counting_iterator(1), + bc::make_counting_iterator(11), + result.begin(), queue); + CHECK_RANGE_EQUAL(int_, 10, result, (0, 1, 3, 6, 10, 15, 21, 28, 36, 45)); + + // restore + parameters->set(cache_key, "serial_scan_threshold", map_copy_threshold); +} + +BOOST_AUTO_TEST_CASE(inclusive_scan_transform_iterator) +{ + float data[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; + bc::vector<float> input(data, data + 5, queue); + bc::vector<float> output(5, context); + + // normal inclusive scan of the input + bc::inclusive_scan(input.begin(), input.end(), output.begin(), queue); + queue.finish(); + BOOST_CHECK_CLOSE(float(output[0]), 1.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(output[1]), 3.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(output[2]), 6.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(output[3]), 10.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(output[4]), 15.0f, 1e-4f); + + // inclusive scan of squares of the input + using ::boost::compute::_1; + + bc::inclusive_scan(bc::make_transform_iterator(input.begin(), pown(_1, 2)), + bc::make_transform_iterator(input.end(), pown(_1, 2)), + output.begin(), queue); + queue.finish(); + BOOST_CHECK_CLOSE(float(output[0]), 1.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(output[1]), 5.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(output[2]), 14.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(output[3]), 30.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(output[4]), 55.0f, 1e-4f); +} + +BOOST_AUTO_TEST_CASE(inclusive_scan_doctest) +{ +//! [inclusive_scan_int] +// setup input +int data[] = { 1, 2, 3, 4 }; +boost::compute::vector<int> input(data, data + 4, queue); + +// setup output +boost::compute::vector<int> output(4, context); + +// scan values +boost::compute::inclusive_scan( + input.begin(), input.end(), output.begin(), queue +); + +// output = [ 1, 3, 6, 10 ] +//! [inclusive_scan_int] + + CHECK_RANGE_EQUAL(int, 4, output, (1, 3, 6, 10)); +} + +BOOST_AUTO_TEST_CASE(exclusive_scan_doctest) +{ +//! [exclusive_scan_int] +// setup input +int data[] = { 1, 2, 3, 4 }; +boost::compute::vector<int> input(data, data + 4, queue); + +// setup output +boost::compute::vector<int> output(4, context); + +// scan values +boost::compute::exclusive_scan( + input.begin(), input.end(), output.begin(), queue +); + +// output = [ 0, 1, 3, 6 ] +//! [exclusive_scan_int] + + CHECK_RANGE_EQUAL(int, 4, output, (0, 1, 3, 6)); +} + +BOOST_AUTO_TEST_CASE(inclusive_scan_int_multiplies) +{ +//! [inclusive_scan_int_multiplies] +// setup input +int data[] = { 1, 2, 1, 2, 3 }; +boost::compute::vector<int> input(data, data + 5, queue); + +// setup output +boost::compute::vector<int> output(5, context); + +// inclusive scan with multiplication +boost::compute::inclusive_scan( + input.begin(), input.end(), output.begin(), + boost::compute::multiplies<int>(), queue +); + +// output = [1, 2, 2, 4, 12] +//! [inclusive_scan_int_multiplies] + + BOOST_CHECK_EQUAL(input.size(), size_t(5)); + BOOST_CHECK_EQUAL(output.size(), size_t(5)); + + CHECK_RANGE_EQUAL(int, 5, output, (1, 2, 2, 4, 12)); + + // in-place inclusive scan + CHECK_RANGE_EQUAL(int, 5, input, (1, 2, 1, 2, 3)); + boost::compute::inclusive_scan(input.begin(), input.end(), input.begin(), + boost::compute::multiplies<int>(), queue); + CHECK_RANGE_EQUAL(int, 5, input, (1, 2, 2, 4, 12)); +} + +BOOST_AUTO_TEST_CASE(exclusive_scan_int_multiplies) +{ +//! [exclusive_scan_int_multiplies] +// setup input +int data[] = { 1, 2, 1, 2, 3 }; +boost::compute::vector<int> input(data, data + 5, queue); + +// setup output +boost::compute::vector<int> output(5, context); + +// exclusive_scan with multiplication +// initial value equals 10 +boost::compute::exclusive_scan( + input.begin(), input.end(), output.begin(), + int(10), boost::compute::multiplies<int>(), queue +); + +// output = [10, 10, 20, 20, 40] +//! [exclusive_scan_int_multiplies] + + BOOST_CHECK_EQUAL(input.size(), size_t(5)); + BOOST_CHECK_EQUAL(output.size(), size_t(5)); + + CHECK_RANGE_EQUAL(int, 5, output, (10, 10, 20, 20, 40)); + + // in-place exclusive scan + CHECK_RANGE_EQUAL(int, 5, input, (1, 2, 1, 2, 3)); + bc::exclusive_scan(input.begin(), input.end(), input.begin(), + int(10), bc::multiplies<int>(), queue); + CHECK_RANGE_EQUAL(int, 5, input, (10, 10, 20, 20, 40)); +} + +BOOST_AUTO_TEST_CASE(inclusive_scan_int_multiplies_long_vector) +{ + size_t size = 1000; + bc::vector<int> device_vector(size, int(2), queue); + BOOST_CHECK_EQUAL(device_vector.size(), size); + bc::inclusive_scan(device_vector.begin(), device_vector.end(), + device_vector.begin(), bc::multiplies<int>(), queue); + + std::vector<int> host_vector(size, 2); + BOOST_CHECK_EQUAL(host_vector.size(), size); + bc::copy(device_vector.begin(), device_vector.end(), + host_vector.begin(), queue); + + std::vector<int> test(size, 2); + BOOST_CHECK_EQUAL(test.size(), size); + std::partial_sum(test.begin(), test.end(), + test.begin(), std::multiplies<int>()); + + BOOST_CHECK_EQUAL_COLLECTIONS(host_vector.begin(), host_vector.end(), + test.begin(), test.end()); +} + +BOOST_AUTO_TEST_CASE(exclusive_scan_int_multiplies_long_vector) +{ + size_t size = 1000; + bc::vector<int> device_vector(size, int(2), queue); + BOOST_CHECK_EQUAL(device_vector.size(), size); + bc::exclusive_scan(device_vector.begin(), device_vector.end(), + device_vector.begin(), int(10), bc::multiplies<int>(), + queue); + + std::vector<int> host_vector(size, 2); + BOOST_CHECK_EQUAL(host_vector.size(), size); + bc::copy(device_vector.begin(), device_vector.end(), + host_vector.begin(), queue); + + std::vector<int> test(size, 2); + BOOST_CHECK_EQUAL(test.size(), size); + test[0] = 10; + std::partial_sum(test.begin(), test.end(), + test.begin(), std::multiplies<int>()); + + BOOST_CHECK_EQUAL_COLLECTIONS(host_vector.begin(), host_vector.end(), + test.begin(), test.end()); +} + +BOOST_AUTO_TEST_CASE(inclusive_scan_int_custom_function) +{ + BOOST_COMPUTE_FUNCTION(int, multi, (int x, int y), + { + return x * y * 2; + }); + + int data[] = { 1, 2, 1, 2, 3 }; + bc::vector<int> vector(data, data + 5, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(5)); + + bc::vector<int> result(5, context); + BOOST_CHECK_EQUAL(result.size(), size_t(5)); + + // inclusive scan + bc::inclusive_scan(vector.begin(), vector.end(), result.begin(), + multi, queue); + CHECK_RANGE_EQUAL(int, 5, result, (1, 4, 8, 32, 192)); + + // in-place inclusive scan + CHECK_RANGE_EQUAL(int, 5, vector, (1, 2, 1, 2, 3)); + bc::inclusive_scan(vector.begin(), vector.end(), vector.begin(), + multi, queue); + CHECK_RANGE_EQUAL(int, 5, vector, (1, 4, 8, 32, 192)); +} + +BOOST_AUTO_TEST_CASE(exclusive_scan_int_custom_function) +{ + BOOST_COMPUTE_FUNCTION(int, multi, (int x, int y), + { + return x * y * 2; + }); + + int data[] = { 1, 2, 1, 2, 3 }; + bc::vector<int> vector(data, data + 5, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(5)); + + bc::vector<int> result(5, context); + BOOST_CHECK_EQUAL(result.size(), size_t(5)); + + // exclusive_scan + bc::exclusive_scan(vector.begin(), vector.end(), result.begin(), + int(1), multi, queue); + CHECK_RANGE_EQUAL(int, 5, result, (1, 2, 8, 16, 64)); + + // in-place exclusive scan + CHECK_RANGE_EQUAL(int, 5, vector, (1, 2, 1, 2, 3)); + bc::exclusive_scan(vector.begin(), vector.end(), vector.begin(), + int(1), multi, queue); + CHECK_RANGE_EQUAL(int, 5, vector, (1, 2, 8, 16, 64)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_scatter.cpp b/src/boost/libs/compute/test/test_scatter.cpp new file mode 100644 index 00000000..00c74b22 --- /dev/null +++ b/src/boost/libs/compute/test/test_scatter.cpp @@ -0,0 +1,57 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestScatter +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/scatter.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/constant_buffer_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(scatter_int) +{ + int input_data[] = { 1, 2, 3, 4, 5 }; + bc::vector<int> input(input_data, input_data + 5, queue); + + int map_data[] = { 0, 4, 1, 3, 2 }; + bc::vector<int> map(map_data, map_data + 5, queue); + + bc::vector<int> output(5, context); + bc::scatter(input.begin(), input.end(), map.begin(), output.begin(), queue); + CHECK_RANGE_EQUAL(int, 5, output, (1, 3, 5, 4, 2)); +} + +BOOST_AUTO_TEST_CASE(scatter_constant_indices) +{ + int input_data[] = { 1, 2, 3, 4, 5 }; + bc::vector<int> input(input_data, input_data + 5, queue); + + int map_data[] = { 0, 4, 1, 3, 2 }; + bc::buffer map_buffer(context, + 5 * sizeof(int), + bc::buffer::read_only | bc::buffer::use_host_ptr, + map_data); + + bc::vector<int> output(5, context); + bc::scatter(input.begin(), + input.end(), + bc::make_constant_buffer_iterator<int>(map_buffer, 0), + output.begin(), + queue); + CHECK_RANGE_EQUAL(int, 5, output, (1, 3, 5, 4, 2)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_scatter_if.cpp b/src/boost/libs/compute/test/test_scatter_if.cpp new file mode 100644 index 00000000..1233f8c8 --- /dev/null +++ b/src/boost/libs/compute/test/test_scatter_if.cpp @@ -0,0 +1,141 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Pola <jakub.pola@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestScatterIf +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/scatter_if.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/constant_buffer_iterator.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> +#include <boost/compute/functional.hpp> +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(scatter_if_int) +{ + int input_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + bc::vector<int> input(input_data, input_data + 10, queue); + + int map_data[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; + + bc::vector<int> map(map_data, map_data + 10, queue); + + int stencil_data[] = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1}; + + bc::vector<bc::uint_> stencil(stencil_data, stencil_data + 10, queue); + + bc::vector<int> output(input.size(), -1, queue); + + bc::scatter_if(input.begin(), input.end(), + map.begin(), stencil.begin(), + output.begin(), + queue); + + CHECK_RANGE_EQUAL(int, 10, output, (9, -1, 7, -1, 5, -1, 3, -1, 1, -1) ); +} + +BOOST_AUTO_TEST_CASE(scatter_if_constant_indices) +{ + int input_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + bc::vector<int> input(input_data, input_data + 10, queue); + + int map_data[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; + bc::buffer map_buffer(context, + 10 * sizeof(int), + bc::buffer::read_only | bc::buffer::use_host_ptr, + map_data); + + int stencil_data[] = {0, 1, 0, 1, 0, 1, 0, 1, 0, 1}; + bc::buffer stencil_buffer(context, + 10 * sizeof(bc::uint_), + bc::buffer::read_only | bc::buffer::use_host_ptr, + stencil_data); + + bc::vector<int> output(input.size(), -1, queue); + + bc::scatter_if(input.begin(), + input.end(), + bc::make_constant_buffer_iterator<int>(map_buffer, 0), + bc::make_constant_buffer_iterator<int>(stencil_buffer, 0), + output.begin(), + queue); + + CHECK_RANGE_EQUAL(int, 10, output, (9, -1, 7, -1, 5, -1, 3, -1, 1, -1) ); +} + + +BOOST_AUTO_TEST_CASE(scatter_if_function) +{ + int input_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + bc::vector<int> input(input_data, input_data + 10, queue); + + int map_data[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; + bc::vector<int> map(map_data, map_data + 10, queue); + + int stencil_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + bc::vector<bc::uint_> stencil(stencil_data, stencil_data + 10, queue); + + bc::vector<int> output(input.size(), -1, queue); + + BOOST_COMPUTE_FUNCTION(int, gt_than_5, (int x), + { + if (x > 5) + return true; + else + return false; + }); + + bc::scatter_if(input.begin(), + input.end(), + map.begin(), + stencil.begin(), + output.begin(), + gt_than_5, + queue); + + CHECK_RANGE_EQUAL(int, 10, output, (9, 8, 7, 6, -1, -1, -1, -1, -1, -1) ); +} + + +BOOST_AUTO_TEST_CASE(scatter_if_counting_iterator) +{ + int input_data[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; + bc::vector<int> input(input_data, input_data + 10, queue); + + int map_data[] = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; + bc::vector<int> map(map_data, map_data + 10, queue); + + bc::vector<int> output(input.size(), -1, queue); + + BOOST_COMPUTE_FUNCTION(int, gt_than_5, (int x), + { + if (x > 5) + return true; + else + return false; + }); + + bc::scatter_if(input.begin(), + input.end(), + map.begin(), + bc::make_counting_iterator<int>(0), + output.begin(), + gt_than_5, + queue); + + CHECK_RANGE_EQUAL(int, 10, output, (9, 8, 7, 6, -1, -1, -1, -1, -1, -1) ); + +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_search.cpp b/src/boost/libs/compute/test/test_search.cpp new file mode 100644 index 00000000..51943625 --- /dev/null +++ b/src/boost/libs/compute/test/test_search.cpp @@ -0,0 +1,72 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSearch +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/search.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(search_int) +{ + int data[] = {1, 4, 2, 6, 3, 2, 6, 3, 4, 6, 6}; + bc::vector<bc::int_> vectort(data, data + 11, queue); + + int datap[] = {2, 6}; + bc::vector<bc::int_> vectorp(datap, datap + 2, queue); + + bc::vector<bc::int_>::iterator iter = + bc::search(vectort.begin(), vectort.end(), + vectorp.begin(), vectorp.end(), queue); + + BOOST_CHECK(iter == vectort.begin() + 2); + + vectorp[1] = 9; + + iter = + bc::search(vectort.begin(), vectort.end(), + vectorp.begin(), vectorp.end(), queue); + + BOOST_CHECK(iter == vectort.begin() + 11); + + vectorp[0] = 6; + vectorp[1] = 6; + + iter = + bc::search(vectort.begin(), vectort.end(), + vectorp.begin(), vectorp.end(), queue); + + BOOST_CHECK(iter == vectort.begin() + 9); +} + +BOOST_AUTO_TEST_CASE(search_string) +{ + char text[] = "sdabababacabskjabacab"; + bc::vector<bc::char_> vectort(text, text + 21, queue); + + char pattern[] = "aba"; + bc::vector<bc::char_> vectorp(pattern, pattern + 3, queue); + + bc::vector<bc::char_>::iterator iter = + bc::search(vectort.begin(), vectort.end(), + vectorp.begin(), vectorp.end(), queue); + + BOOST_CHECK(iter == vectort.begin() + 2); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_search_n.cpp b/src/boost/libs/compute/test/test_search_n.cpp new file mode 100644 index 00000000..c8b5af07 --- /dev/null +++ b/src/boost/libs/compute/test/test_search_n.cpp @@ -0,0 +1,56 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSearchN +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/search_n.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(search_int) +{ + int data[] = {1, 2, 2, 2, 3, 2, 2, 2, 4, 6, 6}; + bc::vector<bc::int_> vectort(data, data + 11, queue); + + bc::vector<bc::int_>::iterator iter = + bc::search_n(vectort.begin(), vectort.end(), 3, 2, queue); + + BOOST_CHECK(iter == vectort.begin() + 1); + + iter = + bc::search_n(vectort.begin(), vectort.end(), 5, 2, queue); + + BOOST_CHECK(iter == vectort.begin() + 11); + + iter = + bc::search_n(vectort.begin(), vectort.end(), 2, 6, queue); + + BOOST_CHECK(iter == vectort.begin() + 9); +} + +BOOST_AUTO_TEST_CASE(search_string) +{ + char text[] = "asaaababaaca"; + bc::vector<bc::char_> vectort(text, text + 12, queue); + + bc::vector<bc::char_>::iterator iter = + bc::search_n(vectort.begin(), vectort.end(), 2, 'a', queue); + + BOOST_CHECK(iter == vectort.begin() + 2); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_set_difference.cpp b/src/boost/libs/compute/test/test_set_difference.cpp new file mode 100644 index 00000000..d6ecb0a3 --- /dev/null +++ b/src/boost/libs/compute/test/test_set_difference.cpp @@ -0,0 +1,62 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSetDifference +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/set_difference.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(set_difference_int) +{ + int dataset1[] = {1, 1, 2, 2, 2, 2, 3, 3, 4, 5, 6, 10}; + bc::vector<bc::int_> set1(dataset1, dataset1 + 12, queue); + + int dataset2[] = {0, 2, 2, 4, 5, 6, 8, 8, 9, 9, 9, 13}; + bc::vector<bc::int_> set2(dataset2, dataset2 + 12, queue); + + bc::vector<bc::uint_>result(7, queue.get_context()); + + bc::vector<bc::uint_>::iterator iter = + bc::set_difference(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 12, + result.begin(), queue); + + CHECK_RANGE_EQUAL(int, 7, result, (1, 1, 2, 2, 3, 3, 10)); + BOOST_VERIFY(iter == result.begin()+7); +} + +BOOST_AUTO_TEST_CASE(set_difference_string) +{ + char string1[] = "abcccdddeeff"; + bc::vector<bc::char_> set1(string1, string1 + 12, queue); + + char string2[] = "bccdfgh"; + bc::vector<bc::char_> set2(string2, string2 + 7, queue); + + bc::vector<bc::char_>result(7, queue.get_context()); + + bc::vector<bc::char_>::iterator iter = + bc::set_difference(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 7, + result.begin(), queue); + + CHECK_RANGE_EQUAL(char, 7, result, ('a', 'c', 'd', 'd', 'e', 'e', 'f')); + BOOST_VERIFY(iter == result.begin()+7); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_set_intersection.cpp b/src/boost/libs/compute/test/test_set_intersection.cpp new file mode 100644 index 00000000..b33007b7 --- /dev/null +++ b/src/boost/libs/compute/test/test_set_intersection.cpp @@ -0,0 +1,62 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSetIntersection +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/set_intersection.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(set_intersection_int) +{ + int dataset1[] = {1, 1, 2, 2, 2, 2, 3, 3, 4, 5, 6, 10}; + bc::vector<bc::int_> set1(dataset1, dataset1 + 12, queue); + + int dataset2[] = {0, 2, 2, 4, 5, 6, 8, 8, 9, 9, 9, 13}; + bc::vector<bc::int_> set2(dataset2, dataset2 + 12, queue); + + bc::vector<bc::uint_>result(10, queue.get_context()); + + bc::vector<bc::uint_>::iterator iter = + bc::set_intersection(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 12, + result.begin(), queue); + + CHECK_RANGE_EQUAL(int, 5, result, (2, 2, 4, 5, 6)); + BOOST_VERIFY(iter == result.begin()+5); +} + +BOOST_AUTO_TEST_CASE(set_intersection_string) +{ + char string1[] = "abcccdddeeff"; + bc::vector<bc::char_> set1(string1, string1 + 12, queue); + + char string2[] = "bccdfgh"; + bc::vector<bc::char_> set2(string2, string2 + 7, queue); + + bc::vector<bc::char_>result(5, queue.get_context()); + + bc::vector<bc::char_>::iterator iter = + bc::set_intersection(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 7, + result.begin(), queue); + + CHECK_RANGE_EQUAL(char, 5, result, ('b', 'c', 'c', 'd', 'f')); + BOOST_VERIFY(iter == result.begin()+5); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_set_symmetric_difference.cpp b/src/boost/libs/compute/test/test_set_symmetric_difference.cpp new file mode 100644 index 00000000..f90a34b2 --- /dev/null +++ b/src/boost/libs/compute/test/test_set_symmetric_difference.cpp @@ -0,0 +1,63 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSetSymmetricDifference +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/set_symmetric_difference.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(set_symmetric_difference_int) +{ + int dataset1[] = {1, 1, 2, 2, 2, 2, 3, 3, 4, 5, 6, 10}; + bc::vector<bc::int_> set1(dataset1, dataset1 + 12, queue); + + int dataset2[] = {0, 2, 2, 4, 5, 6, 8, 8, 9, 9, 9, 13}; + bc::vector<bc::int_> set2(dataset2, dataset2 + 12, queue); + + bc::vector<bc::uint_>result(14, queue.get_context()); + + bc::vector<bc::uint_>::iterator iter = + bc::set_symmetric_difference(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 12, + result.begin(), queue); + + CHECK_RANGE_EQUAL(int, 14, result, (0, 1, 1, 2, 2, 3, 3, 8, + 8, 9, 9, 9, 10, 13)); + BOOST_VERIFY(iter == result.begin()+14); +} + +BOOST_AUTO_TEST_CASE(set_symmetric_difference_string) +{ + char string1[] = "abcccdddeeff"; + bc::vector<bc::char_> set1(string1, string1 + 12, queue); + + char string2[] = "bccdfgh"; + bc::vector<bc::char_> set2(string2, string2 + 7, queue); + + bc::vector<bc::char_>result(9, queue.get_context()); + + bc::vector<bc::char_>::iterator iter = + bc::set_symmetric_difference(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 7, + result.begin(), queue); + + CHECK_RANGE_EQUAL(char, 9, result, ('a', 'c', 'd', 'd', 'e', 'e', 'f', 'g', 'h')); + BOOST_VERIFY(iter == result.begin()+9); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_set_union.cpp b/src/boost/libs/compute/test/test_set_union.cpp new file mode 100644 index 00000000..f3c6dedb --- /dev/null +++ b/src/boost/libs/compute/test/test_set_union.cpp @@ -0,0 +1,64 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSetUnion +#include <boost/test/unit_test.hpp> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/set_union.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(set_union_int) +{ + int dataset1[] = {1, 1, 2, 2, 2, 2, 3, 3, 4, 5, 6, 10}; + bc::vector<bc::int_> set1(dataset1, dataset1 + 12, queue); + + int dataset2[] = {0, 2, 2, 4, 5, 6, 8, 8, 9, 9, 9, 13}; + bc::vector<bc::int_> set2(dataset2, dataset2 + 12, queue); + + bc::vector<bc::uint_>result(19, queue.get_context()); + + bc::vector<bc::uint_>::iterator iter = + bc::set_union(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 12, + result.begin(), queue); + + CHECK_RANGE_EQUAL(int, 19, result, (0, 1, 1, 2, 2, 2, 2, 3, 3, 4, + 5, 6, 8, 8, 9, 9, 9, 10, 13)); + BOOST_VERIFY(iter == result.begin()+19); +} + +BOOST_AUTO_TEST_CASE(set_union_string) +{ + char string1[] = "abcccdddeeff"; + bc::vector<bc::char_> set1(string1, string1 + 12, queue); + + char string2[] = "bccdfgh"; + bc::vector<bc::char_> set2(string2, string2 + 7, queue); + + bc::vector<bc::char_>result(14, queue.get_context()); + + bc::vector<bc::char_>::iterator iter = + bc::set_union(set1.begin(), set1.begin() + 12, + set2.begin(), set2.begin() + 7, + result.begin(), queue); + + CHECK_RANGE_EQUAL(char, 14, result, ('a', 'b', 'c', 'c', 'c', 'd', 'd', 'd', + 'e', 'e', 'f', 'f', 'g', 'h')); + BOOST_VERIFY(iter == result.begin()+14); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_sort.cpp b/src/boost/libs/compute/test/test_sort.cpp new file mode 100644 index 00000000..3b3a76f7 --- /dev/null +++ b/src/boost/libs/compute/test/test_sort.cpp @@ -0,0 +1,367 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSort +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/struct.hpp> + +struct Particle +{ + Particle(): x(0.f), y(0.f) { } + Particle(float _x, float _y): x(_x), y(_y) { } + + float x; + float y; +}; + +// adapt struct for OpenCL +BOOST_COMPUTE_ADAPT_STRUCT(Particle, Particle, (x, y)) + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +// test trivial sorting of zero and one element vectors +BOOST_AUTO_TEST_CASE(sort_int_0_and_1) +{ + boost::compute::vector<int> vec(context); + BOOST_CHECK_EQUAL(vec.size(), size_t(0)); + BOOST_CHECK(boost::compute::is_sorted(vec.begin(), vec.end(), queue) == true); + boost::compute::sort(vec.begin(), vec.end(), queue); + + vec.push_back(11, queue); + BOOST_CHECK_EQUAL(vec.size(), size_t(1)); + BOOST_CHECK(boost::compute::is_sorted(vec.begin(), vec.end(), queue) == true); + boost::compute::sort(vec.begin(), vec.end(), queue); +} + +// test sorting of two element int vectors +BOOST_AUTO_TEST_CASE(sort_int_2) +{ + int data[] = { 4, 2 }; + boost::compute::vector<int> vec(data, data + 2, queue); + + // check that vec is unsorted + BOOST_CHECK(boost::compute::is_sorted(vec.begin(), vec.end(), queue) == false); + + // sort vec + boost::compute::sort(vec.begin(), vec.end(), queue); + + // check that vec is sorted + BOOST_CHECK(boost::compute::is_sorted(vec.begin(), vec.end(), queue) == true); + + // sort already sorted vec and ensure it is still sorted + boost::compute::sort(vec.begin(), vec.end()); + BOOST_CHECK(boost::compute::is_sorted(vec.begin(), vec.end(), queue) == true); +} + +BOOST_AUTO_TEST_CASE(sort_float_3) +{ + float data[] = { 2.3f, 0.1f, 1.2f }; + boost::compute::vector<float> vec(data, data + 3, queue); + boost::compute::sort(vec.begin(), vec.end(), queue); + CHECK_RANGE_EQUAL(float, 3, vec, (0.1f, 1.2f, 2.3f)); +} + +BOOST_AUTO_TEST_CASE(sort_char_vector) +{ + using boost::compute::char_; + + char_ data[] = { 'c', 'a', '0', '7', 'B', 'F', '\0', '$' }; + boost::compute::vector<char_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(char_, 8, vector, ('\0', '$', '0', '7', 'B', 'F', 'a', 'c')); +} + +BOOST_AUTO_TEST_CASE(sort_uchar_vector) +{ + using boost::compute::uchar_; + + uchar_ data[] = { 0x12, 0x00, 0xFF, 0xB4, 0x80, 0x32, 0x64, 0xA2 }; + boost::compute::vector<uchar_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(uchar_, 8, vector, (0x00, 0x12, 0x32, 0x64, 0x80, 0xA2, 0xB4, 0xFF)); +} + +BOOST_AUTO_TEST_CASE(sort_short_vector) +{ + using boost::compute::short_; + + short_ data[] = { -4, 152, -94, 963, 31002, -456, 0, -2113 }; + boost::compute::vector<short_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(short_, 8, vector, (-2113, -456, -94, -4, 0, 152, 963, 31002)); +} + +BOOST_AUTO_TEST_CASE(sort_ushort_vector) +{ + using boost::compute::ushort_; + + ushort_ data[] = { 4, 152, 94, 963, 63202, 34560, 0, 2113 }; + boost::compute::vector<ushort_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(ushort_, 8, vector, (0, 4, 94, 152, 963, 2113, 34560, 63202)); +} + +BOOST_AUTO_TEST_CASE(sort_int_vector) +{ + int data[] = { -4, 152, -5000, 963, 75321, -456, 0, 1112 }; + boost::compute::vector<int> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(int, 8, vector, (-5000, -456, -4, 0, 152, 963, 1112, 75321)); +} + +BOOST_AUTO_TEST_CASE(sort_uint_vector) +{ + using boost::compute::uint_; + + uint_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<uint_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(uint_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_long_vector) +{ + using boost::compute::long_; + + long_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<long_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(long_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_ulong_vector) +{ + using boost::compute::ulong_; + + ulong_ data[] = { 500, 1988, 123456, 562, 0, 4000000, 9852, 102030 }; + boost::compute::vector<ulong_> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(ulong_, 8, vector, (0, 500, 562, 1988, 9852, 102030, 123456, 4000000)); +} + +BOOST_AUTO_TEST_CASE(sort_float_vector) +{ + float data[] = { -6023.0f, 152.5f, -63.0f, 1234567.0f, 11.2f, + -5000.1f, 0.0f, 14.0f, -8.25f, -0.0f }; + boost::compute::vector<float> vector(data, data + 10, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(10)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL( + float, 10, vector, + (-6023.0f, -5000.1f, -63.0f, -8.25f, -0.0f, 0.0f, 11.2f, 14.0f, 152.5f, 1234567.0f) + ); +} + +BOOST_AUTO_TEST_CASE(sort_double_vector) +{ + if(!device.supports_extension("cl_khr_fp64")){ + std::cout << "skipping test: device does not support double" << std::endl; + return; + } + + double data[] = { -6023.0, 152.5, -63.0, 1234567.0, 11.2, + -5000.1, 0.0, 14.0, -8.25, -0.0 }; + boost::compute::vector<double> vector(data, data + 10, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(10)); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + boost::compute::sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(boost::compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL( + double, 10, vector, + (-6023.0, -5000.1, -63.0, -8.25, -0.0, 0.0, 11.2, 14.0, 152.5, 1234567.0) + ); + +} + +BOOST_AUTO_TEST_CASE(reverse_sort_int_vector) +{ + int data[] = { -4, 152, -5000, 963, 75321, -456, 0, 1112 }; + boost::compute::vector<int> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + + boost::compute::sort(vector.begin(), vector.end(), + boost::compute::greater<int>(), queue); + CHECK_RANGE_EQUAL(int, 8, vector, (75321, 1112, 963, 152, 0, -4, -456, -5000)); +} + +BOOST_AUTO_TEST_CASE(sort_vectors_by_length) +{ + using boost::compute::float2_; + using boost::compute::lambda::_1; + using boost::compute::lambda::_2; + + float data[] = { 1.0f, 0.2f, + 1.3f, 1.0f, + 6.7f, 0.0f, + 5.2f, 3.4f, + 1.4f, 1.4f }; + + // create vector on device containing vectors + boost::compute::vector<float2_> vector( + reinterpret_cast<float2_ *>(data), + reinterpret_cast<float2_ *>(data) + 5, + queue + ); + + // sort vectors by length + boost::compute::sort( + vector.begin(), + vector.end(), + length(_1) < length(_2), + queue + ); + + // copy sorted values back to host + boost::compute::copy( + vector.begin(), + vector.end(), + reinterpret_cast<float2_ *>(data), + queue + ); + + // check values + BOOST_CHECK_EQUAL(data[0], 1.0f); + BOOST_CHECK_EQUAL(data[1], 0.2f); + BOOST_CHECK_EQUAL(data[2], 1.3f); + BOOST_CHECK_EQUAL(data[3], 1.0f); + BOOST_CHECK_EQUAL(data[4], 1.4f); + BOOST_CHECK_EQUAL(data[5], 1.4f); + BOOST_CHECK_EQUAL(data[6], 5.2f); + BOOST_CHECK_EQUAL(data[7], 3.4f); + BOOST_CHECK_EQUAL(data[8], 6.7f); + BOOST_CHECK_EQUAL(data[9], 0.0f); +} + +BOOST_AUTO_TEST_CASE(sort_host_vector) +{ + int data[] = { 5, 2, 3, 6, 7, 4, 0, 1 }; + std::vector<int> vector(data, data + 8); + boost::compute::sort(vector.begin(), vector.end(), queue); + CHECK_RANGE_EQUAL(int, 8, vector, (0, 1, 2, 3, 4, 5, 6, 7)); +} + +BOOST_AUTO_TEST_CASE(sort_custom_struct) +{ + // function to compare particles by their x-coordinate + BOOST_COMPUTE_FUNCTION(bool, sort_by_x, (Particle a, Particle b), + { + return a.x < b.x; + }); + + std::vector<Particle> particles; + particles.push_back(Particle(0.1f, 0.f)); + particles.push_back(Particle(-0.4f, 0.f)); + particles.push_back(Particle(10.0f, 0.f)); + particles.push_back(Particle(0.001f, 0.f)); + + boost::compute::vector<Particle> vector(4, context); + boost::compute::copy(particles.begin(), particles.end(), vector.begin(), queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(4)); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), + sort_by_x, queue) == false + ); + + boost::compute::sort(vector.begin(), vector.end(), sort_by_x, queue); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), + sort_by_x, queue) == true + ); + boost::compute::copy(vector.begin(), vector.end(), particles.begin(), queue); + BOOST_CHECK_CLOSE(particles[0].x, -0.4f, 0.1); + BOOST_CHECK_CLOSE(particles[1].x, 0.001f, 0.1); + BOOST_CHECK_CLOSE(particles[2].x, 0.1f, 0.1); + BOOST_CHECK_CLOSE(particles[3].x, 10.0f, 0.1); +} + +BOOST_AUTO_TEST_CASE(sort_int2) +{ + using bc::int2_; + + BOOST_COMPUTE_FUNCTION(bool, sort_int2, (int2_ a, int2_ b), + { + return a.x < b.x; + }); + + const size_t size = 100; + std::vector<int2_> host(size, int2_(0, 0)); + host[0] = int2_(100.f, 0.f); + host[size/4] = int2_(20.f, 0.f); + host[(size*3)/4] = int2_(9.f, 0.f); + host[size-3] = int2_(-10.0f, 0.f); + host[size/2+1] = int2_(-10.0f, -1.f); + + boost::compute::vector<int2_> vector(size, context); + boost::compute::copy(host.begin(), host.end(), vector.begin(), queue); + BOOST_CHECK_EQUAL(vector.size(), size); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), + sort_int2, queue) == false + ); + + boost::compute::sort(vector.begin(), vector.end(), sort_int2, queue); + BOOST_CHECK( + boost::compute::is_sorted(vector.begin(), vector.end(), + sort_int2, queue) == true + ); + boost::compute::copy(vector.begin(), vector.end(), host.begin(), queue); + BOOST_CHECK_CLOSE(host[0][0], -10.f, 0.1); + BOOST_CHECK_CLOSE(host[1][0], -10.f, 0.1); + BOOST_CHECK_CLOSE(host[(size - 3)][0], 9.f, 0.1); + BOOST_CHECK_CLOSE(host[(size - 2)][0], 20.f, 0.1); + BOOST_CHECK_CLOSE(host[(size - 1)][0], 100.f, 0.1); + BOOST_CHECK_NE(host[0], host[1]); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_sort_by_key.cpp b/src/boost/libs/compute/test/test_sort_by_key.cpp new file mode 100644 index 00000000..978d81d3 --- /dev/null +++ b/src/boost/libs/compute/test/test_sort_by_key.cpp @@ -0,0 +1,207 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSortByKey +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/sort_by_key.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/struct.hpp> + +struct custom_struct +{ + boost::compute::int_ x; + boost::compute::int_ y; + boost::compute::float2_ zw; +}; + +BOOST_COMPUTE_ADAPT_STRUCT(custom_struct, custom_struct, (x, y, zw)) + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +// test trivial sorting of zero element vectors +BOOST_AUTO_TEST_CASE(sort_int_0) +{ + compute::vector<int> keys(context); + compute::vector<int> values(context); + BOOST_CHECK_EQUAL(keys.size(), size_t(0)); + BOOST_CHECK_EQUAL(values.size(), size_t(0)); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end()) == true); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end()) == true); + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue); +} + +// test trivial sorting of one element vectors +BOOST_AUTO_TEST_CASE(sort_int_1) +{ + int keys_data[] = { 11 }; + int values_data[] = { 100 }; + + compute::vector<int> keys(keys_data, keys_data + 1, queue); + compute::vector<int> values(values_data, values_data + 1, queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == true); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue) == true); + + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue); +} + +// test trivial sorting of two element vectors +BOOST_AUTO_TEST_CASE(sort_int_2) +{ + int keys_data[] = { 4, 2 }; + int values_data[] = { 42, 24 }; + + compute::vector<int> keys(keys_data, keys_data + 2, queue); + compute::vector<int> values(values_data, values_data + 2, queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == false); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue) == false); + + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == true); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue) == true); +} + +BOOST_AUTO_TEST_CASE(sort_char_by_int) +{ + int keys_data[] = { 6, 2, 1, 3, 4, 7, 5, 0 }; + compute::char_ values_data[] = { 'g', 'c', 'b', 'd', 'e', 'h', 'f', 'a' }; + + compute::vector<int> keys(keys_data, keys_data + 8, queue); + compute::vector<compute::char_> values(values_data, values_data + 8, queue); + + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + + CHECK_RANGE_EQUAL(int, 8, keys, (0, 1, 2, 3, 4, 5, 6, 7)); + CHECK_RANGE_EQUAL(compute::char_, 8, values, ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h')); +} + +BOOST_AUTO_TEST_CASE(sort_int_and_float) +{ + int n = 1024; + std::vector<int> host_keys(n); + std::vector<float> host_values(n); + for(int i = 0; i < n; i++){ + host_keys[i] = n - i; + host_values[i] = (n - i) / 2.f; + } + + compute::vector<int> keys(host_keys.begin(), host_keys.end(), queue); + compute::vector<float> values(host_values.begin(), host_values.end(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == false); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue) == false); + + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == true); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue) == true); +} + +BOOST_AUTO_TEST_CASE(sort_int_and_float_custom_comparison_func) +{ + using boost::compute::int_; + using boost::compute::float_; + + int n = 1024; + std::vector<int_> host_keys(n); + std::vector<float_> host_values(n); + for(int i = 0; i < n; i++){ + host_keys[i] = n - i; + host_values[i] = (n - i) / 2.f; + } + + BOOST_COMPUTE_FUNCTION(bool, sort_int, (int_ a, int_ b), + { + return a < b; + }); + + compute::vector<int_> keys(host_keys.begin(), host_keys.end(), queue); + compute::vector<float_> values(host_values.begin(), host_values.end(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), sort_int, queue) == false); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue) == false); + + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), sort_int, queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), sort_int, queue) == true); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue) == true); +} + +BOOST_AUTO_TEST_CASE(sort_int_and_float2) +{ + using boost::compute::int_; + using boost::compute::float2_; + + int n = 1024; + std::vector<int_> host_keys(n); + std::vector<float2_> host_values(n); + for(int i = 0; i < n; i++){ + host_keys[i] = n - i; + host_values[i] = float2_((n - i) / 2.f); + } + + BOOST_COMPUTE_FUNCTION(bool, sort_float2, (float2_ a, float2_ b), + { + return a.x < b.x; + }); + + compute::vector<int_> keys(host_keys.begin(), host_keys.end(), queue); + compute::vector<float2_> values(host_values.begin(), host_values.end(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == false); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), sort_float2, queue) == false); + + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == true); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), sort_float2, queue) == true); +} + +BOOST_AUTO_TEST_CASE(sort_custom_struct_by_int) +{ + using boost::compute::int_; + using boost::compute::float2_; + + int_ n = 1024; + std::vector<int_> host_keys(n); + std::vector<custom_struct> host_values(n); + for(int_ i = 0; i < n; i++){ + host_keys[i] = n - i; + host_values[i].x = n - i; + host_values[i].y = n - i; + host_values[i].zw = float2_((n - i) / 0.5f); + } + + BOOST_COMPUTE_FUNCTION(bool, sort_custom_struct, (custom_struct a, custom_struct b), + { + return a.x < b.x; + }); + + compute::vector<int_> keys(host_keys.begin(), host_keys.end(), queue); + compute::vector<custom_struct> values(host_values.begin(), host_values.end(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == false); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), sort_custom_struct, queue) == false); + + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue) == true); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), sort_custom_struct, queue) == true); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_sort_by_transform.cpp b/src/boost/libs/compute/test/test_sort_by_transform.cpp new file mode 100644 index 00000000..25076060 --- /dev/null +++ b/src/boost/libs/compute/test/test_sort_by_transform.cpp @@ -0,0 +1,110 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSortByTransform +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/experimental/sort_by_transform.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(sort_int_by_abs) +{ + int data[] = { 1, -2, 4, -3, 0, 5, -8, -9 }; + compute::vector<int> vector(data, data + 8, queue); + + compute::experimental::sort_by_transform( + vector.begin(), + vector.end(), + compute::abs<int>(), + compute::less<int>(), + queue + ); + + CHECK_RANGE_EQUAL(int, 8, vector, (0, 1, -2, -3, 4, 5, -8, -9)); +} + +BOOST_AUTO_TEST_CASE(sort_vectors_by_length) +{ + using compute::float4_; + + float data[] = { + 1.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 1.0f, 1.0f, 0.0f, + 3.0f, 2.0f, 1.0f, 0.0f, + 0.0f, 0.0f, 0.5f, 0.0f + }; + + compute::vector<float4_> vector(4, context); + compute::copy_n( + reinterpret_cast<float4_ *>(data), 4, vector.begin(), queue + ); + + compute::experimental::sort_by_transform( + vector.begin(), + vector.end(), + compute::length<float4_>(), + compute::less<float>(), + queue + ); + + std::vector<float4_> host_vector(4); + compute::copy( + vector.begin(), vector.end(), host_vector.begin(), queue + ); + BOOST_CHECK_EQUAL(host_vector[0], float4_(0.0f, 0.0f, 0.5f, 0.0f)); + BOOST_CHECK_EQUAL(host_vector[1], float4_(1.0f, 0.0f, 0.0f, 0.0f)); + BOOST_CHECK_EQUAL(host_vector[2], float4_(0.0f, 1.0f, 1.0f, 0.0f)); + BOOST_CHECK_EQUAL(host_vector[3], float4_(3.0f, 2.0f, 1.0f, 0.0f)); +} + +BOOST_AUTO_TEST_CASE(sort_vectors_by_component) +{ + using compute::float4_; + + float data[] = { + 1.0f, 2.0f, 3.0f, 0.0f, + 9.0f, 8.0f, 7.0f, 0.0f, + 4.0f, 5.0f, 6.0f, 0.0f, + 0.0f, 0.0f, 0.0f, 0.0f + }; + + compute::vector<float4_> vector(4, context); + compute::copy_n( + reinterpret_cast<float4_ *>(data), 4, vector.begin(), queue + ); + + // sort by y-component + compute::experimental::sort_by_transform( + vector.begin(), + vector.end(), + compute::get<1>(), + compute::less<float>(), + queue + ); + + std::vector<float4_> host_vector(4); + compute::copy( + vector.begin(), vector.end(), host_vector.begin(), queue + ); + BOOST_CHECK_EQUAL(host_vector[0], float4_(0.0f, 0.0f, 0.0f, 0.0f)); + BOOST_CHECK_EQUAL(host_vector[1], float4_(1.0f, 2.0f, 3.0f, 0.0f)); + BOOST_CHECK_EQUAL(host_vector[2], float4_(4.0f, 5.0f, 6.0f, 0.0f)); + BOOST_CHECK_EQUAL(host_vector[3], float4_(9.0f, 8.0f, 7.0f, 0.0f)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_stable_partition.cpp b/src/boost/libs/compute/test/test_stable_partition.cpp new file mode 100644 index 00000000..08f1fc23 --- /dev/null +++ b/src/boost/libs/compute/test/test_stable_partition.cpp @@ -0,0 +1,38 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestStablePartition +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/stable_partition.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(partition_int) +{ + int dataset[] = {1, 1, -2, 0, 5, -1, 2, 4, 0, -1}; + bc::vector<bc::int_> vector(dataset, dataset + 10, queue); + + bc::vector<bc::int_>::iterator iter = + bc::stable_partition(vector.begin(), vector.begin() + 10, + bc::_1 > 0, queue); + + CHECK_RANGE_EQUAL(int, 10, vector, (1, 1, 5, 2, 4, -2, 0, -1, 0, -1)); + BOOST_VERIFY(iter == vector.begin()+5); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_stable_sort.cpp b/src/boost/libs/compute/test/test_stable_sort.cpp new file mode 100644 index 00000000..d0c573c7 --- /dev/null +++ b/src/boost/libs/compute/test/test_stable_sort.cpp @@ -0,0 +1,92 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestStableSort +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/stable_sort.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(sort_int_vector) +{ + int data[] = { -4, 152, -5000, 963, 75321, -456, 0, 1112 }; + compute::vector<int> vector(data, data + 8, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(8)); + BOOST_CHECK(compute::is_sorted(vector.begin(), vector.end(), queue) == false); + + compute::stable_sort(vector.begin(), vector.end(), queue); + BOOST_CHECK(compute::is_sorted(vector.begin(), vector.end(), queue) == true); + CHECK_RANGE_EQUAL(int, 8, vector, (-5000, -456, -4, 0, 152, 963, 1112, 75321)); + + // sort reversed + compute::stable_sort(vector.begin(), vector.end(), compute::greater<int>(), queue); + CHECK_RANGE_EQUAL(int, 8, vector, (75321, 1112, 963, 152, 0, -4, -456, -5000)); +} + +BOOST_AUTO_TEST_CASE(sort_int2) +{ + using compute::int2_; + + // device vector of int2's + compute::vector<int2_> vec(context); + vec.push_back(int2_(2, 1), queue); + vec.push_back(int2_(2, 2), queue); + vec.push_back(int2_(1, 2), queue); + vec.push_back(int2_(1, 1), queue); + + // function comparing the first component of each int2 + BOOST_COMPUTE_FUNCTION(bool, compare_first, (int2_ a, int2_ b), + { + return a.x < b.x; + }); + + // ensure vector is not sorted + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), compare_first, queue) == false); + + // sort elements based on their first component + compute::stable_sort(vec.begin(), vec.end(), compare_first, queue); + + // ensure vector is now sorted + BOOST_CHECK(compute::is_sorted(vec.begin(), vec.end(), compare_first, queue) == true); + + // check sorted vector order + std::vector<int2_> result(vec.size()); + compute::copy(vec.begin(), vec.end(), result.begin(), queue); + BOOST_CHECK_EQUAL(result[0], int2_(1, 2)); + BOOST_CHECK_EQUAL(result[1], int2_(1, 1)); + BOOST_CHECK_EQUAL(result[2], int2_(2, 1)); + BOOST_CHECK_EQUAL(result[3], int2_(2, 2)); + + // function comparing the second component of each int2 + BOOST_COMPUTE_FUNCTION(bool, compare_second, (int2_ a, int2_ b), + { + return a.y < b.y; + }); + + // sort elements based on their second component + compute::stable_sort(vec.begin(), vec.end(), compare_second, queue); + + // check sorted vector order + compute::copy(vec.begin(), vec.end(), result.begin(), queue); + BOOST_CHECK_EQUAL(result[0], int2_(1, 1)); + BOOST_CHECK_EQUAL(result[1], int2_(2, 1)); + BOOST_CHECK_EQUAL(result[2], int2_(1, 2)); + BOOST_CHECK_EQUAL(result[3], int2_(2, 2)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_stable_sort_by_key.cpp b/src/boost/libs/compute/test/test_stable_sort_by_key.cpp new file mode 100644 index 00000000..0ed7b6a9 --- /dev/null +++ b/src/boost/libs/compute/test/test_stable_sort_by_key.cpp @@ -0,0 +1,206 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2016 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestStableSortByKey +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/stable_sort_by_key.hpp> +#include <boost/compute/algorithm/is_sorted.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(empty_int_by_int) +{ + compute::vector<compute::int_> keys(size_t(0), compute::int_(0), queue); + compute::vector<compute::int_> values(size_t(0), compute::int_(0), queue); + + BOOST_CHECK_EQUAL(keys.size(), size_t(0)); + BOOST_CHECK_EQUAL(values.size(), size_t(0)); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue)); + + compute::stable_sort_by_key( + keys.begin(), keys.end(), values.begin(), queue + ); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end())); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end())); +} + +BOOST_AUTO_TEST_CASE(one_element_int_by_int) +{ + compute::int_ keys_data[] = { 1 }; + compute::int_ values_data[] = { 2 }; + + compute::vector<compute::int_> keys(keys_data, keys_data + 1, queue); + compute::vector<compute::int_> values(values_data, values_data + 1, queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue)); + + compute::stable_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + BOOST_CHECK(compute::is_sorted(values.begin(), values.end(), queue)); +} + +BOOST_AUTO_TEST_CASE(two_elements_int_by_int) +{ + compute::int_ keys_data[] = { 1, -1 }; + compute::int_ values_data[] = { -10, 1 }; + + compute::vector<compute::int_> keys(keys_data, keys_data + 2, queue); + compute::vector<compute::int_> values(values_data, values_data + 2, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::stable_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); +} + +BOOST_AUTO_TEST_CASE(stable_sort_int_by_int) +{ + compute::int_ keys_data[] = { 10, 9, 2, 7, 6, -1, 4, 2, 2, 10 }; + compute::int_ values_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + + compute::vector<compute::int_> keys(keys_data, keys_data + 10, queue); + compute::vector<compute::int_> values(values_data, values_data + 10, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::stable_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + + CHECK_RANGE_EQUAL( + compute::int_, 10, keys, + (-1, 2, 2, 2, 4, 6, 7, 9, 10, 10) // keys + // ( 6, 3, 8, 9, 7, 5, 4, 2, 1, 10) values + ); + CHECK_RANGE_EQUAL( + compute::int_, 10, values, + // (-1, 2, 2, 2, 4, 6, 7, 9, 10, 10) keys + ( 6, 3, 8, 9, 7, 5, 4, 2, 1, 10) // values + ); +} + +BOOST_AUTO_TEST_CASE(stable_sort_uint_by_uint) +{ + compute::uint_ keys_data[] = { 10, 9, 2, 7, 6, 1, 4, 2, 2, 10 }; + compute::uint_ values_data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + + compute::vector<compute::uint_> keys(keys_data, keys_data + 10, queue); + compute::vector<compute::uint_> values(values_data, values_data + 10, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::stable_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + + CHECK_RANGE_EQUAL( + compute::uint_, 10, keys, + (1, 2, 2, 2, 4, 6, 7, 9, 10, 10) // keys + // (6, 3, 8, 9, 7, 5, 4, 2, 1, 10) values + ); + CHECK_RANGE_EQUAL( + compute::uint_, 10, values, + // (1, 2, 2, 2, 4, 6, 7, 9, 10, 10) keys + (6, 3, 8, 9, 7, 5, 4, 2, 1, 10) // values + ); +} + +BOOST_AUTO_TEST_CASE(stable_sort_int_by_float) +{ + compute::float_ keys_data[] = { 10., 5.5, 10., 7., 5.5}; + compute::int_ values_data[] = { 1, 200, -10, 2, 4 }; + + compute::vector<compute::float_> keys(keys_data, keys_data + 5, queue); + compute::vector<compute::uint_> values(values_data, values_data + 5, queue); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), queue)); + compute::stable_sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), queue)); + + CHECK_RANGE_EQUAL( + compute::float_, 5, keys, + (5.5, 5.5, 7., 10., 10.) // keys + // (200, 4, 2, 1, -10) values + ); + CHECK_RANGE_EQUAL( + compute::int_, 5, values, + // (5.5, 5.5, 7., 10., 10.) keys + (200, 4, 2, 1, -10) // values + ); +} + +BOOST_AUTO_TEST_CASE(stable_sort_char_by_int) +{ + compute::int_ keys_data[] = { 6, 1, 1, 3, 4, 7, 5, 1 }; + compute::char_ values_data[] = { 'g', 'c', 'b', 'd', 'e', 'h', 'f', 'a' }; + + compute::vector<compute::int_> keys(keys_data, keys_data + 8, queue); + compute::vector<compute::char_> values(values_data, values_data + 8, queue); + + compute::sort_by_key(keys.begin(), keys.end(), values.begin(), queue); + + CHECK_RANGE_EQUAL( + compute::int_, 8, keys, + (1, 1, 1, 3, 4, 5, 6, 7) + ); + CHECK_RANGE_EQUAL( + compute::char_, 8, values, + ('c', 'b', 'a', 'd', 'e', 'f', 'g', 'h') + ); +} + +BOOST_AUTO_TEST_CASE(stable_sort_mid_uint_by_uint) +{ + using boost::compute::int_; + + const int_ size = 128; + std::vector<int_> keys_data(size); + std::vector<int_> values_data(size); + for(int_ i = 0; i < size; i++){ + keys_data[i] = -i; + values_data[i] = -i; + } + + keys_data[size/2] = -256; + keys_data[size - 2] = -256; + keys_data[size - 1] = -256; + values_data[size/2] = 3; + values_data[size - 2] = 1; + values_data[size - 1] = 2; + + compute::vector<int_> keys(keys_data.begin(), keys_data.end(), queue); + compute::vector<int_> values(values_data.begin(), values_data.end(), queue); + + // less function for float + BOOST_COMPUTE_FUNCTION(bool, comp, (int_ a, int_ b), + { + return a < b; + }); + + BOOST_CHECK(!compute::is_sorted(keys.begin(), keys.end(), comp, queue)); + compute::stable_sort_by_key(keys.begin(), keys.end(), values.begin(), comp, queue); + BOOST_CHECK(compute::is_sorted(keys.begin(), keys.end(), comp, queue)); + + BOOST_CHECK(keys.begin().read(queue) == -256); + BOOST_CHECK((keys.begin() + 1).read(queue) == -256); + BOOST_CHECK((keys.begin() + 2).read(queue) == -256); + + BOOST_CHECK(values.begin().read(queue) == 3); + BOOST_CHECK((values.begin() + 1).read(queue) == 1); + BOOST_CHECK((values.begin() + 2).read(queue) == 2); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_stack.cpp b/src/boost/libs/compute/test/test_stack.cpp new file mode 100644 index 00000000..fffedcc2 --- /dev/null +++ b/src/boost/libs/compute/test/test_stack.cpp @@ -0,0 +1,50 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestStack +#include <boost/test/unit_test.hpp> + +#include <boost/compute/container/stack.hpp> + +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(size) +{ + bc::stack<int> stack; + BOOST_CHECK_EQUAL(stack.size(), size_t(0)); + + stack.push(1); + stack.push(2); + stack.push(3); + BOOST_CHECK_EQUAL(stack.size(), size_t(3)); +} + +BOOST_AUTO_TEST_CASE(push_and_pop) +{ + bc::stack<int> stack; + stack.push(1); + stack.push(2); + stack.push(3); + + BOOST_CHECK_EQUAL(stack.top(), 3); + BOOST_CHECK_EQUAL(stack.size(), size_t(3)); + stack.pop(); + BOOST_CHECK_EQUAL(stack.top(), 2); + BOOST_CHECK_EQUAL(stack.size(), size_t(2)); + stack.pop(); + BOOST_CHECK_EQUAL(stack.top(), 1); + BOOST_CHECK_EQUAL(stack.size(), size_t(1)); + stack.pop(); + BOOST_CHECK_EQUAL(stack.size(), size_t(0)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_strided_iterator.cpp b/src/boost/libs/compute/test/test_strided_iterator.cpp new file mode 100644 index 00000000..e05e8b2e --- /dev/null +++ b/src/boost/libs/compute/test/test_strided_iterator.cpp @@ -0,0 +1,194 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2015 Jakub Szuppe <j.szuppe@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestStridedIterator +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/buffer_iterator.hpp> +#include <boost/compute/iterator/strided_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(value_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::strided_iterator< + boost::compute::buffer_iterator<int> + >::value_type, + int + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::strided_iterator< + boost::compute::buffer_iterator<float> + >::value_type, + float + >::value + )); +} + +BOOST_AUTO_TEST_CASE(base_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::strided_iterator< + boost::compute::buffer_iterator<int> + >::base_type, + boost::compute::buffer_iterator<int> + >::value + )); +} + +BOOST_AUTO_TEST_CASE(distance) +{ + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + boost::compute::vector<int> vec(data, data + 8, queue); + + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_strided_iterator(vec.begin(), 1), + boost::compute::make_strided_iterator(vec.end(), 1) + ), + std::ptrdiff_t(8) + ); + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_strided_iterator(vec.begin(), 2), + boost::compute::make_strided_iterator(vec.end(), 2) + ), + std::ptrdiff_t(4) + ); + + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_strided_iterator(vec.begin(), 3), + boost::compute::make_strided_iterator(vec.begin()+6, 3) + ), + std::ptrdiff_t(2) + ); +} + +BOOST_AUTO_TEST_CASE(copy) +{ + boost::compute::int_ data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + boost::compute::vector<boost::compute::int_> vec(data, data + 8, queue); + + boost::compute::vector<boost::compute::int_> result(4, context); + + // copy every other element to result + boost::compute::copy( + boost::compute::make_strided_iterator(vec.begin(), 2), + boost::compute::make_strided_iterator(vec.end(), 2), + result.begin(), + queue + ); + CHECK_RANGE_EQUAL(boost::compute::int_, 4, result, (1, 3, 5, 7)); + + // copy every 3rd element to result + boost::compute::copy( + boost::compute::make_strided_iterator(vec.begin(), 3), + boost::compute::make_strided_iterator(vec.begin()+9, 3), + result.begin(), + queue + ); + CHECK_RANGE_EQUAL(boost::compute::int_, 3, result, (1, 4, 7)); +} + +BOOST_AUTO_TEST_CASE(make_strided_iterator_end) +{ + boost::compute::int_ data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + boost::compute::vector<boost::compute::int_> vec(data, data + 8, queue); + + // stride equals 3 + typedef boost::compute::vector<boost::compute::int_>::iterator IterType; + boost::compute::strided_iterator<IterType> end = + boost::compute::make_strided_iterator_end(vec.begin(), + vec.end(), + 3); + + // end should be vec.begin() + 9 which is one step after last element + // accessible through strided_iterator, i.e. vec.begin()+6 + BOOST_CHECK(boost::compute::make_strided_iterator(vec.begin()+9, 3) == + end); + + // stride equals 2 + end = boost::compute::make_strided_iterator_end(vec.begin(), + vec.end(), + 2); + // end should be vec.end(), because vector size is divisible by 2 + BOOST_CHECK(boost::compute::make_strided_iterator(vec.end(), 2) == end); + + // stride equals 1000 + end = boost::compute::make_strided_iterator_end(vec.begin(), + vec.end(), + 1000); + // end should be vec.begin() + 1000, because stride > vector size + BOOST_CHECK(boost::compute::make_strided_iterator(vec.begin()+1000, 1000) == + end); + + + // test boost::compute::make_strided_iterator_end with copy(..) + + boost::compute::vector<boost::compute::int_> result(4, context); + + // copy every other element to result + boost::compute::copy( + boost::compute::make_strided_iterator(vec.begin()+1, 2), + boost::compute::make_strided_iterator_end(vec.begin()+1, vec.end(), 2), + result.begin(), + queue + ); + CHECK_RANGE_EQUAL(boost::compute::int_, 4, result, (2, 4, 6, 8)); +} + +BOOST_AUTO_TEST_CASE(iterator_tag) +{ + typedef bc::buffer_iterator<bc::float_> i_type; + + BOOST_STATIC_ASSERT(( + boost::is_same< + std::iterator_traits< + i_type + >::iterator_category, + std::iterator_traits< + bc::strided_iterator<i_type> + >::iterator_category + >::value + )); +} + +BOOST_AUTO_TEST_CASE(std_distance) +{ + bc::vector<bc::float_> vec( + size_t(300), + bc::float_(1.1f), + queue + ); + + bc::strided_iterator<bc::buffer_iterator<bc::float_> > begin(vec.begin(), 1); + bc::strided_iterator<bc::buffer_iterator<bc::float_> > end(vec.end(), 1); + + BOOST_CHECK_EQUAL(std::distance(begin, end), 300); + BOOST_CHECK_EQUAL(std::distance(end, begin), -300); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_string.cpp b/src/boost/libs/compute/test/test_string.cpp new file mode 100644 index 00000000..4406df7f --- /dev/null +++ b/src/boost/libs/compute/test/test_string.cpp @@ -0,0 +1,89 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestString +#include <boost/test/unit_test.hpp> + +#include <boost/compute/container/string.hpp> +#include <boost/compute/container/basic_string.hpp> +#include <boost/test/output_test_stream.hpp> + +#include "context_setup.hpp" +#include "check_macros.hpp" + +using boost::test_tools::output_test_stream; + +BOOST_AUTO_TEST_CASE(empty) +{ + boost::compute::string str; + BOOST_VERIFY(str.empty()); +} + +BOOST_AUTO_TEST_CASE(swap) +{ + // boost::compute::string currently uses only default_queue, default_context, + // default_device so this overrides queue variable set in + // BOOST_FIXTURE_TEST_SUITE(compute_test, Context) in context_setup.hpp + // in case it is not the default_queue + boost::compute::command_queue& queue = + boost::compute::system::default_queue(); + + boost::compute::string str1 = "compute"; + boost::compute::string str2 = "boost"; + BOOST_VERIFY(!str2.empty()); + BOOST_VERIFY(!str2.empty()); + str1.swap(str2); + // this macro uses queue variable and it must be default_queue + CHECK_STRING_EQUAL(str1, "boost"); + CHECK_STRING_EQUAL(str2, "compute"); + str1.clear(); + str1.swap(str2); + CHECK_STRING_EQUAL(str1, "compute"); + CHECK_STRING_EQUAL(str2, ""); + str2.swap(str1); + CHECK_STRING_EQUAL(str1, ""); + CHECK_STRING_EQUAL(str2, "compute"); + str1.swap(str1); + CHECK_STRING_EQUAL(str1, ""); +} + +BOOST_AUTO_TEST_CASE(size) +{ + boost::compute::string str = "string"; + BOOST_VERIFY(!str.empty()); + BOOST_CHECK_EQUAL(str.size(), size_t(6)); + BOOST_CHECK_EQUAL(str.length(), size_t(6)); +} + +BOOST_AUTO_TEST_CASE(find_doctest) +{ +//! [string_find] +boost::compute::string str = "boost::compute::string"; +int pos = str.find("::"); +//! [string_find] + boost::compute::string pattern = "string"; + BOOST_VERIFY(!str.empty()); + BOOST_CHECK_EQUAL(str.find('o'), 1); + BOOST_CHECK_NE(str.find('o'), 2); + BOOST_CHECK_EQUAL(str.find(pattern), 16); + BOOST_CHECK_EQUAL(pos, 5); + BOOST_CHECK_EQUAL(str.find("@#$"), size_t(-1)); +} + +BOOST_AUTO_TEST_CASE(outStream) +{ + output_test_stream output; + boost::compute::string str = "string"; + output<<str; + BOOST_CHECK(output.is_equal("string")); + BOOST_VERIFY(!output.is_equal("!@$%")); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_struct.cpp b/src/boost/libs/compute/test/test_struct.cpp new file mode 100644 index 00000000..d7a7b650 --- /dev/null +++ b/src/boost/libs/compute/test/test_struct.cpp @@ -0,0 +1,165 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#include <boost/compute/config.hpp> + +#define BOOST_TEST_MODULE TestStruct +#include <boost/test/unit_test.hpp> + +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/find_if.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/functional/field.hpp> +#include <boost/compute/types/struct.hpp> +#include <boost/compute/type_traits/type_name.hpp> +#include <boost/compute/type_traits/type_definition.hpp> +#include <boost/compute/utility/source.hpp> + +namespace compute = boost::compute; + +// example code defining an atom class +namespace chemistry { + +struct Atom +{ + Atom(float _x, float _y, float _z, int _number) + : x(_x), y(_y), z(_z), number(_number) + { + } + + float x; + float y; + float z; + int number; +}; + +} // end chemistry namespace + +// adapt the chemistry::Atom class +BOOST_COMPUTE_ADAPT_STRUCT(chemistry::Atom, Atom, (x, y, z, number)) + +struct StructWithArray { + int value; + int array[3]; +}; + +BOOST_COMPUTE_ADAPT_STRUCT(StructWithArray, StructWithArray, (value, array)) + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(atom_type_name) +{ + BOOST_CHECK(std::strcmp(compute::type_name<chemistry::Atom>(), "Atom") == 0); +} + +BOOST_AUTO_TEST_CASE(atom_struct) +{ + std::vector<chemistry::Atom> atoms; + atoms.push_back(chemistry::Atom(1.f, 0.f, 0.f, 1)); + atoms.push_back(chemistry::Atom(0.f, 1.f, 0.f, 1)); + atoms.push_back(chemistry::Atom(0.f, 0.f, 0.f, 8)); + + compute::vector<chemistry::Atom> vec(atoms.size(), context); + compute::copy(atoms.begin(), atoms.end(), vec.begin(), queue); + + // find the oxygen atom + BOOST_COMPUTE_FUNCTION(bool, is_oxygen, (chemistry::Atom atom), + { + return atom.number == 8; + }); + + compute::vector<chemistry::Atom>::iterator iter = + compute::find_if(vec.begin(), vec.end(), is_oxygen, queue); + BOOST_CHECK(iter == vec.begin() + 2); + + // copy the atomic numbers to another vector + compute::vector<int> atomic_numbers(vec.size(), context); + compute::transform( + vec.begin(), vec.end(), + atomic_numbers.begin(), + compute::field<int>("number"), + queue + ); + CHECK_RANGE_EQUAL(int, 3, atomic_numbers, (1, 1, 8)); +} + +BOOST_AUTO_TEST_CASE(custom_kernel) +{ + std::vector<chemistry::Atom> data; + data.push_back(chemistry::Atom(1.f, 0.f, 0.f, 1)); + data.push_back(chemistry::Atom(0.f, 1.f, 0.f, 1)); + data.push_back(chemistry::Atom(0.f, 0.f, 0.f, 8)); + + compute::vector<chemistry::Atom> atoms(data.size(), context); + compute::copy(data.begin(), data.end(), atoms.begin(), queue); + + std::string source = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void custom_kernel(__global const Atom *atoms, + __global float *distances) + { + const uint i = get_global_id(0); + const __global Atom *atom = &atoms[i]; + + const float4 center = { 0, 0, 0, 0 }; + const float4 position = { atom->x, atom->y, atom->z, 0 }; + + distances[i] = distance(position, center); + } + ); + + // add type definition for Atom to the start of the program source + source = compute::type_definition<chemistry::Atom>() + "\n" + source; + + compute::program program = + compute::program::build_with_source(source, context); + + compute::vector<float> distances(atoms.size(), context); + + compute::kernel custom_kernel = program.create_kernel("custom_kernel"); + custom_kernel.set_arg(0, atoms); + custom_kernel.set_arg(1, distances); + + queue.enqueue_1d_range_kernel(custom_kernel, 0, atoms.size(), 1); +} + +// Creates a StructWithArray containing 'x', 'y', 'z'. +StructWithArray make_struct_with_array(int x, int y, int z) +{ + StructWithArray s; + s.value = 0; + s.array[0] = x; + s.array[1] = y; + s.array[2] = z; + return s; +} + +BOOST_AUTO_TEST_CASE(struct_with_array) +{ + compute::vector<StructWithArray> structs(context); + + structs.push_back(make_struct_with_array(1, 2, 3), queue); + structs.push_back(make_struct_with_array(4, 5, 6), queue); + structs.push_back(make_struct_with_array(7, 8, 9), queue); + + BOOST_COMPUTE_FUNCTION(int, sum_array, (StructWithArray x), + { + return x.array[0] + x.array[1] + x.array[2]; + }); + + compute::vector<int> results(structs.size(), context); + compute::transform( + structs.begin(), structs.end(), results.begin(), sum_array, queue + ); + CHECK_RANGE_EQUAL(int, 3, results, (6, 15, 24)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_svm_ptr.cpp b/src/boost/libs/compute/test/test_svm_ptr.cpp new file mode 100644 index 00000000..1546deb7 --- /dev/null +++ b/src/boost/libs/compute/test/test_svm_ptr.cpp @@ -0,0 +1,156 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSvmPtr +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/core.hpp> +#include <boost/compute/svm.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/utility/source.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(empty) +{ +} + +#ifdef BOOST_COMPUTE_CL_VERSION_2_0 +BOOST_AUTO_TEST_CASE(alloc) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + compute::svm_ptr<cl_int> ptr = compute::svm_alloc<cl_int>(context, 8); + compute::svm_free(context, ptr); +} + +BOOST_AUTO_TEST_CASE(svmmemcpy) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + if(bug_in_svmmemcpy(device)){ + std::cerr << "skipping svmmemcpy test case" << std::endl; + return; + } + + cl_int input[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + cl_int output[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + compute::svm_ptr<cl_int> ptr = compute::svm_alloc<cl_int>(context, 8); + compute::svm_ptr<cl_int> ptr2 = compute::svm_alloc<cl_int>(context, 8); + + // copying from and to host mem + queue.enqueue_svm_memcpy(ptr.get(), input, 8 * sizeof(cl_int)); + queue.enqueue_svm_memcpy(output, ptr.get(), 8 * sizeof(cl_int)); + queue.finish(); + + CHECK_HOST_RANGE_EQUAL(cl_int, 8, output, (1, 2, 3, 4, 5, 6, 7, 8)); + + // copying between svm mem + queue.enqueue_svm_memcpy(ptr2.get(), ptr.get(), 8 * sizeof(cl_int)); + queue.enqueue_svm_memcpy(output, ptr2.get(), 8 * sizeof(cl_int)); + queue.finish(); + + CHECK_HOST_RANGE_EQUAL(cl_int, 8, output, (1, 2, 3, 4, 5, 6, 7, 8)); + + compute::svm_free(context, ptr); + compute::svm_free(context, ptr2); +} + +BOOST_AUTO_TEST_CASE(sum_svm_kernel) +{ + REQUIRES_OPENCL_VERSION(2, 0); + + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void sum_svm_mem(__global const int *ptr, __global int *result) + { + int sum = 0; + for(uint i = 0; i < 8; i++){ + sum += ptr[i]; + } + *result = sum; + } + ); + + compute::program program = + compute::program::build_with_source(source, context, "-cl-std=CL2.0"); + + compute::kernel sum_svm_mem_kernel = program.create_kernel("sum_svm_mem"); + + cl_int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::svm_ptr<cl_int> ptr = compute::svm_alloc<cl_int>(context, 8); + queue.enqueue_svm_map(ptr.get(), 8 * sizeof(cl_int), CL_MAP_WRITE); + for(size_t i = 0; i < 8; i ++) { + static_cast<cl_int*>(ptr.get())[i] = data[i]; + } + queue.enqueue_svm_unmap(ptr.get()); + + compute::vector<cl_int> result(1, context); + + sum_svm_mem_kernel.set_arg(0, ptr); + sum_svm_mem_kernel.set_arg(1, result); + queue.enqueue_task(sum_svm_mem_kernel); + + queue.finish(); + BOOST_CHECK_EQUAL(result[0], (36)); + + compute::svm_free(context, ptr); +} +#endif // BOOST_COMPUTE_CL_VERSION_2_0 + +#ifdef BOOST_COMPUTE_CL_VERSION_2_1 +BOOST_AUTO_TEST_CASE(migrate) +{ + REQUIRES_OPENCL_VERSION(2, 1); + + compute::svm_ptr<cl_int> ptr = + compute::svm_alloc<cl_int>(context, 8); + + // Migrate to device + std::vector<const void*> ptrs(1, ptr.get()); + std::vector<size_t> sizes(1, 8 * sizeof(cl_int)); + queue.enqueue_svm_migrate_memory(ptrs, sizes).wait(); + + // Set on device + const char source[] = BOOST_COMPUTE_STRINGIZE_SOURCE( + __kernel void foo(__global int *ptr) + { + for(int i = 0; i < 8; i++){ + ptr[i] = i; + } + } + ); + compute::program program = + compute::program::build_with_source(source, context, "-cl-std=CL2.0"); + compute::kernel foo_kernel = program.create_kernel("foo"); + foo_kernel.set_arg(0, ptr); + queue.enqueue_task(foo_kernel).wait(); + + // Migrate to host + queue.enqueue_svm_migrate_memory( + ptr.get(), 0, boost::compute::command_queue::migrate_to_host + ).wait(); + + // Check + CHECK_HOST_RANGE_EQUAL( + cl_int, 8, + static_cast<cl_int*>(ptr.get()), + (0, 1, 2, 3, 4, 5, 6, 7) + ); + compute::svm_free(context, ptr); +} +#endif // BOOST_COMPUTE_CL_VERSION_2_1 + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_system.cpp b/src/boost/libs/compute/test/test_system.cpp new file mode 100644 index 00000000..afc45fe6 --- /dev/null +++ b/src/boost/libs/compute/test/test_system.cpp @@ -0,0 +1,38 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestSystem +#include <boost/test/unit_test.hpp> + +#include <boost/compute/device.hpp> +#include <boost/compute/system.hpp> + +BOOST_AUTO_TEST_CASE(platform_count) +{ + BOOST_CHECK(boost::compute::system::platform_count() >= 1); +} + +BOOST_AUTO_TEST_CASE(device_count) +{ + BOOST_CHECK(boost::compute::system::device_count() >= 1); +} + +BOOST_AUTO_TEST_CASE(default_device) +{ + boost::compute::device device = boost::compute::system::default_device(); + BOOST_CHECK(device.id() != cl_device_id()); +} + +BOOST_AUTO_TEST_CASE(find_device) +{ + boost::compute::device device = boost::compute::system::default_device(); + const std::string &name = device.name(); + BOOST_CHECK(boost::compute::system::find_device(name).name() == device.name()); +} diff --git a/src/boost/libs/compute/test/test_tabulate.cpp b/src/boost/libs/compute/test/test_tabulate.cpp new file mode 100644 index 00000000..6ef82f45 --- /dev/null +++ b/src/boost/libs/compute/test/test_tabulate.cpp @@ -0,0 +1,37 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestTabulate +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/copy_n.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/experimental/tabulate.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(tabulate_negative_int) +{ + BOOST_COMPUTE_FUNCTION(int, negate, (int x), + { + return -x; + }); + + compute::vector<int> vector(10, context); + compute::experimental::tabulate(vector.begin(), vector.end(), negate, queue); + CHECK_RANGE_EQUAL(int, 10, vector, (0, -1, -2, -3, -4, -5, -6, -7, -8, -9)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_threefry_engine.cpp b/src/boost/libs/compute/test/test_threefry_engine.cpp new file mode 100644 index 00000000..3eddce73 --- /dev/null +++ b/src/boost/libs/compute/test/test_threefry_engine.cpp @@ -0,0 +1,87 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Muhammad Junaid Muzammil <mjunaidmuzammil@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://kylelutz.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestThreefry +#include <boost/test/unit_test.hpp> + +#include <boost/compute/random/threefry_engine.hpp> +#include <boost/compute/container/vector.hpp> + +#include <boost/compute/random/uniform_real_distribution.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(generate_uint) +{ + using boost::compute::uint_; + + boost::compute::threefry_engine<> random_engine(queue); + boost::compute::vector<uint_> random_values(19, context); + + random_engine.generate(random_values.begin(), random_values.end(), queue); + queue.finish(); + CHECK_RANGE_EQUAL( + uint_, 19, random_values, + (uint_(0x6b200159), + uint_(0x99ba4efe), + uint_(0x508efb2c), + uint_(0xc0de3f32), + uint_(0x64a626ec), + uint_(0xfc15e573), + uint_(0xb8abc4d1), + uint_(0x537eb86), + uint_(0xac6dc2bb), + uint_(0xa7adb3c3), + uint_(0x5641e094), + uint_(0xe4ab4fd), + uint_(0xa53c1ce9), + uint_(0xabcf1dba), + uint_(0x2677a25a), + uint_(0x76cf5efc), + uint_(0x2d08247f), + uint_(0x815480f1), + uint_(0x2d1fa53a)) + ); +} + +BOOST_AUTO_TEST_CASE(generate_float) +{ + using boost::compute::float_; + + boost::compute::threefry_engine<> random_engine(queue); + boost::compute::uniform_real_distribution<float_> random_distribution(0.f, 4.f); + + boost::compute::vector<float_> random_values(1024, context); + random_distribution.generate( + random_values.begin(), random_values.end(), random_engine, queue + ); + + std::vector<float_> random_values_host(1024); + boost::compute::copy( + random_values.begin(), random_values.end(), + random_values_host.begin(), + queue + ); + queue.finish(); + + double sum = 0.0; + for(size_t i = 0; i < random_values_host.size(); i++) + { + BOOST_CHECK_LT(random_values_host[i], 4.0f); + BOOST_CHECK_GE(random_values_host[i], 0.0f); + sum += random_values_host[i]; + } + double mean = sum / random_values_host.size(); + // For 1024 it can be 10% off + BOOST_CHECK_CLOSE(mean, 2.0f, 10.0); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_transform.cpp b/src/boost/libs/compute/test/test_transform.cpp new file mode 100644 index 00000000..81b95c0e --- /dev/null +++ b/src/boost/libs/compute/test/test_transform.cpp @@ -0,0 +1,324 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestTransform +#include <boost/test/unit_test.hpp> + +#include <boost/compute/lambda.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/function.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/counting_iterator.hpp> +#include <boost/compute/functional/field.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(transform_int_abs) +{ + int data[] = { 1, -2, -3, -4, 5 }; + bc::vector<int> vector(data, data + 5, queue); + CHECK_RANGE_EQUAL(int, 5, vector, (1, -2, -3, -4, 5)); + + bc::transform(vector.begin(), + vector.end(), + vector.begin(), + bc::abs<int>(), + queue); + CHECK_RANGE_EQUAL(int, 5, vector, (1, 2, 3, 4, 5)); +} + +BOOST_AUTO_TEST_CASE(transform_float_sqrt) +{ + float data[] = { 1.0f, 4.0f, 9.0f, 16.0f }; + bc::vector<float> vector(data, data + 4, queue); + CHECK_RANGE_EQUAL(float, 4, vector, (1.0f, 4.0f, 9.0f, 16.0f)); + + bc::transform(vector.begin(), + vector.end(), + vector.begin(), + bc::sqrt<float>(), + queue); + queue.finish(); + BOOST_CHECK_CLOSE(float(vector[0]), 1.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(vector[1]), 2.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(vector[2]), 3.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(vector[3]), 4.0f, 1e-4f); +} + +BOOST_AUTO_TEST_CASE(transform_float_clamp) +{ + float data[] = { 10.f, 20.f, 30.f, 40.f, 50.f }; + bc::vector<float> vector(data, data + 5, queue); + CHECK_RANGE_EQUAL(float, 5, vector, (10.0f, 20.0f, 30.0f, 40.0f, 50.0f)); + + bc::transform(vector.begin(), + vector.end(), + vector.begin(), + clamp(bc::_1, 15.f, 45.f), + queue); + CHECK_RANGE_EQUAL(float, 5, vector, (15.0f, 20.0f, 30.0f, 40.0f, 45.0f)); +} + +BOOST_AUTO_TEST_CASE(transform_add_int) +{ + int data1[] = { 1, 2, 3, 4 }; + bc::vector<int> input1(data1, data1 + 4, queue); + + int data2[] = { 10, 20, 30, 40 }; + bc::vector<int> input2(data2, data2 + 4, queue); + + bc::vector<int> output(4, context); + bc::transform(input1.begin(), + input1.end(), + input2.begin(), + output.begin(), + bc::plus<int>(), + queue); + CHECK_RANGE_EQUAL(int, 4, output, (11, 22, 33, 44)); + + bc::transform(input1.begin(), + input1.end(), + input2.begin(), + output.begin(), + bc::multiplies<int>(), + queue); + CHECK_RANGE_EQUAL(int, 4, output, (10, 40, 90, 160)); +} + +BOOST_AUTO_TEST_CASE(transform_pow4) +{ + float data[] = { 1.0f, 2.0f, 3.0f, 4.0f }; + bc::vector<float> vector(data, data + 4, queue); + CHECK_RANGE_EQUAL(float, 4, vector, (1.0f, 2.0f, 3.0f, 4.0f)); + + bc::vector<float> result(4, context); + bc::transform(vector.begin(), + vector.end(), + result.begin(), + pown(bc::_1, 4), + queue); + queue.finish(); + BOOST_CHECK_CLOSE(float(result[0]), 1.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(result[1]), 16.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(result[2]), 81.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(result[3]), 256.0f, 1e-4f); +} + +BOOST_AUTO_TEST_CASE(transform_custom_function) +{ + float data[] = { 9.0f, 7.0f, 5.0f, 3.0f }; + bc::vector<float> vector(data, data + 4, queue); + + BOOST_COMPUTE_FUNCTION(float, pow3add4, (float x), + { + return pow(x, 3.0f) + 4.0f; + }); + + bc::vector<float> result(4, context); + bc::transform(vector.begin(), + vector.end(), + result.begin(), + pow3add4, + queue); + queue.finish(); + BOOST_CHECK_CLOSE(float(result[0]), 733.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(result[1]), 347.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(result[2]), 129.0f, 1e-4f); + BOOST_CHECK_CLOSE(float(result[3]), 31.0f, 1e-4f); +} + +BOOST_AUTO_TEST_CASE(extract_vector_component) +{ + using bc::int2_; + + int data[] = { 1, 2, + 3, 4, + 5, 6, + 7, 8 }; + bc::vector<int2_> vector( + reinterpret_cast<int2_ *>(data), + reinterpret_cast<int2_ *>(data) + 4, + queue + ); + CHECK_RANGE_EQUAL( + int2_, 4, vector, + (int2_(1, 2), int2_(3, 4), int2_(5, 6), int2_(7, 8)) + ); + + bc::vector<int> x_components(4, context); + bc::transform(vector.begin(), + vector.end(), + x_components.begin(), + bc::get<0>(), + queue); + CHECK_RANGE_EQUAL(int, 4, x_components, (1, 3, 5, 7)); + + bc::vector<int> y_components(4, context); + bc::transform(vector.begin(), + vector.end(), + y_components.begin(), + bc::get<1>(), + queue); + CHECK_RANGE_EQUAL(int, 4, y_components, (2, 4, 6, 8)); +} + +BOOST_AUTO_TEST_CASE(transform_pinned_vector) +{ + int data[] = { 2, -3, 4, -5, 6, -7 }; + std::vector<int> vector(data, data + 6); + + bc::buffer buffer(context, + vector.size() * sizeof(int), + bc::buffer::read_write | bc::buffer::use_host_ptr, + &vector[0]); + + bc::transform(bc::make_buffer_iterator<int>(buffer, 0), + bc::make_buffer_iterator<int>(buffer, 6), + bc::make_buffer_iterator<int>(buffer, 0), + bc::abs<int>(), + queue); + + void *ptr = queue.enqueue_map_buffer(buffer, + bc::command_queue::map_read, + 0, + buffer.size()); + BOOST_VERIFY(ptr == &vector[0]); + BOOST_CHECK_EQUAL(vector[0], 2); + BOOST_CHECK_EQUAL(vector[1], 3); + BOOST_CHECK_EQUAL(vector[2], 4); + BOOST_CHECK_EQUAL(vector[3], 5); + BOOST_CHECK_EQUAL(vector[4], 6); + BOOST_CHECK_EQUAL(vector[5], 7); + queue.enqueue_unmap_buffer(buffer, ptr); +} + +BOOST_AUTO_TEST_CASE(transform_popcount) +{ + using boost::compute::uint_; + + uint_ data[] = { 0, 1, 2, 3, 4, 45, 127, 5000, 789, 15963 }; + bc::vector<uint_> input(data, data + 10, queue); + bc::vector<uint_> output(input.size(), context); + + bc::transform( + input.begin(), + input.end(), + output.begin(), + bc::popcount<uint_>(), + queue + ); + CHECK_RANGE_EQUAL(uint_, 10, output, (0, 1, 1, 2, 1, 4, 7, 5, 5, 10)); +} + +// generates the first 25 fibonacci numbers in parallel using the +// rounding-based fibonacci formula +BOOST_AUTO_TEST_CASE(generate_fibonacci_sequence) +{ + using boost::compute::uint_; + + boost::compute::vector<uint_> sequence(25, context); + + BOOST_COMPUTE_FUNCTION(uint_, nth_fibonacci, (const uint_ n), + { + const float golden_ratio = (1.f + sqrt(5.f)) / 2.f; + return floor(pown(golden_ratio, n) / sqrt(5.f) + 0.5f); + }); + + boost::compute::transform( + boost::compute::make_counting_iterator(uint_(0)), + boost::compute::make_counting_iterator(uint_(sequence.size())), + sequence.begin(), + nth_fibonacci, + queue + ); + CHECK_RANGE_EQUAL( + uint_, 25, sequence, + (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, + 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368) + ); +} + +BOOST_AUTO_TEST_CASE(field) +{ + using compute::uint2_; + using compute::uint4_; + using compute::field; + + unsigned int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<uint4_> input( + reinterpret_cast<uint4_ *>(data), + reinterpret_cast<uint4_ *>(data) + 2, + queue + ); + compute::vector<uint2_> output(input.size(), context); + + compute::transform( + input.begin(), + input.end(), + output.begin(), + compute::field<uint2_>("xz"), + queue + ); + + queue.finish(); + + BOOST_CHECK_EQUAL(uint2_(output[0]), uint2_(1, 3)); + BOOST_CHECK_EQUAL(uint2_(output[1]), uint2_(5, 7)); +} + +BOOST_AUTO_TEST_CASE(transform_abs_doctest) +{ +//! [transform_abs] +int data[] = { -1, -2, -3, -4 }; +boost::compute::vector<int> vec(data, data + 4, queue); + +using boost::compute::abs; + +// calculate the absolute value for each element in-place +boost::compute::transform( + vec.begin(), vec.end(), vec.begin(), abs<int>(), queue +); + +// vec == { 1, 2, 3, 4 } +//! [transform_abs] + + CHECK_RANGE_EQUAL(int, 4, vec, (1, 2, 3, 4)); +} + +BOOST_AUTO_TEST_CASE(abs_if_odd) +{ + // return absolute value only for odd values + BOOST_COMPUTE_FUNCTION(int, abs_if_odd, (int x), + { + if(x & 1){ + return abs(x); + } + else { + return x; + } + }); + + int data[] = { -2, -3, -4, -5, -6, -7, -8, -9 }; + compute::vector<int> vector(data, data + 8, queue); + + compute::transform( + vector.begin(), vector.end(), vector.begin(), abs_if_odd, queue + ); + + CHECK_RANGE_EQUAL(int, 8, vector, (-2, +3, -4, +5, -6, +7, -8, +9)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_transform_if.cpp b/src/boost/libs/compute/test/test_transform_if.cpp new file mode 100644 index 00000000..fc371327 --- /dev/null +++ b/src/boost/libs/compute/test/test_transform_if.cpp @@ -0,0 +1,40 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestTransformIf +#include <boost/test/unit_test.hpp> + +#include <boost/compute/lambda.hpp> +#include <boost/compute/algorithm/transform_if.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(transform_if_odd) +{ + using boost::compute::abs; + using boost::compute::lambda::_1; + + int data[] = { -2, -3, -4, -5, -6, -7, -8, -9 }; + compute::vector<int> input(data, data + 8, queue); + compute::vector<int> output(input.size(), context); + + compute::vector<int>::iterator end = compute::transform_if( + input.begin(), input.end(), output.begin(), abs<int>(), _1 % 2 != 0, queue + ); + BOOST_CHECK_EQUAL(std::distance(output.begin(), end), 4); + + CHECK_RANGE_EQUAL(int, 4, output, (+3, +5, +7, +9)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_transform_iterator.cpp b/src/boost/libs/compute/test/test_transform_iterator.cpp new file mode 100644 index 00000000..6c77bf75 --- /dev/null +++ b/src/boost/libs/compute/test/test_transform_iterator.cpp @@ -0,0 +1,108 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestTransformIterator +#include <boost/test/unit_test.hpp> + +#include <iterator> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/types.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/buffer_iterator.hpp> +#include <boost/compute/iterator/transform_iterator.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(value_type) +{ + using boost::compute::float4_; + + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::transform_iterator< + boost::compute::buffer_iterator<float>, + boost::compute::sqrt<float> + >::value_type, + float + >::value + )); + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::transform_iterator< + boost::compute::buffer_iterator<float4_>, + boost::compute::length<float4_> + >::value_type, + float + >::value + )); +} + +BOOST_AUTO_TEST_CASE(base_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::transform_iterator< + boost::compute::buffer_iterator<int>, boost::compute::abs<int> + >::base_type, + boost::compute::buffer_iterator<int> + >::value + )); +} + +BOOST_AUTO_TEST_CASE(copy) +{ + int data[] = { 1, -2, 3, -4, 5 }; + boost::compute::vector<int> a(data, data + 5, queue); + + boost::compute::vector<int> b(5, context); + boost::compute::copy( + boost::compute::make_transform_iterator( + a.begin(), + boost::compute::abs<int>() + ), + boost::compute::make_transform_iterator( + a.end(), + boost::compute::abs<int>() + ), + b.begin(), + queue + ); + CHECK_RANGE_EQUAL(int, 5, b, (1, 2, 3, 4, 5)); +} + +BOOST_AUTO_TEST_CASE(copy_abs_doctest) +{ + int data[] = { -1, -2, -3, -4 }; + boost::compute::vector<int> input(data, data + 4, queue); + boost::compute::vector<int> output(4, context); + +//! [copy_abs] +// use abs() from boost.compute +using boost::compute::abs; + +// copy the absolute value for each element in input to output +boost::compute::copy( + boost::compute::make_transform_iterator(input.begin(), abs<int>()), + boost::compute::make_transform_iterator(input.end(), abs<int>()), + output.begin(), + queue +); +//! [copy_abs] + + CHECK_RANGE_EQUAL(int, 4, output, (1, 2, 3, 4)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_transform_reduce.cpp b/src/boost/libs/compute/test/test_transform_reduce.cpp new file mode 100644 index 00000000..5766862d --- /dev/null +++ b/src/boost/libs/compute/test/test_transform_reduce.cpp @@ -0,0 +1,101 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestTransformReduce +#include <boost/test/unit_test.hpp> + +#include <boost/compute/lambda.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/functional.hpp> +#include <boost/compute/algorithm/transform_reduce.hpp> +#include <boost/compute/container/vector.hpp> + +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(sum_abs_int_doctest) +{ + using boost::compute::abs; + using boost::compute::plus; + + int data[] = { 1, -2, -3, -4, 5 }; + compute::vector<int> vec(data, data + 5, queue); + +//! [sum_abs_int] +int sum = 0; +boost::compute::transform_reduce( + vec.begin(), vec.end(), &sum, abs<int>(), plus<int>(), queue +); +//! [sum_abs_int] + + BOOST_CHECK_EQUAL(sum, 15); +} + +BOOST_AUTO_TEST_CASE(multiply_vector_length) +{ + float data[] = { 2.0f, 0.0f, 0.0f, 0.0f, + 0.0f, 3.0f, 0.0f, 0.0f, + 0.0f, 0.0f, 4.0f, 0.0f }; + compute::vector<compute::float4_> vector( + reinterpret_cast<compute::float4_ *>(data), + reinterpret_cast<compute::float4_ *>(data) + 3, + queue + ); + + float product; + compute::transform_reduce( + vector.begin(), + vector.end(), + &product, + compute::length<compute::float4_>(), + compute::multiplies<float>(), + queue + ); + BOOST_CHECK_CLOSE(product, 24.0f, 1e-4f); +} + +BOOST_AUTO_TEST_CASE(mean_and_std_dev) +{ + using compute::lambda::_1; + using compute::lambda::pow; + + float data[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; + compute::vector<float> vector(data, data + 10, queue); + + float sum; + compute::reduce( + vector.begin(), + vector.end(), + &sum, + compute::plus<float>(), + queue + ); + + float mean = sum / vector.size(); + BOOST_CHECK_CLOSE(mean, 5.5f, 1e-4); + + compute::transform_reduce( + vector.begin(), + vector.end(), + &sum, + pow(_1 - mean, 2), + compute::plus<float>(), + queue + ); + + float variance = sum / vector.size(); + BOOST_CHECK_CLOSE(variance, 8.25f, 1e-4); + + float std_dev = std::sqrt(variance); + BOOST_CHECK_CLOSE(std_dev, 2.8722813232690143, 1e-4); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_tuple.cpp b/src/boost/libs/compute/test/test_tuple.cpp new file mode 100644 index 00000000..ece24a37 --- /dev/null +++ b/src/boost/libs/compute/test/test_tuple.cpp @@ -0,0 +1,141 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestTuple +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/tuple/tuple.hpp> +#include <boost/tuple/tuple_io.hpp> +#include <boost/tuple/tuple_comparison.hpp> + +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/find.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/tuple.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(vector_tuple_int_float) +{ + boost::compute::vector<boost::tuple<int, float> > vector(context); + + vector.push_back(boost::make_tuple(1, 2.1f), queue); + vector.push_back(boost::make_tuple(2, 3.2f), queue); + vector.push_back(boost::make_tuple(3, 4.3f), queue); +} + +BOOST_AUTO_TEST_CASE(copy_vector_tuple) +{ + // create vector of tuples on device + boost::compute::vector<boost::tuple<char, int, float> > input(context); + input.push_back(boost::make_tuple('a', 1, 2.3f), queue); + input.push_back(boost::make_tuple('c', 3, 4.5f), queue); + input.push_back(boost::make_tuple('f', 6, 7.8f), queue); + + // copy on device + boost::compute::vector<boost::tuple<char, int, float> > output(context); + + boost::compute::copy( + input.begin(), + input.end(), + output.begin(), + queue + ); + + // copy to host + std::vector<boost::tuple<char, int, float> > host_output(3); + + boost::compute::copy( + input.begin(), + input.end(), + host_output.begin(), + queue + ); + + // check tuple data + BOOST_CHECK_EQUAL(host_output[0], boost::make_tuple('a', 1, 2.3f)); + BOOST_CHECK_EQUAL(host_output[1], boost::make_tuple('c', 3, 4.5f)); + BOOST_CHECK_EQUAL(host_output[2], boost::make_tuple('f', 6, 7.8f)); +} + +BOOST_AUTO_TEST_CASE(extract_tuple_elements) +{ + compute::vector<boost::tuple<char, int, float> > vector(context); + vector.push_back(boost::make_tuple('a', 1, 2.3f), queue); + vector.push_back(boost::make_tuple('c', 3, 4.5f), queue); + vector.push_back(boost::make_tuple('f', 6, 7.8f), queue); + + compute::vector<char> chars(3, context); + compute::transform( + vector.begin(), vector.end(), chars.begin(), compute::get<0>(), queue + ); + CHECK_RANGE_EQUAL(char, 3, chars, ('a', 'c', 'f')); + + compute::vector<int> ints(3, context); + compute::transform( + vector.begin(), vector.end(), ints.begin(), compute::get<1>(), queue + ); + CHECK_RANGE_EQUAL(int, 3, ints, (1, 3, 6)); + + compute::vector<float> floats(3, context); + compute::transform( + vector.begin(), vector.end(), floats.begin(), compute::get<2>(), queue + ); + CHECK_RANGE_EQUAL(float, 3, floats, (2.3f, 4.5f, 7.8f)); +} + +BOOST_AUTO_TEST_CASE(fill_tuple_vector) +{ + if(bug_in_struct_assignment(device)){ + std::cerr << "skipping fill_tuple_vector test" << std::endl; + return; + } + + compute::vector<boost::tuple<char, int, float> > vector(5, context); + compute::fill(vector.begin(), vector.end(), boost::make_tuple('z', 4, 3.14f), queue); + + std::vector<boost::tuple<char, int, float> > host_output(5); + compute::copy(vector.begin(), vector.end(), host_output.begin(), queue); + BOOST_CHECK_EQUAL(host_output[0], boost::make_tuple('z', 4, 3.14f)); + BOOST_CHECK_EQUAL(host_output[1], boost::make_tuple('z', 4, 3.14f)); + BOOST_CHECK_EQUAL(host_output[2], boost::make_tuple('z', 4, 3.14f)); + BOOST_CHECK_EQUAL(host_output[3], boost::make_tuple('z', 4, 3.14f)); + BOOST_CHECK_EQUAL(host_output[4], boost::make_tuple('z', 4, 3.14f)); +} + +#ifndef BOOST_COMPUTE_NO_VARIADIC_TEMPLATES +BOOST_AUTO_TEST_CASE(variadic_tuple) +{ + BOOST_CHECK_EQUAL( + (compute::type_name<boost::tuple<char, short, int, float> >()), + "boost_tuple_char_short_int_float_t" + ); +} +#endif // BOOST_COMPUTE_NO_VARIADIC_TEMPLATES + +#ifndef BOOST_COMPUTE_NO_STD_TUPLE +BOOST_AUTO_TEST_CASE(std_tuple) +{ + BOOST_CHECK_EQUAL( + (compute::type_name<std::tuple<char, short, int, float>>()), + "std_tuple_char_short_int_float_t" + ); +} +#endif // BOOST_COMPUTE_NO_STD_TUPLE + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_type_traits.cpp b/src/boost/libs/compute/test/test_type_traits.cpp new file mode 100644 index 00000000..9654a286 --- /dev/null +++ b/src/boost/libs/compute/test/test_type_traits.cpp @@ -0,0 +1,131 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestTypeTraits +#include <boost/test/unit_test.hpp> + +#include <set> +#include <list> +#include <vector> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> + +#include <boost/compute/types.hpp> +#include <boost/compute/type_traits.hpp> +#include <boost/compute/iterator/buffer_iterator.hpp> +#include <boost/compute/iterator/constant_iterator.hpp> +#include <boost/compute/detail/is_buffer_iterator.hpp> +#include <boost/compute/detail/is_contiguous_iterator.hpp> + +namespace bc = boost::compute; + +BOOST_AUTO_TEST_CASE(scalar_type) +{ + BOOST_STATIC_ASSERT((boost::is_same<bc::scalar_type<bc::int_>::type, int>::value)); + BOOST_STATIC_ASSERT((boost::is_same<bc::scalar_type<bc::int2_>::type, int>::value)); + BOOST_STATIC_ASSERT((boost::is_same<bc::scalar_type<bc::float_>::type, float>::value)); + BOOST_STATIC_ASSERT((boost::is_same<bc::scalar_type<bc::float4_>::type, float>::value)); +} + +BOOST_AUTO_TEST_CASE(vector_size) +{ + BOOST_STATIC_ASSERT(bc::vector_size<bc::int_>::value == 1); + BOOST_STATIC_ASSERT(bc::vector_size<bc::int2_>::value == 2); + BOOST_STATIC_ASSERT(bc::vector_size<bc::float_>::value == 1); + BOOST_STATIC_ASSERT(bc::vector_size<bc::float4_>::value == 4); +} + +BOOST_AUTO_TEST_CASE(is_vector_type) +{ + BOOST_STATIC_ASSERT(bc::is_vector_type<bc::int_>::value == false); + BOOST_STATIC_ASSERT(bc::is_vector_type<bc::int2_>::value == true); + BOOST_STATIC_ASSERT(bc::is_vector_type<bc::float_>::value == false); + BOOST_STATIC_ASSERT(bc::is_vector_type<bc::float4_>::value == true); +} + +BOOST_AUTO_TEST_CASE(make_vector_type) +{ + BOOST_STATIC_ASSERT((boost::is_same<bc::make_vector_type<cl_uint, 2>::type, bc::uint2_>::value)); + BOOST_STATIC_ASSERT((boost::is_same<bc::make_vector_type<int, 4>::type, bc::int4_>::value)); + BOOST_STATIC_ASSERT((boost::is_same<bc::make_vector_type<float, 8>::type, bc::float8_>::value)); + BOOST_STATIC_ASSERT((boost::is_same<bc::make_vector_type<bc::char_, 16>::type, bc::char16_>::value)); +} + +BOOST_AUTO_TEST_CASE(is_fundamental_type) +{ + BOOST_STATIC_ASSERT((bc::is_fundamental<int>::value == true)); + BOOST_STATIC_ASSERT((bc::is_fundamental<bc::int_>::value == true)); + BOOST_STATIC_ASSERT((bc::is_fundamental<bc::int2_>::value == true)); + BOOST_STATIC_ASSERT((bc::is_fundamental<float>::value == true)); + BOOST_STATIC_ASSERT((bc::is_fundamental<bc::float_>::value == true)); + BOOST_STATIC_ASSERT((bc::is_fundamental<bc::float4_>::value == true)); + + BOOST_STATIC_ASSERT((bc::is_fundamental<std::pair<int, float> >::value == false)); + BOOST_STATIC_ASSERT((bc::is_fundamental<std::complex<float> >::value == false)); +} + +BOOST_AUTO_TEST_CASE(type_name) +{ + // scalar types + BOOST_CHECK(std::strcmp(bc::type_name<bc::char_>(), "char") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::uchar_>(), "uchar") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::short_>(), "short") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::ushort_>(), "ushort") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::int_>(), "int") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::uint_>(), "uint") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::long_>(), "long") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::ulong_>(), "ulong") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::float_>(), "float") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::double_>(), "double") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bool>(), "bool") == 0); + + // vector types + BOOST_CHECK(std::strcmp(bc::type_name<bc::char16_>(), "char16") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::uint4_>(), "uint4") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::ulong8_>(), "ulong8") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::float2_>(), "float2") == 0); + BOOST_CHECK(std::strcmp(bc::type_name<bc::double4_>(), "double4") == 0); +} + +BOOST_AUTO_TEST_CASE(is_contiguous_iterator) +{ + using boost::compute::detail::is_contiguous_iterator; + + BOOST_STATIC_ASSERT(is_contiguous_iterator<int *>::value == true); + BOOST_STATIC_ASSERT(is_contiguous_iterator<std::vector<int>::iterator>::value == true); + BOOST_STATIC_ASSERT(is_contiguous_iterator<std::vector<int>::const_iterator>::value == true); + BOOST_STATIC_ASSERT(is_contiguous_iterator<std::list<int>::iterator>::value == false); + BOOST_STATIC_ASSERT(is_contiguous_iterator<std::set<int>::iterator>::value == false); + BOOST_STATIC_ASSERT(is_contiguous_iterator<std::insert_iterator<std::set<int> > >::value == false); + BOOST_STATIC_ASSERT(is_contiguous_iterator<std::back_insert_iterator<std::vector<int> > >::value == false); +} + +BOOST_AUTO_TEST_CASE(is_buffer_iterator) +{ + using boost::compute::detail::is_buffer_iterator; + + BOOST_STATIC_ASSERT(is_buffer_iterator<boost::compute::buffer_iterator<int> >::value == true); + BOOST_STATIC_ASSERT(is_buffer_iterator<boost::compute::constant_iterator<int> >::value == false); +} + +BOOST_AUTO_TEST_CASE(is_device_iterator) +{ + using boost::compute::is_device_iterator; + + BOOST_STATIC_ASSERT(is_device_iterator<boost::compute::buffer_iterator<int> >::value == true); + BOOST_STATIC_ASSERT(is_device_iterator<const boost::compute::buffer_iterator<int> >::value == true); + BOOST_STATIC_ASSERT(is_device_iterator<boost::compute::constant_iterator<int> >::value == true); + BOOST_STATIC_ASSERT(is_device_iterator<const boost::compute::constant_iterator<int> >::value == true); + BOOST_STATIC_ASSERT(is_device_iterator<float *>::value == false); + BOOST_STATIC_ASSERT(is_device_iterator<const float *>::value == false); + BOOST_STATIC_ASSERT(is_device_iterator<std::vector<int>::iterator>::value == false); + BOOST_STATIC_ASSERT(is_device_iterator<const std::vector<int>::iterator>::value == false); +} diff --git a/src/boost/libs/compute/test/test_types.cpp b/src/boost/libs/compute/test/test_types.cpp new file mode 100644 index 00000000..3ee0e791 --- /dev/null +++ b/src/boost/libs/compute/test/test_types.cpp @@ -0,0 +1,97 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestTypes +#include <boost/test/unit_test.hpp> + +#include <string> +#include <sstream> + +#include <boost/compute/types/fundamental.hpp> + +BOOST_AUTO_TEST_CASE(vector_ctor) +{ + boost::compute::int4_ i4(1, 2, 3, 4); + BOOST_CHECK(i4 == boost::compute::int4_(1, 2, 3, 4)); + BOOST_CHECK_EQUAL(i4, boost::compute::int4_(1, 2, 3, 4)); + BOOST_CHECK_EQUAL(i4[0], 1); + BOOST_CHECK_EQUAL(i4[1], 2); + BOOST_CHECK_EQUAL(i4[2], 3); + BOOST_CHECK_EQUAL(i4[3], 4); + + i4 = boost::compute::int4_(1); + BOOST_CHECK(i4 == boost::compute::int4_(1, 1, 1, 1)); + BOOST_CHECK(i4 == (boost::compute::vector_type<int, size_t(4)>(1))); + BOOST_CHECK_EQUAL(i4, boost::compute::int4_(1, 1, 1, 1)); + BOOST_CHECK_EQUAL(i4[0], 1); + BOOST_CHECK_EQUAL(i4[1], 1); + BOOST_CHECK_EQUAL(i4[2], 1); + BOOST_CHECK_EQUAL(i4[3], 1); +} + +BOOST_AUTO_TEST_CASE(vector_string) +{ + std::stringstream stream; + stream << boost::compute::int2_(1, 2); + BOOST_CHECK_EQUAL(stream.str(), std::string("int2(1, 2)")); +} + +BOOST_AUTO_TEST_CASE(vector_accessors_basic) +{ + boost::compute::float4_ v; + v.x = 1; + v.y = 2; + v.z = 3; + v.w = 4; + BOOST_CHECK(v == boost::compute::float4_(1, 2, 3, 4)); +} + +BOOST_AUTO_TEST_CASE(vector_accessors_all) +{ + boost::compute::int2_ i2(1, 2); + BOOST_CHECK_EQUAL(i2.x, 1); + BOOST_CHECK_EQUAL(i2.y, 2); + + boost::compute::int4_ i4(1, 2, 3, 4); + BOOST_CHECK_EQUAL(i4.x, 1); + BOOST_CHECK_EQUAL(i4.y, 2); + BOOST_CHECK_EQUAL(i4.z, 3); + BOOST_CHECK_EQUAL(i4.w, 4); + + boost::compute::int8_ i8(1, 2, 3, 4, 5, 6, 7, 8); + BOOST_CHECK_EQUAL(i8.s0, 1); + BOOST_CHECK_EQUAL(i8.s1, 2); + BOOST_CHECK_EQUAL(i8.s2, 3); + BOOST_CHECK_EQUAL(i8.s3, 4); + BOOST_CHECK_EQUAL(i8.s4, 5); + BOOST_CHECK_EQUAL(i8.s5, 6); + BOOST_CHECK_EQUAL(i8.s6, 7); + BOOST_CHECK_EQUAL(i8.s7, 8); + + boost::compute::int16_ i16( + 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16); + BOOST_CHECK_EQUAL(i16.s0, 1); + BOOST_CHECK_EQUAL(i16.s1, 2); + BOOST_CHECK_EQUAL(i16.s2, 3); + BOOST_CHECK_EQUAL(i16.s3, 4); + BOOST_CHECK_EQUAL(i16.s4, 5); + BOOST_CHECK_EQUAL(i16.s5, 6); + BOOST_CHECK_EQUAL(i16.s6, 7); + BOOST_CHECK_EQUAL(i16.s7, 8); + BOOST_CHECK_EQUAL(i16.s8, 9); + BOOST_CHECK_EQUAL(i16.s9, 10); + BOOST_CHECK_EQUAL(i16.sa, 11); + BOOST_CHECK_EQUAL(i16.sb, 12); + BOOST_CHECK_EQUAL(i16.sc, 13); + BOOST_CHECK_EQUAL(i16.sd, 14); + BOOST_CHECK_EQUAL(i16.se, 15); + BOOST_CHECK_EQUAL(i16.sf, 16); +} diff --git a/src/boost/libs/compute/test/test_uniform_int_distribution.cpp b/src/boost/libs/compute/test/test_uniform_int_distribution.cpp new file mode 100644 index 00000000..55338a28 --- /dev/null +++ b/src/boost/libs/compute/test/test_uniform_int_distribution.cpp @@ -0,0 +1,77 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestUniformIntDistribution +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/count_if.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/uniform_int_distribution.hpp> +#include <boost/compute/lambda.hpp> + +#include "context_setup.hpp" + +namespace compute=boost::compute; + +BOOST_AUTO_TEST_CASE(uniform_int_distribution_doctest) +{ + using boost::compute::uint_; + using boost::compute::lambda::_1; + + boost::compute::vector<uint_> vec(128, context); + +//! [generate] +// initialize the default random engine +boost::compute::default_random_engine engine(queue); + +// setup the uniform distribution to produce integers 0 and 1 +boost::compute::uniform_int_distribution<uint_> distribution(0, 1); + +// generate the random values and store them to 'vec' +distribution.generate(vec.begin(), vec.end(), engine, queue); +//! [generate] + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + vec.begin(), vec.end(), _1 > 1, queue + ), + size_t(0) + ); +} + +BOOST_AUTO_TEST_CASE(issue159) { + using boost::compute::lambda::_1; + + boost::compute::vector<int> input(10, context); + + // generate random numbers between 1 and 10 + compute::default_random_engine rng(queue); + compute::uniform_int_distribution<int> d(1, 10); + d.generate(input.begin(), input.end(), rng, queue); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + input.begin(), input.end(), _1 > 10, queue + ), + size_t(0) + ); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + input.begin(), input.end(), _1 < 1, queue + ), + size_t(0) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_uniform_real_distribution.cpp b/src/boost/libs/compute/test/test_uniform_real_distribution.cpp new file mode 100644 index 00000000..d5394427 --- /dev/null +++ b/src/boost/libs/compute/test/test_uniform_real_distribution.cpp @@ -0,0 +1,105 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestUniformRealDistribution +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/count_if.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/function.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/random/default_random_engine.hpp> +#include <boost/compute/random/uniform_real_distribution.hpp> +#include <boost/compute/lambda.hpp> +#include <boost/compute/types/fundamental.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(uniform_real_distribution_doctest) +{ + using boost::compute::lambda::_1; + + boost::compute::vector<float> vec(128, context); + +//! [generate] +// initialize the default random engine +boost::compute::default_random_engine engine(queue); + +// setup the uniform distribution to produce floats between 1 and 100 +boost::compute::uniform_real_distribution<float> distribution(1.0f, 100.0f); + +// generate the random values and store them to 'vec' +distribution.generate(vec.begin(), vec.end(), engine, queue); +//! [generate] + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + vec.begin(), vec.end(), _1 < 1.0f || _1 >= 100.0f, queue + ), + size_t(0) + ); +} + +template<class T> +class range_test_engine +{ +public: + explicit range_test_engine(boost::compute::command_queue &queue) { + (void) queue; + } + + template<class OutputIterator, class Function> + void generate(OutputIterator first, OutputIterator last, Function op, boost::compute::command_queue &queue) + { + boost::compute::vector<T> tmp(std::distance(first, last), queue.get_context()); + + BOOST_COMPUTE_FUNCTION(T, max_random, (const T x), + { + if(get_global_id(0) < 1) + return (ValueType) MAX_RANDOM; + else + return (ValueType) 0; + }); + + max_random.define("MAX_RANDOM", "UINT_MAX"); + max_random.define("ValueType", boost::compute::type_name<T>()); + + boost::compute::transform(tmp.begin(), tmp.end(), tmp.begin(), max_random, queue); + boost::compute::transform(tmp.begin(), tmp.end(), first, op, queue); + } +}; + +// For checking if result is in the correct range [low, hi) +BOOST_AUTO_TEST_CASE(uniform_real_distribution_range) +{ + using boost::compute::lambda::_1; + + boost::compute::vector<float> vec(32, context); + + // initialize the range_test_engine + range_test_engine<boost::compute::uint_> engine(queue); + + // setup the uniform distribution to produce floats between 0.9 and 1.0 + boost::compute::uniform_real_distribution<float> distribution(0.9f, 1.0f); + + // generate the random values and store them to 'vec' + distribution.generate(vec.begin(), vec.end(), engine, queue); + + BOOST_CHECK_EQUAL( + boost::compute::count_if( + vec.begin(), vec.end(), _1 < 0.9f || _1 >= 1.0f, queue + ), + size_t(0) + ); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_unique.cpp b/src/boost/libs/compute/test/test_unique.cpp new file mode 100644 index 00000000..f754323b --- /dev/null +++ b/src/boost/libs/compute/test/test_unique.cpp @@ -0,0 +1,96 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestUnique +#include <boost/test/unit_test.hpp> + +#include <boost/compute/function.hpp> +#include <boost/compute/algorithm/iota.hpp> +#include <boost/compute/algorithm/none_of.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/algorithm/unique.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(unique_int) +{ + int data[] = {1, 6, 6, 4, 2, 2, 4}; + + compute::vector<int> input(data, data + 7, queue); + + compute::vector<int>::iterator iter = + compute::unique(input.begin(), input.end(), queue); + + BOOST_VERIFY(iter == input.begin() + 5); + CHECK_RANGE_EQUAL(int, 7, input, (1, 6, 4, 2, 4, 2, 4)); +} + +BOOST_AUTO_TEST_CASE(all_same_float) +{ + compute::vector<float> vec(1024, context); + compute::fill(vec.begin(), vec.end(), 3.14f, queue); + + compute::vector<float>::iterator iter = + compute::unique(vec.begin(), vec.end(), queue); + + BOOST_VERIFY(iter == vec.begin() + 1); + + float first; + compute::copy_n(vec.begin(), 1, &first, queue); + BOOST_CHECK_EQUAL(first, 3.14f); +} + +BOOST_AUTO_TEST_CASE(unique_even_uints) +{ + using compute::uint_; + + // create vector filled with [0, 1, 2, ...] + compute::vector<uint_> vec(1024, context); + compute::iota(vec.begin(), vec.end(), 0, queue); + + // all should be unique + compute::vector<uint_>::iterator iter = compute::unique( + vec.begin(), vec.end(), queue + ); + BOOST_VERIFY(iter == vec.end()); + + // if odd, return the prior even number, else return the number + BOOST_COMPUTE_FUNCTION(uint_, odd_to_even, (uint_ x), + { + if(x & 1){ + return x - 1; + } + else { + return x; + } + }); + + // set all odd numbers the previous even number + compute::transform( + vec.begin(), vec.end(), vec.begin(), odd_to_even, queue + ); + + // now the vector should contain [0, 0, 2, 2, 4, 4, ...] + iter = compute::unique(vec.begin(), vec.end(), queue); + BOOST_VERIFY(iter == vec.begin() + (vec.size() / 2)); + + // ensure all of the values are even + BOOST_COMPUTE_FUNCTION(bool, is_odd, (uint_ x), + { + return x & 1; + }); + BOOST_VERIFY(compute::none_of(vec.begin(), vec.end(), is_odd, queue)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_unique_copy.cpp b/src/boost/libs/compute/test/test_unique_copy.cpp new file mode 100644 index 00000000..eaaf55e1 --- /dev/null +++ b/src/boost/libs/compute/test/test_unique_copy.cpp @@ -0,0 +1,37 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Roshan <thisisroshansmail@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestUniqueCopy +#include <boost/test/unit_test.hpp> + +#include <boost/compute/algorithm/unique_copy.hpp> +#include <boost/compute/container/vector.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(unique_copy_int) +{ + int data[] = {1, 6, 6, 4, 2, 2, 4}; + + bc::vector<int> input(data, data + 7, queue); + bc::vector<int> result(5, context); + + bc::vector<int>::iterator iter = + bc::unique_copy(input.begin(), input.end(), result.begin(), queue); + + BOOST_VERIFY(iter == result.begin() + 5); + CHECK_RANGE_EQUAL(int, 5, result, (1, 6, 4, 2, 4)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_unsupported_extension.cpp b/src/boost/libs/compute/test/test_unsupported_extension.cpp new file mode 100644 index 00000000..d87198d0 --- /dev/null +++ b/src/boost/libs/compute/test/test_unsupported_extension.cpp @@ -0,0 +1,18 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2014 Fabian Köhler <fabian2804@googlemail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// +#define BOOST_TEST_MODULE TestUnsupportedExtension +#include <boost/test/unit_test.hpp> +#include <boost/compute/exception/unsupported_extension_error.hpp> + +BOOST_AUTO_TEST_CASE(unsupported_extension_error_what) +{ + boost::compute::unsupported_extension_error error("CL_DUMMY_EXTENSION"); + BOOST_CHECK_EQUAL(std::string(error.what()), std::string("OpenCL extension CL_DUMMY_EXTENSION not supported")); +} diff --git a/src/boost/libs/compute/test/test_user_defined_types.cpp b/src/boost/libs/compute/test/test_user_defined_types.cpp new file mode 100644 index 00000000..d9f75169 --- /dev/null +++ b/src/boost/libs/compute/test/test_user_defined_types.cpp @@ -0,0 +1,122 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestUserDefinedTypes +#include <boost/test/unit_test.hpp> + +#include <iostream> + +#include <boost/compute/function.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/algorithm/sort.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/types/struct.hpp> + +namespace compute = boost::compute; + +// user-defined data type containing two int's and a float +struct UDD +{ + int a; + int b; + float c; +}; + +// make UDD available to OpenCL +BOOST_COMPUTE_ADAPT_STRUCT(UDD, UDD, (a, b, c)) + +// comparison operator for UDD +bool operator==(const UDD &lhs, const UDD &rhs) +{ + return lhs.a == rhs.a && lhs.b == rhs.b && lhs.c == rhs.c; +} + +// output stream operator for UDD +std::ostream& operator<<(std::ostream &stream, const UDD &x) +{ + return stream << "(" << x.a << ", " << x.b << ", " << x.c << ")"; +} + +// function to generate a random UDD on the host +UDD rand_UDD() +{ + UDD udd; + udd.a = rand() % 100; + udd.b = rand() % 100; + udd.c = (float)(rand() % 100) / 1.3f; + + return udd; +} + +// function to compare two UDD's on the host by their first component +bool compare_UDD_host(const UDD &lhs, const UDD &rhs) +{ + return lhs.a < rhs.a; +} + +// function to compate two UDD's on the device by their first component +BOOST_COMPUTE_FUNCTION(bool, compare_UDD_device, (UDD lhs, UDD rhs), +{ + return lhs.a < rhs.a; +}); + +#include "check_macros.hpp" +#include "context_setup.hpp" + +// see: issue #11 (https://github.com/boostorg/compute/issues/11) +BOOST_AUTO_TEST_CASE(issue_11) +{ + if(device.vendor() == "NVIDIA" && device.platform().name() == "Apple"){ + // FIXME: this test currently segfaults on NVIDIA GPUs on Apple + std::cerr << "skipping issue test on NVIDIA GPU on Apple platform" << std::endl; + return; + } + + // create vector of random values on the host + std::vector<UDD> host_vector(10); + std::generate(host_vector.begin(), host_vector.end(), rand_UDD); + + // transfer the values to the device + compute::vector<UDD> device_vector(host_vector.size(), context); + compute::copy( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + // sort values on the device + compute::sort( + device_vector.begin(), + device_vector.end(), + compare_UDD_device, + queue + ); + + // sort values on the host + std::sort( + host_vector.begin(), + host_vector.end(), + compare_UDD_host + ); + + // copy sorted device values back to the host + std::vector<UDD> tmp(10); + compute::copy( + device_vector.begin(), + device_vector.end(), + tmp.begin(), + queue + ); + + // verify sorted values + for(size_t i = 0; i < host_vector.size(); i++){ + BOOST_CHECK_EQUAL(tmp[i], host_vector[i]); + } +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_user_event.cpp b/src/boost/libs/compute/test/test_user_event.cpp new file mode 100644 index 00000000..2afbd146 --- /dev/null +++ b/src/boost/libs/compute/test/test_user_event.cpp @@ -0,0 +1,35 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestUserEvent +#include <boost/test/unit_test.hpp> + +#include <boost/compute/user_event.hpp> + +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(empty){} + +#ifdef BOOST_COMPUTE_CL_VERSION_1_1 +BOOST_AUTO_TEST_CASE(user_event) +{ + REQUIRES_OPENCL_VERSION(1, 1); + + boost::compute::user_event event(context); + BOOST_CHECK(event.get() != cl_event()); + BOOST_CHECK(event.status() != CL_COMPLETE); + + event.set_status(CL_COMPLETE); + event.wait(); + BOOST_CHECK(event.status() == CL_COMPLETE); +} +#endif // BOOST_COMPUTE_CL_VERSION_1_1 + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_valarray.cpp b/src/boost/libs/compute/test/test_valarray.cpp new file mode 100644 index 00000000..f6c97673 --- /dev/null +++ b/src/boost/libs/compute/test/test_valarray.cpp @@ -0,0 +1,361 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestValarray +#include <boost/test/unit_test.hpp> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/container/valarray.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +BOOST_AUTO_TEST_CASE(size) +{ + boost::compute::valarray<float> array; + BOOST_CHECK_EQUAL(array.size(), size_t(0)); + + array.resize(10); + BOOST_CHECK_EQUAL(array.size(), size_t(10)); +} + +BOOST_AUTO_TEST_CASE(at) +{ + int data[] = { 1, 2, 3, 4, 5 }; + boost::compute::valarray<int> array(data, 5); + BOOST_CHECK_EQUAL(array.size(), size_t(5)); + + boost::compute::system::finish(); + BOOST_CHECK_EQUAL(int(array[0]), int(1)); + BOOST_CHECK_EQUAL(int(array[1]), int(2)); + BOOST_CHECK_EQUAL(int(array[2]), int(3)); + BOOST_CHECK_EQUAL(int(array[3]), int(4)); + BOOST_CHECK_EQUAL(int(array[4]), int(5)); +} + +BOOST_AUTO_TEST_CASE(min_and_max) +{ + int data[] = { 5, 2, 3, 7, 1, 9, 6, 5 }; + boost::compute::valarray<int> array(data, 8); + BOOST_CHECK_EQUAL(array.size(), size_t(8)); + + BOOST_CHECK_EQUAL((array.min)(), int(1)); + BOOST_CHECK_EQUAL((array.max)(), int(9)); +} + +BOOST_AUTO_TEST_CASE(sum) +{ + int data[] = { 1, 2, 3, 4 }; + boost::compute::valarray<int> array(data, 4); + boost::compute::system::finish(); + + BOOST_CHECK_EQUAL(array.size(), size_t(4)); + BOOST_CHECK_EQUAL(array.sum(), int(10)); +} + +BOOST_AUTO_TEST_CASE(apply) +{ + int data[] = { -1, 2, -3, 4 }; + boost::compute::valarray<int> array(data, 4); + + boost::compute::abs<int> abs; + boost::compute::valarray<int> result = array.apply(abs); + boost::compute::system::finish(); + BOOST_CHECK_EQUAL(int(result[0]), int(1)); + BOOST_CHECK_EQUAL(int(result[1]), int(2)); + BOOST_CHECK_EQUAL(int(result[2]), int(3)); + BOOST_CHECK_EQUAL(int(result[3]), int(4)); +} + +/// \internal_ +/// Tests for compound assignment operators that works for floating +/// point types. +#define BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT(op, op_name) \ +BOOST_AUTO_TEST_CASE(op_name##_ca_operator_no_fp) \ +{ \ + float data[] = { 1, 2, 3, 4 }; \ + boost::compute::valarray<float> array1(data, 4); \ + boost::compute::valarray<float> array2(data, 4); \ + boost::compute::system::finish(); \ + \ + array1 op##= 1; \ + boost::compute::system::finish(); \ + BOOST_CHECK_CLOSE(float(array1[0]), float(1.0f op 1.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array1[1]), float(2.0f op 1.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array1[2]), float(3.0f op 1.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array1[3]), float(4.0f op 1.0f), 1e-4f); \ + \ + array1 = boost::compute::valarray<float>(data, 4); \ + boost::compute::system::finish(); \ + \ + array1 op##= array2; \ + boost::compute::system::finish(); \ + BOOST_CHECK_CLOSE(float(array1[0]), float(1.0f op 1.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array1[1]), float(2.0f op 2.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array1[2]), float(3.0f op 3.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array1[3]), float(4.0f op 4.0f), 1e-4f); \ + \ + array2 op##= array2; \ + boost::compute::system::finish(); \ + BOOST_CHECK_CLOSE(float(array2[0]), float(1.0f op 1.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array2[1]), float(2.0f op 2.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array2[2]), float(3.0f op 3.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(array2[3]), float(4.0f op 4.0f), 1e-4f); \ + \ +} + +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT(+, plus) +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT(-, minus) +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT(*, multiplies) +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT(/, divides) + +#undef BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT + +/// \internal_ +/// Tests for compound assignment operators that does NOT work for floating +/// point types. +/// Note: modulo operator works only for integer types. +#define BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT_NO_FP(op, op_name) \ +BOOST_AUTO_TEST_CASE(op_name##_ca_operator) \ +{ \ + int data[] = { 1, 2, 3, 4 }; \ + boost::compute::valarray<int> array1(data, 4); \ + boost::compute::valarray<int> array2(data, 4); \ + boost::compute::system::finish(); \ + \ + array1 op##= 1; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(int(array1[0]), int(1 op 1)); \ + BOOST_CHECK_EQUAL(int(array1[1]), int(2 op 1)); \ + BOOST_CHECK_EQUAL(int(array1[2]), int(3 op 1)); \ + BOOST_CHECK_EQUAL(int(array1[3]), int(4 op 1)); \ + \ + array1 = boost::compute::valarray<int>(data, 4); \ + boost::compute::system::finish(); \ + \ + array1 op##= array2; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(int(array1[0]), int(1 op 1)); \ + BOOST_CHECK_EQUAL(int(array1[1]), int(2 op 2)); \ + BOOST_CHECK_EQUAL(int(array1[2]), int(3 op 3)); \ + BOOST_CHECK_EQUAL(int(array1[3]), int(4 op 4)); \ + \ + array2 op##= array2; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(int(array2[0]), int(1 op 1)); \ + BOOST_CHECK_EQUAL(int(array2[1]), int(2 op 2)); \ + BOOST_CHECK_EQUAL(int(array2[2]), int(3 op 3)); \ + BOOST_CHECK_EQUAL(int(array2[3]), int(4 op 4)); \ + \ +} + +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT_NO_FP(%, modulus) +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT_NO_FP(^, bit_xor) +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT_NO_FP(&, bit_and) +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT_NO_FP(|, bit_or) +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT_NO_FP(<<, shift_left) +BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT_NO_FP(>>, shift_right) + +#undef BOOST_COMPUTE_TEST_VALARRAY_COMPOUND_ASSIGNMENT_NO_FP + +BOOST_AUTO_TEST_CASE(unary_plus_operator) +{ + int data[] = { 1, 2, 3, 4 }; + boost::compute::valarray<int> array(data, 4); + boost::compute::system::finish(); + + boost::compute::valarray<int> result = +array; + boost::compute::system::finish(); + BOOST_CHECK_EQUAL(int(result[0]), +(int(1))); + BOOST_CHECK_EQUAL(int(result[1]), +(int(2))); + BOOST_CHECK_EQUAL(int(result[2]), +(int(3))); + BOOST_CHECK_EQUAL(int(result[3]), +(int(4))); +} + +BOOST_AUTO_TEST_CASE(unary_minus_operator) +{ + int data[] = { -1, 2, 0, 4 }; + boost::compute::valarray<int> array(data, 4); + boost::compute::system::finish(); + + boost::compute::valarray<int> result = -array; + boost::compute::system::finish(); + BOOST_CHECK_EQUAL(int(result[0]), int(1)); + BOOST_CHECK_EQUAL(int(result[1]), int(-2)); + BOOST_CHECK_EQUAL(int(result[2]), int(0)); + BOOST_CHECK_EQUAL(int(result[3]), int(-4)); +} + +BOOST_AUTO_TEST_CASE(unary_bitwise_not_operator) +{ + int data[] = { 1, 2, 3, 4 }; + boost::compute::valarray<int> array(data, 4); + boost::compute::system::finish(); + + boost::compute::valarray<int> result = ~array; + boost::compute::system::finish(); + BOOST_CHECK_EQUAL(int(result[0]), ~(int(1))); + BOOST_CHECK_EQUAL(int(result[1]), ~(int(2))); + BOOST_CHECK_EQUAL(int(result[2]), ~(int(3))); + BOOST_CHECK_EQUAL(int(result[3]), ~(int(4))); +} + +BOOST_AUTO_TEST_CASE(unary_logical_not_operator) +{ + int data[] = { 1, -2, 0, 4 }; + boost::compute::valarray<int> array(data, 4); + boost::compute::system::finish(); + + boost::compute::valarray<char> result = !array; + boost::compute::system::finish(); + BOOST_CHECK_EQUAL(bool(result[0]), !(int(1))); + BOOST_CHECK_EQUAL(bool(result[1]), !(int(-2))); + BOOST_CHECK_EQUAL(bool(result[2]), !(int(0))); + BOOST_CHECK_EQUAL(bool(result[3]), !(int(4))); +} + +/// \internal_ +/// Tests for binary operators that works for floating +/// point types. +#define BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR(op, op_name) \ +BOOST_AUTO_TEST_CASE(op_name##_binary_operator) \ +{ \ + float data1[] = { 1, 2, 3, 4 }; \ + float data2[] = { 4, 2, 3, 0 }; \ + boost::compute::valarray<float> array1(data1, 4); \ + boost::compute::valarray<float> array2(data2, 4); \ + boost::compute::system::finish(); \ + \ + boost::compute::valarray<float> result = 2.0f op array1; \ + boost::compute::system::finish(); \ + BOOST_CHECK_CLOSE(float(result[0]), float(2.0f op 1.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[1]), float(2.0f op 2.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[2]), float(2.0f op 3.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[3]), float(2.0f op 4.0f), 1e-4f); \ + \ + result = array1 op 2.0f; \ + boost::compute::system::finish(); \ + BOOST_CHECK_CLOSE(float(result[0]), float(1.0f op 2.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[1]), float(2.0f op 2.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[2]), float(3.0f op 2.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[3]), float(4.0f op 2.0f), 1e-4f); \ + \ + result = array2 op array1; \ + boost::compute::system::finish(); \ + BOOST_CHECK_CLOSE(float(result[0]), float(4.0f op 1.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[1]), float(2.0f op 2.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[2]), float(3.0f op 3.0f), 1e-4f); \ + BOOST_CHECK_CLOSE(float(result[3]), float(0.0f op 4.0f), 1e-4f); \ +} + +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR(+, plus) +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR(-, minus) +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR(*, multiplies) +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR(/, divides) + +#undef BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR + +/// \internal_ +/// Tests for compound assignment operators that does NOT work for floating +/// point types. +/// Note: modulo operator works only for integer types. +#define BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR_NO_FP(op, op_name) \ +BOOST_AUTO_TEST_CASE(op_name##_binary_operator) \ +{ \ + int data1[] = { 1, 2, 3, 4 }; \ + int data2[] = { 4, 5, 2, 1 }; \ + boost::compute::valarray<int> array1(data1, 4); \ + boost::compute::valarray<int> array2(data2, 4); \ + boost::compute::system::finish(); \ + \ + boost::compute::valarray<int> result = 5 op array1; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(int(result[0]), int(5 op 1)); \ + BOOST_CHECK_EQUAL(int(result[1]), int(5 op 2)); \ + BOOST_CHECK_EQUAL(int(result[2]), int(5 op 3)); \ + BOOST_CHECK_EQUAL(int(result[3]), int(5 op 4)); \ + \ + result = array1 op 5; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(int(result[0]), int(1 op 5)); \ + BOOST_CHECK_EQUAL(int(result[1]), int(2 op 5)); \ + BOOST_CHECK_EQUAL(int(result[2]), int(3 op 5)); \ + BOOST_CHECK_EQUAL(int(result[3]), int(4 op 5)); \ + \ + result = array1 op array2; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(int(result[0]), int(1 op 4)); \ + BOOST_CHECK_EQUAL(int(result[1]), int(2 op 5)); \ + BOOST_CHECK_EQUAL(int(result[2]), int(3 op 2)); \ + BOOST_CHECK_EQUAL(int(result[3]), int(4 op 1)); \ +} + +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR_NO_FP(^, bit_xor) +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR_NO_FP(&, bit_and) +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR_NO_FP(|, bit_or) +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR_NO_FP(<<, shift_left) +BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR_NO_FP(>>, shift_right) + +#undef BOOST_COMPUTE_TEST_VALARRAY_BINARY_OPERATOR_NO_FP + +/// \internal_ +/// Macro for generating tests for valarray comparison operators. +#define BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR(op, op_name) \ +BOOST_AUTO_TEST_CASE(op_name##_comparision_operator) \ +{ \ + int data1[] = { 1, 2, 0, 4 }; \ + int data2[] = { 4, 0, 2, 1 }; \ + boost::compute::valarray<int> array1(data1, 4); \ + boost::compute::valarray<int> array2(data2, 4); \ + boost::compute::system::finish(); \ + \ + boost::compute::valarray<char> result = 2 op array1; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(bool(result[0]), bool(2 op 1)); \ + BOOST_CHECK_EQUAL(bool(result[1]), bool(2 op 2)); \ + BOOST_CHECK_EQUAL(bool(result[2]), bool(2 op 0)); \ + BOOST_CHECK_EQUAL(bool(result[3]), bool(2 op 4)); \ + \ + result = array1 op 2; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(bool(result[0]), bool(1 op 2)); \ + BOOST_CHECK_EQUAL(bool(result[1]), bool(2 op 2)); \ + BOOST_CHECK_EQUAL(bool(result[2]), bool(0 op 2)); \ + BOOST_CHECK_EQUAL(bool(result[3]), bool(4 op 2)); \ + \ + result = array1 op array2; \ + boost::compute::system::finish(); \ + BOOST_CHECK_EQUAL(bool(result[0]), bool(1 op 4)); \ + BOOST_CHECK_EQUAL(bool(result[1]), bool(2 op 0)); \ + BOOST_CHECK_EQUAL(bool(result[2]), bool(0 op 2)); \ + BOOST_CHECK_EQUAL(bool(result[3]), bool(4 op 1)); \ +} + +BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR(==, equal_to) +BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR(!=, not_equal_to) +BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR(>, greater) +BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR(<, less) +BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR(>=, greater_equal) +BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR(<=, less_equal) + +/// \internal_ +/// Macro for generating tests for valarray binary logical operators. +#define BOOST_COMPUTE_TEST_VALARRAY_LOGICAL_OPERATOR(op, op_name) \ + BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR(op, op_name) + +BOOST_COMPUTE_TEST_VALARRAY_LOGICAL_OPERATOR(&&, logical_and) +BOOST_COMPUTE_TEST_VALARRAY_LOGICAL_OPERATOR(||, logical_or) + +#undef BOOST_COMPUTE_TEST_VALARRAY_LOGICAL_OPERATOR + +#undef BOOST_COMPUTE_TEST_VALARRAY_COMPARISON_OPERATOR + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_vector.cpp b/src/boost/libs/compute/test/test_vector.cpp new file mode 100644 index 00000000..c3dd8b79 --- /dev/null +++ b/src/boost/libs/compute/test/test_vector.cpp @@ -0,0 +1,502 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestVector +#include <boost/test/unit_test.hpp> +#include <boost/concept_check.hpp> + +#include <iostream> + +#include <boost/compute/system.hpp> +#include <boost/compute/command_queue.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/fill.hpp> +#include <boost/compute/algorithm/find.hpp> +#include <boost/compute/algorithm/remove.hpp> +#include <boost/compute/allocator/pinned_allocator.hpp> +#include <boost/compute/container/vector.hpp> + +#include "quirks.hpp" +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace bc = boost::compute; +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(concept_check) +{ + BOOST_CONCEPT_ASSERT((boost::Container<bc::vector<int> >)); + //BOOST_CONCEPT_ASSERT((boost::SequenceConcept<bc::vector<int> >)); + BOOST_CONCEPT_ASSERT((boost::ReversibleContainer<bc::vector<int> >)); + BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<bc::vector<int>::iterator>)); + BOOST_CONCEPT_ASSERT((boost::RandomAccessIterator<bc::vector<int>::const_iterator>)); +} + +BOOST_AUTO_TEST_CASE(size) +{ + bc::vector<int> empty_vector(context); + BOOST_CHECK_EQUAL(empty_vector.size(), size_t(0)); + BOOST_CHECK_EQUAL(empty_vector.empty(), true); + + bc::vector<int> int_vector(10, context); + BOOST_CHECK_EQUAL(int_vector.size(), size_t(10)); + BOOST_CHECK_EQUAL(int_vector.empty(), false); +} + +BOOST_AUTO_TEST_CASE(resize) +{ + bc::vector<int> int_vector(10, context); + BOOST_CHECK_EQUAL(int_vector.size(), size_t(10)); + + int_vector.resize(20, queue); + BOOST_CHECK_EQUAL(int_vector.size(), size_t(20)); + + int_vector.resize(5, queue); + BOOST_CHECK_EQUAL(int_vector.size(), size_t(5)); +} + +BOOST_AUTO_TEST_CASE(reserve) +{ + const float growth_factor = 1.5f; + + bc::vector<int> int_vector(10, context); + BOOST_CHECK_EQUAL(int_vector.size(), size_t(10)); + BOOST_CHECK_EQUAL(int_vector.capacity(), size_t(10)); + + int_vector.reserve(20, queue); + BOOST_CHECK_EQUAL(int_vector.size(), size_t(10)); + BOOST_CHECK_EQUAL(int_vector.capacity(), size_t(20 * growth_factor)); + + int_vector.reserve(5, queue); + BOOST_CHECK_EQUAL(int_vector.size(), size_t(10)); + BOOST_CHECK_EQUAL(int_vector.capacity(), size_t(20 * growth_factor)); +} + +BOOST_AUTO_TEST_CASE(array_operator) +{ + bc::vector<int> vector(10, context); + bc::fill(vector.begin(), vector.end(), 0, queue); + CHECK_RANGE_EQUAL(int, 10, vector, (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)); + + bc::fill(vector.begin(), vector.end(), 42, queue); + CHECK_RANGE_EQUAL(int, 10, vector, (42, 42, 42, 42, 42, 42, 42, 42, 42, 42)); + + vector[0] = 9; + CHECK_RANGE_EQUAL(int, 10, vector, (9, 42, 42, 42, 42, 42, 42, 42, 42, 42)); +} + +BOOST_AUTO_TEST_CASE(front_and_back) +{ + int int_data[] = { 1, 2, 3, 4, 5 }; + bc::vector<int> int_vector(5, context); + bc::copy(int_data, int_data + 5, int_vector.begin(), queue); + queue.finish(); + BOOST_CHECK_EQUAL(int_vector.front(), 1); + BOOST_CHECK_EQUAL(int_vector.back(), 5); + + bc::fill(int_vector.begin(), int_vector.end(), 10, queue); + queue.finish(); + BOOST_CHECK_EQUAL(int_vector.front(), 10); + BOOST_CHECK_EQUAL(int_vector.back(), 10); + + float float_data[] = { 1.1f, 2.2f, 3.3f, 4.4f, 5.5f }; + bc::vector<float> float_vector(5, context); + bc::copy(float_data, float_data + 5, float_vector.begin(), queue); + queue.finish(); + BOOST_CHECK_EQUAL(float_vector.front(), 1.1f); + BOOST_CHECK_EQUAL(float_vector.back(), 5.5f); +} + +BOOST_AUTO_TEST_CASE(host_iterator_constructor) +{ + std::vector<int> host_vector; + host_vector.push_back(10); + host_vector.push_back(20); + host_vector.push_back(30); + host_vector.push_back(40); + + bc::vector<int> device_vector(host_vector.begin(), host_vector.end(), + queue); + CHECK_RANGE_EQUAL(int, 4, device_vector, (10, 20, 30, 40)); +} + +BOOST_AUTO_TEST_CASE(device_iterator_constructor) +{ + int data[] = { 1, 5, 10, 15 }; + bc::vector<int> a(data, data + 4, queue); + CHECK_RANGE_EQUAL(int, 4, a, (1, 5, 10, 15)); + + bc::vector<int> b(a.begin(), a.end(), queue); + CHECK_RANGE_EQUAL(int, 4, b, (1, 5, 10, 15)); +} + +BOOST_AUTO_TEST_CASE(push_back) +{ + bc::vector<int> vector(context); + BOOST_VERIFY(vector.empty()); + + vector.push_back(12, queue); + BOOST_VERIFY(!vector.empty()); + BOOST_CHECK_EQUAL(vector.size(), size_t(1)); + CHECK_RANGE_EQUAL(int, 1, vector, (12)); + + vector.push_back(24, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(2)); + CHECK_RANGE_EQUAL(int, 2, vector, (12, 24)); + + vector.push_back(36, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(3)); + CHECK_RANGE_EQUAL(int, 3, vector, (12, 24, 36)); + + for(int i = 0; i < 100; i++){ + vector.push_back(i, queue); + } + queue.finish(); + BOOST_CHECK_EQUAL(vector.size(), size_t(103)); + BOOST_CHECK_EQUAL(vector[0], 12); + BOOST_CHECK_EQUAL(vector[1], 24); + BOOST_CHECK_EQUAL(vector[2], 36); + BOOST_CHECK_EQUAL(vector[102], 99); +} + +BOOST_AUTO_TEST_CASE(at) +{ + bc::vector<int> vector(context); + vector.push_back(1, queue); + vector.push_back(2, queue); + vector.push_back(3, queue); + queue.finish(); + BOOST_CHECK_EQUAL(vector.at(0), 1); + BOOST_CHECK_EQUAL(vector.at(1), 2); + BOOST_CHECK_EQUAL(vector.at(2), 3); + BOOST_CHECK_THROW(vector.at(3), std::out_of_range); +} + +BOOST_AUTO_TEST_CASE(erase) +{ + int data[] = { 1, 2, 5, 7, 9 }; + bc::vector<int> vector(data, data + 5, queue); + queue.finish(); + BOOST_CHECK_EQUAL(vector.size(), size_t(5)); + + vector.erase(vector.begin() + 1, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, vector, (1, 5, 7, 9)); + + vector.erase(vector.begin() + 2, vector.end(), queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(2)); + CHECK_RANGE_EQUAL(int, 2, vector, (1, 5)); +} + +BOOST_AUTO_TEST_CASE(max_size) +{ + bc::vector<int> vector(100, context); + BOOST_CHECK_EQUAL(vector.size(), size_t(100)); + BOOST_VERIFY(vector.max_size() > vector.size()); +} + +#ifndef BOOST_COMPUTE_NO_RVALUE_REFERENCES +BOOST_AUTO_TEST_CASE(move_ctor) +{ + int data[] = { 11, 12, 13, 14 }; + bc::vector<int> a(data, data + 4, queue); + BOOST_CHECK_EQUAL(a.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, a, (11, 12, 13, 14)); + + bc::vector<int> b(std::move(a)); + BOOST_CHECK(a.size() == 0); + BOOST_CHECK(a.get_buffer().get() == 0); + BOOST_CHECK_EQUAL(b.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, b, (11, 12, 13, 14)); +} + +BOOST_AUTO_TEST_CASE(move_ctor_custom_alloc) +{ + int data[] = { 11, 12, 13, 14 }; + bc::vector<int, bc::pinned_allocator<int> > a(data, data + 4, queue); + BOOST_CHECK_EQUAL(a.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, a, (11, 12, 13, 14)); + + bc::vector<int, bc::pinned_allocator<int> > b(std::move(a)); + BOOST_CHECK(a.size() == 0); + BOOST_CHECK(a.get_buffer().get() == 0); + BOOST_CHECK_EQUAL(b.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, b, (11, 12, 13, 14)); +} +#endif // BOOST_COMPUTE_NO_RVALUE_REFERENCES + +#ifdef BOOST_COMPUTE_USE_CPP11 +#ifndef BOOST_COMPUTE_NO_HDR_INITIALIZER_LIST +BOOST_AUTO_TEST_CASE(initializer_list_ctor) +{ + // ctor with std::initializer_list<T> always uses + // default_queue in this case + bc::vector<int> vector = { 2, -4, 6, 8 }; + BOOST_CHECK_EQUAL(vector.size(), size_t(4)); + BOOST_CHECK_EQUAL(vector[0], 2); + BOOST_CHECK_EQUAL(vector[1], -4); + BOOST_CHECK_EQUAL(vector[2], 6); + BOOST_CHECK_EQUAL(vector[3], 8); +} +#endif // BOOST_COMPUTE_NO_HDR_INITIALIZER_LIST +#endif // BOOST_COMPUTE_USE_CPP11 + +BOOST_AUTO_TEST_CASE(vector_double) +{ + if(!device.supports_extension("cl_khr_fp64")){ + return; + } + + bc::vector<double> vector(context); + vector.push_back(1.21, queue); + vector.push_back(3.14, queue); + vector.push_back(7.89, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(3)); + CHECK_RANGE_EQUAL(double, 3, vector, (1.21, 3.14, 7.89)); + + bc::vector<double> other(vector.begin(), vector.end(), queue); + CHECK_RANGE_EQUAL(double, 3, other, (1.21, 3.14, 7.89)); + + bc::fill(other.begin(), other.end(), 8.95, queue); + CHECK_RANGE_EQUAL(double, 3, other, (8.95, 8.95, 8.95)); +} + +BOOST_AUTO_TEST_CASE(vector_iterator) +{ + bc::vector<int> vector(context); + vector.push_back(2, queue); + vector.push_back(4, queue); + vector.push_back(6, queue); + vector.push_back(8, queue); + queue.finish(); + BOOST_CHECK_EQUAL(vector.size(), size_t(4)); + BOOST_CHECK_EQUAL(vector[0], 2); + BOOST_CHECK_EQUAL(*vector.begin(), 2); + BOOST_CHECK_EQUAL(vector.begin()[0], 2); + BOOST_CHECK_EQUAL(vector[1], 4); + BOOST_CHECK_EQUAL(*(vector.begin()+1), 4); + BOOST_CHECK_EQUAL(vector.begin()[1], 4); + BOOST_CHECK_EQUAL(vector[2], 6); + BOOST_CHECK_EQUAL(*(vector.begin()+2), 6); + BOOST_CHECK_EQUAL(vector.begin()[2], 6); + BOOST_CHECK_EQUAL(vector[3], 8); + BOOST_CHECK_EQUAL(*(vector.begin()+3), 8); + BOOST_CHECK_EQUAL(vector.begin()[3], 8); +} + +BOOST_AUTO_TEST_CASE(vector_erase_remove) +{ + int data[] = { 2, 6, 3, 4, 2, 4, 5, 6, 1 }; + bc::vector<int> vector(data, data + 9, queue); + BOOST_CHECK_EQUAL(vector.size(), size_t(9)); + + // remove 4's + vector.erase(bc::remove(vector.begin(), vector.end(), 4, queue), vector.end()); + BOOST_CHECK_EQUAL(vector.size(), size_t(7)); + BOOST_VERIFY(bc::find(vector.begin(), vector.end(), 4, queue) == vector.end()); + + // remove 2's + vector.erase(bc::remove(vector.begin(), vector.end(), 2, queue), vector.end()); + BOOST_CHECK_EQUAL(vector.size(), size_t(5)); + BOOST_VERIFY(bc::find(vector.begin(), vector.end(), 2, queue) == vector.end()); + + // remove 6's + vector.erase(bc::remove(vector.begin(), vector.end(), 6, queue), vector.end()); + BOOST_CHECK_EQUAL(vector.size(), size_t(3)); + BOOST_VERIFY(bc::find(vector.begin(), vector.end(), 6, queue) == vector.end()); + + // check the rest of the values + CHECK_RANGE_EQUAL(int, 3, vector, (3, 5, 1)); +} + +// see issue #132 (https://github.com/boostorg/compute/issues/132) +BOOST_AUTO_TEST_CASE(swap_between_contexts) +{ + compute::context ctx1(device); + compute::context ctx2(device); + + compute::vector<int> vec1(32, ctx1); + compute::vector<int> vec2(32, ctx2); + + BOOST_CHECK(vec1.get_allocator().get_context() == ctx1); + BOOST_CHECK(vec2.get_allocator().get_context() == ctx2); + + vec1.swap(vec2); + + BOOST_CHECK(vec1.get_allocator().get_context() == ctx2); + BOOST_CHECK(vec2.get_allocator().get_context() == ctx1); + + vec1.resize(64); + vec2.resize(64); +} + +BOOST_AUTO_TEST_CASE(assign_from_std_vector) +{ + std::vector<int> host_vector; + host_vector.push_back(1); + host_vector.push_back(9); + host_vector.push_back(7); + host_vector.push_back(9); + + compute::vector<int> device_vector(context); + device_vector.assign(host_vector.begin(), host_vector.end(), queue); + BOOST_CHECK_EQUAL(device_vector.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, device_vector, (1, 9, 7, 9)); +} + +BOOST_AUTO_TEST_CASE(assign_constant_value) +{ + compute::vector<float> device_vector(10, context); + device_vector.assign(3, 6.28f, queue); + BOOST_CHECK_EQUAL(device_vector.size(), size_t(3)); + CHECK_RANGE_EQUAL(float, 3, device_vector, (6.28f, 6.28f, 6.28f)); +} + +BOOST_AUTO_TEST_CASE(resize_throw_exception) +{ + if(bug_in_clcreatebuffer(device)) { + std::cerr + << "skipping resize_throw_exception test on Apple platform" + << std::endl; + return; + } + + // create vector with eight items + int data[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; + compute::vector<int> vec(data, data + 8, queue); + + // try to resize to 2x larger than the global memory size + BOOST_CHECK_THROW( + vec.resize((device.global_memory_size() / sizeof(int)) * 2), + boost::compute::opencl_error + ); + + // ensure vector data is still the same + BOOST_CHECK_EQUAL(vec.size(), size_t(8)); + CHECK_RANGE_EQUAL(int, 8, vec, (1, 2, 3, 4, 5, 6, 7, 8)); +} + +BOOST_AUTO_TEST_CASE(copy_ctor_custom_alloc) +{ + int data[] = { 11, 12, 13, 14 }; + bc::vector<int, bc::pinned_allocator<int> > a(data, data + 4, queue); + BOOST_CHECK_EQUAL(a.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, a, (11, 12, 13, 14)); + + bc::vector<int, bc::pinned_allocator<int> > b(a, queue); + BOOST_CHECK_EQUAL(b.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, b, (11, 12, 13, 14)); +} + +BOOST_AUTO_TEST_CASE(copy_ctor_different_alloc) +{ + int data[] = { 11, 12, 13, 14 }; + bc::vector<int> a(data, data + 4, queue); + BOOST_CHECK_EQUAL(a.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, a, (11, 12, 13, 14)); + + bc::vector<int, bc::pinned_allocator<int> > b(a, queue); + BOOST_CHECK_EQUAL(b.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, b, (11, 12, 13, 14)); + + std::vector<int> host_vector; + host_vector.push_back(1); + host_vector.push_back(9); + host_vector.push_back(7); + host_vector.push_back(9); + + bc::vector<int, bc::pinned_allocator<int> > c(host_vector, queue); + BOOST_CHECK_EQUAL(c.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, c, (1, 9, 7, 9)); +} + +BOOST_AUTO_TEST_CASE(assignment_operator) +{ + int adata[] = { 11, 12, 13, 14 }; + bc::vector<int> a(adata, adata + 4, queue); + BOOST_CHECK_EQUAL(a.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, a, (11, 12, 13, 14)); + + bc::vector<int> b = a; + BOOST_CHECK_EQUAL(b.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, b, (11, 12, 13, 14)); + + bc::vector<int, bc::pinned_allocator<int> > c(context); + c = b; + BOOST_CHECK_EQUAL(c.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, c, (11, 12, 13, 14)); + + int ddata[] = { 21, 22, 23 }; + bc::vector<int, bc::pinned_allocator<int> > d(ddata, ddata + 3, queue); + BOOST_CHECK_EQUAL(d.size(), size_t(3)); + CHECK_RANGE_EQUAL(int, 3, d, (21, 22, 23)); + + a = d; + BOOST_CHECK_EQUAL(a.size(), size_t(3)); + CHECK_RANGE_EQUAL(int, 3, a, (21, 22, 23)); + + std::vector<int> host_vector; + host_vector.push_back(1); + host_vector.push_back(9); + host_vector.push_back(7); + host_vector.push_back(9); + + d = host_vector; + BOOST_CHECK_EQUAL(d.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, d, (1, 9, 7, 9)); +} + +BOOST_AUTO_TEST_CASE(swap_ctor_custom_alloc) +{ + int adata[] = { 11, 12, 13, 14 }; + bc::vector<int, bc::pinned_allocator<int> > a(adata, adata + 4, queue); + BOOST_CHECK_EQUAL(a.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, a, (11, 12, 13, 14)); + + int bdata[] = { 21, 22, 23 }; + bc::vector<int, bc::pinned_allocator<int> > b(bdata, bdata + 3, queue); + BOOST_CHECK_EQUAL(b.size(), size_t(3)); + CHECK_RANGE_EQUAL(int, 3, b, (21, 22, 23)); + + a.swap(b); + BOOST_CHECK_EQUAL(a.size(), size_t(3)); + CHECK_RANGE_EQUAL(int, 3, a, (21, 22, 23)); + BOOST_CHECK_EQUAL(b.size(), size_t(4)); + CHECK_RANGE_EQUAL(int, 4, b, (11, 12, 13, 14)); +} + +BOOST_AUTO_TEST_CASE(shrink_to_fit) +{ + bc::vector<bc::int_> int_vector(5, context); + BOOST_CHECK_EQUAL(int_vector.size(), 5); + BOOST_CHECK(int_vector.capacity() >= 5); + + int_vector.reserve(15); + BOOST_CHECK_EQUAL(int_vector.size(), 5); + BOOST_CHECK(int_vector.capacity() >= 15); + + int_vector.shrink_to_fit(); + BOOST_CHECK_EQUAL(int_vector.size(), 5); + BOOST_CHECK_EQUAL(int_vector.capacity(), 5); + + int_vector.clear(); + BOOST_CHECK_EQUAL(int_vector.size(), 0); + BOOST_CHECK_EQUAL(int_vector.capacity(), 5); + + int_vector.shrink_to_fit(); + BOOST_CHECK_EQUAL(int_vector.size(), 0); + BOOST_CHECK_EQUAL(int_vector.capacity(), 0); + + int_vector.reserve(15); + BOOST_CHECK_EQUAL(int_vector.size(), 0); + BOOST_CHECK(int_vector.capacity() >= 15); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_wait_list.cpp b/src/boost/libs/compute/test/test_wait_list.cpp new file mode 100644 index 00000000..f6e0570a --- /dev/null +++ b/src/boost/libs/compute/test/test_wait_list.cpp @@ -0,0 +1,82 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestWaitList +#include <boost/test/unit_test.hpp> + +#include <algorithm> +#include <vector> + +#include <boost/compute/command_queue.hpp> +#include <boost/compute/system.hpp> +#include <boost/compute/async/future.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/utility/wait_list.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(create_wait_list) +{ + compute::wait_list events; + BOOST_CHECK_EQUAL(events.size(), size_t(0)); + BOOST_CHECK_EQUAL(events.empty(), true); + BOOST_CHECK(events.get_event_ptr() == 0); +} + +#ifndef BOOST_COMPUTE_NO_HDR_INITIALIZER_LIST +BOOST_AUTO_TEST_CASE(create_wait_list_from_initializer_list) +{ + compute::event event0; + compute::event event1; + compute::event event2; + compute::wait_list events = { event0, event1, event2 }; + BOOST_CHECK_EQUAL(events.size(), size_t(3)); + CHECK_RANGE_EQUAL(compute::event, 3, events, (event0, event1, event2)); +} +#endif // BOOST_COMPUTE_NO_HDR_INITIALIZER_LIST + +BOOST_AUTO_TEST_CASE(insert_future) +{ + // create vector on the host + std::vector<int> host_vector(4); + std::fill(host_vector.begin(), host_vector.end(), 7); + + // create vector on the device + compute::vector<int> device_vector(4, context); + + // create wait list + compute::wait_list events; + + // copy values to device + compute::future<void> future = compute::copy_async( + host_vector.begin(), host_vector.end(), device_vector.begin(), queue + ); + + // add future event to the wait list + events.insert(future); + BOOST_CHECK_EQUAL(events.size(), size_t(1)); + BOOST_CHECK(events.get_event_ptr() != 0); + + // wait for copy to complete + events.wait(); + + // check values + CHECK_RANGE_EQUAL(int, 4, device_vector, (7, 7, 7, 7)); + + // clear the event list + events.clear(); + BOOST_CHECK_EQUAL(events.size(), size_t(0)); +} + +BOOST_AUTO_TEST_SUITE_END() diff --git a/src/boost/libs/compute/test/test_zip_iterator.cpp b/src/boost/libs/compute/test/test_zip_iterator.cpp new file mode 100644 index 00000000..ae76d580 --- /dev/null +++ b/src/boost/libs/compute/test/test_zip_iterator.cpp @@ -0,0 +1,232 @@ +//---------------------------------------------------------------------------// +// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com> +// +// Distributed under the Boost Software License, Version 1.0 +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt +// +// See http://boostorg.github.com/compute for more information. +//---------------------------------------------------------------------------// + +#define BOOST_TEST_MODULE TestZipIterator +#include <boost/test/unit_test.hpp> + +#include <boost/type_traits.hpp> +#include <boost/static_assert.hpp> +#include <boost/tuple/tuple_io.hpp> +#include <boost/tuple/tuple_comparison.hpp> + +#include <boost/compute/functional.hpp> +#include <boost/compute/algorithm/copy.hpp> +#include <boost/compute/algorithm/transform.hpp> +#include <boost/compute/container/vector.hpp> +#include <boost/compute/iterator/constant_iterator.hpp> +#include <boost/compute/iterator/zip_iterator.hpp> +#include <boost/compute/types/tuple.hpp> + +#include "check_macros.hpp" +#include "context_setup.hpp" + +namespace compute = boost::compute; + +BOOST_AUTO_TEST_CASE(value_type) +{ + BOOST_STATIC_ASSERT(( + boost::is_same< + boost::compute::zip_iterator< + boost::tuple< + boost::compute::buffer_iterator<float>, + boost::compute::buffer_iterator<int> + > + >::value_type, + boost::tuple<float, int> + >::value + )); +} + +BOOST_AUTO_TEST_CASE(distance) +{ + boost::compute::vector<char> char_vector(5, context); + boost::compute::vector<int> int_vector(5, context); + + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_zip_iterator( + boost::make_tuple( + char_vector.begin(), + int_vector.begin() + ) + ), + boost::compute::make_zip_iterator( + boost::make_tuple( + char_vector.end(), + int_vector.end() + ) + ) + ), + ptrdiff_t(5) + ); + + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_zip_iterator( + boost::make_tuple( + char_vector.begin(), + int_vector.begin() + ) + ) + 1, + boost::compute::make_zip_iterator( + boost::make_tuple( + char_vector.end(), + int_vector.end() + ) + ) - 1 + ), + ptrdiff_t(3) + ); + + BOOST_CHECK_EQUAL( + std::distance( + boost::compute::make_zip_iterator( + boost::make_tuple( + char_vector.begin() + 2, + int_vector.begin() + 2 + ) + ), + boost::compute::make_zip_iterator( + boost::make_tuple( + char_vector.end() - 1, + int_vector.end() - 1 + ) + ) + ), + ptrdiff_t(2) + ); +} + +BOOST_AUTO_TEST_CASE(copy) +{ + // create three separate vectors of three different types + char char_data[] = { 'x', 'y', 'z' }; + boost::compute::vector<char> char_vector(char_data, char_data + 3, queue); + + int int_data[] = { 4, 7, 9 }; + boost::compute::vector<int> int_vector(int_data, int_data + 3, queue); + + float float_data[] = { 3.2f, 4.5f, 7.6f }; + boost::compute::vector<float> float_vector(float_data, float_data + 3, queue); + + // zip all three vectors into a single tuple vector + boost::compute::vector<boost::tuple<char, int, float> > tuple_vector(3, context); + + boost::compute::copy( + boost::compute::make_zip_iterator( + boost::make_tuple( + char_vector.begin(), + int_vector.begin(), + float_vector.begin() + ) + ), + boost::compute::make_zip_iterator( + boost::make_tuple( + char_vector.end(), + int_vector.end(), + float_vector.end() + ) + ), + tuple_vector.begin(), + queue + ); + + // copy tuple vector to host + std::vector<boost::tuple<char, int, float> > host_vector(3); + + boost::compute::copy( + tuple_vector.begin(), + tuple_vector.end(), + host_vector.begin(), + queue + ); + + // check tuple values + BOOST_CHECK_EQUAL(host_vector[0], boost::make_tuple('x', 4, 3.2f)); + BOOST_CHECK_EQUAL(host_vector[1], boost::make_tuple('y', 7, 4.5f)); + BOOST_CHECK_EQUAL(host_vector[2], boost::make_tuple('z', 9, 7.6f)); +} + +BOOST_AUTO_TEST_CASE(zip_iterator_get) +{ + int data1[] = { 0, 2, 4, 6, 8 }; + int data2[] = { 1, 3, 5, 7, 9 }; + + compute::vector<int> input1(data1, data1 + 5, queue); + compute::vector<int> input2(data2, data2 + 5, queue); + compute::vector<int> output(5, context); + + // extract first component from (input1) + compute::transform( + compute::make_zip_iterator( + boost::make_tuple(input1.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(input1.end()) + ), + output.begin(), + compute::get<0>(), + queue + ); + CHECK_RANGE_EQUAL(int, 5, output, (0, 2, 4, 6, 8)); + + // extract first component from (input2, input1) + compute::transform( + compute::make_zip_iterator( + boost::make_tuple(input2.begin(), input1.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(input2.end(), input1.end()) + ), + output.begin(), + compute::get<0>(), + queue + ); + CHECK_RANGE_EQUAL(int, 5, output, (1, 3, 5, 7, 9)); + + // extract second component from (input1, input2, input1) + compute::transform( + compute::make_zip_iterator( + boost::make_tuple(input1.begin(), input2.begin(), input1.begin()) + ), + compute::make_zip_iterator( + boost::make_tuple(input1.end(), input2.end(), input1.end()) + ), + output.begin(), + compute::get<1>(), + queue + ); + CHECK_RANGE_EQUAL(int, 5, output, (1, 3, 5, 7, 9)); +} + +BOOST_AUTO_TEST_CASE(zip_constant_iterator) +{ + compute::vector<int> result(4, context); + + compute::transform( + compute::make_zip_iterator( + boost::make_tuple( + compute::make_constant_iterator(7) + ) + ), + compute::make_zip_iterator( + boost::make_tuple( + compute::make_constant_iterator(7, result.size()) + ) + ), + result.begin(), + compute::get<0>(), + queue + ); + + CHECK_RANGE_EQUAL(int, 4, result, (7, 7, 7, 7)); +} + +BOOST_AUTO_TEST_SUITE_END() |