97 lines
3.4 KiB
C++
97 lines
3.4 KiB
C++
//---------------------------------------------------------------------------//
|
|
// 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;
|
|
}
|