mirror of
https://github.com/opencv/opencv.git
synced 2024-11-28 05:06:29 +08:00
improved performance of bitwise ops
This commit is contained in:
Ilya Lavrenov
parent
adc15c2bba
commit
6f76e7b42d
@ -1336,157 +1336,118 @@ int cv::ocl::countNonZero(const oclMat &src)
|
||||
////////////////////////////////bitwise_op////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
static void bitwise_unary_run(const oclMat &src1, oclMat &dst, string kernelName, const cv::ocl::ProgramEntry* source)
|
||||
enum { AND = 0, OR, XOR, NOT };
|
||||
|
||||
static void bitwise_run(const oclMat & src1, const oclMat & src2, const Scalar & src3, const oclMat & mask,
|
||||
oclMat & dst, int operationType)
|
||||
{
|
||||
dst.create(src1.size(), src1.type());
|
||||
|
||||
int channels = dst.oclchannels();
|
||||
int depth = dst.depth();
|
||||
|
||||
int vector_lengths[4][7] = {{4, 4, 4, 4, 1, 1, 1},
|
||||
{4, 4, 4, 4, 1, 1, 1},
|
||||
{4, 4, 4, 4, 1, 1, 1},
|
||||
{4, 4, 4, 4, 1, 1, 1}
|
||||
};
|
||||
|
||||
size_t vector_length = vector_lengths[channels - 1][depth];
|
||||
int offset_cols = (dst.offset / dst.elemSize1()) & (vector_length - 1);
|
||||
int cols = divUp(dst.cols * channels + offset_cols, vector_length);
|
||||
|
||||
#ifdef ANDROID
|
||||
size_t localThreads[3] = { 64, 2, 1 };
|
||||
#else
|
||||
size_t localThreads[3] = { 64, 4, 1 };
|
||||
#endif
|
||||
size_t globalThreads[3] = { cols, dst.rows, 1 };
|
||||
|
||||
int dst_step1 = dst.cols * dst.elemSize();
|
||||
vector<pair<size_t , const void *> > args;
|
||||
args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.step ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.offset ));
|
||||
args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.offset ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&dst_step1 ));
|
||||
|
||||
openCLExecuteKernel(src1.clCxt, source, kernelName, globalThreads, localThreads, args, -1, depth);
|
||||
}
|
||||
|
||||
enum { AND = 0, OR, XOR };
|
||||
|
||||
static void bitwise_binary_run(const oclMat &src1, const oclMat &src2, const Scalar& src3, const oclMat &mask,
|
||||
oclMat &dst, int operationType)
|
||||
{
|
||||
CV_Assert(operationType >= AND && operationType <= XOR);
|
||||
CV_Assert(src2.empty() || (!src2.empty() && src1.type() == src2.type() && src1.size() == src2.size()));
|
||||
CV_Assert(mask.empty() || (!mask.empty() && mask.type() == CV_8UC1 && mask.size() == src1.size()));
|
||||
CV_Assert(operationType >= AND && operationType <= NOT);
|
||||
CV_Assert(src2.empty() || (src1.type() == src2.type() && src1.size() == src2.size()));
|
||||
CV_Assert(mask.empty() || (mask.type() == CV_8UC1 && mask.size() == src1.size()));
|
||||
|
||||
dst.create(src1.size(), src1.type());
|
||||
oclMat m;
|
||||
double scalar[4];
|
||||
|
||||
const char operationMap[] = { '&', '|', '^' };
|
||||
std::string kernelName("arithm_bitwise_binary");
|
||||
bool haveScalar = src2.empty() && operationType != NOT, haveMask = !mask.empty();
|
||||
int ocn = dst.oclchannels(), depth = dst.depth();
|
||||
const char operationMap[] = { '&', '|', '^', '~' };
|
||||
const char * const typeMap[] = { "uchar", "uchar", "ushort", "ushort", "int", "int", "ulong" };
|
||||
const char * const channelMap[] = { "", "", "2", "4", "4", "", "", "", "8", "", "", "", "", "", "", "", "16" };
|
||||
const int preferredVectorWidth[] = { 4, 4, 2, 2, 1, 1, 1 };
|
||||
int kercn = haveMask || haveScalar ? ocn : preferredVectorWidth[depth];
|
||||
|
||||
int vlen = std::min<int>(8, src1.elemSize1() * src1.oclchannels());
|
||||
std::string vlenstr = vlen > 1 ? format("%d", vlen) : "";
|
||||
std::string buildOptions = format("-D Operation=%c -D vloadn=vload%s -D vstoren=vstore%s -D elemSize=%d -D vlen=%d"
|
||||
" -D ucharv=uchar%s",
|
||||
operationMap[operationType], vlenstr.c_str(), vlenstr.c_str(),
|
||||
(int)src1.elemSize(), vlen, vlenstr.c_str());
|
||||
|
||||
#ifdef ANDROID
|
||||
size_t localThreads[3] = { 16, 10, 1 };
|
||||
#else
|
||||
size_t localThreads[3] = { 16, 16, 1 };
|
||||
#endif
|
||||
size_t globalThreads[3] = { dst.cols, dst.rows, 1 };
|
||||
|
||||
vector<pair<size_t , const void *> > args;
|
||||
args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.step ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.offset ));
|
||||
|
||||
if (src2.empty())
|
||||
if (!haveScalar && !haveMask)
|
||||
{
|
||||
m.create(1, 1, dst.type());
|
||||
m.setTo(src3);
|
||||
|
||||
args.push_back( make_pair( sizeof(cl_mem), (void *)&m.data ));
|
||||
|
||||
kernelName += "_scalar";
|
||||
int velemsize = dst.elemSize1() * kercn;
|
||||
while (src1.offset % velemsize != 0 || src1.step % velemsize != 0 || src1.cols * ocn % kercn != 0 ||
|
||||
src2.offset % velemsize != 0 || src2.step % velemsize != 0 || src2.cols * ocn % kercn != 0 ||
|
||||
dst.offset % velemsize != 0 || dst.step % velemsize != 0 || dst.cols * ocn % kercn != 0)
|
||||
kercn >>= 1, velemsize >>= 1;
|
||||
}
|
||||
else
|
||||
|
||||
int cols = dst.cols * ocn / kercn;
|
||||
|
||||
std::string buildOptions = format("-D Operation=%c -D T=%s%s", operationMap[operationType],
|
||||
typeMap[depth], channelMap[kercn]);
|
||||
|
||||
vector<pair<size_t , const void *> > args;
|
||||
args.push_back( make_pair( sizeof(cl_mem), (void *)&src1.data ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.step ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.offset ));
|
||||
|
||||
if (haveScalar)
|
||||
{
|
||||
int sctype = CV_MAKE_TYPE(dst.depth(), ocn);
|
||||
cv::scalarToRawData(src3, scalar, sctype);
|
||||
|
||||
args.push_back( make_pair( CV_ELEM_SIZE(sctype), (void *)scalar ));
|
||||
|
||||
buildOptions += " -D HAVE_SCALAR";
|
||||
}
|
||||
else if (operationType != NOT)
|
||||
{
|
||||
args.push_back( make_pair( sizeof(cl_mem), (void *)&src2.data ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src2.step ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src2.offset ));
|
||||
|
||||
buildOptions += " -D OP_BINARY";
|
||||
}
|
||||
|
||||
if (!mask.empty())
|
||||
if (haveMask)
|
||||
{
|
||||
args.push_back( make_pair( sizeof(cl_mem), (void *)&mask.data ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&mask.step ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&mask.offset ));
|
||||
|
||||
kernelName += "_mask";
|
||||
buildOptions += " -D HAVE_MASK";
|
||||
}
|
||||
|
||||
args.push_back( make_pair( sizeof(cl_mem), (void *)&dst.data ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.step ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.offset ));
|
||||
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.cols ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&src1.rows ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&dst.rows ));
|
||||
args.push_back( make_pair( sizeof(cl_int), (void *)&cols ));
|
||||
|
||||
openCLExecuteKernel(src1.clCxt, mask.empty() ? (!src2.empty() ? &arithm_bitwise_binary : &arithm_bitwise_binary_scalar) :
|
||||
(!src2.empty() ? &arithm_bitwise_binary_mask : &arithm_bitwise_binary_scalar_mask),
|
||||
kernelName, globalThreads, localThreads,
|
||||
size_t globalsize[3] = { dst.cols * ocn / kercn, dst.rows, 1 };
|
||||
globalsize[0] = divUp(globalsize[0], 256) * 256;
|
||||
openCLExecuteKernel(src1.clCxt, &arithm_bitwise, "arithm_bitwise", globalsize, NULL,
|
||||
args, -1, -1, buildOptions.c_str());
|
||||
}
|
||||
|
||||
void cv::ocl::bitwise_not(const oclMat &src, oclMat &dst)
|
||||
{
|
||||
if (!src.clCxt->supportsFeature(FEATURE_CL_DOUBLE) && src.depth() == CV_64F)
|
||||
{
|
||||
CV_Error(CV_OpenCLDoubleNotSupported, "Selected device doesn't support double");
|
||||
return;
|
||||
}
|
||||
|
||||
dst.create(src.size(), src.type());
|
||||
bitwise_unary_run(src, dst, "arithm_bitwise_not", &arithm_bitwise_not);
|
||||
bitwise_run(src, oclMat(), Scalar(), oclMat(), dst, NOT);
|
||||
}
|
||||
|
||||
void cv::ocl::bitwise_or(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask)
|
||||
{
|
||||
bitwise_binary_run(src1, src2, Scalar(), mask, dst, OR);
|
||||
bitwise_run(src1, src2, Scalar(), mask, dst, OR);
|
||||
}
|
||||
|
||||
void cv::ocl::bitwise_or(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask)
|
||||
{
|
||||
bitwise_binary_run(src1, oclMat(), src2, mask, dst, OR);
|
||||
bitwise_run(src1, oclMat(), src2, mask, dst, OR);
|
||||
}
|
||||
|
||||
void cv::ocl::bitwise_and(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask)
|
||||
{
|
||||
bitwise_binary_run(src1, src2, Scalar(), mask, dst, AND);
|
||||
bitwise_run(src1, src2, Scalar(), mask, dst, AND);
|
||||
}
|
||||
|
||||
void cv::ocl::bitwise_and(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask)
|
||||
{
|
||||
bitwise_binary_run(src1, oclMat(), src2, mask, dst, AND);
|
||||
bitwise_run(src1, oclMat(), src2, mask, dst, AND);
|
||||
}
|
||||
|
||||
void cv::ocl::bitwise_xor(const oclMat &src1, const oclMat &src2, oclMat &dst, const oclMat &mask)
|
||||
{
|
||||
bitwise_binary_run(src1, src2, Scalar(), mask, dst, XOR);
|
||||
bitwise_run(src1, src2, Scalar(), mask, dst, XOR);
|
||||
}
|
||||
|
||||
void cv::ocl::bitwise_xor(const oclMat &src1, const Scalar &src2, oclMat &dst, const oclMat &mask)
|
||||
{
|
||||
bitwise_binary_run(src1, oclMat(), src2, mask, dst, XOR);
|
||||
bitwise_run(src1, oclMat(), src2, mask, dst, XOR);
|
||||
}
|
||||
|
||||
oclMat cv::ocl::operator ~ (const oclMat &src)
|
||||
|
||||
@ -48,35 +48,46 @@
|
||||
/////////////////////////////////////////// bitwise_binary //////////////////////////////////////////
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
__kernel void arithm_bitwise_binary(__global uchar * src1, int src1_step, int src1_offset,
|
||||
__global uchar * src2, int src2_step, int src2_offset,
|
||||
__global uchar * dst, int dst_step, int dst_offset,
|
||||
int cols, int rows)
|
||||
__kernel void arithm_bitwise(__global uchar * src1ptr, int src1_step, int src1_offset,
|
||||
#ifdef OP_BINARY
|
||||
__global uchar * src2ptr, int src2_step, int src2_offset,
|
||||
#elif defined HAVE_SCALAR
|
||||
T scalar,
|
||||
#endif
|
||||
#ifdef HAVE_MASK
|
||||
__global uchar * mask, int mask_step, int mask_offset,
|
||||
#endif
|
||||
__global uchar * dstptr, int dst_step, int dst_offset, int dst_rows, int dst_cols)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
if (x < dst_cols && y < dst_rows)
|
||||
{
|
||||
#if elemSize > 1
|
||||
x *= elemSize;
|
||||
#ifdef HAVE_MASK
|
||||
mask += mad24(y, mask_step, x + mask_offset);
|
||||
if (mask[0])
|
||||
#endif
|
||||
int src1_index = mad24(y, src1_step, x + src1_offset);
|
||||
int src2_index = mad24(y, src2_step, x + src2_offset);
|
||||
int dst_index = mad24(y, dst_step, x + dst_offset);
|
||||
|
||||
#if elemSize > 1
|
||||
#pragma unroll
|
||||
for (int i = 0; i < elemSize; i += vlen)
|
||||
{
|
||||
ucharv t0 = vloadn(0, src1 + src1_index + i);
|
||||
ucharv t1 = vloadn(0, src2 + src2_index + i);
|
||||
ucharv t2 = t0 Operation t1;
|
||||
|
||||
vstoren(t2, 0, dst + dst_index + i);
|
||||
}
|
||||
#else
|
||||
dst[dst_index] = src1[src1_index] Operation src2[src2_index];
|
||||
int src1_index = mad24(y, src1_step, mad24(x, (int)sizeof(T), src1_offset));
|
||||
#ifdef OP_BINARY
|
||||
int src2_index = mad24(y, src2_step, mad24(x, (int)sizeof(T), src2_offset));
|
||||
#endif
|
||||
int dst_index = mad24(y, dst_step, mad24(x, (int)sizeof(T), dst_offset));
|
||||
|
||||
__global const T * src1 = (__global const T *)(src1ptr + src1_index);
|
||||
#ifdef OP_BINARY
|
||||
__global const T * src2 = (__global const T *)(src2ptr + src2_index);
|
||||
#endif
|
||||
__global T * dst = (__global T *)(dstptr + dst_index);
|
||||
|
||||
#ifdef OP_BINARY
|
||||
dst[0] = src1[0] Operation src2[0];
|
||||
#elif defined HAVE_SCALAR
|
||||
dst[0] = src1[0] Operation scalar;
|
||||
#else
|
||||
dst[0] = Operation src1[0];
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,88 +0,0 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
|
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// @Authors
|
||||
// Jiang Liyuan, jlyuan001.good@163.com
|
||||
// Peng Xiao, pengxiao@outlook.com
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's 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.
|
||||
//
|
||||
// * The name of the copyright holders may not 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 Intel Corporation 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.
|
||||
//
|
||||
//M*/
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////bitwise_binary////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
__kernel void arithm_bitwise_binary_mask(__global uchar * src1, int src1_step, int src1_offset,
|
||||
__global uchar * src2, int src2_step, int src2_offset,
|
||||
__global uchar * mask, int mask_step, int mask_offset,
|
||||
__global uchar * dst, int dst_step, int dst_offset,
|
||||
int cols1, int rows)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols1 && y < rows)
|
||||
{
|
||||
int mask_index = mad24(y, mask_step, mask_offset + x);
|
||||
|
||||
if (mask[mask_index])
|
||||
{
|
||||
#if elemSize > 1
|
||||
x *= elemSize;
|
||||
#endif
|
||||
int src1_index = mad24(y, src1_step, x + src1_offset);
|
||||
int src2_index = mad24(y, src2_step, x + src2_offset);
|
||||
int dst_index = mad24(y, dst_step, x + dst_offset);
|
||||
|
||||
#if elemSize > 1
|
||||
#pragma unroll
|
||||
for (int i = 0; i < elemSize; i += vlen)
|
||||
{
|
||||
ucharv t0 = vloadn(0, src1 + src1_index + i);
|
||||
ucharv t1 = vloadn(0, src2 + src2_index + i);
|
||||
ucharv t2 = t0 Operation t1;
|
||||
|
||||
vstoren(t2, 0, dst + dst_index + i);
|
||||
}
|
||||
#else
|
||||
dst[dst_index] = src1[src1_index] Operation src2[src2_index];
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,82 +0,0 @@
|
||||
////////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
|
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// @Authors
|
||||
// Jiang Liyuan, jlyuan001.good@163.com
|
||||
// Peng Xiao, pengxiao@outlook.com
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's 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.
|
||||
//
|
||||
// * The name of the copyright holders may not 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 Intel Corporation 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.
|
||||
//
|
||||
//
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////bitwise_binary/////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
__kernel void arithm_bitwise_binary_scalar(
|
||||
__global uchar *src1, int src1_step, int src1_offset,
|
||||
__global uchar *src2,
|
||||
__global uchar *dst, int dst_step, int dst_offset,
|
||||
int cols, int rows)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
#if elemSize > 1
|
||||
x *= elemSize;
|
||||
#endif
|
||||
int src1_index = mad24(y, src1_step, src1_offset + x);
|
||||
int dst_index = mad24(y, dst_step, dst_offset + x);
|
||||
|
||||
#if elemSize > 1
|
||||
#pragma unroll
|
||||
for (int i = 0; i < elemSize; i += vlen)
|
||||
{
|
||||
ucharv t0 = vloadn(0, src1 + src1_index + i);
|
||||
ucharv t1 = vloadn(0, src2 + i);
|
||||
ucharv t2 = t0 Operation t1;
|
||||
|
||||
vstoren(t2, 0, dst + dst_index + i);
|
||||
}
|
||||
#else
|
||||
dst[dst_index] = src1[src1_index] Operation src2[0];
|
||||
#endif
|
||||
}
|
||||
}
|
||||
@ -1,86 +0,0 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
|
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// @Authors
|
||||
// Jiang Liyuan, jlyuan001.good@163.com
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's 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.
|
||||
//
|
||||
// * The name of the copyright holders may not 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 Intel Corporation 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.
|
||||
//
|
||||
//M*/
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////bitwise_binary////////////////////////////////////////////
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
__kernel void arithm_bitwise_binary_scalar_mask(__global uchar *src1, int src1_step, int src1_offset,
|
||||
__global uchar *src2,
|
||||
__global uchar *mask, int mask_step, int mask_offset,
|
||||
__global uchar *dst, int dst_step, int dst_offset,
|
||||
int cols, int rows)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
int mask_index = mad24(y, mask_step, x + mask_offset);
|
||||
|
||||
if (mask[mask_index])
|
||||
{
|
||||
#if elemSize > 1
|
||||
x *= elemSize;
|
||||
#endif
|
||||
int src1_index = mad24(y, src1_step, x + src1_offset);
|
||||
int dst_index = mad24(y, dst_step, x + dst_offset);
|
||||
|
||||
#if elemSize > 1
|
||||
#pragma unroll
|
||||
for (int i = 0; i < elemSize; i += vlen)
|
||||
{
|
||||
ucharv t0 = vloadn(0, src1 + src1_index + i);
|
||||
ucharv t1 = vloadn(0, src2 + i);
|
||||
ucharv t2 = t0 Operation t1;
|
||||
|
||||
vstoren(t2, 0, dst + dst_index + i);
|
||||
}
|
||||
#else
|
||||
dst[dst_index] = src1[src1_index] Operation src2[0];
|
||||
#endif
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,253 +0,0 @@
|
||||
/*M///////////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
||||
//
|
||||
// By downloading, copying, installing or using the software you agree to this license.
|
||||
// If you do not agree to this license, do not download, install,
|
||||
// copy or use the software.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2010-2012, Institute Of Software Chinese Academy Of Science, all rights reserved.
|
||||
// Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved.
|
||||
// Third party copyrights are property of their respective owners.
|
||||
//
|
||||
// @Authors
|
||||
// Jiang Liyuan, jlyuan001.good@163.com
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistribution's of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistribution's 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.
|
||||
//
|
||||
// * The name of the copyright holders may not 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 Intel Corporation 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.
|
||||
//
|
||||
//M*/
|
||||
|
||||
#ifdef DOUBLE_SUPPORT
|
||||
#ifdef cl_amd_fp64
|
||||
#pragma OPENCL EXTENSION cl_amd_fp64:enable
|
||||
#elif defined (cl_khr_fp64)
|
||||
#pragma OPENCL EXTENSION cl_khr_fp64:enable
|
||||
#endif
|
||||
#endif
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////BITWISE_NOT////////////////////////////////////////////////
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
__kernel void arithm_bitwise_not_D0 (__global uchar *src1, int src1_step, int src1_offset,
|
||||
__global uchar *dst, int dst_step, int dst_offset,
|
||||
int rows, int cols, int dst_step1)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
x = x << 2;
|
||||
int src1_index = mad24(y, src1_step, x + src1_offset);
|
||||
|
||||
int dst_end = mad24(y, dst_step, dst_offset + dst_step1);
|
||||
int dst_index = mad24(y, dst_step, dst_offset + x);
|
||||
|
||||
uchar4 src1_data = vload4(0, src1 + src1_index);
|
||||
uchar4 dst_data = vload4(0, dst + dst_index);
|
||||
uchar4 tmp_data = ~src1_data;
|
||||
|
||||
dst_data.x = dst_index + 0 < dst_end ? tmp_data.x : dst_data.x;
|
||||
dst_data.y = dst_index + 1 < dst_end ? tmp_data.y : dst_data.y;
|
||||
dst_data.z = dst_index + 2 < dst_end ? tmp_data.z : dst_data.z;
|
||||
dst_data.w = dst_index + 3 < dst_end ? tmp_data.w : dst_data.w;
|
||||
|
||||
vstore4(dst_data, 0, dst + dst_index);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
__kernel void arithm_bitwise_not_D1 (__global char *src1, int src1_step, int src1_offset,
|
||||
__global char *dst, int dst_step, int dst_offset,
|
||||
int rows, int cols, int dst_step1)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
x = x << 2;
|
||||
int src1_index = mad24(y, src1_step, x + src1_offset);
|
||||
|
||||
int dst_end = mad24(y, dst_step, dst_offset + dst_step1);
|
||||
int dst_index = mad24(y, dst_step, dst_offset + x);
|
||||
|
||||
char4 src1_data = vload4(0, src1 + src1_index);
|
||||
char4 dst_data = vload4(0, dst + dst_index);
|
||||
char4 tmp_data = ~src1_data;
|
||||
|
||||
dst_data.x = dst_index + 0 < dst_end ? tmp_data.x : dst_data.x;
|
||||
dst_data.y = dst_index + 1 < dst_end ? tmp_data.y : dst_data.y;
|
||||
dst_data.z = dst_index + 2 < dst_end ? tmp_data.z : dst_data.z;
|
||||
dst_data.w = dst_index + 3 < dst_end ? tmp_data.w : dst_data.w;
|
||||
|
||||
vstore4(dst_data, 0, dst + dst_index);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
__kernel void arithm_bitwise_not_D2 (__global ushort *src1, int src1_step, int src1_offset,
|
||||
__global ushort *dst, int dst_step, int dst_offset,
|
||||
int rows, int cols, int dst_step1)
|
||||
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
x = x << 2;
|
||||
|
||||
#ifdef dst_align
|
||||
#undef dst_align
|
||||
#endif
|
||||
#define dst_align ((dst_offset >> 1) & 3)
|
||||
int src1_index = mad24(y, src1_step, (x << 1) + src1_offset - (dst_align << 1));
|
||||
|
||||
int dst_start = mad24(y, dst_step, dst_offset);
|
||||
int dst_end = mad24(y, dst_step, dst_offset + dst_step1);
|
||||
int dst_index = mad24(y, dst_step, dst_offset + (x << 1) & (int)0xfffffff8);
|
||||
|
||||
ushort4 src1_data = vload4(0, (__global ushort *)((__global char *)src1 + src1_index));
|
||||
|
||||
ushort4 dst_data = *((__global ushort4 *)((__global char *)dst + dst_index));
|
||||
ushort4 tmp_data = ~ src1_data;
|
||||
|
||||
dst_data.x = ((dst_index + 0 >= dst_start) && (dst_index + 0 < dst_end)) ? tmp_data.x : dst_data.x;
|
||||
dst_data.y = ((dst_index + 2 >= dst_start) && (dst_index + 2 < dst_end)) ? tmp_data.y : dst_data.y;
|
||||
dst_data.z = ((dst_index + 4 >= dst_start) && (dst_index + 4 < dst_end)) ? tmp_data.z : dst_data.z;
|
||||
dst_data.w = ((dst_index + 6 >= dst_start) && (dst_index + 6 < dst_end)) ? tmp_data.w : dst_data.w;
|
||||
|
||||
*((__global ushort4 *)((__global char *)dst + dst_index)) = dst_data;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
__kernel void arithm_bitwise_not_D3 (__global short *src1, int src1_step, int src1_offset,
|
||||
__global short *dst, int dst_step, int dst_offset,
|
||||
int rows, int cols, int dst_step1)
|
||||
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
x = x << 2;
|
||||
|
||||
#ifdef dst_align
|
||||
#undef dst_align
|
||||
#endif
|
||||
#define dst_align ((dst_offset >> 1) & 3)
|
||||
int src1_index = mad24(y, src1_step, (x << 1) + src1_offset - (dst_align << 1));
|
||||
|
||||
int dst_start = mad24(y, dst_step, dst_offset);
|
||||
int dst_end = mad24(y, dst_step, dst_offset + dst_step1);
|
||||
int dst_index = mad24(y, dst_step, dst_offset + (x << 1) & (int)0xfffffff8);
|
||||
|
||||
short4 src1_data = vload4(0, (__global short *)((__global char *)src1 + src1_index));
|
||||
|
||||
short4 dst_data = *((__global short4 *)((__global char *)dst + dst_index));
|
||||
short4 tmp_data = ~ src1_data;
|
||||
|
||||
dst_data.x = ((dst_index + 0 >= dst_start) && (dst_index + 0 < dst_end)) ? tmp_data.x : dst_data.x;
|
||||
dst_data.y = ((dst_index + 2 >= dst_start) && (dst_index + 2 < dst_end)) ? tmp_data.y : dst_data.y;
|
||||
dst_data.z = ((dst_index + 4 >= dst_start) && (dst_index + 4 < dst_end)) ? tmp_data.z : dst_data.z;
|
||||
dst_data.w = ((dst_index + 6 >= dst_start) && (dst_index + 6 < dst_end)) ? tmp_data.w : dst_data.w;
|
||||
|
||||
*((__global short4 *)((__global char *)dst + dst_index)) = dst_data;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
__kernel void arithm_bitwise_not_D4 (__global int *src1, int src1_step, int src1_offset,
|
||||
__global int *dst, int dst_step, int dst_offset,
|
||||
int rows, int cols, int dst_step1)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
int src1_index = mad24(y, src1_step, (x << 2) + src1_offset);
|
||||
int dst_index = mad24(y, dst_step, (x << 2) + dst_offset);
|
||||
|
||||
int data1 = *((__global int *)((__global char *)src1 + src1_index));
|
||||
int tmp = ~ data1;
|
||||
|
||||
*((__global int *)((__global char *)dst + dst_index)) = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
__kernel void arithm_bitwise_not_D5 (__global char *src, int src_step, int src_offset,
|
||||
__global char *dst, int dst_step, int dst_offset,
|
||||
int rows, int cols, int dst_step1)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
int src_index = mad24(y, src_step, (x << 2) + src_offset);
|
||||
int dst_index = mad24(y, dst_step, (x << 2) + dst_offset);
|
||||
|
||||
char4 data;
|
||||
|
||||
data = *((__global char4 *)((__global char *)src + src_index));
|
||||
data = ~ data;
|
||||
|
||||
*((__global char4 *)((__global char *)dst + dst_index)) = data;
|
||||
}
|
||||
}
|
||||
|
||||
#if defined (DOUBLE_SUPPORT)
|
||||
__kernel void arithm_bitwise_not_D6 (__global char *src, int src_step, int src_offset,
|
||||
__global char *dst, int dst_step, int dst_offset,
|
||||
int rows, int cols, int dst_step1)
|
||||
{
|
||||
int x = get_global_id(0);
|
||||
int y = get_global_id(1);
|
||||
|
||||
if (x < cols && y < rows)
|
||||
{
|
||||
int src_index = mad24(y, src_step, (x << 3) + src_offset);
|
||||
int dst_index = mad24(y, dst_step, (x << 3) + dst_offset);
|
||||
|
||||
char8 data;
|
||||
|
||||
data = *((__global char8 *)((__global char *)src + src_index));
|
||||
data = ~ data;
|
||||
|
||||
*((__global char8 *)((__global char *)dst + dst_index)) = data;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
Loading…
Reference in New Issue
Block a user