diff --git a/acl/CMakeLists.txt b/acl/CMakeLists.txt index dc33fbf..e5e14f6 100644 --- a/acl/CMakeLists.txt +++ b/acl/CMakeLists.txt @@ -1,9 +1,9 @@ -#if(NOT HAVE_ACL) -# ocv_module_disable(acl) -# return() -#endif() +# if(NOT HAVE_ACL) +# ocv_module_disable(acl) +# return() +# endif() -#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" "-DENABLE_DVPP_INTERFACE") +# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" "-DENABLE_DVPP_INTERFACE") set(acl_lib "/usr/local/Ascend/ascend-toolkit/latest/acllib/lib64/stub/") set(acl_lib "/usr/local/Ascend/ascend-toolkit/latest/fwkacllib/lib64/stub/") diff --git a/acl/include/opencv2/acl/acl.hpp b/acl/include/opencv2/acl/acl.hpp index dcaa2fe..0aa18be 100644 --- a/acl/include/opencv2/acl/acl.hpp +++ b/acl/include/opencv2/acl/acl.hpp @@ -1,8 +1,9 @@ -/*M/////////////////////////////////////////////////////////////////////////////////////// +/* M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // -// By downloading, copying, installing or using the software you agree to this license. +// 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. // @@ -10,28 +11,35 @@ // 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, Institute Of Software Chinese Academy Of Science, +all rights reserved. // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. // Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. // Third party copyrights are property of their respective owners. // -// Redistribution and use in source and binary forms, with or without modification, +// 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, +// * 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 +// * 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 +// 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, +// 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 @@ -39,19 +47,19 @@ // 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*/ +//M */ #ifndef OPENCV_ACL_HPP #define OPENCV_ACL_HPP -#include "acl_type.hpp" #include "acl_init.hpp" #include "acl_mat.hpp" -#include "operator_desc.hpp" +#include "acl_type.hpp" +#include "gemm.hpp" +#include "init_core.hpp" +#include "mat_core.hpp" #include "mathfuncs.hpp" #include "matrices.hpp" -#include "gemm.hpp" -#include "mat_core.hpp" -#include "init_core.hpp" +#include "operator_desc.hpp" #endif diff --git a/acl/include/opencv2/acl/acl_init.hpp b/acl/include/opencv2/acl/acl_init.hpp index 4a1139b..0054b26 100644 --- a/acl/include/opencv2/acl/acl_init.hpp +++ b/acl/include/opencv2/acl/acl_init.hpp @@ -4,55 +4,52 @@ #include #include -#include "opencv2/core.hpp" #include "acl_type.hpp" +#include "opencv2/core.hpp" -using namespace std; +namespace cv { +namespace acl { +CV_EXPORTS Mutex &getInitMutex(); +//////////////////////////////// aclEnv //////////////////////////////// +class CV_EXPORTS aclEnv { + public: + aclEnv(); + aclEnv(const char *config_path); + static aclEnv *get_acl_env(const char *config_path); + int get_device_count(); + int *refcount; + ~aclEnv(); -namespace cv -{ - namespace acl - { - CV_EXPORTS Mutex &getInitMutex(); - //////////////////////////////// aclEnv //////////////////////////////// - class CV_EXPORTS aclEnv - { - public: - aclEnv(); - aclEnv(const char* config_path); - static aclEnv* get_acl_env(const char* config_path); - int get_device_count(); - int *refcount; - ~aclEnv(); - private: - uint32_t _device_count; - }; + private: + uint32_t _device_count; +}; - //////////////////////////////// aclCxt //////////////////////////////// - class CV_EXPORTS aclCxt - { - public: - aclCxt(); - aclCxt(int device_id); +//////////////////////////////// aclCxt //////////////////////////////// +class CV_EXPORTS aclCxt { + public: + aclCxt(); + aclCxt(int device_id); - aclrtContext* get_context(); - void set_current_context(); + aclrtContext *get_context(); + void set_current_context(); - void create_stream(int count = 1); - aclStream get_stream(const size_t index = 0); - ~aclCxt(); - private: - int32_t _device_id; - aclrtContext* _context; - std::vector _acl_streams; - }; + void create_stream(int count = 1); + aclStream get_stream(const size_t index = 0); + ~aclCxt(); - CV_EXPORTS void wait_stream(aclCxt* context, const int stream_id = 0); - //////////////////////////////// device //////////////////////////////// - CV_EXPORTS aclCxt *set_device(const char* config_path, int device_id = 0, int stream_count = 1); - CV_EXPORTS void release_device(aclCxt* context); + private: + int32_t _device_id; + aclrtContext *_context; + std::vector _acl_streams; +}; - } /* end of namespace acl */ +CV_EXPORTS void wait_stream(aclCxt *context, const int stream_id = 0); +//////////////////////////////// device //////////////////////////////// +CV_EXPORTS aclCxt *set_device(const char *config_path, int device_id = 0, + int stream_count = 1); +CV_EXPORTS void release_device(aclCxt *context); + +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/include/opencv2/acl/acl_mat.hpp b/acl/include/opencv2/acl/acl_mat.hpp index bd48e06..fe1a764 100644 --- a/acl/include/opencv2/acl/acl_mat.hpp +++ b/acl/include/opencv2/acl/acl_mat.hpp @@ -2,172 +2,185 @@ #define OPENCV_ACL_MAT_HPP #include "acl/acl.h" -#include "opencv2/core.hpp" -#include "acl_type.hpp" #include "acl_init.hpp" +#include "acl_type.hpp" +#include "opencv2/core.hpp" +namespace cv { +namespace acl { +//////////////////////////////// aclMat //////////////////////////////// +class CV_EXPORTS aclMat { + public: + //! default constructor + aclMat(); + //! constructs aclMatrix of the specified size and type (_type is CV_8UC1, + //! CV_16FC1 etc.) + aclMat(int rows, int cols, int type, aclCxt *acl_context, + ALIGNMENT config = MEMORY_UNALIGNED, + MemMallocPolicy policy = MALLOC_NORMAL_ONLY); + aclMat(Size size, int type, aclCxt *acl_context, + ALIGNMENT config = MEMORY_UNALIGNED, + MemMallocPolicy policy = MALLOC_NORMAL_ONLY); + //! copy constructor + aclMat(const aclMat &m); + //! constructor for aclMatrix headers pointing to user-allocated data + aclMat(int rows, int cols, int type, void *data, aclCxt *acl_context, + ALIGNMENT config = MEMORY_UNALIGNED, size_t step = Mat::AUTO_STEP); + aclMat(Size size, int type, void *data, aclCxt *acl_context, + ALIGNMENT config = MEMORY_UNALIGNED, size_t step = Mat::AUTO_STEP); + //! creates a matrix header for a part of the bigger matrix + aclMat(const aclMat &m, const Range &rowRange, + const Range &colRange = Range::all()); + aclMat(const aclMat &m, const Rect &roi); + //! builds aclMat from Mat. Perfom blocking upload to device. + aclMat(const Mat &m, aclCxt *acl_context, ALIGNMENT config = MEMORY_UNALIGNED, + MemMallocPolicy policy = MALLOC_NORMAL_ONLY); + //! destructor - calls release() + ~aclMat(); -namespace cv -{ - namespace acl - { - //////////////////////////////// aclMat //////////////////////////////// - class CV_EXPORTS aclMat - { - public: - //! default constructor - aclMat(); - //! constructs aclMatrix of the specified size and type (_type is CV_8UC1, CV_16FC1 etc.) - aclMat(int rows, int cols, int type, aclCxt *acl_context, ALIGNMENT config = MEMORY_UNALIGNED, MemMallocPolicy policy = MALLOC_NORMAL_ONLY); - aclMat(Size size, int type, aclCxt *acl_context, ALIGNMENT config = MEMORY_UNALIGNED, MemMallocPolicy policy = MALLOC_NORMAL_ONLY); - //! copy constructor - aclMat(const aclMat &m); - //! constructor for aclMatrix headers pointing to user-allocated data - aclMat(int rows, int cols, int type, void *data, aclCxt* acl_context, ALIGNMENT config = MEMORY_UNALIGNED, size_t step = Mat::AUTO_STEP); - aclMat(Size size, int type, void *data, aclCxt* acl_context, ALIGNMENT config = MEMORY_UNALIGNED, size_t step = Mat::AUTO_STEP); - //! creates a matrix header for a part of the bigger matrix - aclMat(const aclMat &m, const Range &rowRange, const Range &colRange = Range::all()); - aclMat(const aclMat &m, const Rect &roi); - //! builds aclMat from Mat. Perfom blocking upload to device. - aclMat (const Mat &m, aclCxt* acl_context, ALIGNMENT config = MEMORY_UNALIGNED, MemMallocPolicy policy = MALLOC_NORMAL_ONLY); - //! destructor - calls release() - ~aclMat(); + //! assignment operators shallow copy + aclMat &operator=(const aclMat &m); + //! assignment operator. Perfom blocking upload to device. + aclMat &operator=(const Mat &m); - //! assignment operators shallow copy - aclMat &operator=(const aclMat &m); - //! assignment operator. Perfom blocking upload to device. - aclMat &operator=(const Mat &m); - - //! pefroms blocking upload data to aclMat. - void upload(const Mat &m, ALIGNMENT config = MEMORY_UNALIGNED); - void upload(const Mat &m, aclStream stream, ALIGNMENT config = MEMORY_UNALIGNED); - //! downloads data from device to host memory. Blocking calls. - void download(Mat &m, ALIGNMENT config = MEMORY_UNALIGNED) const; - void download(Mat &m, aclStream stream, ALIGNMENT config = MEMORY_UNALIGNED) const; - - operator Mat() const; - aclMat clone() const; - void copyTo(aclMat& dest) const; + //! pefroms blocking upload data to aclMat. + void upload(const Mat &m, ALIGNMENT config = MEMORY_UNALIGNED); + void upload(const Mat &m, aclStream stream, + ALIGNMENT config = MEMORY_UNALIGNED); + //! downloads data from device to host memory. Blocking calls. + void download(Mat &m, ALIGNMENT config = MEMORY_UNALIGNED) const; + void download(Mat &m, aclStream stream, + ALIGNMENT config = MEMORY_UNALIGNED) const; - //! returns a new aclMatrix header for the specified row - aclMat row(int y) const; - //! returns a new aclMatrix header for the specified column - aclMat col(int x) const; - //! ... for the specified row span - aclMat rowRange(int startrow, int endrow) const; - aclMat rowRange(const Range &r) const; - //! ... for the specified column span - aclMat colRange(int startcol, int endcol) const; - aclMat colRange(const Range &r) const; + operator Mat() const; + aclMat clone() const; + void copyTo(aclMat &dest) const; - //! locates aclMatrix header within a parent aclMatrix. See below - void locateROI(Size &wholeSize, Point &ofs) const; - //! moves/resizes the current aclMatrix ROI inside the parent aclMatrix. - aclMat &adjustROI(int dtop, int dbottom, int dleft, int dright); + //! returns a new aclMatrix header for the specified row + aclMat row(int y) const; + //! returns a new aclMatrix header for the specified column + aclMat col(int x) const; + //! ... for the specified row span + aclMat rowRange(int startrow, int endrow) const; + aclMat rowRange(const Range &r) const; + //! ... for the specified column span + aclMat colRange(int startcol, int endcol) const; + aclMat colRange(const Range &r) const; - //! allocates new aclMatrix data unless the aclMatrix already has specified size and type. - // previous data is unreferenced if needed. - void create(int rows, int cols, int type, ALIGNMENT config = MEMORY_UNALIGNED, MemMallocPolicy policy = MALLOC_NORMAL_ONLY); - void create(Size size, int type, ALIGNMENT config = MEMORY_UNALIGNED, MemMallocPolicy policy = MALLOC_NORMAL_ONLY); + //! locates aclMatrix header within a parent aclMatrix. See below + void locateROI(Size &wholeSize, Point &ofs) const; + //! moves/resizes the current aclMatrix ROI inside the parent aclMatrix. + aclMat &adjustROI(int dtop, int dbottom, int dleft, int dright); - //! allocates new aclMatrix with specified device memory type. - void createEx(int rows, int cols, int type, ALIGNMENT config = MEMORY_UNALIGNED, MemMallocPolicy policy = MALLOC_NORMAL_ONLY); - void createEx(Size size, int type, ALIGNMENT config = MEMORY_UNALIGNED, MemMallocPolicy policy = MALLOC_NORMAL_ONLY); + //! allocates new aclMatrix data unless the aclMatrix already has specified + //! size and type. + // previous data is unreferenced if needed. + void create(int rows, int cols, int type, ALIGNMENT config = MEMORY_UNALIGNED, + MemMallocPolicy policy = MALLOC_NORMAL_ONLY); + void create(Size size, int type, ALIGNMENT config = MEMORY_UNALIGNED, + MemMallocPolicy policy = MALLOC_NORMAL_ONLY); - //! decreases reference counter; - // deallocate the data when reference counter reaches 0. - void release(); + //! allocates new aclMatrix with specified device memory type. + void createEx(int rows, int cols, int type, + ALIGNMENT config = MEMORY_UNALIGNED, + MemMallocPolicy policy = MALLOC_NORMAL_ONLY); + void createEx(Size size, int type, ALIGNMENT config = MEMORY_UNALIGNED, + MemMallocPolicy policy = MALLOC_NORMAL_ONLY); - //! swaps with other smart pointer - void swap(aclMat &mat); + //! decreases reference counter; + // deallocate the data when reference counter reaches 0. + void release(); - //! extracts a rectangular sub-aclMatrix - // (this is a generalized form of row, rowRange etc.) - aclMat operator()( Range rowRange, Range colRange ) const; - aclMat operator()( const Rect &roi ) const; + //! swaps with other smart pointer + void swap(aclMat &mat); - aclMat& operator+=( const aclMat& m ); - aclMat& operator-=( const aclMat& m ); - aclMat& operator/=( const aclMat& m ); - aclMat& operator*=( const aclMat& m ); - - - //! returns true if the aclMatrix data is continuous - // (i.e. when there are no gaps between successive rows). - // similar to CV_IS_aclMat_CONT(cvaclMat->type) - bool isContinuous() const; + //! extracts a rectangular sub-aclMatrix + // (this is a generalized form of row, rowRange etc.) + aclMat operator()(Range rowRange, Range colRange) const; + aclMat operator()(const Rect &roi) const; - //! returns element size in bytes, - // similar to CV_ELEM_SIZE(cvMat->type) - size_t elemSize() const; - //! returns the size of element channel in bytes. - size_t elemSize1() const; + aclMat &operator+=(const aclMat &m); + aclMat &operator-=(const aclMat &m); + aclMat &operator/=(const aclMat &m); + aclMat &operator*=(const aclMat &m); - //! returns element type, similar to CV_MAT_TYPE(cvMat->type) - int type() const; - //! returns element type, i.e. 8UC3 returns 8UC4 because in acl - //! 3 channels element actually use 4 channel space - int acltype() const; - //! returns element type, similar to CV_MAT_DEPTH(cvMat->type) - int depth() const; + //! returns true if the aclMatrix data is continuous + // (i.e. when there are no gaps between successive rows). + // similar to CV_IS_aclMat_CONT(cvaclMat->type) + bool isContinuous() const; - //! returns element type, similar to CV_MAT_CN(cvMat->type) - int channels() const; - //! returns element type, return 4 for 3 channels element, - //!becuase 3 channels element actually use 4 channel space - int aclchannels() const; + //! returns element size in bytes, + // similar to CV_ELEM_SIZE(cvMat->type) + size_t elemSize() const; + //! returns the size of element channel in bytes. + size_t elemSize1() const; - //! returns step/elemSize1() - size_t step1() const; - //! returns aclMatrix size: - // width == number of columns, height == number of rows - Size size() const; - //! returns true if aclMatrix data is NULL - bool empty() const; + //! returns element type, similar to CV_MAT_TYPE(cvMat->type) + int type() const; + //! returns element type, i.e. 8UC3 returns 8UC4 because in acl + //! 3 channels element actually use 4 channel space + int acltype() const; + //! returns element type, similar to CV_MAT_DEPTH(cvMat->type) + int depth() const; - friend void swap(aclMat &a, aclMat &b); - friend void ensureSizeIsEnough(int rows, int cols, int type, aclMat &m, ALIGNMENT config = MEMORY_UNALIGNED); - friend void ensureSizeIsEnough(Size size, int type, aclMat &m, ALIGNMENT config = MEMORY_UNALIGNED); + //! returns element type, similar to CV_MAT_CN(cvMat->type) + int channels() const; + //! returns element type, return 4 for 3 channels element, + //! becuase 3 channels element actually use 4 channel space + int aclchannels() const; - /*! includes several bit-fields: - - the magic signature - - continuity flag - - depth - - number of channels - */ - int flags; - //! the number of rows and columns - int rows, cols; - //! a distance between successive rows in bytes; includes the gap if any - size_t step; - //! pointer to the data(ACL memory object) - //uchar *data; + //! returns step/elemSize1() + size_t step1() const; + //! returns aclMatrix size: + // width == number of columns, height == number of rows + Size size() const; + //! returns true if aclMatrix data is NULL + bool empty() const; - //! OpenCL context associated with the aclMat object. - void *data; // TODO + friend void swap(aclMat &a, aclMat &b); + friend void ensureSizeIsEnough(int rows, int cols, int type, aclMat &m, + ALIGNMENT config = MEMORY_UNALIGNED); + friend void ensureSizeIsEnough(Size size, int type, aclMat &m, + ALIGNMENT config = MEMORY_UNALIGNED); - //! pointer to the reference counter; - // when aclMatrix points to user-allocated data, the pointer is NULL - int *refcount; + /*! includes several bit-fields: + - the magic signature + - continuity flag + - depth + - number of channels + */ + int flags; + //! the number of rows and columns + int rows, cols; + //! a distance between successive rows in bytes; includes the gap if any + size_t step; + //! pointer to the data(ACL memory object) + // uchar *data; - //! helper fields used in locateROI and adjustROI - //datastart and dataend are not used in current version - uchar *datastart; - uchar *dataend; + //! OpenCL context associated with the aclMat object. + void *data; // TODO - //add offset for handle ROI, calculated in byte - int offset; - //add wholerows and wholecols for the whole matrix, datastart and dataend are no longer used - int wholerows; - int wholecols; + //! pointer to the reference counter; + // when aclMatrix points to user-allocated data, the pointer is NULL + int *refcount; - aclCxt *acl_context; - size_t totalSize; + //! helper fields used in locateROI and adjustROI + // datastart and dataend are not used in current version + uchar *datastart; + uchar *dataend; - }; - } /* end of namespace acl */ + // add offset for handle ROI, calculated in byte + int offset; + // add wholerows and wholecols for the whole matrix, datastart and dataend are + // no longer used + int wholerows; + int wholecols; + + aclCxt *acl_context; + size_t totalSize; +}; +} /* end of namespace acl */ } /* end of namespace cv */ - #endif \ No newline at end of file diff --git a/acl/include/opencv2/acl/acl_type.hpp b/acl/include/opencv2/acl/acl_type.hpp index f2f9648..d027555 100644 --- a/acl/include/opencv2/acl/acl_type.hpp +++ b/acl/include/opencv2/acl/acl_type.hpp @@ -1,8 +1,9 @@ -/*M/////////////////////////////////////////////////////////////////////////////////////// +/* M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // -// By downloading, copying, installing or using the software you agree to this license. +// 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. // @@ -10,28 +11,35 @@ // 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, Institute Of Software Chinese Academy Of Science, +all rights reserved. // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. // Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. // Third party copyrights are property of their respective owners. // -// Redistribution and use in source and binary forms, with or without modification, +// 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, +// * 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 +// * 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 +// 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, +// 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 @@ -39,7 +47,7 @@ // 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*/ +//M */ #ifndef OPENCV_ACL_TYPE_HPP #define OPENCV_ACL_TYPE_HPP @@ -48,110 +56,102 @@ #define AclVerifyCall(expr) __aclSafeCall(res, __FILE__, __LINE__, __func__) #include -#include "opencv2/core.hpp" + #include "acl/acl.h" +#include "opencv2/core.hpp" -namespace cv -{ - namespace acl - { - /** - * An error is reported if the expression value is not 0 - */ - static inline void __aclSafeCall(int err, const char* file, const int line, const char *func="") - { - if(0 != err) - { - const char* function = func ? func : "unknown function"; - std::cerr << "Acl Called Error: " << "file " << file << ", func " << function << ", line " << line << " errorCode: " << err << std::endl; - std::cerr.flush(); - } - } +namespace cv { +namespace acl { +/** + * An error is reported if the expression value is not 0 + */ +static inline void __aclSafeCall(int err, const char *file, const int line, + const char *func = "") { + if (0 != err) { + const char *function = func ? func : "unknown function"; + std::cerr << "Acl Called Error: " + << "file " << file << ", func " << function << ", line " << line + << " errorCode: " << err << std::endl; + std::cerr.flush(); + } +} - /* Memory alignment */ - enum ALIGNMENT { MEMORY_UNALIGNED = 0, MEMORY_ALIGN = 1}; +/* Memory alignment */ +enum ALIGNMENT { MEMORY_UNALIGNED = 0, MEMORY_ALIGN = 1 }; - enum { MAGIC_VAL = 0x42FF0000, AUTO_STEP = 0, CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, SUBMATRIX_FLAG = CV_SUBMAT_FLAG }; - enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 }; +enum { + MAGIC_VAL = 0x42FF0000, + AUTO_STEP = 0, + CONTINUOUS_FLAG = CV_MAT_CONT_FLAG, + SUBMATRIX_FLAG = CV_SUBMAT_FLAG +}; +enum { MAGIC_MASK = 0xFFFF0000, TYPE_MASK = 0x00000FFF, DEPTH_MASK = 7 }; - typedef aclrtStream aclStream; +typedef aclrtStream aclStream; - typedef enum Opdims { TWO_DIMS = 1, FOUR_DIMS } Opdims; +typedef enum Opdims { TWO_DIMS = 1, FOUR_DIMS } Opdims; - enum DeviceType - { - ACL_DEVICE_TYPE_DEFAULT = (1 << 0), - ACL_DEVICE_TYPE_200 = (1 << 1), - ACL_DEVICE_TYPE_ACCELERATOR = (1 << 3), - }; +enum DeviceType { + ACL_DEVICE_TYPE_DEFAULT = (1 << 0), + ACL_DEVICE_TYPE_200 = (1 << 1), + ACL_DEVICE_TYPE_ACCELERATOR = (1 << 3), +}; - enum AttrType - { - OP_BOOL = 1, - OP_INT, - OP_FLOAT, - OP_STRING - }; +enum AttrType { OP_BOOL = 1, OP_INT, OP_FLOAT, OP_STRING }; - typedef enum MemMallocPolicy - { - MALLOC_HUGE_FIRST = 1, - MALLOC_HUGE_ONLY, - MALLOC_NORMAL_ONLY, - MALLOC_HUGE_FIRST_P2P, - MALLOC_HUGE_ONLY_P2P, - MALLOC_NORMAL_ONLY_P2P - } MemMallocPolicy; +typedef enum MemMallocPolicy { + MALLOC_HUGE_FIRST = 1, + MALLOC_HUGE_ONLY, + MALLOC_NORMAL_ONLY, + MALLOC_HUGE_FIRST_P2P, + MALLOC_HUGE_ONLY_P2P, + MALLOC_NORMAL_ONLY_P2P +} MemMallocPolicy; +CV_EXPORTS aclDataType type_transition(int depth); +CV_EXPORTS aclrtMemMallocPolicy type_transition(MemMallocPolicy type); - CV_EXPORTS aclDataType type_transition(int depth); - CV_EXPORTS aclrtMemMallocPolicy type_transition(MemMallocPolicy type); +inline aclDataType type_transition(int depth) { + switch (depth) { + case CV_8U: + return ACL_UINT8; + case CV_8S: + return ACL_INT8; + case CV_16U: + return ACL_UINT16; + case CV_16S: + return ACL_INT16; + case CV_16F: + return ACL_FLOAT16; + case CV_32S: + return ACL_INT32; + case CV_32F: + return ACL_FLOAT; + case CV_64F: + return ACL_DOUBLE; + } + return ACL_DT_UNDEFINED; +} - inline aclDataType type_transition(int depth) - { - switch (depth) - { - case CV_8U: - return ACL_UINT8; - case CV_8S: - return ACL_INT8; - case CV_16U: - return ACL_UINT16; - case CV_16S: - return ACL_INT16; - case CV_16F: - return ACL_FLOAT16; - case CV_32S: - return ACL_INT32; - case CV_32F: - return ACL_FLOAT; - case CV_64F: - return ACL_DOUBLE; - } - return ACL_DT_UNDEFINED; - } +inline aclrtMemMallocPolicy type_transition(MemMallocPolicy type) { + switch (type) { + case MALLOC_HUGE_FIRST: + return ACL_MEM_MALLOC_HUGE_FIRST; + case MALLOC_HUGE_ONLY: + return ACL_MEM_MALLOC_HUGE_ONLY; + case MALLOC_NORMAL_ONLY: + return ACL_MEM_MALLOC_NORMAL_ONLY; + case MALLOC_HUGE_FIRST_P2P: + return ACL_MEM_MALLOC_HUGE_FIRST_P2P; + case MALLOC_HUGE_ONLY_P2P: + return ACL_MEM_MALLOC_HUGE_ONLY_P2P; + case MALLOC_NORMAL_ONLY_P2P: + return ACL_MEM_MALLOC_NORMAL_ONLY_P2P; + } + return ACL_MEM_MALLOC_HUGE_FIRST; +} - inline aclrtMemMallocPolicy type_transition(MemMallocPolicy type) - { - switch (type) - { - case MALLOC_HUGE_FIRST: - return ACL_MEM_MALLOC_HUGE_FIRST; - case MALLOC_HUGE_ONLY: - return ACL_MEM_MALLOC_HUGE_ONLY; - case MALLOC_NORMAL_ONLY: - return ACL_MEM_MALLOC_NORMAL_ONLY; - case MALLOC_HUGE_FIRST_P2P: - return ACL_MEM_MALLOC_HUGE_FIRST_P2P; - case MALLOC_HUGE_ONLY_P2P: - return ACL_MEM_MALLOC_HUGE_ONLY_P2P; - case MALLOC_NORMAL_ONLY_P2P: - return ACL_MEM_MALLOC_NORMAL_ONLY_P2P; - } - return ACL_MEM_MALLOC_HUGE_FIRST; - } - - } /* end of namespace acl */ +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/include/opencv2/acl/gemm.hpp b/acl/include/opencv2/acl/gemm.hpp index 33e477d..5ef73de 100644 --- a/acl/include/opencv2/acl/gemm.hpp +++ b/acl/include/opencv2/acl/gemm.hpp @@ -3,19 +3,20 @@ #include "acl_mat.hpp" -namespace cv -{ - namespace acl - { - // matrix multiplication - CV_EXPORTS void MatMul(const aclMat& src1, const aclMat& src2, aclMat& dest, int stream_id = 0); - // convolution - CV_EXPORTS void Convolution(const aclMat& src, const aclMat& kernel, aclMat& dest, \ - const vector& stridesList = vector {1, 1, 1, 1}, const vector& padsList = vector {0, 0, 0, 0}, int stream_id = 0); +namespace cv { +namespace acl { +// matrix multiplication +CV_EXPORTS void MatMul(const aclMat &src1, const aclMat &src2, aclMat &dest, + int stream_id = 0); +// convolution +CV_EXPORTS void Convolution( + const aclMat &src, const aclMat &kernel, aclMat &dest, + const std::vector &stridesList = std::vector{1, 1, 1, 1}, + const std::vector &padsList = std::vector{0, 0, 0, 0}, + int stream_id = 0); - } /* end of namespace acl */ +} /* end of namespace acl */ } /* end of namespace cv */ - -#endif \ No newline at end of file +#endif \ No newline at end of file diff --git a/acl/include/opencv2/acl/init_core.hpp b/acl/include/opencv2/acl/init_core.hpp index 8ba5445..acbf926 100644 --- a/acl/include/opencv2/acl/init_core.hpp +++ b/acl/include/opencv2/acl/init_core.hpp @@ -3,115 +3,96 @@ #include "acl_init.hpp" -namespace cv -{ - namespace acl - { - ///////////////////////////aclEnv////////////////////////////////// - /** - * acl init - */ - inline aclEnv::aclEnv() - {} +namespace cv { +namespace acl { +///////////////////////////aclEnv////////////////////////////////// +/** + * acl init + */ +inline aclEnv::aclEnv() {} - inline aclEnv::aclEnv(const char* config_path) - { - uint32_t device_count; +inline aclEnv::aclEnv(const char *config_path) { + uint32_t device_count; - AclSafeCall(aclInit(config_path)); - - AclSafeCall(aclrtGetDeviceCount(&device_count)); + AclSafeCall(aclInit(config_path)); - _device_count = device_count; - // Reference Counting - refcount = static_cast(fastMalloc(sizeof(*refcount))); - *refcount = 0; - - clog << "aclInit() is success" << endl; - } + AclSafeCall(aclrtGetDeviceCount(&device_count)); - inline int aclEnv::get_device_count() - { - return _device_count; - } + _device_count = device_count; + // Reference Counting + refcount = static_cast(fastMalloc(sizeof(*refcount))); + *refcount = 0; - inline aclEnv::~aclEnv() - { - AclSafeCall(aclFinalize()); - clog << "aclFinalize() is success" << endl; - } + std::clog << "aclInit() is success" << std::endl; +} - - /////////////////////////////////////////aclCxt//////////////////////////// - inline aclCxt::aclCxt() {}; +inline int aclEnv::get_device_count() { return _device_count; } - inline aclCxt::aclCxt(int device_id) : _device_id(device_id) - { - _context = static_cast(fastMalloc(sizeof(*_context))); - AclSafeCall(aclrtCreateContext(_context, _device_id)); +inline aclEnv::~aclEnv() { + AclSafeCall(aclFinalize()); + std::clog << "aclFinalize() is success" << std::endl; +} - clog << "aclrtCreateContext() is success" << endl; - } +/////////////////////////////////////////aclCxt//////////////////////////// +inline aclCxt::aclCxt(){}; - inline aclrtContext* aclCxt::get_context() - { - return _context; - } +inline aclCxt::aclCxt(int device_id) : _device_id(device_id) { + _context = static_cast(fastMalloc(sizeof(*_context))); + AclSafeCall(aclrtCreateContext(_context, _device_id)); - /** - * set current context - */ - inline void aclCxt::set_current_context() - { - AclSafeCall(aclrtSetCurrentContext(*_context)); - } + std::clog << "aclrtCreateContext() is success" << std::endl; +} - inline void aclCxt::create_stream(int count) - { - CV_Assert(count > 0); +inline aclrtContext *aclCxt::get_context() { return _context; } - int i; - for(i = 0; i 0); - clog << "aclrtCreateStream() is success" << endl; - } + int i; + for (i = 0; i < count; i++) { + aclStream stream; + AclSafeCall(aclrtCreateStream(&stream)); - inline aclrtStream aclCxt::get_stream(const size_t index) - { - CV_Assert(index < _acl_streams.size()); - return _acl_streams[index]; - } + _acl_streams.push_back(stream); + } - /** - * destroy stream and context - */ - inline aclCxt::~aclCxt() - { - size_t i = 0; - - AclSafeCall(aclrtSetCurrentContext(*_context)); - for (i = 0; i < _acl_streams.size(); i++) - { - aclStream acl_stream = _acl_streams[i]; - AclSafeCall(aclrtDestroyStream(acl_stream)); - } + std::clog << "aclrtCreateStream() is success" << std::endl; +} - clog << "aclrtDestroyStream() is success" << endl; +inline aclrtStream aclCxt::get_stream(const size_t index) { + CV_Assert(index < _acl_streams.size()); + return _acl_streams[index]; +} - // empty vector - std::vector().swap(_acl_streams); - AclSafeCall(aclrtDestroyContext(*_context)); +/** + * destroy stream and context + */ +inline aclCxt::~aclCxt() { + size_t i = 0; - clog << "aclrtDestroyContext() is success" << endl; - } + AclSafeCall(aclrtSetCurrentContext(*_context)); + for (i = 0; i < _acl_streams.size(); i++) { + aclStream acl_stream = _acl_streams[i]; + AclSafeCall(aclrtDestroyStream(acl_stream)); + } - } /* end of namespace acl */ + std::clog << "aclrtDestroyStream() is success" << std::endl; + + // empty vector + std::vector().swap(_acl_streams); + AclSafeCall(aclrtDestroyContext(*_context)); + + std::clog << "aclrtDestroyContext() is success" << std::endl; +} + +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/include/opencv2/acl/mat_core.hpp b/acl/include/opencv2/acl/mat_core.hpp index 9cbd93c..e3a8192 100644 --- a/acl/include/opencv2/acl/mat_core.hpp +++ b/acl/include/opencv2/acl/mat_core.hpp @@ -3,384 +3,410 @@ #include "acl_type.hpp" -namespace cv -{ - namespace acl - { - //////////////////////////////////////////////////////////////////////// - //////////////////////////////// aclMat //////////////////////////////// - //////////////////////////////////////////////////////////////////////// +namespace cv { +namespace acl { +//////////////////////////////// aclMat //////////////////////////////// +inline aclMat::aclMat() + : flags(0), + rows(0), + cols(0), + step(0), + data(nullptr), + refcount(nullptr), + datastart(nullptr), + dataend(nullptr), + offset(0), + wholerows(0), + wholecols(0), + acl_context(0), + totalSize(0) {} - inline aclMat::aclMat() - : flags(0), rows(0), cols(0), step(0), data(nullptr), refcount(nullptr), - datastart(nullptr), dataend(nullptr), offset(0), wholerows(0), wholecols(0), acl_context(0), totalSize(0) - { - } +/** + * @param [in] _acl_context: Acl context + * @param [in] config: Byte aligned or not, Default MEMORY_UNALIGNED + * @param [in] policy: Acl Memory Application mode, Default + * ACL_MEM_MALLOC_NORMAL_ONLY + */ +inline aclMat::aclMat(int _rows, int _cols, int _type, aclCxt *_acl_context, + ALIGNMENT config, MemMallocPolicy policy) + : flags(0), + rows(0), + cols(0), + step(0), + data(nullptr), + refcount(nullptr), + datastart(nullptr), + dataend(nullptr), + offset(0), + wholerows(0), + wholecols(0), + acl_context(_acl_context), + totalSize(0) { + if (_rows > 0 && _cols > 0) create(_rows, _cols, _type, config, policy); +} - /** - * @param [in] _acl_context: Acl context - * @param [in] config: Byte aligned or not, Default MEMORY_UNALIGNED - * @param [in] policy: Acl Memory Application mode, Default ACL_MEM_MALLOC_NORMAL_ONLY - */ - inline aclMat::aclMat(int _rows, int _cols, int _type, aclCxt *_acl_context, ALIGNMENT config, MemMallocPolicy policy) - : flags(0), rows(0), cols(0), step(0), data(nullptr), refcount(nullptr), datastart(nullptr), - dataend(nullptr), offset(0), wholerows(0), wholecols(0), acl_context(_acl_context), totalSize(0) - { - if (_rows > 0 && _cols > 0) - create(_rows, _cols, _type, config, policy); - } +inline aclMat::aclMat(Size _size, int _type, aclCxt *_acl_context, + ALIGNMENT config, MemMallocPolicy policy) + : flags(0), + rows(0), + cols(0), + step(0), + data(nullptr), + refcount(nullptr), + datastart(nullptr), + dataend(nullptr), + offset(0), + wholerows(0), + wholecols(0), + acl_context(_acl_context), + totalSize(0) { + if (_size.height > 0 && _size.width > 0) create(_size, _type, config, policy); +} - inline aclMat::aclMat(Size _size, int _type, aclCxt *_acl_context, ALIGNMENT config, MemMallocPolicy policy) - : flags(0), rows(0), cols(0), step(0), data(nullptr), refcount(nullptr), datastart(nullptr), - dataend(nullptr), offset(0), wholerows(0), wholecols(0), acl_context(_acl_context), totalSize(0) - { - if (_size.height > 0 && _size.width > 0) - create(_size, _type, config, policy); - } +inline aclMat::aclMat(const aclMat &m) + : flags(m.flags), + rows(m.rows), + cols(m.cols), + step(m.step), + data(m.data), + refcount(m.refcount), + datastart(m.datastart), + dataend(m.dataend), + offset(m.offset), + wholerows(m.wholerows), + wholecols(m.wholecols), + acl_context(m.acl_context), + totalSize(m.totalSize) { + if (refcount) CV_XADD(refcount, 1); +} - inline aclMat::aclMat(const aclMat &m) - : flags(m.flags), rows(m.rows), cols(m.cols), step(m.step), data(m.data), refcount(m.refcount), - datastart(m.datastart), dataend(m.dataend), offset(m.offset), wholerows(m.wholerows), wholecols(m.wholecols), - acl_context(m.acl_context), totalSize(m.totalSize) - { - if (refcount) - CV_XADD(refcount, 1); - } +inline aclMat::aclMat(int _rows, int _cols, int _type, void *_data, + aclCxt *_acl_context, ALIGNMENT config, size_t _step) + : flags(0), + rows(0), + cols(0), + step(0), + data(nullptr), + refcount(nullptr), + datastart(nullptr), + dataend(nullptr), + offset(0), + wholerows(0), + wholecols(0), + acl_context(_acl_context), + totalSize(0) { + cv::Mat m(_rows, _cols, _type, _data, _step); + if (m.rows > 0 && m.cols > 0) create(m.rows, m.cols, m.type(), config); + upload(m, config); +} - inline aclMat::aclMat(int _rows, int _cols, int _type, void *_data, aclCxt *_acl_context, ALIGNMENT config, size_t _step) - : flags(0), rows(0), cols(0), step(0), data(nullptr), refcount(nullptr), datastart(nullptr), - dataend(nullptr), offset(0), wholerows(0), wholecols(0), acl_context(_acl_context), totalSize(0) - { - cv::Mat m(_rows, _cols, _type, _data, _step); - if (m.rows > 0 && m.cols > 0) - create(m.rows, m.cols, m.type(), config); - upload(m, config); - } +inline aclMat::aclMat(Size _size, int _type, void *_data, aclCxt *_acl_context, + ALIGNMENT config, size_t _step) + : flags(0), + rows(0), + cols(0), + step(0), + data(nullptr), + refcount(nullptr), + datastart(nullptr), + dataend(nullptr), + offset(0), + wholerows(0), + wholecols(0), + acl_context(_acl_context), + totalSize(0) { + cv::Mat m(_size, _type, _data, _step); + if (m.rows > 0 && m.cols > 0) create(m.rows, m.cols, m.type(), config); + upload(m, config); +} - inline aclMat::aclMat(Size _size, int _type, void *_data, aclCxt *_acl_context, ALIGNMENT config, size_t _step) - : flags(0), rows(0), cols(0), step(0), data(nullptr), refcount(nullptr), datastart(nullptr), - dataend(nullptr), offset(0), wholerows(0), wholecols(0), acl_context(_acl_context), totalSize(0) - { - cv::Mat m(_size, _type, _data, _step); - if (m.rows > 0 && m.cols > 0) - create(m.rows, m.cols, m.type(), config); - upload(m, config); - } +/** + * @param [in] rRange: rows begin to end, Range(start, end) + * @param [in] cRange: cols begin to end, Range(start, end) + */ +inline aclMat::aclMat(const aclMat &m, const Range &rRange, const Range &cRange) + : flags(m.flags), + step(m.step), + refcount(m.refcount), + datastart(m.datastart), + dataend(m.dataend), + offset(m.offset), + wholerows(m.wholerows), + wholecols(m.wholecols), + acl_context(m.acl_context), + totalSize(m.totalSize) { + if (rRange == Range::all()) + rows = m.rows; + else { + CV_Assert(0 <= rRange.start && rRange.start <= rRange.end && + rRange.end <= m.rows); + rows = rRange.size(); + offset += step * rRange.start; + } - /** - * @param [in] rRange: rows begin to end, Range(start, end) - * @param [in] cRange: cols begin to end, Range(start, end) - */ - inline aclMat::aclMat(const aclMat &m, const Range &rRange, const Range &cRange) - : flags(m.flags), step(m.step), refcount(m.refcount), datastart(m.datastart), dataend(m.dataend), - offset(m.offset), wholerows(m.wholerows), wholecols(m.wholecols), acl_context(m.acl_context), totalSize(m.totalSize) - { - if (rRange == Range::all()) - rows = m.rows; - else - { - CV_Assert(0 <= rRange.start && rRange.start <= rRange.end && rRange.end <= m.rows); - rows = rRange.size(); - offset += step * rRange.start; - } + if (cRange == Range::all()) + cols = m.cols; + else { + CV_Assert(0 <= cRange.start && cRange.start <= cRange.end && + cRange.end <= m.cols); + cols = cRange.size(); + offset += cRange.start * elemSize(); + flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1; + } - if (cRange == Range::all()) - cols = m.cols; - else - { - CV_Assert(0 <= cRange.start && cRange.start <= cRange.end && cRange.end <= m.cols); - cols = cRange.size(); - offset += cRange.start * elemSize(); - flags &= cols < m.cols ? ~Mat::CONTINUOUS_FLAG : -1; - } + if (rows == 1) flags |= Mat::CONTINUOUS_FLAG; - if (rows == 1) - flags |= Mat::CONTINUOUS_FLAG; + if (refcount) CV_XADD(refcount, 1); + if (rows <= 0 || cols <= 0) rows = cols = 0; - if (refcount) - CV_XADD(refcount, 1); - if (rows <= 0 || cols <= 0) - rows = cols = 0; + data = static_cast((static_cast(m.data) + offset)); +} - data = static_cast((static_cast(m.data) + offset)); - } +/** + * @param [in] roi: Matrix position, Rect(x, y, width, height) + * + */ +inline aclMat::aclMat(const aclMat &m, const Rect &roi) + : flags(m.flags), + rows(roi.height), + cols(roi.width), + step(m.step), + refcount(m.refcount), + datastart(m.datastart), + dataend(m.dataend), + offset(m.offset), + wholerows(m.wholerows), + wholecols(m.wholecols), + acl_context(m.acl_context), + totalSize(m.totalSize) { + flags &= roi.width < m.cols ? ~Mat::CONTINUOUS_FLAG : -1; + offset += roi.y * step + roi.x * elemSize(); + CV_Assert(0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.wholecols && + 0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.wholerows); + if (refcount) CV_XADD(refcount, 1); + if (rows <= 0 || cols <= 0) rows = cols = 0; - /** - * @param [in] roi: Matrix position, Rect(x, y, width, height) - * - */ - inline aclMat::aclMat(const aclMat &m, const Rect &roi) - : flags(m.flags), rows(roi.height), cols(roi.width), step(m.step), refcount(m.refcount), datastart(m.datastart), - dataend(m.dataend), offset(m.offset), wholerows(m.wholerows), wholecols(m.wholecols), acl_context(m.acl_context), - totalSize(m.totalSize) - { - flags &= roi.width < m.cols ? ~Mat::CONTINUOUS_FLAG : -1; - offset += roi.y * step + roi.x * elemSize(); - CV_Assert(0 <= roi.x && 0 <= roi.width && roi.x + roi.width <= m.wholecols && - 0 <= roi.y && 0 <= roi.height && roi.y + roi.height <= m.wholerows); - if (refcount) - CV_XADD(refcount, 1); - if (rows <= 0 || cols <= 0) - rows = cols = 0; + data = static_cast((static_cast(m.data) + offset)); +} - data = static_cast((static_cast(m.data) + offset)); - } +inline aclMat::aclMat(const Mat &m, aclCxt *_acl_context, ALIGNMENT config, + MemMallocPolicy policy) + : flags(0), + rows(m.rows), + cols(m.cols), + step(0), + data(nullptr), + refcount(nullptr), + datastart(nullptr), + dataend(nullptr), + offset(0), + wholerows(0), + wholecols(0), + acl_context(_acl_context), + totalSize(0) { + if (m.rows > 0 && m.cols > 0) + create(m.rows, m.cols, m.type(), config, policy); + upload(m, config); +} - inline aclMat::aclMat(const Mat &m, aclCxt *_acl_context, ALIGNMENT config, MemMallocPolicy policy) - : flags(0), rows(m.rows), cols(m.cols), step(0), data(nullptr), refcount(nullptr), datastart(nullptr), - dataend(nullptr), offset(0), wholerows(0), wholecols(0), acl_context(_acl_context), totalSize(0) - { - if (m.rows > 0 && m.cols > 0) - create(m.rows, m.cols, m.type(), config, policy); - upload(m, config); - } +inline aclMat::~aclMat() { + if (refcount) release(); +} - inline aclMat::~aclMat() - { - if (refcount) - release(); - } +inline aclMat &aclMat::operator=(const aclMat &m) { + if (this != &m) { + if (refcount) release(); + flags = m.flags; + rows = m.rows; + cols = m.cols; + step = m.step; + datastart = m.datastart; + dataend = m.dataend; + offset = m.offset; + wholerows = m.wholerows; + wholecols = m.wholecols; + refcount = m.refcount; + acl_context = m.acl_context; + totalSize = m.totalSize; + data = m.data; + if (m.refcount) CV_XADD(m.refcount, 1); + } + return *this; +} - inline aclMat &aclMat::operator=(const aclMat &m) - { - if (this != &m) - { - - if (refcount) - release(); - flags = m.flags; - rows = m.rows; - cols = m.cols; - step = m.step; - datastart = m.datastart; - dataend = m.dataend; - offset = m.offset; - wholerows = m.wholerows; - wholecols = m.wholecols; - refcount = m.refcount; - acl_context = m.acl_context; - totalSize = m.totalSize; - data = m.data; - if (m.refcount) - CV_XADD(m.refcount, 1); - } - return *this; - } +inline aclMat &aclMat::operator=(const Mat &m) { + upload(m); + return *this; +} - inline aclMat& aclMat::operator=(const Mat &m) - { - upload(m); - return *this; - } +inline aclMat::operator Mat() const { + Mat m(rows, cols, type()); + download(m); + return m; +} - inline aclMat::operator Mat() const - { - Mat m(rows, cols, type()); - download(m); - return m; - } +inline aclMat aclMat::clone() const { + aclMat m; + copyTo(m); + return m; +} - inline aclMat aclMat::clone() const - { - aclMat m; - copyTo(m); - return m; - } +inline void aclMat::copyTo(aclMat &dest) const { + if (this != &dest) { + dest.rows = rows; + dest.cols = cols; + dest.step = step; + dest.wholerows = wholerows; + dest.wholecols = wholecols; + dest.refcount = refcount; + dest.acl_context = acl_context; + dest.totalSize = totalSize; - inline void aclMat::copyTo(aclMat& dest) const - { - if (this != &dest) - { - dest.rows = rows; - dest.cols = cols; - dest.step = step; - dest.wholerows = wholerows; - dest.wholecols = wholecols; - dest.refcount = refcount; - dest.acl_context = acl_context; - dest.totalSize = totalSize; + void *dev_ptr; + AclSafeCall( + aclrtMalloc(&dev_ptr, totalSize, type_transition(MALLOC_NORMAL_ONLY))); + AclSafeCall(aclrtMemcpy(dev_ptr, totalSize, data, totalSize, + ACL_MEMCPY_DEVICE_TO_DEVICE)); - void *dev_ptr; - AclSafeCall(aclrtMalloc(&dev_ptr, totalSize, type_transition(MALLOC_NORMAL_ONLY))); - AclSafeCall(aclrtMemcpy(dev_ptr, totalSize, data, totalSize, ACL_MEMCPY_DEVICE_TO_DEVICE)); + dest.data = dev_ptr; + dest.datastart = static_cast(data); + dest.dataend = static_cast(data) + totalSize; + dest.refcount = static_cast(fastMalloc(sizeof(*refcount))); + *refcount = 0; + CV_XADD(refcount, 1); + dest.flags |= Mat::CONTINUOUS_FLAG; + } +} - dest.data = dev_ptr; - dest.datastart = static_cast(data); - dest.dataend = static_cast(data) + totalSize; - dest.refcount = static_cast(fastMalloc(sizeof(*refcount))); - *refcount = 0; - CV_XADD(refcount, 1); - dest.flags |= Mat::CONTINUOUS_FLAG; - } - } +inline aclMat aclMat::row(int y) const { + return aclMat(*this, Range(y, y + 1), Range::all()); +} - inline aclMat aclMat::row(int y) const - { - return aclMat(*this, Range(y, y + 1), Range::all()); - } +inline aclMat aclMat::col(int x) const { + return aclMat(*this, Range::all(), Range(x, x + 1)); +} - inline aclMat aclMat::col(int x) const - { - return aclMat(*this, Range::all(), Range(x, x + 1)); - } +inline aclMat aclMat::rowRange(int startrow, int endrow) const { + return aclMat(*this, Range(startrow, endrow), Range::all()); +} - inline aclMat aclMat::rowRange(int startrow, int endrow) const - { - return aclMat(*this, Range(startrow, endrow), Range::all()); - } +inline aclMat aclMat::rowRange(const Range &r) const { + return aclMat(*this, r, Range::all()); +} - inline aclMat aclMat::rowRange(const Range &r) const - { - return aclMat(*this, r, Range::all()); - } +inline aclMat aclMat::colRange(int startcol, int endcol) const { + return aclMat(*this, Range::all(), Range(startcol, endcol)); +} - inline aclMat aclMat::colRange(int startcol, int endcol) const - { - return aclMat(*this, Range::all(), Range(startcol, endcol)); - } +inline aclMat aclMat::colRange(const Range &r) const { + return aclMat(*this, Range::all(), r); +} - inline aclMat aclMat::colRange(const Range &r) const - { - return aclMat(*this, Range::all(), r); - } +inline void aclMat::locateROI(Size &wholeSize, Point &ofs) const { + size_t esz = elemSize(); + CV_DbgAssert(step > 0); + if (offset == 0) + ofs.x = ofs.y = 0; + else { + ofs.y = (int)(offset / step); + ofs.x = (int)((offset - step * ofs.y) / esz); + CV_DbgAssert(data == (datastart + ofs.y * step + ofs.x * esz)); + } + wholeSize.height = wholerows; + wholeSize.width = wholecols; +} - inline void aclMat::locateROI( Size &wholeSize, Point &ofs ) const - { - size_t esz = elemSize(); - CV_DbgAssert(step > 0); - if(offset == 0) - ofs.x = ofs.y = 0; - else - { - ofs.y = (int)(offset / step); - ofs.x = (int)((offset - step * ofs.y) / esz); - CV_DbgAssert(data == (datastart + ofs.y * step + ofs.x * esz)); - } - wholeSize.height = wholerows; - wholeSize.width = wholecols; - } +inline aclMat &aclMat::adjustROI(int dtop, int dbottom, int dleft, int dright) { + Size wholeSize; + Point ofs; + size_t esz = elemSize(); + locateROI(wholeSize, ofs); + int row1 = std::max(ofs.y - dtop, 0), + row2 = std::min(ofs.y + rows + dbottom, wholeSize.height); + int col1 = std::max(ofs.x - dleft, 0), + col2 = std::min(ofs.x + cols + dright, wholeSize.width); + offset += (row1 - ofs.y) * step + (col1 - ofs.x) * esz; + rows = row2 - row1; + cols = col2 - col1; + if (esz * cols == step || rows == 1) + flags |= Mat::CONTINUOUS_FLAG; + else + flags &= ~Mat::CONTINUOUS_FLAG; - inline aclMat &aclMat::adjustROI( int dtop, int dbottom, int dleft, int dright ) - { - Size wholeSize; - Point ofs; - size_t esz = elemSize(); - locateROI( wholeSize, ofs ); - int row1 = std::max(ofs.y - dtop, 0), row2 = std::min(ofs.y + rows + dbottom, wholeSize.height); - int col1 = std::max(ofs.x - dleft, 0), col2 = std::min(ofs.x + cols + dright, wholeSize.width); - offset += (row1 - ofs.y) * step + (col1 - ofs.x) * esz; - rows = row2 - row1; - cols = col2 - col1; - if( esz * cols == step || rows == 1 ) - flags |= Mat::CONTINUOUS_FLAG; - else - flags &= ~Mat::CONTINUOUS_FLAG; - - data = static_cast((static_cast(datastart) + offset)); - return *this; - } + data = static_cast((static_cast(datastart) + offset)); + return *this; +} - inline void aclMat::swap(aclMat &b) - { - std::swap( flags, b.flags ); - std::swap( rows, b.rows ); - std::swap( cols, b.cols ); - std::swap( step, b.step ); - std::swap( data, b.data ); - std::swap( datastart, b.datastart ); - std::swap( dataend, b.dataend ); - std::swap( refcount, b.refcount ); - std::swap( offset, b.offset ); - std::swap( wholerows, b.wholerows ); - std::swap( wholecols, b.wholecols ); - std::swap( acl_context, b.acl_context); - std::swap( totalSize, b.totalSize); - } +inline void aclMat::swap(aclMat &b) { + std::swap(flags, b.flags); + std::swap(rows, b.rows); + std::swap(cols, b.cols); + std::swap(step, b.step); + std::swap(data, b.data); + std::swap(datastart, b.datastart); + std::swap(dataend, b.dataend); + std::swap(refcount, b.refcount); + std::swap(offset, b.offset); + std::swap(wholerows, b.wholerows); + std::swap(wholecols, b.wholecols); + std::swap(acl_context, b.acl_context); + std::swap(totalSize, b.totalSize); +} - inline aclMat aclMat::operator()( Range rRange, Range cRange ) const - { - return aclMat(*this, rRange, cRange); - } +inline aclMat aclMat::operator()(Range rRange, Range cRange) const { + return aclMat(*this, rRange, cRange); +} - inline aclMat aclMat::operator()( const Rect &roi ) const - { - return aclMat(*this, roi); - } +inline aclMat aclMat::operator()(const Rect &roi) const { + return aclMat(*this, roi); +} - inline bool aclMat::isContinuous() const - { - return (flags & Mat::CONTINUOUS_FLAG) != 0; - } +inline bool aclMat::isContinuous() const { + return (flags & Mat::CONTINUOUS_FLAG) != 0; +} - inline size_t aclMat::elemSize() const - { - return CV_ELEM_SIZE((CV_MAKE_TYPE(type(), channels()))); - } +inline size_t aclMat::elemSize() const { + return CV_ELEM_SIZE((CV_MAKE_TYPE(type(), channels()))); +} - inline size_t aclMat::elemSize1() const - { - return CV_ELEM_SIZE1(flags); - } +inline size_t aclMat::elemSize1() const { return CV_ELEM_SIZE1(flags); } - inline int aclMat::type() const - { - return CV_MAT_TYPE(flags); - } +inline int aclMat::type() const { return CV_MAT_TYPE(flags); } - inline int aclMat::acltype() const - { - return CV_MAKE_TYPE(depth(), aclchannels()); - } +inline int aclMat::acltype() const { + return CV_MAKE_TYPE(depth(), aclchannels()); +} - inline int aclMat::depth() const - { - return CV_MAT_DEPTH(flags); - } +inline int aclMat::depth() const { return CV_MAT_DEPTH(flags); } - inline int aclMat::channels() const - { - return CV_MAT_CN(flags); - } +inline int aclMat::channels() const { return CV_MAT_CN(flags); } - inline int aclMat::aclchannels() const - { - return (CV_MAT_CN(flags)) == 3 ? 4 : (CV_MAT_CN(flags)); - } +inline int aclMat::aclchannels() const { + return (CV_MAT_CN(flags)) == 3 ? 4 : (CV_MAT_CN(flags)); +} - inline size_t aclMat::step1() const - { - return step / elemSize1(); - } +inline size_t aclMat::step1() const { return step / elemSize1(); } - inline Size aclMat::size() const - { - return Size(cols, rows); - } +inline Size aclMat::size() const { return Size(cols, rows); } - inline bool aclMat::empty() const - { - return data == 0; - } +inline bool aclMat::empty() const { return data == 0; } - inline void swap( aclMat &a, aclMat &b ) - { - a.swap(b); - } +inline void swap(aclMat &a, aclMat &b) { a.swap(b); } - inline void ensureSizeIsEnough(int rows, int cols, int type, aclMat &m, ALIGNMENT config) - { - if (m.type() == type && m.rows >= rows && m.cols >= cols) - m = m(Rect(0, 0, cols, rows)); - else - m.create(rows, cols, type, config); - } +inline void ensureSizeIsEnough(int rows, int cols, int type, aclMat &m, + ALIGNMENT config) { + if (m.type() == type && m.rows >= rows && m.cols >= cols) + m = m(Rect(0, 0, cols, rows)); + else + m.create(rows, cols, type, config); +} - inline void ensureSizeIsEnough(Size size, int type, ALIGNMENT config, aclMat &m) - { - ensureSizeIsEnough(size.height, size.width, type, m, config); - } +inline void ensureSizeIsEnough(Size size, int type, ALIGNMENT config, + aclMat &m) { + ensureSizeIsEnough(size.height, size.width, type, m, config); +} - } /* end of namespace acl */ +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/include/opencv2/acl/mathfuncs.hpp b/acl/include/opencv2/acl/mathfuncs.hpp index f2462c6..0c33cd1 100644 --- a/acl/include/opencv2/acl/mathfuncs.hpp +++ b/acl/include/opencv2/acl/mathfuncs.hpp @@ -1,4 +1,4 @@ -#ifndef OPENCV_MATHFUNCS_HPP +#ifndef OPENCV_MATHFUNCS_HPP #define OPENCV_MATHFUNCS_HPP #include "acl_mat.hpp" @@ -7,20 +7,23 @@ * mathfunctions; */ -namespace cv -{ - namespace acl - { - CV_EXPORTS aclMat abs(const aclMat &src, int stream_id = 0); - CV_EXPORTS void pow(const aclMat &src, double power, aclMat &dest, int stream_id = 0); - CV_EXPORTS void sqrt(const aclMat &src, aclMat &dest, int stream_id = 0); - CV_EXPORTS void add(const aclMat &src, const aclMat &other_src, aclMat &dest, int stream_id = 0); - CV_EXPORTS void divide(const aclMat &src, const aclMat &other_src, aclMat &dest, int stream_id = 0); - CV_EXPORTS void exp(const aclMat &src, aclMat &dest, int stream_id = 0); - CV_EXPORTS void log(const aclMat &src, aclMat &dest, int stream_id = 0); - CV_EXPORTS void max(const aclMat &src, const aclMat &other_src, aclMat &dest, int stream_id = 0); - CV_EXPORTS void min(const aclMat &src, const aclMat &other_src, aclMat &dest, int stream_id = 0); - } /* end of namespace acl */ +namespace cv { +namespace acl { +CV_EXPORTS aclMat abs(const aclMat &src, int stream_id = 0); +CV_EXPORTS void pow(const aclMat &src, double power, aclMat &dest, + int stream_id = 0); +CV_EXPORTS void sqrt(const aclMat &src, aclMat &dest, int stream_id = 0); +CV_EXPORTS void add(const aclMat &src, const aclMat &other_src, aclMat &dest, + int stream_id = 0); +CV_EXPORTS void divide(const aclMat &src, const aclMat &other_src, aclMat &dest, + int stream_id = 0); +CV_EXPORTS void exp(const aclMat &src, aclMat &dest, int stream_id = 0); +CV_EXPORTS void log(const aclMat &src, aclMat &dest, int stream_id = 0); +CV_EXPORTS void max(const aclMat &src, const aclMat &other_src, aclMat &dest, + int stream_id = 0); +CV_EXPORTS void min(const aclMat &src, const aclMat &other_src, aclMat &dest, + int stream_id = 0); +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/include/opencv2/acl/matrices.hpp b/acl/include/opencv2/acl/matrices.hpp index 3ca90da..6c84b9b 100644 --- a/acl/include/opencv2/acl/matrices.hpp +++ b/acl/include/opencv2/acl/matrices.hpp @@ -1,22 +1,19 @@ -#ifndef OPENCV_MATRICES_HPP +#ifndef OPENCV_MATRICES_HPP #define OPENCV_MATRICES_HPP #include "acl_mat.hpp" -namespace cv -{ - namespace acl - { - // Matrix lookup table - //CV_EXPORTS void lookUpTable(const aclMat& src, const aclMat& lut, aclMat& dst); - // Multiple channel merge - CV_EXPORTS void merge(const vector& mv, aclMat& dst, int stream_id = 0); - // Split into channels - CV_EXPORTS void split(const aclMat& src, vector& mv, int stream_id = 0); - // Matrix transpose - CV_EXPORTS void transpose(const aclMat& src, aclMat& dest, int stream_id = 0); - CV_EXPORTS void flip(const aclMat& src, aclMat& dest, int flipCode = 0, int stream_id = 0); - } /* end of namespace acl */ +namespace cv { +namespace acl { +// Multiple channel merge +CV_EXPORTS void merge(const std::vector &mv, aclMat &dst, int stream_id = 0); +// Split into channels +CV_EXPORTS void split(const aclMat &src, std::vector &mv, int stream_id = 0); +// Matrix transpose +CV_EXPORTS void transpose(const aclMat &src, aclMat &dest, int stream_id = 0); +CV_EXPORTS void flip(const aclMat &src, aclMat &dest, int flipCode = 0, + int stream_id = 0); +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/include/opencv2/acl/operator_desc.hpp b/acl/include/opencv2/acl/operator_desc.hpp index 9860da7..1453da9 100644 --- a/acl/include/opencv2/acl/operator_desc.hpp +++ b/acl/include/opencv2/acl/operator_desc.hpp @@ -4,90 +4,96 @@ #include #include -#include "acl_type.hpp" +#include "acl/acl.h" #include "acl_init.hpp" #include "acl_mat.hpp" -#include "acl/acl.h" +#include "acl_type.hpp" -namespace cv -{ - namespace acl - { - class CV_EXPORTS OperatorDesc - { - public: - /** - * Constructor - * @param [in] opType: op type - */ - OperatorDesc(std::string opType); +namespace cv { +namespace acl { +class CV_EXPORTS OperatorDesc { + public: + /** + * Constructor + * @param [in] opType: op type + */ + OperatorDesc(std::string opType); - /** - * Destructor - */ - virtual ~OperatorDesc(); + /** + * Destructor + */ + virtual ~OperatorDesc(); - /** - * Add an input tensor description - * @param [in] dataType: data type - * @param [in] numDims: number of dims - * @param [in] dims: dims - * @param [in] format: format - * @return OperatorDesc - */ - OperatorDesc &AddInputTensorDesc(aclDataType dataType, int numDims, const int64_t *dims, aclFormat format); + /** + * Add an input tensor description + * @param [in] dataType: data type + * @param [in] numDims: number of dims + * @param [in] dims: dims + * @param [in] format: format + * @return OperatorDesc + */ + OperatorDesc &AddInputTensorDesc(aclDataType dataType, int numDims, + const int64_t *dims, aclFormat format); - /** - * Add an output tensor description - * @param [in] dataType: data type - * @param [in] numDims: number of dims - * @param [in] dims: dims - * @param [in] format: format - * @return OperatorDesc - */ - OperatorDesc &AddOutputTensorDesc(aclDataType dataType, int numDims, const int64_t *dims, aclFormat format); + /** + * Add an output tensor description + * @param [in] dataType: data type + * @param [in] numDims: number of dims + * @param [in] dims: dims + * @param [in] format: format + * @return OperatorDesc + */ + OperatorDesc &AddOutputTensorDesc(aclDataType dataType, int numDims, + const int64_t *dims, aclFormat format); - template - bool AddTensorAttr(const char *attrName, AttrType type, T vaule) - { - if (opAttr == nullptr) - return false; - switch (type) - { - case OP_BOOL: - aclopSetAttrBool(opAttr, attrName, vaule); - break; - case OP_INT: - aclopSetAttrInt(opAttr, attrName, vaule); - break; - case OP_FLOAT: - aclopSetAttrFloat(opAttr, attrName, vaule); - break; - default: - break; - } - return true; - } - std::string opType; - std::vector inputDesc; - std::vector outputDesc; - aclopAttr *opAttr; - }; + template + bool AddTensorAttr(const char *attrName, AttrType type, T vaule) { + if (opAttr == nullptr) return false; + switch (type) { + case OP_BOOL: + aclopSetAttrBool(opAttr, attrName, vaule); + break; + case OP_INT: + aclopSetAttrInt(opAttr, attrName, vaule); + break; + case OP_FLOAT: + aclopSetAttrFloat(opAttr, attrName, vaule); + break; + default: + break; + } + return true; + } + std::string opType; + std::vector inputDesc; + std::vector outputDesc; + aclopAttr *opAttr; +}; - - // Create operator description - CV_EXPORTS OperatorDesc CreateOpDesc(const string opType, const vector &input_Mat, vector &output_Mat, aclFormat format = ACL_FORMAT_NHWC, Opdims config = FOUR_DIMS); - // Compile and run the operator - CV_EXPORTS void compileAndRunop(OperatorDesc &opDesc, vector &inputBuffers_, vector &outputBuffers_, aclCxt *acl_context, int stream_id); - // Suitable for one input and one output - CV_EXPORTS void OneInAndOneOut(const aclMat &input, aclMat &output, const string opType, int stream_id = 0); - // Suitable for tow input and one output - CV_EXPORTS void TwoInAndOneOut(const aclMat &inputMat, const aclMat &inputMatOther, aclMat &outputMat, const string opType, int stream_id = 0); - // run the operator - CV_EXPORTS void Runop(vector &input, vector &output, OperatorDesc &opDesc, int stream_id); +// Create operator description +CV_EXPORTS OperatorDesc CreateOpDesc(const std::string opType, + const std::vector &input_Mat, + std::vector &output_Mat, + aclFormat format = ACL_FORMAT_NHWC, + Opdims config = FOUR_DIMS); +// Compile and run the operator +CV_EXPORTS void compileAndRunop(OperatorDesc &opDesc, + std::vector &inputBuffers_, + std::vector &outputBuffers_, + aclCxt *acl_context, int stream_id); +// Suitable for one input and one output +CV_EXPORTS void OneInAndOneOut(const aclMat &input, aclMat &output, + const std::string opType, int stream_id = 0); +// Suitable for tow input and one output +CV_EXPORTS void TwoInAndOneOut(const aclMat &inputMat, + const aclMat &inputMatOther, aclMat &outputMat, + const std::string opType, int stream_id = 0); +// run the operator +CV_EXPORTS void Runop(std::vector &input, std::vector &output, + OperatorDesc &opDesc, int stream_id); - } /* end of namespace acl */ +} /* end of namespace acl */ } /* end of namespace cv */ -#endif // OPERATOR_DESC_HPP +#endif // OPERATOR_DESC_HPP diff --git a/acl/src/acl_init.cpp b/acl/src/acl_init.cpp index 1eeb00b..6019931 100644 --- a/acl/src/acl_init.cpp +++ b/acl/src/acl_init.cpp @@ -1,8 +1,9 @@ -/*M/////////////////////////////////////////////////////////////////////////////////////// +/* M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // -// By downloading, copying, installing or using the software you agree to this license. +// 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. // @@ -10,28 +11,35 @@ // 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, Institute Of Software Chinese Academy Of Science, +all rights reserved. // Copyright (C) 2010-2012, Advanced Micro Devices, Inc., all rights reserved. // Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. // Third party copyrights are property of their respective owners. // -// Redistribution and use in source and binary forms, with or without modification, +// 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, +// * 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 +// * 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 +// 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, +// 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 @@ -39,85 +47,74 @@ // 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*/ +//M */ #include "precomp.hpp" +using namespace std; +using namespace cv; +using namespace cv::acl; +namespace cv { +namespace acl { +///////////////////////////aclEnv////////////////////////////////// +static Mutex *__initmutex = NULL; +Mutex &getInitMutex() { + if (__initmutex == NULL) __initmutex = new Mutex(); + return *__initmutex; +} +aclEnv *global_aclenv = nullptr; +aclEnv *aclEnv::get_acl_env(const char *config_path) { + if (nullptr == global_aclenv) { + AutoLock lock(getInitMutex()); + if (nullptr == global_aclenv) global_aclenv = new aclEnv(config_path); + } + return global_aclenv; +} -namespace cv -{ - namespace acl - { - ///////////////////////////aclEnv////////////////////////////////// - static Mutex *__initmutex = NULL; - Mutex &getInitMutex() - { - if (__initmutex == NULL) - __initmutex = new Mutex(); - return *__initmutex; - } +void wait_stream(aclCxt *acl_context, const int stream_id) { + aclrtSynchronizeStream(acl_context->get_stream(stream_id)); +} - aclEnv *global_aclenv = nullptr; - aclEnv* aclEnv::get_acl_env(const char* config_path) - { - if (nullptr == global_aclenv) - { - AutoLock lock(getInitMutex()); - if (nullptr == global_aclenv) - global_aclenv = new aclEnv(config_path); - } - return global_aclenv; - } +/////////////////////////create acl context//////////////////////// +/** + * @brief: set device and stream + * @param [in] config_path: ajson path + * @param [in] device_id: device id + * @param [in] stream_count: stream count + */ +aclCxt *set_device(const char *config_path, int device_id, int stream_count) { + aclEnv *acl_env = aclEnv::get_acl_env(config_path); + if (global_aclenv->refcount) { + AutoLock lock(getInitMutex()); + CV_XADD(global_aclenv->refcount, 1); + } + int device_count = acl_env->get_device_count(); + CV_Assert(device_id < device_count); - void wait_stream(aclCxt * acl_context, const int stream_id) - { - aclrtSynchronizeStream(acl_context->get_stream(stream_id)); - } + aclCxt *acl_context = new aclCxt(device_id); + acl_context->set_current_context(); + acl_context->create_stream(stream_count); - /////////////////////////create acl context//////////////////////// - /** - * @brief: set device and stream - * @param [in] config_path: ajson path - * @param [in] device_id: device id - * @param [in] stream_count: stream count - */ - aclCxt *set_device(const char* config_path, int device_id, int stream_count) - { - aclEnv *acl_env = aclEnv::get_acl_env(config_path); - if (global_aclenv->refcount) { - AutoLock lock(getInitMutex()); - CV_XADD(global_aclenv->refcount, 1); - } - int device_count = acl_env->get_device_count(); - CV_Assert(device_id < device_count); + clog << "set_device() is success" << endl; + return acl_context; +} - aclCxt *acl_context = new aclCxt(device_id); - acl_context->set_current_context(); - acl_context->create_stream(stream_count); +void release_device(aclCxt *context) { + CV_Assert(context); + delete context; + context = nullptr; + if (global_aclenv->refcount) { + AutoLock lock(getInitMutex()); + CV_XADD(global_aclenv->refcount, -1); - clog << "set_device() is success" << endl; - return acl_context; - } + if (*(global_aclenv->refcount) == 0) { + delete global_aclenv; + global_aclenv = nullptr; + } + } + clog << "release_device() is success" << endl; +} - void release_device(aclCxt* context) - { - CV_Assert(context); - delete context; - context = nullptr; - if (global_aclenv->refcount) - { - AutoLock lock(getInitMutex()); - CV_XADD(global_aclenv->refcount, -1); - - if (*(global_aclenv->refcount) == 0) - { - delete global_aclenv; - global_aclenv = nullptr; - } - } - clog << "release_device() is success" << endl; - } - - } /* end of namespace acl */ +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/src/acl_mat.cpp b/acl/src/acl_mat.cpp index 7ed754f..1ff0055 100644 --- a/acl/src/acl_mat.cpp +++ b/acl/src/acl_mat.cpp @@ -1,216 +1,213 @@ #include "precomp.hpp" - #define ALIGN 64 -namespace cv -{ - namespace acl - { - /* Memory alignment */ - static inline size_t alignSize(size_t sz, int n = ALIGN); - - void aclMat::upload(const Mat &m, ALIGNMENT config) - { - CV_Assert((config == ALIGNMENT::MEMORY_ALIGN) || (config == ALIGNMENT::MEMORY_UNALIGNED)); - if (config == ALIGNMENT::MEMORY_UNALIGNED) - { - CV_Assert(m.data && (this->step == m.step) && (this->rows == m.rows) && (this->cols == m.cols) && (this->type() == m.type())); - aclrtMemcpy((void *)this->data, (m.step * m.rows), (void *)m.data, (m.step * m.rows), ACL_MEMCPY_HOST_TO_DEVICE); - } - else if (config == ALIGNMENT::MEMORY_ALIGN) - { - CV_Assert(m.data && (this->rows == m.rows) && (this->cols == m.cols) && (this->type() == m.type())); - aclrtMemcpy2d((void *)this->data, this->step, (void *)m.data, m.step, m.cols * m.elemSize(), m.rows, ACL_MEMCPY_HOST_TO_DEVICE); - } - } +using namespace std; +using namespace cv; +using namespace cv::acl; +namespace cv { +namespace acl { +/* Memory alignment */ +static inline size_t alignSize(size_t sz, int n = ALIGN); - void aclMat::upload(const Mat &m, aclStream stream, ALIGNMENT config) - { - CV_Assert((config == ALIGNMENT::MEMORY_ALIGN) || (config == ALIGNMENT::MEMORY_UNALIGNED)); - if (config == ALIGNMENT::MEMORY_UNALIGNED) - { - CV_Assert(m.data && (this->step == m.step) && (this->rows == m.rows) && (this->cols == m.cols) && (this->type() == m.type())); - aclrtMemcpyAsync((void *)this->data, this->totalSize, (void *)m.data, (m.step * m.rows), ACL_MEMCPY_HOST_TO_DEVICE, stream); - } - else if (config == ALIGNMENT::MEMORY_ALIGN) - { - CV_Assert(m.data && (this->rows == m.rows) && (this->cols == m.cols) && (this->type() == m.type())); - aclrtMemcpy2dAsync((void *)this->data, this->step, (void *)m.data, m.step, m.cols * m.elemSize(), m.rows, ACL_MEMCPY_HOST_TO_DEVICE, stream); - } - AclSafeCall(aclrtSynchronizeStream(stream)); - } +void aclMat::upload(const Mat &m, ALIGNMENT config) { + CV_Assert((config == ALIGNMENT::MEMORY_ALIGN) || + (config == ALIGNMENT::MEMORY_UNALIGNED)); + if (config == ALIGNMENT::MEMORY_UNALIGNED) { + CV_Assert(m.data && (this->step == m.step) && (this->rows == m.rows) && + (this->cols == m.cols) && (this->type() == m.type())); + aclrtMemcpy((void *)this->data, (m.step * m.rows), (void *)m.data, + (m.step * m.rows), ACL_MEMCPY_HOST_TO_DEVICE); + } else if (config == ALIGNMENT::MEMORY_ALIGN) { + CV_Assert(m.data && (this->rows == m.rows) && (this->cols == m.cols) && + (this->type() == m.type())); + aclrtMemcpy2d((void *)this->data, this->step, (void *)m.data, m.step, + m.cols * m.elemSize(), m.rows, ACL_MEMCPY_HOST_TO_DEVICE); + } +} +void aclMat::upload(const Mat &m, aclStream stream, ALIGNMENT config) { + CV_Assert((config == ALIGNMENT::MEMORY_ALIGN) || + (config == ALIGNMENT::MEMORY_UNALIGNED)); + if (config == ALIGNMENT::MEMORY_UNALIGNED) { + CV_Assert(m.data && (this->step == m.step) && (this->rows == m.rows) && + (this->cols == m.cols) && (this->type() == m.type())); + aclrtMemcpyAsync((void *)this->data, this->totalSize, (void *)m.data, + (m.step * m.rows), ACL_MEMCPY_HOST_TO_DEVICE, stream); + } else if (config == ALIGNMENT::MEMORY_ALIGN) { + CV_Assert(m.data && (this->rows == m.rows) && (this->cols == m.cols) && + (this->type() == m.type())); + aclrtMemcpy2dAsync((void *)this->data, this->step, (void *)m.data, m.step, + m.cols * m.elemSize(), m.rows, ACL_MEMCPY_HOST_TO_DEVICE, + stream); + } + AclSafeCall(aclrtSynchronizeStream(stream)); +} - void aclMat::download(Mat &m, ALIGNMENT config) const - { - CV_Assert((config == ALIGNMENT::MEMORY_ALIGN) || (config == ALIGNMENT::MEMORY_UNALIGNED)); - if (config == ALIGNMENT::MEMORY_UNALIGNED) - { - CV_Assert(m.data && (this->step == m.step) && (this->rows == m.rows) && (this->cols == m.cols) && (this->type() == m.type())); - aclrtMemcpy((void *)m.data, (m.step * m.rows), (void *)(this->data), (m.step * m.rows), ACL_MEMCPY_DEVICE_TO_HOST); - } - else if (config == ALIGNMENT::MEMORY_ALIGN) - { - CV_Assert(m.data && (this->rows == m.rows) && (this->cols == m.cols) && (this->type() == m.type())); - aclrtMemcpy2d((void *)m.data, m.step, (void *)(this->data), this->step, this->cols * this->elemSize(), this->rows, ACL_MEMCPY_DEVICE_TO_HOST); - } - return; - } +void aclMat::download(Mat &m, ALIGNMENT config) const { + CV_Assert((config == ALIGNMENT::MEMORY_ALIGN) || + (config == ALIGNMENT::MEMORY_UNALIGNED)); + if (config == ALIGNMENT::MEMORY_UNALIGNED) { + CV_Assert(m.data && (this->step == m.step) && (this->rows == m.rows) && + (this->cols == m.cols) && (this->type() == m.type())); + aclrtMemcpy((void *)m.data, (m.step * m.rows), (void *)(this->data), + (m.step * m.rows), ACL_MEMCPY_DEVICE_TO_HOST); + } else if (config == ALIGNMENT::MEMORY_ALIGN) { + CV_Assert(m.data && (this->rows == m.rows) && (this->cols == m.cols) && + (this->type() == m.type())); + aclrtMemcpy2d((void *)m.data, m.step, (void *)(this->data), this->step, + this->cols * this->elemSize(), this->rows, + ACL_MEMCPY_DEVICE_TO_HOST); + } + return; +} - void aclMat::download(Mat &m, aclStream stream, ALIGNMENT config) const - { - CV_Assert((config == ALIGNMENT::MEMORY_ALIGN) || (config == ALIGNMENT::MEMORY_UNALIGNED)); - if (config == ALIGNMENT::MEMORY_UNALIGNED) - { - CV_Assert(m.data && (this->step == m.step) && (this->rows == m.rows) && (this->cols == m.cols) && (this->type() == m.type())); - aclrtMemcpyAsync((void *)m.data, (m.step * m.rows), (void *)(this->data), this->totalSize, ACL_MEMCPY_DEVICE_TO_HOST, stream); - } - else if (config == ALIGNMENT::MEMORY_ALIGN) - { - CV_Assert(m.data && (this->rows == m.rows) && (this->cols == m.cols) && (this->type() == m.type())); - aclrtMemcpy2dAsync((void *)m.data, m.step, (void *)(this->data), this->step, this->cols * this->elemSize(), this->rows, ACL_MEMCPY_DEVICE_TO_HOST, stream); - } - AclSafeCall(aclrtSynchronizeStream(stream)); - return; - } +void aclMat::download(Mat &m, aclStream stream, ALIGNMENT config) const { + CV_Assert((config == ALIGNMENT::MEMORY_ALIGN) || + (config == ALIGNMENT::MEMORY_UNALIGNED)); + if (config == ALIGNMENT::MEMORY_UNALIGNED) { + CV_Assert(m.data && (this->step == m.step) && (this->rows == m.rows) && + (this->cols == m.cols) && (this->type() == m.type())); + aclrtMemcpyAsync((void *)m.data, (m.step * m.rows), (void *)(this->data), + this->totalSize, ACL_MEMCPY_DEVICE_TO_HOST, stream); + } else if (config == ALIGNMENT::MEMORY_ALIGN) { + CV_Assert(m.data && (this->rows == m.rows) && (this->cols == m.cols) && + (this->type() == m.type())); + aclrtMemcpy2dAsync((void *)m.data, m.step, (void *)(this->data), this->step, + this->cols * this->elemSize(), this->rows, + ACL_MEMCPY_DEVICE_TO_HOST, stream); + } + AclSafeCall(aclrtSynchronizeStream(stream)); + return; +} - void aclMat::create(int _rows, int _cols, int _type, ALIGNMENT config, MemMallocPolicy policy) - { - createEx(_rows, _cols, _type, config, policy); - } +void aclMat::create(int _rows, int _cols, int _type, ALIGNMENT config, + MemMallocPolicy policy) { + createEx(_rows, _cols, _type, config, policy); +} - void aclMat::create(Size size, int type, ALIGNMENT config, MemMallocPolicy policy) - { - createEx(size, type, config, policy); - } +void aclMat::create(Size size, int type, ALIGNMENT config, + MemMallocPolicy policy) { + createEx(size, type, config, policy); +} - inline size_t alignSize(size_t sz, int n) - { - return (((sz) + n - 1) / n ) * n; - } +inline size_t alignSize(size_t sz, int n) { return (((sz) + n - 1) / n) * n; } - /* core logic */ - void aclMat::createEx(int _rows, int _cols, int _type, ALIGNMENT config, MemMallocPolicy policy) - { - /* TO ENSURE */ - //_type &= CV_MAT_TYPE_MASK; - _type &= TYPE_MASK; - if (rows == _rows && cols == _cols && type() == _type && data) - return; +/* core logic */ +void aclMat::createEx(int _rows, int _cols, int _type, ALIGNMENT config, + MemMallocPolicy policy) { + /* TO ENSURE */ + //_type &= CV_MAT_TYPE_MASK; + _type &= TYPE_MASK; + if (rows == _rows && cols == _cols && type() == _type && data) return; - if (data) - release(); - - CV_DbgAssert(_rows >= 0 && _cols >= 0); + if (data) release(); - if (_rows > 0 && _cols > 0) - { - /* TO ENSURE */ - //flags = (_type & CV_MAT_TYPE_MASK) | MAGIC_VAL; - flags = Mat::MAGIC_VAL + _type; - rows = _rows; - cols = _cols; - wholerows = _rows; - wholecols = _cols; - size_t esz = elemSize(); - void *dev_ptr; - if (config == ALIGNMENT::MEMORY_ALIGN) - { - if (channels() == 3) - step = alignSize(cols * esz, ALIGN * channels()); - else - step = alignSize(cols * esz); - } - else - step = cols * esz; - totalSize = step * rows; + CV_DbgAssert(_rows >= 0 && _cols >= 0); - AclSafeCall(aclrtMalloc(&dev_ptr, totalSize, type_transition(policy))); + if (_rows > 0 && _cols > 0) { + /* TO ENSURE */ + // flags = (_type & CV_MAT_TYPE_MASK) | MAGIC_VAL; + flags = Mat::MAGIC_VAL + _type; + rows = _rows; + cols = _cols; + wholerows = _rows; + wholecols = _cols; + size_t esz = elemSize(); + void *dev_ptr; + if (config == ALIGNMENT::MEMORY_ALIGN) { + if (channels() == 3) + step = alignSize(cols * esz, ALIGN * channels()); + else + step = alignSize(cols * esz); + } else + step = cols * esz; + totalSize = step * rows; - data = dev_ptr; - datastart = static_cast(data); - dataend = static_cast(data) + totalSize; - refcount = static_cast(fastMalloc(sizeof(*refcount))); - *refcount = 0; - CV_XADD(refcount, 1); - flags |= Mat::CONTINUOUS_FLAG; - } - } + AclSafeCall(aclrtMalloc(&dev_ptr, totalSize, type_transition(policy))); - void aclMat::createEx(Size size, int type, ALIGNMENT config, MemMallocPolicy policy) - { - createEx(size.height, size.width, type, config, policy); - } + data = dev_ptr; + datastart = static_cast(data); + dataend = static_cast(data) + totalSize; + refcount = static_cast(fastMalloc(sizeof(*refcount))); + *refcount = 0; + CV_XADD(refcount, 1); + flags |= Mat::CONTINUOUS_FLAG; + } +} - void aclMat::release() - { - CV_XADD(refcount, -1); - if (data && (*refcount == 0)) - { - aclrtFree(data); - } - data = nullptr; - datastart = nullptr; - dataend = nullptr; - } +void aclMat::createEx(Size size, int type, ALIGNMENT config, + MemMallocPolicy policy) { + createEx(size.height, size.width, type, config, policy); +} - aclMat &aclMat::operator+=(const aclMat &m) - { - CV_Assert(this->rows == m.rows && this->cols == m.cols && this->type() == m.type()); - TwoInAndOneOut(*this, m, *this, "Add"); - return *this; - } +void aclMat::release() { + CV_XADD(refcount, -1); + if (data && (*refcount == 0)) { + aclrtFree(data); + } + data = nullptr; + datastart = nullptr; + dataend = nullptr; +} - aclMat &aclMat::operator-=(const aclMat &m) - { - CV_Assert(this->rows == m.rows && this->cols == m.cols && this->type() == m.type()); - TwoInAndOneOut(*this, m, *this, "Sub"); - return *this; - } +aclMat &aclMat::operator+=(const aclMat &m) { + CV_Assert(this->rows == m.rows && this->cols == m.cols && + this->type() == m.type()); + TwoInAndOneOut(*this, m, *this, "Add"); + return *this; +} - aclMat &aclMat::operator/=(const aclMat &m) - { - CV_Assert(this->rows == m.rows && this->cols == m.cols && this->type() == m.type()); - TwoInAndOneOut(*this, m, *this, "Div"); - return *this; - } +aclMat &aclMat::operator-=(const aclMat &m) { + CV_Assert(this->rows == m.rows && this->cols == m.cols && + this->type() == m.type()); + TwoInAndOneOut(*this, m, *this, "Sub"); + return *this; +} - aclMat &aclMat::operator*=(const aclMat &m) - { - CV_Assert(this->cols == m.rows && this->type() == m.type()); - vector input_Mat; - vector output_Mat; - vector inputBuffers_; - vector outputBuffers_; - aclMat newMat{this->rows, m.cols, this->type(), this->acl_context}; +aclMat &aclMat::operator/=(const aclMat &m) { + CV_Assert(this->rows == m.rows && this->cols == m.cols && + this->type() == m.type()); + TwoInAndOneOut(*this, m, *this, "Div"); + return *this; +} - input_Mat.emplace_back(*this); - input_Mat.emplace_back(m); - output_Mat.emplace_back(newMat); +aclMat &aclMat::operator*=(const aclMat &m) { + CV_Assert(this->cols == m.rows && this->type() == m.type()); + vector input_Mat; + vector output_Mat; + vector inputBuffers_; + vector outputBuffers_; + aclMat newMat{this->rows, m.cols, this->type(), this->acl_context}; - OperatorDesc opDesc = CreateOpDesc("MatMul", input_Mat, output_Mat, ACL_FORMAT_NHWC, TWO_DIMS); - opDesc.AddInputTensorDesc(ACL_DT_UNDEFINED, 0, nullptr, ACL_FORMAT_UNDEFINED); - opDesc.AddTensorAttr("transpose_x1", OP_BOOL, false); - opDesc.AddTensorAttr("transpose_x2", OP_BOOL, false); + input_Mat.emplace_back(*this); + input_Mat.emplace_back(m); + output_Mat.emplace_back(newMat); - inputBuffers_.emplace_back(aclCreateDataBuffer(this->data, this->totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(m.data, m.totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(nullptr, 0)); - outputBuffers_.emplace_back(aclCreateDataBuffer(newMat.data, newMat.totalSize)); + OperatorDesc opDesc = + CreateOpDesc("MatMul", input_Mat, output_Mat, ACL_FORMAT_NHWC, TWO_DIMS); + opDesc.AddInputTensorDesc(ACL_DT_UNDEFINED, 0, nullptr, ACL_FORMAT_UNDEFINED); + opDesc.AddTensorAttr("transpose_x1", OP_BOOL, false); + opDesc.AddTensorAttr("transpose_x2", OP_BOOL, false); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, this->acl_context, 0); + inputBuffers_.emplace_back(aclCreateDataBuffer(this->data, this->totalSize)); + inputBuffers_.emplace_back(aclCreateDataBuffer(m.data, m.totalSize)); + inputBuffers_.emplace_back(aclCreateDataBuffer(nullptr, 0)); + outputBuffers_.emplace_back( + aclCreateDataBuffer(newMat.data, newMat.totalSize)); - *this = newMat; + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, this->acl_context, 0); - for (size_t i = 0; i < inputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); - for (size_t i = 0; i < outputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); + *this = newMat; - return *this; - } + for (size_t i = 0; i < inputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); + for (size_t i = 0; i < outputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); - } /* end of namespace acl */ + return *this; +} + +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/src/gemm.cpp b/acl/src/gemm.cpp index e779081..bd686f1 100644 --- a/acl/src/gemm.cpp +++ b/acl/src/gemm.cpp @@ -1,88 +1,103 @@ #include "precomp.hpp" -namespace cv -{ - namespace acl - { - /** - * @brief: matrix multiplication - * - */ - void MatMul(const aclMat& src1, const aclMat& src2, aclMat& dest, int stream_id) - { - CV_Assert(src1.cols == src2.rows && src1.type() == src2.type()); - vector input_Mat; - vector output_Mat; - vector inputBuffers_; - vector outputBuffers_; +using namespace std; +using namespace cv; +using namespace cv::acl; +namespace cv { +namespace acl { +/** + * @brief: matrix multiplication + * + */ +void MatMul(const aclMat& src1, const aclMat& src2, aclMat& dest, + int stream_id) { + CV_Assert(src1.cols == src2.rows && src1.type() == src2.type()); + vector input_Mat; + vector output_Mat; + vector inputBuffers_; + vector outputBuffers_; - input_Mat.emplace_back(src1); - input_Mat.emplace_back(src2); - output_Mat.emplace_back(dest); + input_Mat.emplace_back(src1); + input_Mat.emplace_back(src2); + output_Mat.emplace_back(dest); - inputBuffers_.emplace_back(aclCreateDataBuffer(src1.data, src1.totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(src2.data, src2.totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(nullptr, 0)); - outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); + inputBuffers_.emplace_back(aclCreateDataBuffer(src1.data, src1.totalSize)); + inputBuffers_.emplace_back(aclCreateDataBuffer(src2.data, src2.totalSize)); + inputBuffers_.emplace_back(aclCreateDataBuffer(nullptr, 0)); + outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); - OperatorDesc opDesc = CreateOpDesc("MatMul", input_Mat, output_Mat, ACL_FORMAT_NHWC, TWO_DIMS); - opDesc.AddInputTensorDesc(ACL_DT_UNDEFINED, 0, nullptr, ACL_FORMAT_UNDEFINED); - opDesc.AddTensorAttr("transpose_x1", OP_BOOL, false); - opDesc.AddTensorAttr("transpose_x2", OP_BOOL, false); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, stream_id); + OperatorDesc opDesc = + CreateOpDesc("MatMul", input_Mat, output_Mat, ACL_FORMAT_NHWC, TWO_DIMS); + opDesc.AddInputTensorDesc(ACL_DT_UNDEFINED, 0, nullptr, ACL_FORMAT_UNDEFINED); + opDesc.AddTensorAttr("transpose_x1", OP_BOOL, false); + opDesc.AddTensorAttr("transpose_x2", OP_BOOL, false); + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, + stream_id); - for (size_t i = 0; i < inputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); - for (size_t i = 0; i < outputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); - } + for (size_t i = 0; i < inputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); + for (size_t i = 0; i < outputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); +} - /** - * @brief convolution - * @param [in] src: characteristic matrix - * @param [in] kernel: convolution kernel - * @param [in] dest: destination matrix - * @param [in] stridesList: strides, The N and C dimensions must be set to 1 - * @param [in] padSList: pads, vector(top, bottom, left, right) - */ - void Convolution(const aclMat& src, const aclMat& kernel, aclMat& dest, const vector& stridesList, const vector& padsList, int stream_id) - { - vector inputBuffers_; - vector outputBuffers_; - vector dilationsList{1, 1, 1, 1}; - string opType = "Conv2D"; - int dest_rows = (src.rows + padsList[0] + padsList[1] - (1 * (kernel.rows - 1) + 1)) / stridesList[2] + 1; - int dest_cols = (src.cols + padsList[2] + padsList[3] - (1 * (kernel.cols - 1) + 1)) / stridesList[3] + 1; - aclMat acl_dest{dest_rows, dest_cols, src.type(), src.acl_context}; +/** + * @brief convolution + * @param [in] src: characteristic matrix + * @param [in] kernel: convolution kernel + * @param [in] dest: destination matrix + * @param [in] stridesList: strides, The N and C dimensions must be set to 1 + * @param [in] padSList: pads, vector(top, bottom, left, right) + */ +void Convolution(const aclMat& src, const aclMat& kernel, aclMat& dest, + const vector& stridesList, + const vector& padsList, int stream_id) { + vector inputBuffers_; + vector outputBuffers_; + vector dilationsList{1, 1, 1, 1}; + string opType = "Conv2D"; + int dest_rows = + (src.rows + padsList[0] + padsList[1] - (1 * (kernel.rows - 1) + 1)) / + stridesList[2] + + 1; + int dest_cols = + (src.cols + padsList[2] + padsList[3] - (1 * (kernel.cols - 1) + 1)) / + stridesList[3] + + 1; + aclMat acl_dest{dest_rows, dest_cols, src.type(), src.acl_context}; - vector shape{1, 1, src.rows, src.cols}; - vector shape1{1, 1, kernel.rows, kernel.cols}; - vector shape2{1, 1, acl_dest.rows, acl_dest.cols}; + vector shape{1, 1, src.rows, src.cols}; + vector shape1{1, 1, kernel.rows, kernel.cols}; + vector shape2{1, 1, acl_dest.rows, acl_dest.cols}; - aclDataType dataType = type_transition(src.depth()); - aclFormat format = ACL_FORMAT_NCHW; - OperatorDesc opDesc(opType); - opDesc.AddInputTensorDesc(dataType, shape.size(), shape.data(), format); - opDesc.AddInputTensorDesc(dataType, shape1.size(), shape1.data(), format); - opDesc.AddOutputTensorDesc(dataType, shape2.size(), shape2.data(), format); + aclDataType dataType = type_transition(src.depth()); + aclFormat format = ACL_FORMAT_NCHW; + OperatorDesc opDesc(opType); + opDesc.AddInputTensorDesc(dataType, shape.size(), shape.data(), format); + opDesc.AddInputTensorDesc(dataType, shape1.size(), shape1.data(), format); + opDesc.AddOutputTensorDesc(dataType, shape2.size(), shape2.data(), format); - auto opAttr = opDesc.opAttr; - aclopSetAttrListInt(opAttr, "strides", stridesList.size(), stridesList.data()); - aclopSetAttrListInt(opAttr, "pads", padsList.size(), padsList.data()); - aclopSetAttrListInt(opAttr, "dilations", dilationsList.size(), dilationsList.data()); + auto opAttr = opDesc.opAttr; + aclopSetAttrListInt(opAttr, "strides", stridesList.size(), + stridesList.data()); + aclopSetAttrListInt(opAttr, "pads", padsList.size(), padsList.data()); + aclopSetAttrListInt(opAttr, "dilations", dilationsList.size(), + dilationsList.data()); - inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(kernel.data, kernel.totalSize)); - outputBuffers_.emplace_back(aclCreateDataBuffer(acl_dest.data, acl_dest.totalSize)); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, src.acl_context, stream_id); - acl_dest.data = aclGetDataBufferAddr(outputBuffers_[0]); - dest = acl_dest; + inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); + inputBuffers_.emplace_back( + aclCreateDataBuffer(kernel.data, kernel.totalSize)); + outputBuffers_.emplace_back( + aclCreateDataBuffer(acl_dest.data, acl_dest.totalSize)); + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, src.acl_context, + stream_id); + acl_dest.data = aclGetDataBufferAddr(outputBuffers_[0]); + dest = acl_dest; - for (size_t i = 0; i < inputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); - for (size_t i = 0; i < outputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); - } - } /* end of namespace acl */ + for (size_t i = 0; i < inputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); + for (size_t i = 0; i < outputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); +} +} /* end of namespace acl */ } /* end of namespace cv */ \ No newline at end of file diff --git a/acl/src/mathfuncs.cpp b/acl/src/mathfuncs.cpp index e328fd5..d363f8a 100644 --- a/acl/src/mathfuncs.cpp +++ b/acl/src/mathfuncs.cpp @@ -1,224 +1,224 @@ #include "precomp.hpp" -namespace cv -{ - namespace acl - { - aclMat abs(const aclMat& a, int stream_id) - { - aclMat dest(a.rows, a.cols, a.type(), a.acl_context); - OneInAndOneOut(a, dest, "Abs", stream_id); - return dest; - } +using namespace std; +using namespace cv; +using namespace cv::acl; +namespace cv { +namespace acl { +aclMat abs(const aclMat &a, int stream_id) { + aclMat dest(a.rows, a.cols, a.type(), a.acl_context); + OneInAndOneOut(a, dest, "Abs", stream_id); + return dest; +} - static void *power_data(double power, aclDataType type, size_t powersize) - { - void *dev_ptr; +static void *power_data(double power, aclDataType type, size_t powersize) { + void *dev_ptr; - switch(type) - { - case ACL_UINT8: - { - aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); - uchar power_8u = uchar(power); - aclrtMemcpy(dev_ptr, powersize, static_cast(&power_8u), powersize, ACL_MEMCPY_HOST_TO_DEVICE); - return dev_ptr; - } - case ACL_INT8: - { - aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); - char power_8s = char(power); - aclrtMemcpy(dev_ptr, powersize, static_cast(&power_8s), powersize, ACL_MEMCPY_HOST_TO_DEVICE); - return dev_ptr; - } - case ACL_FLOAT16: - { - aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); - float16_t power_16f = float16_t(power); - aclrtMemcpy(dev_ptr, powersize, static_cast(&power_16f), powersize, ACL_MEMCPY_HOST_TO_DEVICE); - return dev_ptr; - } - case ACL_INT32: - { - aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); - int power_32s = int(power); - aclrtMemcpy(dev_ptr, powersize, static_cast(&power_32s), powersize, ACL_MEMCPY_HOST_TO_DEVICE); - return dev_ptr; - } - case ACL_FLOAT: - { - aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); - float power_32f = float(power); - aclrtMemcpy(dev_ptr, powersize, static_cast(&power_32f), powersize, ACL_MEMCPY_HOST_TO_DEVICE); - return dev_ptr; - } - case ACL_DOUBLE: - { - aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); - double power_64f = double(power); - aclrtMemcpy(dev_ptr, powersize, static_cast(&power_64f), powersize, ACL_MEMCPY_HOST_TO_DEVICE); - return dev_ptr; - } - default: - return nullptr; - } - - } + switch (type) { + case ACL_UINT8: { + aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); + uchar power_8u = uchar(power); + aclrtMemcpy(dev_ptr, powersize, static_cast(&power_8u), powersize, + ACL_MEMCPY_HOST_TO_DEVICE); + return dev_ptr; + } + case ACL_INT8: { + aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); + char power_8s = char(power); + aclrtMemcpy(dev_ptr, powersize, static_cast(&power_8s), powersize, + ACL_MEMCPY_HOST_TO_DEVICE); + return dev_ptr; + } + case ACL_FLOAT16: { + aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); + float16_t power_16f = float16_t(power); + aclrtMemcpy(dev_ptr, powersize, static_cast(&power_16f), + powersize, ACL_MEMCPY_HOST_TO_DEVICE); + return dev_ptr; + } + case ACL_INT32: { + aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); + int power_32s = int(power); + aclrtMemcpy(dev_ptr, powersize, static_cast(&power_32s), + powersize, ACL_MEMCPY_HOST_TO_DEVICE); + return dev_ptr; + } + case ACL_FLOAT: { + aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); + float power_32f = float(power); + aclrtMemcpy(dev_ptr, powersize, static_cast(&power_32f), + powersize, ACL_MEMCPY_HOST_TO_DEVICE); + return dev_ptr; + } + case ACL_DOUBLE: { + aclrtMalloc(&dev_ptr, powersize, ACL_MEM_MALLOC_NORMAL_ONLY); + double power_64f = double(power); + aclrtMemcpy(dev_ptr, powersize, static_cast(&power_64f), + powersize, ACL_MEMCPY_HOST_TO_DEVICE); + return dev_ptr; + } + default: + return nullptr; + } +} - void pow(const aclMat& src, double power, aclMat& dest, int stream_id) - { - vector input_Mat; - vector output_Mat; - vector inputBuffers_; - vector outputBuffers_; +void pow(const aclMat &src, double power, aclMat &dest, int stream_id) { + vector input_Mat; + vector output_Mat; + vector inputBuffers_; + vector outputBuffers_; - aclDataType dataType = type_transition(src.depth()); - - input_Mat.emplace_back(src); - output_Mat.emplace_back(dest); + aclDataType dataType = type_transition(src.depth()); - OperatorDesc opDesc = CreateOpDesc("Pow", input_Mat, output_Mat); - vector shape2{1}; - opDesc.AddInputTensorDesc(dataType, shape2.size(), shape2.data(), ACL_FORMAT_NHWC); + input_Mat.emplace_back(src); + output_Mat.emplace_back(dest); - size_t size = aclGetTensorDescSize(opDesc.inputDesc[1]); - void *power_dev = power_data(power, dataType, size); + OperatorDesc opDesc = CreateOpDesc("Pow", input_Mat, output_Mat); + vector shape2{1}; + opDesc.AddInputTensorDesc(dataType, shape2.size(), shape2.data(), + ACL_FORMAT_NHWC); - inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(power_dev, size)); + size_t size = aclGetTensorDescSize(opDesc.inputDesc[1]); + void *power_dev = power_data(power, dataType, size); - outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); + inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); + inputBuffers_.emplace_back(aclCreateDataBuffer(power_dev, size)); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, stream_id); + outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); - aclrtFree(power_dev); - for (size_t i = 0; i < inputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); - for (size_t i = 0; i < outputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); - } + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, + stream_id); - void add(const aclMat& src, const aclMat& other_src, aclMat& dest, int stream_id) - { - bool is_correct; - - is_correct = (src.rows == other_src.rows); - is_correct &= (src.rows == dest.rows); - is_correct &= (src.cols == other_src.cols); - is_correct &= (src.cols == dest.cols); - is_correct &= (src.type() == other_src.type()); - is_correct &= (src.type() == dest.type()); - CV_Assert(is_correct); + aclrtFree(power_dev); + for (size_t i = 0; i < inputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); + for (size_t i = 0; i < outputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); +} - TwoInAndOneOut(src, other_src, dest, "Add", stream_id); - } - - void divide(const aclMat& src, const aclMat& other_src, aclMat& dest, int stream_id) - { - bool is_correct; +void add(const aclMat &src, const aclMat &other_src, aclMat &dest, + int stream_id) { + bool is_correct; - is_correct = (src.rows == other_src.rows); - is_correct &= (src.rows == dest.rows); - is_correct &= (src.cols == other_src.cols); - is_correct &= (src.cols == dest.cols); - is_correct &= (src.type() == other_src.type()); - is_correct &= (src.type() == dest.type()); - CV_Assert(is_correct); + is_correct = (src.rows == other_src.rows); + is_correct &= (src.rows == dest.rows); + is_correct &= (src.cols == other_src.cols); + is_correct &= (src.cols == dest.cols); + is_correct &= (src.type() == other_src.type()); + is_correct &= (src.type() == dest.type()); + CV_Assert(is_correct); - TwoInAndOneOut(src, other_src, dest, "Div", stream_id); - } + TwoInAndOneOut(src, other_src, dest, "Add", stream_id); +} - void exp(const aclMat& src, aclMat& dest, int stream_id) - { - CV_Assert(src.rows == dest.rows && src.cols == dest.cols && src.type() == dest.type()); +void divide(const aclMat &src, const aclMat &other_src, aclMat &dest, + int stream_id) { + bool is_correct; - vector input_Mat; - vector output_Mat; + is_correct = (src.rows == other_src.rows); + is_correct &= (src.rows == dest.rows); + is_correct &= (src.cols == other_src.cols); + is_correct &= (src.cols == dest.cols); + is_correct &= (src.type() == other_src.type()); + is_correct &= (src.type() == dest.type()); + CV_Assert(is_correct); - vector inputBuffers_; - vector outputBuffers_; + TwoInAndOneOut(src, other_src, dest, "Div", stream_id); +} - input_Mat.emplace_back(src); - output_Mat.emplace_back(dest); +void exp(const aclMat &src, aclMat &dest, int stream_id) { + CV_Assert(src.rows == dest.rows && src.cols == dest.cols && + src.type() == dest.type()); - inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); - outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); + vector input_Mat; + vector output_Mat; - OperatorDesc opDesc = CreateOpDesc("Exp", input_Mat, output_Mat); - opDesc.AddTensorAttr("base", OP_FLOAT, -1.0); - opDesc.AddTensorAttr("scale", OP_FLOAT, 1.0); - opDesc.AddTensorAttr("shift", OP_FLOAT, 0.0); - - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, stream_id); + vector inputBuffers_; + vector outputBuffers_; - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[0])); - } + input_Mat.emplace_back(src); + output_Mat.emplace_back(dest); - void log(const aclMat &src, aclMat &dest, int stream_id) - { - CV_Assert(src.rows == dest.rows && src.cols == dest.cols && src.type() == dest.type()); + inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); + outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); - vector input_Mat; - vector output_Mat; + OperatorDesc opDesc = CreateOpDesc("Exp", input_Mat, output_Mat); + opDesc.AddTensorAttr("base", OP_FLOAT, -1.0); + opDesc.AddTensorAttr("scale", OP_FLOAT, 1.0); + opDesc.AddTensorAttr("shift", OP_FLOAT, 0.0); - vector inputBuffers_; - vector outputBuffers_; + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, + stream_id); - input_Mat.emplace_back(src); - output_Mat.emplace_back(dest); + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[0])); +} - inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); - outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); +void log(const aclMat &src, aclMat &dest, int stream_id) { + CV_Assert(src.rows == dest.rows && src.cols == dest.cols && + src.type() == dest.type()); - OperatorDesc opDesc = CreateOpDesc("Log", input_Mat, output_Mat); - opDesc.AddTensorAttr("base", OP_FLOAT, -1.0); - opDesc.AddTensorAttr("scale", OP_FLOAT, 1.0); - opDesc.AddTensorAttr("shift", OP_FLOAT, 0.0); - - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, stream_id); + vector input_Mat; + vector output_Mat; - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[0])); - } + vector inputBuffers_; + vector outputBuffers_; - void max(const aclMat &src, const aclMat &other_src, aclMat &dest, int stream_id) - { - bool is_correct; + input_Mat.emplace_back(src); + output_Mat.emplace_back(dest); - is_correct = (src.rows == other_src.rows); - is_correct &= (src.rows == dest.rows); - is_correct &= (src.cols == other_src.cols); - is_correct &= (src.cols == dest.cols); - is_correct &= (src.type() == other_src.type()); - is_correct &= (src.type() == dest.type()); - CV_Assert(is_correct); + inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); + outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); - TwoInAndOneOut(src, other_src, dest, "Maximum", stream_id); - } + OperatorDesc opDesc = CreateOpDesc("Log", input_Mat, output_Mat); + opDesc.AddTensorAttr("base", OP_FLOAT, -1.0); + opDesc.AddTensorAttr("scale", OP_FLOAT, 1.0); + opDesc.AddTensorAttr("shift", OP_FLOAT, 0.0); - void min(const aclMat &src, const aclMat &other_src, aclMat &dest, int stream_id) - { - bool is_correct; + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, + stream_id); - is_correct = (src.rows == other_src.rows); - is_correct &= (src.rows == dest.rows); - is_correct &= (src.cols == other_src.cols); - is_correct &= (src.cols == dest.cols); - is_correct &= (src.type() == other_src.type()); - is_correct &= (src.type() == dest.type()); - CV_Assert(is_correct); + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[0])); +} - TwoInAndOneOut(src, other_src, dest, "Minimum", stream_id); - } +void max(const aclMat &src, const aclMat &other_src, aclMat &dest, + int stream_id) { + bool is_correct; - void sqrt(const aclMat &src, aclMat &dest, int stream_id) - { - CV_Assert(src.rows == dest.rows && src.cols == dest.cols && src.type() == dest.type()); + is_correct = (src.rows == other_src.rows); + is_correct &= (src.rows == dest.rows); + is_correct &= (src.cols == other_src.cols); + is_correct &= (src.cols == dest.cols); + is_correct &= (src.type() == other_src.type()); + is_correct &= (src.type() == dest.type()); + CV_Assert(is_correct); - OneInAndOneOut(src, dest, "Sqrt", stream_id); - } + TwoInAndOneOut(src, other_src, dest, "Maximum", stream_id); +} - } /* end of namespace acl */ +void min(const aclMat &src, const aclMat &other_src, aclMat &dest, + int stream_id) { + bool is_correct; + + is_correct = (src.rows == other_src.rows); + is_correct &= (src.rows == dest.rows); + is_correct &= (src.cols == other_src.cols); + is_correct &= (src.cols == dest.cols); + is_correct &= (src.type() == other_src.type()); + is_correct &= (src.type() == dest.type()); + CV_Assert(is_correct); + + TwoInAndOneOut(src, other_src, dest, "Minimum", stream_id); +} + +void sqrt(const aclMat &src, aclMat &dest, int stream_id) { + CV_Assert(src.rows == dest.rows && src.cols == dest.cols && + src.type() == dest.type()); + + OneInAndOneOut(src, dest, "Sqrt", stream_id); +} + +} /* end of namespace acl */ } /* end of namespace cv */ \ No newline at end of file diff --git a/acl/src/matrices.cpp b/acl/src/matrices.cpp index 80fec64..615cc32 100644 --- a/acl/src/matrices.cpp +++ b/acl/src/matrices.cpp @@ -1,60 +1,11 @@ #include "precomp.hpp" -namespace cv -{ - namespace acl - { -/* - //disable - void lookUpTable(const aclMat& src, const aclMat& lut, aclMat& dest) - { - bool is_correct; - is_correct = ((src.depth() == CV_8U) || (src.depth() == CV_8S)); - is_correct &= ((lut.depth() == CV_8U) || (lut.depth() == CV_8S)); - is_correct &= (lut.totalSize == 256); - CV_Assert(is_correct); - - vector input_Mat; - vector output_Mat; - vector inputBuffers_; - vector outputBuffers_; - - uchar keyValue[256]; - for (int i = 0; i < 256; ++i) - keyValue[i] = i; - aclMat key(1, 256, src.type(), keyValue, src.acl_context); - - input_Mat.emplace_back(src); - input_Mat.emplace_back(key); - input_Mat.emplace_back(lut); - - inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(key.data, key.totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(lut.data, lut.totalSize)); - - aclDataType dataType = type_transition(input_Mat[0].depth()); - aclFormat format = ACL_FORMAT_NHWC; - - OperatorDesc opDesc("LookupTableImport"); - vector shape1{src.rows, src.cols * src.channels()}; - vector shape2{lut.rows, lut.cols * lut.channels()}; - vector shape3{dest.rows, dest.cols * dest.channels()}; - opDesc.AddInputTensorDesc(dataType, shape1.size(), shape1.data(), format); - opDesc.AddInputTensorDesc(dataType, shape2.size(), shape2.data(), format); - opDesc.AddInputTensorDesc(dataType, shape3.size(), shape3.data(), format); - - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context); - - dest.data = aclGetDataBufferAddr(inputBuffers_[0]); - - for (size_t i = 0; i < inputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); - for (size_t i = 0; i < outputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); - } -*/ - -/* +using namespace std; +using namespace cv; +using namespace cv::acl; +namespace cv { +namespace acl { +#if 0 void merge(const vector& mv, aclMat& dest) { vector inputBuffers_; @@ -66,191 +17,190 @@ namespace cv for (size_t i = 0; i < mv.size(); ++i) { int cols = mv[i].step/mv[i].elemSize(); - vector inputShape{1, mv[i].rows, cols, mv[i].channels()}; - opDesc.AddInputTensorDesc(dataType, inputShape.size(), inputShape.data(), ACL_FORMAT_ND); + vector inputShape{1, mv[i].rows, cols, + mv[i].channels()}; opDesc.AddInputTensorDesc(dataType, inputShape.size(), + inputShape.data(), ACL_FORMAT_ND); } int cols = dest.step/dest.elemSize(); vector outputShape{1, dest.rows, cols, dest.channels()}; - opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), ACL_FORMAT_ND); + opDesc.AddOutputTensorDesc(dataType, outputShape.size(), + outputShape.data(), ACL_FORMAT_ND); for (size_t i = 0; i < opDesc.inputDesc.size(); ++i) { - inputBuffers_.emplace_back(aclCreateDataBuffer(mv[i].data, mv[i].totalSize)); + inputBuffers_.emplace_back(aclCreateDataBuffer(mv[i].data, + mv[i].totalSize)); } - outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); + outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, + dest.totalSize)); aclopSetAttrInt(opDesc.opAttr, "N", mv.size()); aclopSetAttrInt(opDesc.opAttr, "concat_dim", 3); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context); + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, + dest.acl_context); for (size_t i = 0; i < inputBuffers_.size(); i++) AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); for (size_t i = 0; i < outputBuffers_.size(); i++) AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); } -*/ - static int merge_type(int depth, int channels) - { - switch (depth) - { - case CV_8U: - return CV_8UC(channels); - case CV_8S: - return CV_8SC(channels); - case CV_32F: - return CV_32FC(channels); - case CV_32S: - return CV_32SC(channels); - case CV_64F: - return CV_64FC(channels); - } - return -1; - } +#endif - void merge(const vector& mv, aclMat& dest, int stream_id) - { - vector inputBuffers_; - vector outputBuffers_; +static int merge_type(int depth, int channels) { + switch (depth) { + case CV_8U: + return CV_8UC(channels); + case CV_8S: + return CV_8SC(channels); + case CV_32F: + return CV_32FC(channels); + case CV_32S: + return CV_32SC(channels); + case CV_64F: + return CV_64FC(channels); + } + return -1; +} - OperatorDesc opDesc("Concat"); - aclDataType dataType = type_transition(mv[0].depth()); +void merge(const vector &mv, aclMat &dest, int stream_id) { + vector inputBuffers_; + vector outputBuffers_; - vector inputShape{}; - opDesc.AddInputTensorDesc(ACL_INT32, inputShape.size(), inputShape.data(), ACL_FORMAT_ND); + OperatorDesc opDesc("Concat"); + aclDataType dataType = type_transition(mv[0].depth()); - for (size_t i = 0; i < mv.size(); ++i) - { - int cols = mv[i].step/mv[i].elemSize(); - vector inputShape{1, mv[i].rows, cols, mv[i].channels()}; - opDesc.AddInputTensorDesc(dataType, inputShape.size(), inputShape.data(), ACL_FORMAT_NHWC); - } + vector inputShape{}; + opDesc.AddInputTensorDesc(ACL_INT32, inputShape.size(), inputShape.data(), + ACL_FORMAT_ND); - int cols = mv[0].step/mv[0].elemSize(); - int channels = mv.size(); - vector outputShape{1, mv[0].rows, cols, channels}; - opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), ACL_FORMAT_NHWC); + for (size_t i = 0; i < mv.size(); ++i) { + int cols = mv[i].step / mv[i].elemSize(); + vector inputShape{1, mv[i].rows, cols, mv[i].channels()}; + opDesc.AddInputTensorDesc(dataType, inputShape.size(), inputShape.data(), + ACL_FORMAT_NHWC); + } - ino64_t N = mv.size(); - aclopSetAttrInt(opDesc.opAttr, "N", N); + int cols = mv[0].step / mv[0].elemSize(); + int channels = mv.size(); + vector outputShape{1, mv[0].rows, cols, channels}; + opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), + ACL_FORMAT_NHWC); - aclSetTensorDescName(opDesc.inputDesc[0], "concat_dim"); - - aclSetTensorDescName(opDesc.inputDesc[1], "x0"); - aclSetTensorDescName(opDesc.inputDesc[2], "x1"); - if (mv.size() == 3) - aclSetTensorDescName(opDesc.inputDesc[3], "x2"); - else if(mv.size() == 4) - aclSetTensorDescName(opDesc.inputDesc[4], "x3"); - aclSetTensorDescName(opDesc.outputDesc[0], "y"); + ino64_t N = mv.size(); + aclopSetAttrInt(opDesc.opAttr, "N", N); - void *dev; - int64_t concat_dim = 3; - size_t size = aclGetTensorDescSize(opDesc.inputDesc[0]); - aclrtMalloc(&dev, size, ACL_MEM_MALLOC_NORMAL_ONLY); - aclrtMemcpy(dev, size, &concat_dim, size, ACL_MEMCPY_HOST_TO_DEVICE); - inputBuffers_.emplace_back(aclCreateDataBuffer(dev, size)); + aclSetTensorDescName(opDesc.inputDesc[0], "concat_dim"); - for (size_t i = 0; i < mv.size(); ++i) - inputBuffers_.emplace_back(aclCreateDataBuffer(mv[i].data, mv[i].totalSize)); + aclSetTensorDescName(opDesc.inputDesc[1], "x0"); + aclSetTensorDescName(opDesc.inputDesc[2], "x1"); + if (mv.size() == 3) + aclSetTensorDescName(opDesc.inputDesc[3], "x2"); + else if (mv.size() == 4) + aclSetTensorDescName(opDesc.inputDesc[4], "x3"); + aclSetTensorDescName(opDesc.outputDesc[0], "y"); - int type = merge_type(mv[0].depth(), channels); - aclMat temp(mv[0].rows, mv[0].cols, type, mv[0].acl_context); - dest = temp; - outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); + void *dev; + int64_t concat_dim = 3; + size_t size = aclGetTensorDescSize(opDesc.inputDesc[0]); + aclrtMalloc(&dev, size, ACL_MEM_MALLOC_NORMAL_ONLY); + aclrtMemcpy(dev, size, &concat_dim, size, ACL_MEMCPY_HOST_TO_DEVICE); + inputBuffers_.emplace_back(aclCreateDataBuffer(dev, size)); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, stream_id); + for (size_t i = 0; i < mv.size(); ++i) + inputBuffers_.emplace_back( + aclCreateDataBuffer(mv[i].data, mv[i].totalSize)); - for (size_t i = 0; i < inputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); - for (size_t i = 0; i < outputBuffers_.size(); i++) - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); + int type = merge_type(mv[0].depth(), channels); + aclMat temp(mv[0].rows, mv[0].cols, type, mv[0].acl_context); + dest = temp; + outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); - aclrtFree(dev); - } - - + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, + stream_id); + + for (size_t i = 0; i < inputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); + for (size_t i = 0; i < outputBuffers_.size(); i++) + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); + + aclrtFree(dev); +} /** * @brief : Dynamic shape reasoning - * + * */ +void transpose(const aclMat &src, aclMat &dest, int stream_id) { + vector inputBuffers_; + vector outputBuffers_; + vector inputBuffers_host; - void transpose(const aclMat& src, aclMat& dest, int stream_id) - { - vector inputBuffers_; - vector outputBuffers_; - vector inputBuffers_host; + OperatorDesc opDesc("Transpose"); + aclDataType dataType = type_transition(src.depth()); - OperatorDesc opDesc("Transpose"); - aclDataType dataType = type_transition(src.depth()); + vector inputShape1{1, src.rows, src.cols, src.channels()}; + opDesc.AddInputTensorDesc(dataType, inputShape1.size(), inputShape1.data(), + ACL_FORMAT_ND); - vector inputShape1{1, src.rows, src.cols, src.channels()}; - opDesc.AddInputTensorDesc(dataType, inputShape1.size(), inputShape1.data(), ACL_FORMAT_ND); + vector inputShape2{4}; + opDesc.AddInputTensorDesc(ACL_INT32, inputShape2.size(), inputShape2.data(), + ACL_FORMAT_ND); - vector inputShape2{4}; - opDesc.AddInputTensorDesc(ACL_INT32, inputShape2.size(), inputShape2.data(), ACL_FORMAT_ND); + vector outputShape{-1, -1, -1, -1}; + opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), + ACL_FORMAT_ND); - vector outputShape{-1, -1, -1, -1}; - opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), ACL_FORMAT_ND); + inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); - inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); + void *dev; + void *perm; - void *dev; - void *perm; + size_t size = aclGetTensorDescSize(opDesc.inputDesc[1]); + aclrtMalloc(&dev, size, ACL_MEM_MALLOC_NORMAL_ONLY); + aclrtMallocHost(&perm, aclGetTensorDescSize(opDesc.inputDesc.data()[1])); + ((int *)perm)[0] = 0; + ((int *)perm)[1] = 2; + ((int *)perm)[2] = 1; + ((int *)perm)[3] = 3; + aclrtMemcpy(dev, size, perm, size, ACL_MEMCPY_HOST_TO_DEVICE); + inputBuffers_.emplace_back(aclCreateDataBuffer(dev, size)); - size_t size = aclGetTensorDescSize(opDesc.inputDesc[1]); - aclrtMalloc(&dev, size, ACL_MEM_MALLOC_NORMAL_ONLY); - aclrtMallocHost(&perm, aclGetTensorDescSize(opDesc.inputDesc.data()[1])); - ((int *)perm)[0] = 0; - ((int *)perm)[1] = 2; - ((int *)perm)[2] = 1; - ((int *)perm)[3] = 3; - aclrtMemcpy(dev, size, perm, size, ACL_MEMCPY_HOST_TO_DEVICE); - inputBuffers_.emplace_back(aclCreateDataBuffer(dev, size)); + AclSafeCall(aclopCompile(opDesc.opType.c_str(), opDesc.inputDesc.size(), + opDesc.inputDesc.data(), opDesc.outputDesc.size(), + opDesc.outputDesc.data(), opDesc.opAttr, + ACL_ENGINE_SYS, ACL_COMPILE_SYS, nullptr)); - AclSafeCall(aclopCompile(opDesc.opType.c_str(), - opDesc.inputDesc.size(), - opDesc.inputDesc.data(), - opDesc.outputDesc.size(), - opDesc.outputDesc.data(), - opDesc.opAttr, - ACL_ENGINE_SYS, - ACL_COMPILE_SYS, - nullptr)); + void *host_data; + size_t host_size = src.totalSize; + aclrtMallocHost(&host_data, host_size); + aclrtMemcpy(host_data, host_size, src.data, host_size, + ACL_MEMCPY_DEVICE_TO_HOST); + inputBuffers_host.emplace_back(aclCreateDataBuffer(host_data, host_size)); + inputBuffers_host.emplace_back(aclCreateDataBuffer(perm, size)); - void *host_data; - size_t host_size = src.totalSize; - aclrtMallocHost(&host_data, host_size); - aclrtMemcpy(host_data, host_size, src.data, host_size, ACL_MEMCPY_DEVICE_TO_HOST); - inputBuffers_host.emplace_back(aclCreateDataBuffer(host_data, host_size)); - inputBuffers_host.emplace_back(aclCreateDataBuffer(perm, size)); + AclSafeCall(aclopInferShape("Transpose", opDesc.inputDesc.size(), + opDesc.inputDesc.data(), inputBuffers_host.data(), + opDesc.outputDesc.size(), + opDesc.outputDesc.data(), opDesc.opAttr)); + outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); - AclSafeCall(aclopInferShape("Transpose", opDesc.inputDesc.size(), opDesc.inputDesc.data(), \ - inputBuffers_host.data(), opDesc.outputDesc.size(), opDesc.outputDesc.data(), opDesc.opAttr)); - outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); - - AclSafeCall(aclopExecuteV2(opDesc.opType.c_str(), - inputBuffers_.size(), - opDesc.inputDesc.data(), - inputBuffers_.data(), - outputBuffers_.size(), - opDesc.outputDesc.data(), - outputBuffers_.data(), - opDesc.opAttr, - dest.acl_context->get_stream(stream_id))); - - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[1])); - AclSafeCall(aclDestroyDataBuffer(inputBuffers_host[0])); - AclSafeCall(aclDestroyDataBuffer(inputBuffers_host[1])); - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[0])); - AclSafeCall(aclrtFree(dev)); - AclSafeCall(aclrtFreeHost(perm)); - AclSafeCall(aclrtFreeHost(host_data)); - } + AclSafeCall(aclopExecuteV2(opDesc.opType.c_str(), inputBuffers_.size(), + opDesc.inputDesc.data(), inputBuffers_.data(), + outputBuffers_.size(), opDesc.outputDesc.data(), + outputBuffers_.data(), opDesc.opAttr, + dest.acl_context->get_stream(stream_id))); + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[1])); + AclSafeCall(aclDestroyDataBuffer(inputBuffers_host[0])); + AclSafeCall(aclDestroyDataBuffer(inputBuffers_host[1])); + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[0])); + AclSafeCall(aclrtFree(dev)); + AclSafeCall(aclrtFreeHost(perm)); + AclSafeCall(aclrtFreeHost(host_data)); +} /* transposeD */ #if 0 @@ -281,65 +231,63 @@ namespace cv } #endif - static int split_type(int depth) - { - switch (depth) - { - case CV_8U: - return CV_8UC1; - case CV_8S: - return CV_8SC1; - case CV_32F: - return CV_32FC1; - case CV_32S: - return CV_32SC1; - case CV_64F: - return CV_64FC1; - } - return -1; - } +static int split_type(int depth) { + switch (depth) { + case CV_8U: + return CV_8UC1; + case CV_8S: + return CV_8SC1; + case CV_32F: + return CV_32FC1; + case CV_32S: + return CV_32SC1; + case CV_64F: + return CV_64FC1; + } + return -1; +} - void split(const aclMat& src, vector& mv, int stream_id) - { - vector inputBuffers_; - vector outputBuffers_; - int split_dim = 3; - int num_split = src.channels(); +void split(const aclMat &src, vector &mv, int stream_id) { + vector inputBuffers_; + vector outputBuffers_; + int split_dim = 3; + int num_split = src.channels(); - OperatorDesc opDesc("SplitD"); - aclDataType dataType = type_transition(src.depth()); + OperatorDesc opDesc("SplitD"); + aclDataType dataType = type_transition(src.depth()); - int cols = src.step/src.elemSize(); - vector inputShape1{1, src.rows, cols, src.channels()}; - opDesc.AddInputTensorDesc(dataType, inputShape1.size(), inputShape1.data(), ACL_FORMAT_ND); + int cols = src.step / src.elemSize(); + vector inputShape1{1, src.rows, cols, src.channels()}; + opDesc.AddInputTensorDesc(dataType, inputShape1.size(), inputShape1.data(), + ACL_FORMAT_ND); - for (int i = 0; i < num_split; ++i) - { - vector outputShape{1, src.rows, cols, 1}; - opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), ACL_FORMAT_ND); - } - - auto opAttr = opDesc.opAttr; - aclopSetAttrInt(opAttr, "split_dim", split_dim); - aclopSetAttrInt(opAttr, "num_split", num_split); + for (int i = 0; i < num_split; ++i) { + vector outputShape{1, src.rows, cols, 1}; + opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), + ACL_FORMAT_ND); + } - inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); + auto opAttr = opDesc.opAttr; + aclopSetAttrInt(opAttr, "split_dim", split_dim); + aclopSetAttrInt(opAttr, "num_split", num_split); - int type = split_type(src.depth()); - for (int i = 0; i < num_split; ++i) - { - aclMat tmp(src.rows, src.cols, type, src.acl_context); - mv[i] = tmp; - outputBuffers_.emplace_back(aclCreateDataBuffer(mv[i].data, mv[i].totalSize)); - } + inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, src.acl_context, stream_id); + int type = split_type(src.depth()); + for (int i = 0; i < num_split; ++i) { + aclMat tmp(src.rows, src.cols, type, src.acl_context); + mv[i] = tmp; + outputBuffers_.emplace_back( + aclCreateDataBuffer(mv[i].data, mv[i].totalSize)); + } - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); - for (int i = 0; i < num_split; ++i) - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); - } + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, src.acl_context, + stream_id); + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); + for (int i = 0; i < num_split; ++i) + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); +} #if 0 //disable @@ -429,56 +377,57 @@ namespace cv } #endif - static void flip_(const aclMat& src, aclMat& dest, int axis, int stream_id) - { - vector inputBuffers_; - vector outputBuffers_; +static void flip_(const aclMat &src, aclMat &dest, int axis, int stream_id) { + vector inputBuffers_; + vector outputBuffers_; - OperatorDesc opDesc("ReverseV2"); - aclDataType dataType = type_transition(src.depth()); + OperatorDesc opDesc("ReverseV2"); + aclDataType dataType = type_transition(src.depth()); - vector inputShape1{1, src.rows, src.cols, src.channels()}; - opDesc.AddInputTensorDesc(dataType, inputShape1.size(), inputShape1.data(), ACL_FORMAT_ND); + vector inputShape1{1, src.rows, src.cols, src.channels()}; + opDesc.AddInputTensorDesc(dataType, inputShape1.size(), inputShape1.data(), + ACL_FORMAT_ND); - vector inputShape2{1}; - opDesc.AddInputTensorDesc(ACL_INT32, inputShape2.size(), inputShape2.data(), ACL_FORMAT_ND); + vector inputShape2{1}; + opDesc.AddInputTensorDesc(ACL_INT32, inputShape2.size(), inputShape2.data(), + ACL_FORMAT_ND); - vector outputShape{1, dest.rows, dest.cols, dest.channels()}; - opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), ACL_FORMAT_ND); - - inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); + vector outputShape{1, dest.rows, dest.cols, dest.channels()}; + opDesc.AddOutputTensorDesc(dataType, outputShape.size(), outputShape.data(), + ACL_FORMAT_ND); - void *dev; - size_t size = aclGetTensorDescSize(opDesc.inputDesc[1]); - aclrtMalloc(&dev, size, ACL_MEM_MALLOC_NORMAL_ONLY); - aclrtMemcpy(dev, size, &axis, size, ACL_MEMCPY_HOST_TO_DEVICE); - inputBuffers_.emplace_back(aclCreateDataBuffer(dev, size)); + inputBuffers_.emplace_back(aclCreateDataBuffer(src.data, src.totalSize)); - outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); + void *dev; + size_t size = aclGetTensorDescSize(opDesc.inputDesc[1]); + aclrtMalloc(&dev, size, ACL_MEM_MALLOC_NORMAL_ONLY); + aclrtMemcpy(dev, size, &axis, size, ACL_MEMCPY_HOST_TO_DEVICE); + inputBuffers_.emplace_back(aclCreateDataBuffer(dev, size)); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, stream_id); - - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[1])); - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[0])); - AclSafeCall(aclrtFree(dev)); - } + outputBuffers_.emplace_back(aclCreateDataBuffer(dest.data, dest.totalSize)); - void flip(const aclMat& src, aclMat& dest, int filpCode, int stream_id) - { - if (filpCode == 0) { - flip_(src, dest, 1, stream_id); - } - else if (filpCode > 0) { - flip_(src, dest, 2, stream_id); - } - else { - flip_(src, dest, 2, stream_id); - aclMat tmp(dest.rows, dest.cols, dest.type(), dest.acl_context); - aclrtMemcpy(tmp.data, dest.totalSize, dest.data, dest.totalSize, ACL_MEMCPY_DEVICE_TO_DEVICE); - flip_(tmp, dest, 1, stream_id); - } - } - } /* end of namespace acl */ + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, dest.acl_context, + stream_id); + + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[0])); + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[1])); + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[0])); + AclSafeCall(aclrtFree(dev)); +} + +void flip(const aclMat &src, aclMat &dest, int filpCode, int stream_id) { + if (filpCode == 0) { + flip_(src, dest, 1, stream_id); + } else if (filpCode > 0) { + flip_(src, dest, 2, stream_id); + } else { + flip_(src, dest, 2, stream_id); + aclMat tmp(dest.rows, dest.cols, dest.type(), dest.acl_context); + aclrtMemcpy(tmp.data, dest.totalSize, dest.data, dest.totalSize, + ACL_MEMCPY_DEVICE_TO_DEVICE); + flip_(tmp, dest, 1, stream_id); + } +} +} /* end of namespace acl */ } /* end of namespace cv */ \ No newline at end of file diff --git a/acl/src/operator_desc.cpp b/acl/src/operator_desc.cpp index 56b231d..9d39ef6 100644 --- a/acl/src/operator_desc.cpp +++ b/acl/src/operator_desc.cpp @@ -1,181 +1,166 @@ /** -* @file operator_desc.cpp -* -* Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved. -* -* This program is distributed in the hope that it will be useful, -* but WITHOUT ANY WARRANTY; without even the implied warranty of -* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. -*/ + * @file operator_desc.cpp + * + * Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + */ #include "precomp.hpp" using namespace std; +using namespace cv; +using namespace cv::acl; +namespace cv { +namespace acl { +OperatorDesc::OperatorDesc(std::string opType) : opType(std::move(opType)) { + opAttr = aclopCreateAttr(); +} -namespace cv -{ - namespace acl - { - OperatorDesc::OperatorDesc(std::string opType) : opType(std::move(opType)) - { - opAttr = aclopCreateAttr(); - } +OperatorDesc::~OperatorDesc() { + for (auto* desc : inputDesc) { + aclDestroyTensorDesc(desc); + } - OperatorDesc::~OperatorDesc() - { - for (auto *desc : inputDesc) - { - aclDestroyTensorDesc(desc); - } + for (auto* desc : outputDesc) { + aclDestroyTensorDesc(desc); + } - for (auto *desc : outputDesc) - { - aclDestroyTensorDesc(desc); - } + aclopDestroyAttr(opAttr); +} - aclopDestroyAttr(opAttr); - } +OperatorDesc& OperatorDesc::AddInputTensorDesc(aclDataType dataType, + int numDims, const int64_t* dims, + aclFormat format) { + aclTensorDesc* desc = aclCreateTensorDesc(dataType, numDims, dims, format); + CV_Assert(desc); + inputDesc.emplace_back(desc); + return *this; +} - OperatorDesc &OperatorDesc::AddInputTensorDesc(aclDataType dataType, - int numDims, - const int64_t *dims, - aclFormat format) - { - aclTensorDesc *desc = aclCreateTensorDesc(dataType, numDims, dims, format); - CV_Assert(desc); - inputDesc.emplace_back(desc); - return *this; - } +OperatorDesc& OperatorDesc::AddOutputTensorDesc(aclDataType dataType, + int numDims, + const int64_t* dims, + aclFormat format) { + aclTensorDesc* desc = aclCreateTensorDesc(dataType, numDims, dims, format); + CV_Assert(desc); + outputDesc.emplace_back(desc); + return *this; +} - OperatorDesc &OperatorDesc::AddOutputTensorDesc(aclDataType dataType, - int numDims, - const int64_t *dims, - aclFormat format) - { - aclTensorDesc *desc = aclCreateTensorDesc(dataType, numDims, dims, format); - CV_Assert(desc); - outputDesc.emplace_back(desc); - return *this; - } +/** + * @brief create operator describe + * + */ +OperatorDesc CreateOpDesc(const string opType, const vector& input_Mat, + vector& output_Mat, aclFormat format, + Opdims config) { + CV_Assert(config == TWO_DIMS || config == FOUR_DIMS); - /** - * @brief create operator describe - * - */ - OperatorDesc CreateOpDesc(const string opType, const vector& input_Mat, vector& output_Mat, aclFormat format, Opdims config) - { - CV_Assert(config == TWO_DIMS || config == FOUR_DIMS); + size_t i; + aclDataType dataType = type_transition(input_Mat[0].depth()); - size_t i; - aclDataType dataType = type_transition(input_Mat[0].depth()); + OperatorDesc opDesc(opType); + for (i = 0; i < input_Mat.size(); ++i) { + if (config == TWO_DIMS) { + int cols = input_Mat[i].step / input_Mat[i].elemSize(); + vector shape{input_Mat[i].rows, cols}; + opDesc.AddInputTensorDesc(dataType, shape.size(), shape.data(), format); + } else if (config == FOUR_DIMS) { + int cols = input_Mat[i].step / input_Mat[i].elemSize(); + vector shape{1, input_Mat[i].rows, cols, + input_Mat[i].channels()}; + opDesc.AddInputTensorDesc(dataType, shape.size(), shape.data(), format); + } + } - OperatorDesc opDesc(opType); - for (i = 0; i < input_Mat.size(); ++i) { - if (config == TWO_DIMS) - { - int cols = input_Mat[i].step / input_Mat[i].elemSize(); - vector shape{input_Mat[i].rows, cols}; - opDesc.AddInputTensorDesc(dataType, shape.size(), shape.data(), format); - } - else if(config == FOUR_DIMS) - { - int cols = input_Mat[i].step / input_Mat[i].elemSize(); - vector shape{1, input_Mat[i].rows, cols, input_Mat[i].channels()}; - opDesc.AddInputTensorDesc(dataType, shape.size(), shape.data(), format); - } - } + for (i = 0; i < output_Mat.size(); ++i) { + if (config == TWO_DIMS) { + int cols = output_Mat[i].step / output_Mat[i].elemSize(); + vector shape{output_Mat[i].rows, cols}; + opDesc.AddOutputTensorDesc(dataType, shape.size(), shape.data(), format); + } else if (config == FOUR_DIMS) { + int cols = output_Mat[i].step / output_Mat[i].elemSize(); + vector shape{1, output_Mat[i].rows, cols, + output_Mat[i].channels()}; + opDesc.AddOutputTensorDesc(dataType, shape.size(), shape.data(), format); + } + } - for (i = 0; i < output_Mat.size(); ++i) { - if (config == TWO_DIMS) - { - int cols = output_Mat[i].step / output_Mat[i].elemSize(); - vector shape{output_Mat[i].rows, cols}; - opDesc.AddOutputTensorDesc(dataType, shape.size(), shape.data(), format); - } - else if(config == FOUR_DIMS) - { - int cols = output_Mat[i].step / output_Mat[i].elemSize(); - vector shape{1, output_Mat[i].rows, cols, output_Mat[i].channels()}; - opDesc.AddOutputTensorDesc(dataType, shape.size(), shape.data(), format); - } - } + return opDesc; +} - return opDesc; - } +/** + * @brief compile and run operator + * + */ +void compileAndRunop(OperatorDesc& opDesc, + vector& inputBuffers_, + vector& outputBuffers_, + aclCxt* acl_context, int stream_id) { + AclSafeCall(aclopCompile(opDesc.opType.c_str(), opDesc.inputDesc.size(), + opDesc.inputDesc.data(), opDesc.outputDesc.size(), + opDesc.outputDesc.data(), opDesc.opAttr, + ACL_ENGINE_SYS, ACL_COMPILE_SYS, nullptr)); - /** - * @brief compile and run operator - * - */ - void compileAndRunop(OperatorDesc& opDesc, vector& inputBuffers_, vector& outputBuffers_, aclCxt *acl_context, int stream_id) - { - AclSafeCall(aclopCompile(opDesc.opType.c_str(), - opDesc.inputDesc.size(), - opDesc.inputDesc.data(), - opDesc.outputDesc.size(), - opDesc.outputDesc.data(), - opDesc.opAttr, - ACL_ENGINE_SYS, - ACL_COMPILE_SYS, - nullptr)); - - AclSafeCall(aclopExecuteV2(opDesc.opType.c_str(), - inputBuffers_.size(), - opDesc.inputDesc.data(), - inputBuffers_.data(), - outputBuffers_.size(), - opDesc.outputDesc.data(), - outputBuffers_.data(), - opDesc.opAttr, - acl_context->get_stream(stream_id))); - } + AclSafeCall(aclopExecuteV2(opDesc.opType.c_str(), inputBuffers_.size(), + opDesc.inputDesc.data(), inputBuffers_.data(), + outputBuffers_.size(), opDesc.outputDesc.data(), + outputBuffers_.data(), opDesc.opAttr, + acl_context->get_stream(stream_id))); +} - void Runop(vector& input, vector& output, OperatorDesc& opDesc, int stream_id) - { - size_t i; +void Runop(vector& input, vector& output, OperatorDesc& opDesc, + int stream_id) { + size_t i; - vector inputBuffers_; - vector outputBuffers_; + vector inputBuffers_; + vector outputBuffers_; - for (i = 0; i < input.size(); ++i) - inputBuffers_.emplace_back(aclCreateDataBuffer(input[i].data, input[i].totalSize)); - for (i = 0; i < output.size(); ++i) - outputBuffers_.emplace_back(aclCreateDataBuffer(output[i].data, output[i].totalSize)); + for (i = 0; i < input.size(); ++i) + inputBuffers_.emplace_back( + aclCreateDataBuffer(input[i].data, input[i].totalSize)); + for (i = 0; i < output.size(); ++i) + outputBuffers_.emplace_back( + aclCreateDataBuffer(output[i].data, output[i].totalSize)); - compileAndRunop(opDesc, inputBuffers_, outputBuffers_, output[0].acl_context, stream_id); + compileAndRunop(opDesc, inputBuffers_, outputBuffers_, output[0].acl_context, + stream_id); - for (i = 0; i < input.size(); ++i) - AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); - for (i = 0; i < output.size(); ++i) - AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); - } + for (i = 0; i < input.size(); ++i) + AclSafeCall(aclDestroyDataBuffer(inputBuffers_[i])); + for (i = 0; i < output.size(); ++i) + AclSafeCall(aclDestroyDataBuffer(outputBuffers_[i])); +} - void OneInAndOneOut(const aclMat& inputMat, aclMat& outputMat, const string opType, int stream_id) - { - vector input_Mat; - vector output_Mat; +void OneInAndOneOut(const aclMat& inputMat, aclMat& outputMat, + const string opType, int stream_id) { + vector input_Mat; + vector output_Mat; - input_Mat.emplace_back(inputMat); - output_Mat.emplace_back(outputMat); + input_Mat.emplace_back(inputMat); + output_Mat.emplace_back(outputMat); - OperatorDesc opDesc = CreateOpDesc(opType, input_Mat, output_Mat); - Runop(input_Mat, output_Mat, opDesc, stream_id); - } + OperatorDesc opDesc = CreateOpDesc(opType, input_Mat, output_Mat); + Runop(input_Mat, output_Mat, opDesc, stream_id); +} - void TwoInAndOneOut(const aclMat& inputMat, const aclMat& inputMatOther, aclMat& outputMat, const string opType, int stream_id) - { - vector input_Mat; - vector output_Mat; +void TwoInAndOneOut(const aclMat& inputMat, const aclMat& inputMatOther, + aclMat& outputMat, const string opType, int stream_id) { + vector input_Mat; + vector output_Mat; - input_Mat.emplace_back(inputMat); - input_Mat.emplace_back(inputMatOther); - output_Mat.emplace_back(outputMat); - - OperatorDesc opDesc = CreateOpDesc(opType, input_Mat, output_Mat); - Runop(input_Mat, output_Mat, opDesc, stream_id); - } + input_Mat.emplace_back(inputMat); + input_Mat.emplace_back(inputMatOther); + output_Mat.emplace_back(outputMat); - } /* end of namespace acl */ + OperatorDesc opDesc = CreateOpDesc(opType, input_Mat, output_Mat); + Runop(input_Mat, output_Mat, opDesc, stream_id); +} + +} /* end of namespace acl */ } /* end of namespace cv */ diff --git a/acl/src/precomp.hpp b/acl/src/precomp.hpp index d9d5319..52dbdeb 100644 --- a/acl/src/precomp.hpp +++ b/acl/src/precomp.hpp @@ -1,8 +1,9 @@ -/*M/////////////////////////////////////////////////////////////////////////////////////// +/* M/////////////////////////////////////////////////////////////////////////////////////// // // IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. // -// By downloading, copying, installing or using the software you agree to this license. +// 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. // @@ -14,23 +15,29 @@ // Copyright (C) 2009, Willow Garage Inc., all rights reserved. // Third party copyrights are property of their respective owners. // -// Redistribution and use in source and binary forms, with or without modification, +// 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, +// * 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 +// * 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 +// 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, +// 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 @@ -38,12 +45,11 @@ // 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*/ +//M */ #ifndef OPENCV_ACL_PRECOMP_HPP__ #define OPENCV_ACL_PRECOMP_HPP__ - #include #include #include @@ -52,19 +58,16 @@ #include #include #include + #include #include - -#include "opencv2/core.hpp" -#include "opencv2/acl/acl.hpp" -#include "opencv2/core/utility.hpp" -#include "opencv2/acl/operator_desc.hpp" #include "acl/acl.h" #include "acl/acl_op_compiler.h" +#include "opencv2/acl/acl.hpp" +#include "opencv2/acl/operator_desc.hpp" +#include "opencv2/core.hpp" +#include "opencv2/core/utility.hpp" -using namespace std; -using namespace cv; -using namespace cv::acl; #endif diff --git a/acl/test/acl.cpp b/acl/test/acl.cpp index bd26327..6f63ad0 100644 --- a/acl/test/acl.cpp +++ b/acl/test/acl.cpp @@ -1,299 +1,277 @@ +#include "test_common.hpp" #include "test_correctness.hpp" #include "test_perf.hpp" -#include "test_common.hpp" +using namespace cv; +using namespace cv::acl; +using namespace cvtest; +using namespace testing; +using namespace std; -namespace opencv_test -{ - namespace - { - aclCxt *acl_context_0 = set_device("../../modules/acl/test/acl.json", 2, 3); - ////////////////////////////////////////////////////Correctness_test//////////////////////////////////////////////////////// - /* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 - * test function: - * config: MEMORY_ALIGN - * aclMat(int rows, int cols, int type, aclCxt *acl_context, ALIGNMENT config = MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); - * aclMat(Size size, int type, aclCxt *acl_context, ALIGNMENT config = MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); - * aclMat(const aclMat &m); - * - */ - TEST(ACLMAT_CONSTRUCTOR, MEMORY_ALIGN) - { - AclMat_Test test; - test.Test_constructor_ALIGN(acl_context_0); - } +namespace opencv_test { +namespace { +aclCxt *acl_context_0 = set_device("../../modules/acl/test/acl.json", 2, 3); +////////////////////////////////////////////////////Correctness_test//////////////////////////////////////////////////////// +/* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 + * test function: + * config: MEMORY_ALIGN + * aclMat(int rows, int cols, int type, aclCxt *acl_context, ALIGNMENT config = + * MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); + * aclMat(Size size, int type, aclCxt *acl_context, ALIGNMENT config = + * MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); + * aclMat(const aclMat &m); + * + */ +TEST(ACLMAT_CONSTRUCTOR, MEMORY_ALIGN) { + AclMat_Test test; + test.Test_constructor_ALIGN(acl_context_0); +} - /* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 - * test function: - * config: MEMORY_UNALIGNED - * aclMat(int rows, int cols, int type, aclCxt *acl_context, ALIGNMENT config = MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); - * aclMat(Size size, int type, aclCxt *acl_context, ALIGNMENT config = MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); - * - */ - TEST(ACLMAT_CONSTRUCTOR, MEMORY_UNALIGNED) - { - AclMat_Test test; - test.Test_constructor_UNALIGNED(acl_context_0); - } +/* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 + * test function: + * config: MEMORY_UNALIGNED + * aclMat(int rows, int cols, int type, aclCxt *acl_context, ALIGNMENT config = + * MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); + * aclMat(Size size, int type, aclCxt *acl_context, ALIGNMENT config = + * MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); + * + */ +TEST(ACLMAT_CONSTRUCTOR, MEMORY_UNALIGNED) { + AclMat_Test test; + test.Test_constructor_UNALIGNED(acl_context_0); +} - /* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 - * test function: - * aclMat(const aclMat &m); - */ - TEST(ACLMAT_CONSTRUCTOR, COPY_CONSTRUCTOR) - { - AclMat_Test test; - test.Test_constructor(acl_context_0); - } +/* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 + * test function: + * aclMat(const aclMat &m); + */ +TEST(ACLMAT_CONSTRUCTOR, COPY_CONSTRUCTOR) { + AclMat_Test test; + test.Test_constructor(acl_context_0); +} - /* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 - * test function: - * aclMat(int rows, int cols, int type, void *data, aclCxt* acl_context, ALIGNMENT config = MEMORY_UNALIGNED, size_t step = Mat::AUTO_STEP); - * aclMat(Size size, int type, void *data, aclCxt* acl_context, ALIGNMENT config = MEMORY_UNALIGNED, size_t step = Mat::AUTO_STEP); - */ - TEST(ACLMAT_CONSTRUCTOR, DATA) - { - AclMat_Test test; - test.Test_constructor_DATA(acl_context_0); - } +/* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 + * test function: + * aclMat(int rows, int cols, int type, void *data, aclCxt* acl_context, + * ALIGNMENT config = MEMORY_UNALIGNED, size_t step = Mat::AUTO_STEP); + * aclMat(Size size, int type, void *data, aclCxt* acl_context, ALIGNMENT config + * = MEMORY_UNALIGNED, size_t step = Mat::AUTO_STEP); + */ +TEST(ACLMAT_CONSTRUCTOR, DATA) { + AclMat_Test test; + test.Test_constructor_DATA(acl_context_0); +} - /* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 - * test function: - * aclMat(const aclMat &m, const Range &rowRange, const Range &colRange = Range::all()); - * - */ - TEST(ACLMAT_CONSTRUCTOR, RANGE) - { - AclMat_Test test; - test.Test_constructor_RANGE(acl_context_0); - } +/* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 + * test function: + * aclMat(const aclMat &m, const Range &rowRange, const Range &colRange = + * Range::all()); + * + */ +TEST(ACLMAT_CONSTRUCTOR, RANGE) { + AclMat_Test test; + test.Test_constructor_RANGE(acl_context_0); +} - /* - * test function: - * aclMat(const aclMat &m, const Rect &roi); - * - */ - TEST(ACLMAT_CONSTRUCTOR, ROI) - { - AclMat_Test test; - test.Test_constructor_ROI(acl_context_0); - } - - /* - * test function: - * aclMat (const Mat &m, aclCxt* acl_context, ALIGNMENT config = MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); - */ - TEST(ACLMAT_CONSTRUCTOR, MAT) - { - AclMat_Test test; - test.Test_constructor_MAT(acl_context_0); - } +/* + * test function: + * aclMat(const aclMat &m, const Rect &roi); + * + */ +TEST(ACLMAT_CONSTRUCTOR, ROI) { + AclMat_Test test; + test.Test_constructor_ROI(acl_context_0); +} - /* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 - * test function: - * CV_EXPORTS void upload(const Mat &m, ALIGNMENT config = MEMORY_UNALIGNED); - * CV_EXPORTS void upload(const Mat &m, aclStream stream, ALIGNMENT config = MEMORY_UNALIGNED); - * - */ - TEST(ACLMAT_FUNCTION, DATA_TRANSFER) - { - AclMat_Test test; - test.Test_DATA_TRANSFER(acl_context_0); - } +/* + * test function: + * aclMat (const Mat &m, aclCxt* acl_context, ALIGNMENT config = + * MEMORY_UNALIGNED, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST); + */ +TEST(ACLMAT_CONSTRUCTOR, MAT) { + AclMat_Test test; + test.Test_constructor_MAT(acl_context_0); +} - /* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 - * test function: - * CV_EXPORTS void download(Mat &m, ALIGNMENT config = MEMORY_UNALIGNED) const; - * CV_EXPORTS void download(Mat &m, aclStream stream, ALIGNMENT config = MEMORY_UNALIGNED) const; - * - */ - TEST(ACLMAT_FUNCTION, DATA_TRANSFERASYNC) - { - AclMat_Test test; - test.Test_DATA_TRANSFERASYNC(acl_context_0); - } +/* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 + * test function: + * CV_EXPORTS void upload(const Mat &m, ALIGNMENT config = MEMORY_UNALIGNED); + * CV_EXPORTS void upload(const Mat &m, aclStream stream, ALIGNMENT config = + * MEMORY_UNALIGNED); + * + */ +TEST(ACLMAT_FUNCTION, DATA_TRANSFER) { + AclMat_Test test; + test.Test_DATA_TRANSFER(acl_context_0); +} - /* - * test function: - * void locateROI(Size &wholeSize, Point &ofs) const; - */ - TEST(ACLMAT_FUNCTION, LOCATEROI) - { - AclMat_Test test; - test.Test_locateROI(acl_context_0); - } +/* range: rows: 1 ~ 64, cols: 1 ~ 64, type: 0 ~ 7 + * test function: + * CV_EXPORTS void download(Mat &m, ALIGNMENT config = MEMORY_UNALIGNED) const; + * CV_EXPORTS void download(Mat &m, aclStream stream, ALIGNMENT config = + * MEMORY_UNALIGNED) const; + * + */ +TEST(ACLMAT_FUNCTION, DATA_TRANSFERASYNC) { + AclMat_Test test; + test.Test_DATA_TRANSFERASYNC(acl_context_0); +} - /* - * test function: - * void swap(aclMat &mat); - * - */ - TEST(ACLMAT_FUNCTION, SWAP) - { - AclMat_Test test; - test.Test_swap(acl_context_0); - } +/* + * test function: + * void locateROI(Size &wholeSize, Point &ofs) const; + */ +TEST(ACLMAT_FUNCTION, LOCATEROI) { + AclMat_Test test; + test.Test_locateROI(acl_context_0); +} - /* - * test function: - * operator+=() - * - */ - TEST(ACLMAT_FUNCTION, OPERATOR_ADD) - { - AclMat_Test test; - test.Test_operator_add(acl_context_0); - } +/* + * test function: + * void swap(aclMat &mat); + * + */ +TEST(ACLMAT_FUNCTION, SWAP) { + AclMat_Test test; + test.Test_swap(acl_context_0); +} - /* - * test function: - * operator-=() - * - */ - TEST(ACLMAT_FUNCTION, OPERATOR_SUB) - { - AclMat_Test test; - test.Test_operator_sub(acl_context_0); - } +/* + * test function: + * operator+=() + * + */ +TEST(ACLMAT_FUNCTION, OPERATOR_ADD) { + AclMat_Test test; + test.Test_operator_add(acl_context_0); +} - /* - * test function: - * operator*=() - * - */ - TEST(ACLMAT_FUNCTION, OPERATOR_MUL) - { - AclMat_Test test; - test.Test_operator_mul(acl_context_0); - } +/* + * test function: + * operator-=() + * + */ +TEST(ACLMAT_FUNCTION, OPERATOR_SUB) { + AclMat_Test test; + test.Test_operator_sub(acl_context_0); +} - /* - * test function: - * operator/=() - * - */ - TEST(ACLMAT_FUNCTION, OPERATOR_DIV) - { - AclMat_Test test; - test.Test_operator_div(acl_context_0); - } - -////////////////////////////////////////////////////Perf_test//////////////////////////////////////////////////////// +/* + * test function: + * operator*=() + * + */ +TEST(ACLMAT_FUNCTION, OPERATOR_MUL) { + AclMat_Test test; + test.Test_operator_mul(acl_context_0); +} - TEST(Operator, add) - { - PERF_TEST test; - test.Test_operator_add_perf(acl_context_0); - } +/* + * test function: + * operator/=() + * + */ +TEST(ACLMAT_FUNCTION, OPERATOR_DIV) { + AclMat_Test test; + test.Test_operator_div(acl_context_0); +} - TEST(Operator, sub) - { - PERF_TEST test; - test.Test_operator_sub_perf(acl_context_0); - } +////////////////////////////////////////////////////Perf_test//////////////////////////////////////////////////////// - TEST(Operator, div) - { - PERF_TEST test; - test.Test_operator_div_perf(acl_context_0); - } +TEST(Operator, add) { + PERF_TEST test; + test.Test_operator_add_perf(acl_context_0); +} - TEST(Operator, mul) - { - PERF_TEST test; - test.Test_operator_mul_perf(acl_context_0); - } +TEST(Operator, sub) { + PERF_TEST test; + test.Test_operator_sub_perf(acl_context_0); +} - TEST(Mathfunction, abs) - { - PERF_TEST test; - test.Test_Abs(acl_context_0); - } +TEST(Operator, div) { + PERF_TEST test; + test.Test_operator_div_perf(acl_context_0); +} - TEST(Mathfunction, pow) - { - PERF_TEST test; - test.Test_Pow(acl_context_0); - } +TEST(Operator, mul) { + PERF_TEST test; + test.Test_operator_mul_perf(acl_context_0); +} - TEST(Mathfunction, sqrt) - { - PERF_TEST test; - test.Test_Sqrt(acl_context_0); - } +TEST(Mathfunction, abs) { + PERF_TEST test; + test.Test_Abs(acl_context_0); +} - TEST(Mathfunction, add) - { - PERF_TEST test; - test.Test_Add(acl_context_0); - } +TEST(Mathfunction, pow) { + PERF_TEST test; + test.Test_Pow(acl_context_0); +} - TEST(Mathfunction, divide) - { - PERF_TEST test; - test.Test_Divide(acl_context_0); - } +TEST(Mathfunction, sqrt) { + PERF_TEST test; + test.Test_Sqrt(acl_context_0); +} - TEST(Mathfunction, exp) - { - PERF_TEST test; - test.Test_Exp(acl_context_0); - } +TEST(Mathfunction, add) { + PERF_TEST test; + test.Test_Add(acl_context_0); +} - TEST(Mathfunction, log) - { - PERF_TEST test; - test.Test_Log(acl_context_0); - } +TEST(Mathfunction, divide) { + PERF_TEST test; + test.Test_Divide(acl_context_0); +} - TEST(Mathfunction, max) - { - PERF_TEST test; - test.Test_Max(acl_context_0); - } +TEST(Mathfunction, exp) { + PERF_TEST test; + test.Test_Exp(acl_context_0); +} - TEST(Mathfunction, min) - { - PERF_TEST test; - test.Test_Min(acl_context_0); - } +TEST(Mathfunction, log) { + PERF_TEST test; + test.Test_Log(acl_context_0); +} - TEST(Gemm, MatMul) - { - PERF_TEST test; - test.Test_MatMul(acl_context_0); - } +TEST(Mathfunction, max) { + PERF_TEST test; + test.Test_Max(acl_context_0); +} - TEST(Gemm, Convolution) - { - PERF_TEST test; - test.Test_Convolution(acl_context_0); - } +TEST(Mathfunction, min) { + PERF_TEST test; + test.Test_Min(acl_context_0); +} - TEST(Matrices, merge) - { - PERF_TEST test; - test.Test_Merge(acl_context_0); - } +TEST(Gemm, MatMul) { + PERF_TEST test; + test.Test_MatMul(acl_context_0); +} - TEST(Matrices, split) - { - PERF_TEST test; - test.Test_Split(acl_context_0); - } +TEST(Gemm, Convolution) { + PERF_TEST test; + test.Test_Convolution(acl_context_0); +} +TEST(Matrices, merge) { + PERF_TEST test; + test.Test_Merge(acl_context_0); +} - TEST(Matrices, transpose) - { - PERF_TEST test; - test.Test_Transpose(acl_context_0); - } +TEST(Matrices, split) { + PERF_TEST test; + test.Test_Split(acl_context_0); +} - TEST(Matrices, flip) - { - PERF_TEST test; - test.Test_Flip(acl_context_0); - release_device(acl_context_0); - } - } -} \ No newline at end of file +TEST(Matrices, transpose) { + PERF_TEST test; + test.Test_Transpose(acl_context_0); +} + +TEST(Matrices, flip) { + PERF_TEST test; + test.Test_Flip(acl_context_0); + release_device(acl_context_0); +} +} // namespace +} // namespace opencv_test \ No newline at end of file diff --git a/acl/test/acl.json b/acl/test/acl.json index 2c63c08..9e26dfe 100644 --- a/acl/test/acl.json +++ b/acl/test/acl.json @@ -1,2 +1 @@ -{ -} +{} \ No newline at end of file diff --git a/acl/test/test_acl.cpp b/acl/test/test_acl.cpp index d6cad03..4b63e0e 100644 --- a/acl/test/test_acl.cpp +++ b/acl/test/test_acl.cpp @@ -1,216 +1,202 @@ #include "test_common.hpp" #include "test_perf.hpp" +using namespace cv; +using namespace cv::acl; +using namespace cvtest; +using namespace testing; +using namespace std; -void PERF_TEST::Test_operator_add_perf(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; +void PERF_TEST::Test_operator_add_perf(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; - vector type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Perf test : Function: operator+=()", type[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); + vector type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Perf test : Function: operator+=()", type[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src, 1); - test.SetDataRange(mat_dest, 1); + test.SetDataRange(mat_src, 1); + test.SetDataRange(mat_dest, 1); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - mat_dest += mat_src; - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) mat_dest += mat_src; + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - aclmat_dest += aclmat_src; - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - aclmat_dest += aclmat_src; - wait_stream(acl_context); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + aclmat_dest += aclmat_src; + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) aclmat_dest += aclmat_src; + wait_stream(acl_context); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } -void PERF_TEST::Test_operator_sub_perf(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; +void PERF_TEST::Test_operator_sub_perf(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; - vector type{CV_8UC1, CV_32FC1, CV_32SC1,CV_64FC1}; - //vector type{CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Perf test : Function: operator-=()", type[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); + vector type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1}; + // vector type{CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Perf test : Function: operator-=()", type[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src, 4); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src, 4); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - mat_dest -= mat_src; - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) mat_dest -= mat_src; + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - aclmat_dest -= aclmat_src; - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - aclmat_dest -= aclmat_src; - wait_stream(acl_context); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + aclmat_dest -= aclmat_src; + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) aclmat_dest -= aclmat_src; + wait_stream(acl_context); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - //bool ret = test.Test_Diff(mat_dest, mat_dest1); - //ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + // bool ret = test.Test_Diff(mat_dest, mat_dest1); + // ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } -void PERF_TEST::Test_operator_div_perf(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; +void PERF_TEST::Test_operator_div_perf(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; - //vector type{CV_32FC1}; - vector type{CV_8UC1,CV_32FC1, CV_32SC1, CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Perf test : Function: operator/=()", type[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i], Scalar(1, 2, 4)); - Mat mat_dest(val, val, type[i], Scalar(2, 4, 8)); - Mat mat_dest1(val, val, type[i]); + // vector type{CV_32FC1}; + vector type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Perf test : Function: operator/=()", type[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i], Scalar(1, 2, 4)); + Mat mat_dest(val, val, type[i], Scalar(2, 4, 8)); + Mat mat_dest1(val, val, type[i]); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - mat_dest /= mat_src; - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) mat_dest /= mat_src; + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - aclmat_dest /= aclmat_src; - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - aclmat_dest /= aclmat_src; - wait_stream(acl_context); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + aclmat_dest /= aclmat_src; + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) aclmat_dest /= aclmat_src; + wait_stream(acl_context); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - //bool ret = test.Test_Diff(mat_dest, mat_dest1); - //ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + // bool ret = test.Test_Diff(mat_dest, mat_dest1); + // ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } -void PERF_TEST::Test_operator_mul_perf(aclCxt *acl_context) -{ - int val, n; - int valmax = 4096; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - vector type{CV_32FC1}; +void PERF_TEST::Test_operator_mul_perf(aclCxt *acl_context) { + int val, n; + int valmax = 4096; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; + vector type{CV_32FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src, 1); - test.SetDataRange(mat_dest, 1); + test.SetDataRange(mat_src, 1); + test.SetDataRange(mat_dest, 1); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - mat_dest *= mat_src; - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) mat_dest *= mat_src; + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - aclmat_dest *= aclmat_src; - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - aclmat_dest *= aclmat_src; - wait_stream(acl_context); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + aclmat_dest *= aclmat_src; + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) aclmat_dest *= aclmat_src; + wait_stream(acl_context); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } - diff --git a/acl/test/test_common.cpp b/acl/test/test_common.cpp index 322c651..fef4562 100644 --- a/acl/test/test_common.cpp +++ b/acl/test/test_common.cpp @@ -1,306 +1,319 @@ #include "test_common.hpp" -Common_Test::Common_Test() { - srand((unsigned)time(NULL)); +using namespace cv; +using namespace cv::acl; +using namespace cvtest; +using namespace testing; +using namespace std; + +Common_Test::Common_Test() { srand((unsigned)time(NULL)); } + +Common_Test::~Common_Test() {} + +bool Common_Test::Test_Diff(const aclMat &aclmat, const Mat &mat, + ALIGNMENT config) { + bool is_correct; + + if (config == ALIGNMENT::MEMORY_UNALIGNED) { + is_correct = (aclmat.rows == mat.rows); + is_correct &= (aclmat.cols == mat.cols); + is_correct &= (aclmat.channels() == mat.channels()); + is_correct &= (aclmat.type() == mat.type()); + is_correct &= (aclmat.step == mat.step); + is_correct &= (aclmat.elemSize() == mat.elemSize()); + is_correct &= (aclmat.totalSize == mat.total() * mat.elemSize()); + is_correct &= + ((aclmat.dataend - aclmat.datastart) == (mat.dataend - mat.datastart)); + + Mat mat_dest(mat.rows, mat.cols, mat.type()); + aclmat.download(mat_dest); + is_correct &= Test_Diff(mat, mat_dest); + } else { + is_correct = (aclmat.rows == mat.rows); + is_correct &= (aclmat.cols == mat.cols); + is_correct &= (aclmat.channels() == mat.channels()); + is_correct &= (aclmat.type() == mat.type()); + is_correct &= (aclmat.elemSize() == mat.elemSize()); + + Mat mat_dest(mat.rows, mat.cols, mat.type()); + aclmat.download(mat_dest, MEMORY_ALIGN); + is_correct &= Test_Diff(mat, mat_dest); + } + + return is_correct; } -Common_Test::~Common_Test() { +bool Common_Test::Test_Diff(const aclMat &aclmat, const aclMat &aclmat_other) { + bool is_correct; + is_correct = (aclmat.flags == aclmat_other.flags); + is_correct &= (aclmat.rows == aclmat_other.rows); + is_correct &= (aclmat.cols == aclmat_other.cols); + is_correct &= (aclmat.type() == aclmat_other.type()); + is_correct &= (aclmat.step == aclmat_other.step); + is_correct &= (aclmat.data == aclmat_other.data); + is_correct &= (aclmat.refcount == aclmat_other.refcount); + is_correct &= (aclmat.datastart == aclmat_other.datastart); + is_correct &= (aclmat.dataend == aclmat_other.dataend); + is_correct &= (aclmat.offset == aclmat_other.offset); + is_correct &= (aclmat.wholerows == aclmat_other.wholerows); + is_correct &= (aclmat.wholecols == aclmat_other.wholecols); + is_correct &= (aclmat.acl_context == aclmat_other.acl_context); + is_correct &= (aclmat.totalSize == aclmat_other.totalSize); + + return is_correct; } -bool Common_Test::Test_Diff(const aclMat& aclmat, const Mat& mat, ALIGNMENT config) { - bool is_correct; +bool Common_Test::Test_Diff(const Mat &mat, const Mat &mat_other) { + bool is_correct; - if (config == ALIGNMENT::MEMORY_UNALIGNED) - { - is_correct = (aclmat.rows == mat.rows); - is_correct &= (aclmat.cols == mat.cols); - is_correct &= (aclmat.channels() == mat.channels()); - is_correct &= (aclmat.type() == mat.type()); - is_correct &= (aclmat.step == mat.step); - is_correct &= (aclmat.elemSize() == mat.elemSize()); - is_correct &= (aclmat.totalSize == mat.total() * mat.elemSize()); - is_correct &= ((aclmat.dataend - aclmat.datastart) == (mat.dataend - mat.datastart)); - - Mat mat_dest(mat.rows, mat.cols, mat.type()); - aclmat.download(mat_dest); - is_correct &= Test_Diff(mat, mat_dest); - } - else - { - is_correct = (aclmat.rows == mat.rows); - is_correct &= (aclmat.cols == mat.cols); - is_correct &= (aclmat.channels() == mat.channels()); - is_correct &= (aclmat.type() == mat.type()); - is_correct &= (aclmat.elemSize() == mat.elemSize()); + is_correct = (mat.rows == mat_other.rows); + is_correct &= (mat.cols == mat_other.cols); + is_correct &= (mat.type() == mat_other.type()); + is_correct &= (mat.channels() == mat.channels()); + is_correct &= (mat.step == mat_other.step); + is_correct &= (mat.elemSize() == mat_other.elemSize()); + is_correct &= (mat.total() == mat_other.total()); - Mat mat_dest(mat.rows, mat.cols, mat.type()); - aclmat.download(mat_dest, MEMORY_ALIGN); - is_correct &= Test_Diff(mat, mat_dest); - } - - return is_correct; -} - -bool Common_Test::Test_Diff(const aclMat& aclmat, const aclMat& aclmat_other) { - bool is_correct; - - is_correct = (aclmat.flags == aclmat_other.flags); - is_correct &= (aclmat.rows == aclmat_other.rows); - is_correct &= (aclmat.cols == aclmat_other.cols); - is_correct &= (aclmat.type() == aclmat_other.type()); - is_correct &= (aclmat.step == aclmat_other.step); - is_correct &= (aclmat.data == aclmat_other.data); - is_correct &= (aclmat.refcount == aclmat_other.refcount); - is_correct &= (aclmat.datastart == aclmat_other.datastart); - is_correct &= (aclmat.dataend == aclmat_other.dataend); - is_correct &= (aclmat.offset == aclmat_other.offset); - is_correct &= (aclmat.wholerows == aclmat_other.wholerows); - is_correct &= (aclmat.wholecols == aclmat_other.wholecols); - is_correct &= (aclmat.acl_context == aclmat_other.acl_context); - is_correct &= (aclmat.totalSize == aclmat_other.totalSize); - - return is_correct; -} - -bool Common_Test::Test_Diff(const Mat &mat, const Mat &mat_other) -{ - bool is_correct; - - is_correct = (mat.rows == mat_other.rows); - is_correct &= (mat.cols == mat_other.cols); - is_correct &= (mat.type() == mat_other.type()); - is_correct &= (mat.channels() == mat.channels()); - is_correct &= (mat.step == mat_other.step); - is_correct &= (mat.elemSize() == mat_other.elemSize()); - is_correct &= (mat.total() == mat_other.total()); - - switch (mat.depth()) - { + switch (mat.depth()) { case CV_8U: - for (int i = 0; (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); i += mat.channels()) - { - for (int j = 0; j < mat.channels(); ++j) - is_correct &= ((mat.data)[i+j] == (mat_other.data)[i+j]); - } - return is_correct; + for (int i = 0; + (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); + i += mat.channels()) { + for (int j = 0; j < mat.channels(); ++j) + is_correct &= ((mat.data)[i + j] == (mat_other.data)[i + j]); + } + return is_correct; case CV_16U: - for (int i = 0; (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); i += mat.channels()) - { - for (int j = 0; j < mat.channels(); ++j) - is_correct &= (((unsigned short *)mat.data)[i+j] == ((unsigned short *)mat_other.data)[i+j]); - } - return is_correct; + for (int i = 0; + (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); + i += mat.channels()) { + for (int j = 0; j < mat.channels(); ++j) + is_correct &= (((unsigned short *)mat.data)[i + j] == + ((unsigned short *)mat_other.data)[i + j]); + } + return is_correct; case CV_32S: - for (int i = 0; (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); i += mat.channels()) - { - for (int j = 0; j < mat.channels(); ++j) - is_correct &= (((int *)(mat.data))[i+j] == (((int *)mat_other.data))[i+j]); - } - return is_correct; + for (int i = 0; + (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); + i += mat.channels()) { + for (int j = 0; j < mat.channels(); ++j) + is_correct &= + (((int *)(mat.data))[i + j] == (((int *)mat_other.data))[i + j]); + } + return is_correct; case CV_32F: - for (int i = 0; (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); i += mat.channels()) - { - for (int j = 0; j < mat.channels(); ++j) - is_correct &= ((((float *)(mat.data))[i+j] - (((float *)mat_other.data))[i+j] >= -0.00001) || \ - (((float *)(mat.data))[i+j] - (((float *)mat_other.data))[i+j] <= 0.00001)); - } - return is_correct; + for (int i = 0; + (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); + i += mat.channels()) { + for (int j = 0; j < mat.channels(); ++j) + is_correct &= ((((float *)(mat.data))[i + j] - + (((float *)mat_other.data))[i + j] >= + -0.00001) || + (((float *)(mat.data))[i + j] - + (((float *)mat_other.data))[i + j] <= + 0.00001)); + } + return is_correct; case CV_64F: - for (int i = 0; (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); i += mat.channels()) - { - for (int j = 0; j < mat.channels(); ++j) - is_correct &= ((((double *)(mat.data))[i+j] - (((double *)mat_other.data))[i+j] >= -0.00001) || \ - (((double *)(mat.data))[i+j] - (((double *)mat_other.data))[i+j] <= 0.00001)); - } - return is_correct; - } - return is_correct; + for (int i = 0; + (is_correct == true) && (i < mat.rows * mat.cols * mat.channels()); + i += mat.channels()) { + for (int j = 0; j < mat.channels(); ++j) + is_correct &= ((((double *)(mat.data))[i + j] - + (((double *)mat_other.data))[i + j] >= + -0.00001) || + (((double *)(mat.data))[i + j] - + (((double *)mat_other.data))[i + j] <= + 0.00001)); + } + return is_correct; + } + return is_correct; } -void Common_Test::MatShow(cv::Mat &m, string str) -{ - cout << str.c_str() << endl; - cout << m; - cout << endl - << endl - << endl; +void Common_Test::MatShow(cv::Mat &m, string str) { + cout << str.c_str() << endl; + cout << m; + cout << endl << endl << endl; } -void Common_Test::StatShow(cv::Mat &mat_src, aclMat &aclmat_dst) -{ - cout << "//////////////////////////////// MatStat ////////////////////////////////" << endl; - cout << "type: " << mat_src.type() << endl; - cout << "elemSize: " << mat_src.elemSize() << endl; - cout << "channels: " << mat_src.channels() << endl; - cout << "step: " << mat_src.step << endl; - cout << "totalSize: " << mat_src.rows * mat_src.cols * mat_src.elemSize() << endl; - cout << "totalSize: " << mat_src.total() * mat_src.elemSize() << endl; - cout << "dataend - datastart: " << mat_src.dataend - mat_src.datastart << endl; +void Common_Test::StatShow(cv::Mat &mat_src, aclMat &aclmat_dst) { + cout << "//////////////////////////////// MatStat " + "////////////////////////////////" + << endl; + cout << "type: " << mat_src.type() << endl; + cout << "elemSize: " << mat_src.elemSize() << endl; + cout << "channels: " << mat_src.channels() << endl; + cout << "step: " << mat_src.step << endl; + cout << "totalSize: " << mat_src.rows * mat_src.cols * mat_src.elemSize() + << endl; + cout << "totalSize: " << mat_src.total() * mat_src.elemSize() << endl; + cout << "dataend - datastart: " << mat_src.dataend - mat_src.datastart + << endl; - cout << "//////////////////////////////// aclMatStat ////////////////////////////////" << endl; - cout << "type: " << aclmat_dst.type() << endl; - cout << "elemSize: " << aclmat_dst.elemSize() << endl; - cout << "channels: " << aclmat_dst.channels() << endl; - cout << "step: " << aclmat_dst.step << endl; - cout << "totalSize: " << aclmat_dst.rows * aclmat_dst.step << endl; - cout << "totalSize: " << aclmat_dst.totalSize << endl; - cout << "dataend - datastart: " << aclmat_dst.dataend - aclmat_dst.datastart << endl; - cout << "wholerows: " << aclmat_dst.wholerows << endl; - cout << "wholecols: " << aclmat_dst.wholecols << endl; - cout << "offset : " << aclmat_dst.offset << endl; + cout << "//////////////////////////////// aclMatStat " + "////////////////////////////////" + << endl; + cout << "type: " << aclmat_dst.type() << endl; + cout << "elemSize: " << aclmat_dst.elemSize() << endl; + cout << "channels: " << aclmat_dst.channels() << endl; + cout << "step: " << aclmat_dst.step << endl; + cout << "totalSize: " << aclmat_dst.rows * aclmat_dst.step << endl; + cout << "totalSize: " << aclmat_dst.totalSize << endl; + cout << "dataend - datastart: " << aclmat_dst.dataend - aclmat_dst.datastart + << endl; + cout << "wholerows: " << aclmat_dst.wholerows << endl; + cout << "wholecols: " << aclmat_dst.wholecols << endl; + cout << "offset : " << aclmat_dst.offset << endl; } -void Common_Test::PrintLog(const string& funcname, int type) -{ - switch (type) - { +void Common_Test::PrintLog(const string &funcname, int type) { + switch (type) { case CV_8UC1: - cout << funcname << "\t" - << "Type: CV_8UC1" << endl; - break; + cout << funcname << "\t" + << "Type: CV_8UC1" << endl; + break; case CV_8UC2: - cout << funcname << "\t" - << "Type: CV_8UC2" << endl; - break; + cout << funcname << "\t" + << "Type: CV_8UC2" << endl; + break; case CV_8UC3: - cout << funcname << "\t" - << "Type: CV_8UC3" << endl; - break; + cout << funcname << "\t" + << "Type: CV_8UC3" << endl; + break; case CV_8UC4: - cout << funcname << "\t" - << "Type: CV_8UC4" << endl; - break; + cout << funcname << "\t" + << "Type: CV_8UC4" << endl; + break; case CV_8SC1: - cout << funcname << "\t" - << "Type: CV_8SC1" << endl; - break; + cout << funcname << "\t" + << "Type: CV_8SC1" << endl; + break; case CV_8SC2: - cout << funcname << "\t" - << "Type: CV_8SC2" << endl; - break; + cout << funcname << "\t" + << "Type: CV_8SC2" << endl; + break; case CV_8SC3: - cout << funcname << "\t" - << "Type: CV_8SC3" << endl; - break; + cout << funcname << "\t" + << "Type: CV_8SC3" << endl; + break; case CV_8SC4: - cout << funcname << "\t" - << "Type: CV_8SC4" << endl; - break; + cout << funcname << "\t" + << "Type: CV_8SC4" << endl; + break; case CV_16FC1: - cout << funcname << "\t" - << "Type: CV_16FC1" << endl; - break; + cout << funcname << "\t" + << "Type: CV_16FC1" << endl; + break; case CV_16FC2: - cout << funcname << "\t" - << "Type: CV_16FC2" << endl; - break; + cout << funcname << "\t" + << "Type: CV_16FC2" << endl; + break; case CV_16FC3: - cout << funcname << "\t" - << "Type: CV_16FC3" << endl; - break; + cout << funcname << "\t" + << "Type: CV_16FC3" << endl; + break; case CV_16FC4: - cout << funcname << "\t" - << "Type: CV_16FC4" << endl; - break; + cout << funcname << "\t" + << "Type: CV_16FC4" << endl; + break; case CV_32FC1: - cout << funcname << "\t" - << "Type: CV_32FC1" << endl; - break; + cout << funcname << "\t" + << "Type: CV_32FC1" << endl; + break; case CV_32FC2: - cout << funcname << "\t" - << "Type: CV_32FC2" << endl; - break; + cout << funcname << "\t" + << "Type: CV_32FC2" << endl; + break; case CV_32FC3: - cout << funcname << "\t" - << "Type: CV_32FC3" << endl; - break; + cout << funcname << "\t" + << "Type: CV_32FC3" << endl; + break; case CV_32FC4: - cout << funcname << "\t" - << "Type: CV_32FC4" << endl; - break; + cout << funcname << "\t" + << "Type: CV_32FC4" << endl; + break; case CV_32SC1: - cout << funcname << "\t" - << "Type: CV_32SC1" << endl; - break; + cout << funcname << "\t" + << "Type: CV_32SC1" << endl; + break; case CV_32SC2: - cout << funcname << "\t" - << "Type: CV_32SC2" << endl; - break; + cout << funcname << "\t" + << "Type: CV_32SC2" << endl; + break; case CV_32SC3: - cout << funcname << "\t" - << "Type: CV_32SC3" << endl; - break; + cout << funcname << "\t" + << "Type: CV_32SC3" << endl; + break; case CV_32SC4: - cout << funcname << "\t" - << "Type: CV_32SC4" << endl; - break; + cout << funcname << "\t" + << "Type: CV_32SC4" << endl; + break; case CV_64FC1: - cout << funcname << "\t" - << "Type: CV_64FC1" << endl; - break; + cout << funcname << "\t" + << "Type: CV_64FC1" << endl; + break; case CV_64FC2: - cout << funcname << "\t" - << "Type: CV_64FC2" << endl; - break; + cout << funcname << "\t" + << "Type: CV_64FC2" << endl; + break; case CV_64FC3: - cout << funcname << "\t" - << "Type: CV_64FC3" << endl; - break; + cout << funcname << "\t" + << "Type: CV_64FC3" << endl; + break; case CV_64FC4: - cout << funcname << "\t" - << "Type: CV_64FC4" << endl; - break; + cout << funcname << "\t" + << "Type: CV_64FC4" << endl; + break; default: - break; - } + break; + } } /* srand((unsigned)time(NULL)) in constructor */ size_t Common_Test::RandDom_(int config) { - return static_cast(rand() % config); + return static_cast(rand() % config); } -bool Common_Test::SetDataRange(Mat &src, int dataRange) -{ - switch (src.depth()) - { +bool Common_Test::SetDataRange(Mat &src, int dataRange) { + switch (src.depth()) { case CV_8U: - for (int i = 0; i < src.rows * src.cols * src.channels(); i += src.channels()) - { - for (int j = 0; j < src.channels(); ++j) - (src.data)[i+j] = RandDom_(dataRange) + 1; - } - return true; + for (int i = 0; i < src.rows * src.cols * src.channels(); + i += src.channels()) { + for (int j = 0; j < src.channels(); ++j) + (src.data)[i + j] = RandDom_(dataRange) + 1; + } + return true; case CV_16U: - for (int i = 0; i < src.rows * src.cols * src.channels(); i += src.channels()) - { - for (int j = 0; j < src.channels(); ++j) - ((unsigned short *)src.data)[i+j] = RandDom_(dataRange) + 1; - } - return true; + for (int i = 0; i < src.rows * src.cols * src.channels(); + i += src.channels()) { + for (int j = 0; j < src.channels(); ++j) + ((unsigned short *)src.data)[i + j] = RandDom_(dataRange) + 1; + } + return true; case CV_32S: - for (int i = 0; i < src.rows * src.cols * src.channels(); i += src.channels()) - { - for (int j = 0; j < src.channels(); ++j) - ((int *)src.data)[i+j] = RandDom_(dataRange) + 1; - } - return true; + for (int i = 0; i < src.rows * src.cols * src.channels(); + i += src.channels()) { + for (int j = 0; j < src.channels(); ++j) + ((int *)src.data)[i + j] = RandDom_(dataRange) + 1; + } + return true; case CV_32F: - for (int i = 0; i < src.rows * src.cols * src.channels(); i += src.channels()) - { - for (int j = 0; j < src.channels(); ++j) - ((float *)src.data)[i+j] = RandDom_(dataRange) / 1.0 + 1; - } - return true; + for (int i = 0; i < src.rows * src.cols * src.channels(); + i += src.channels()) { + for (int j = 0; j < src.channels(); ++j) + ((float *)src.data)[i + j] = RandDom_(dataRange) / 1.0 + 1; + } + return true; case CV_64F: - for (int i = 0; i < src.rows * src.cols * src.channels(); i += src.channels()) - { - for (int j = 0; j < src.channels(); ++j) - ((double *)src.data)[i+j] = RandDom_(dataRange) / 1.0 + 1; - } - return true; + for (int i = 0; i < src.rows * src.cols * src.channels(); + i += src.channels()) { + for (int j = 0; j < src.channels(); ++j) + ((double *)src.data)[i + j] = RandDom_(dataRange) / 1.0 + 1; + } + return true; default: - return false; - } + return false; + } } diff --git a/acl/test/test_common.hpp b/acl/test/test_common.hpp index 809783b..843aed0 100644 --- a/acl/test/test_common.hpp +++ b/acl/test/test_common.hpp @@ -3,25 +3,24 @@ #include "test_precomp.hpp" -typedef enum TestDatatype { - INT = 1, - FLOAT -} TestDatatype; +typedef enum TestDatatype { INT = 1, FLOAT } TestDatatype; class CV_EXPORTS Common_Test { - public: - Common_Test(); - ~Common_Test(); - CV_EXPORTS bool Test_Diff(const aclMat& aclmat, const Mat& mat, ALIGNMENT config = ALIGNMENT::MEMORY_UNALIGNED); - CV_EXPORTS bool Test_Diff(const aclMat& aclmat, const aclMat& aclmat_other); - CV_EXPORTS bool Test_Diff(const Mat& mat, const Mat& mat_other); - CV_EXPORTS void MatShow(Mat &m, string str); - CV_EXPORTS void StatShow(Mat &mat_src, aclMat &aclmat_dst); - CV_EXPORTS void PrintLog(const string& funcname, int type); + public: + Common_Test(); + ~Common_Test(); + CV_EXPORTS bool Test_Diff( + const cv::acl::aclMat& aclmat, const cv::Mat& mat, + cv::acl::ALIGNMENT config = cv::acl::ALIGNMENT::MEMORY_UNALIGNED); + CV_EXPORTS bool Test_Diff(const cv::acl::aclMat& aclmat, + const cv::acl::aclMat& aclmat_other); + CV_EXPORTS bool Test_Diff(const cv::Mat& mat, const cv::Mat& mat_other); + CV_EXPORTS void MatShow(cv::Mat& m, std::string str); + CV_EXPORTS void StatShow(cv::Mat& mat_src, cv::acl::aclMat& aclmat_dst); + CV_EXPORTS void PrintLog(const std::string& funcname, int type); - CV_EXPORTS size_t RandDom_(int config = 0xff); - CV_EXPORTS bool SetDataRange(Mat &src, int dataRange = 0xff); + CV_EXPORTS size_t RandDom_(int config = 0xff); + CV_EXPORTS bool SetDataRange(cv::Mat& src, int dataRange = 0xff); }; - #endif \ No newline at end of file diff --git a/acl/test/test_correctness.cpp b/acl/test/test_correctness.cpp index 0c453c6..59d13f3 100644 --- a/acl/test/test_correctness.cpp +++ b/acl/test/test_correctness.cpp @@ -1,698 +1,706 @@ -/////////////////////////////////////////////////////////////////////////////////////// +/* 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. +// 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. -// Copyright (C) 2010-2012, Multicoreware, Inc., all rights reserved. -// Third party copyrights are property of their respective owners. +// 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. Copyright (C) 2010-2012, Multicoreware, Inc., all rights +// reserved. Third party copyrights are property of their respective owners. // // -// Redistribution and use in source and binary forms, with or without modification, -// are permitted provided that the following conditions are met: +// 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, +// * 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 +// * 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. +// 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*/ +// M*/ - - -#include "test_common.hpp" #include "test_correctness.hpp" -AclMat_Test::AclMat_Test() { +#include "test_common.hpp" -} +using namespace cv; +using namespace cv::acl; +using namespace cvtest; +using namespace testing; +using namespace std; -AclMat_Test::~AclMat_Test() { +AclMat_Test::AclMat_Test() {} -} +AclMat_Test::~AclMat_Test() {} /* thread function */ void thread_handler(void) { - aclCxt *acl_context_0 = set_device("/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 0, 1); - release_device(acl_context_0); + aclCxt *acl_context_0 = + set_device("/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 0, 1); + release_device(acl_context_0); } void AclMat_Test::Test_set_device() { - /* Current thread */ - aclCxt *acl_context_0 = set_device("/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 0, 1); + /* Current thread */ + aclCxt *acl_context_0 = + set_device("/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 0, 1); - /* Different scope */ - { - aclCxt *acl_context_1 = set_device("/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 2, 3); - release_device(acl_context_1); - } + /* Different scope */ + { + aclCxt *acl_context_1 = set_device( + "/home/perfxlab4/OpenCV_ACL/modules/acl/test/acl.json", 2, 3); + release_device(acl_context_1); + } - release_device(acl_context_0); - /* Different thread */ - thread t(thread_handler); - t.join(); + release_device(acl_context_0); + /* Different thread */ + thread t(thread_handler); + t.join(); } void AclMat_Test::Test_constructor_UNALIGNED(aclCxt *acl_context) { - Common_Test test; - int rows, cols, type; - bool ret; - const int rowsMax = 128; - const int colsMax = 128; - const int typeMax = 7; + Common_Test test; + int rows, cols, type; + bool ret; + const int rowsMax = 128; + const int colsMax = 128; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) { - for (rows = 1; rows < rowsMax; rows++) { - for (cols = 1; cols < colsMax; cols++) { - Mat mat_src(rows, cols, type); - aclMat aclmat_src(rows, cols, type, acl_context); - test.SetDataRange(mat_src, 32); - aclmat_src.upload(mat_src); - ret = test.Test_Diff(aclmat_src, mat_src); - ASSERT_TRUE(ret); - } - } + for (type = 0; type < typeMax; type++) { + for (rows = 1; rows < rowsMax; rows++) { + for (cols = 1; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + aclMat aclmat_src(rows, cols, type, acl_context); + test.SetDataRange(mat_src, 32); + aclmat_src.upload(mat_src); + ret = test.Test_Diff(aclmat_src, mat_src); + ASSERT_TRUE(ret); + } } - clog << "Test_constructor_UNALIGNED: -> aclMat(rows, cols, type, acl_context, config, policy) <- is success" << endl; + } + clog << "Test_constructor_UNALIGNED: -> aclMat(rows, cols, type, " + "acl_context, config, policy) <- is success" + << endl; - for (type = 0; type < typeMax; type++) { - for (rows = 1; rows < rowsMax; rows++) { - for (cols = 1; cols < colsMax; cols++) { - Mat mat_src(cv::Size(cols, rows), type); - test.SetDataRange(mat_src, 32); - aclMat aclmat_src(cv::Size(cols, rows), type, acl_context); - aclmat_src.upload(mat_src); - ret = test.Test_Diff(aclmat_src, mat_src); - ASSERT_TRUE(ret); - } - } + for (type = 0; type < typeMax; type++) { + for (rows = 1; rows < rowsMax; rows++) { + for (cols = 1; cols < colsMax; cols++) { + Mat mat_src(cv::Size(cols, rows), type); + test.SetDataRange(mat_src, 32); + aclMat aclmat_src(cv::Size(cols, rows), type, acl_context); + aclmat_src.upload(mat_src); + ret = test.Test_Diff(aclmat_src, mat_src); + ASSERT_TRUE(ret); + } } - clog << "Test_constructor_UNALIGNED: -> aclMat(size, type, acl_context, config, policy) <- is success" << endl; + } + clog << "Test_constructor_UNALIGNED: -> aclMat(size, type, acl_context, " + "config, policy) <- is success" + << endl; } void AclMat_Test::Test_constructor_ALIGN(aclCxt *acl_context) { - Common_Test test; - int rows, cols, type; - bool ret; - const int rowsMax = 128; - const int colsMax = 128; - const int typeMax = 7; + Common_Test test; + int rows, cols, type; + bool ret; + const int rowsMax = 128; + const int colsMax = 128; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) { - for (rows = 1; rows < rowsMax; rows++) { - for (cols = 1; cols < colsMax; cols++) { - Mat mat_src(rows, cols, type); - test.SetDataRange(mat_src, 32); - aclMat aclmat_src(rows, cols, type, acl_context, MEMORY_ALIGN); - aclmat_src.upload(mat_src, MEMORY_ALIGN); - ret = test.Test_Diff(aclmat_src, mat_src, MEMORY_ALIGN); - ASSERT_TRUE(ret); - } - } + for (type = 0; type < typeMax; type++) { + for (rows = 1; rows < rowsMax; rows++) { + for (cols = 1; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + test.SetDataRange(mat_src, 32); + aclMat aclmat_src(rows, cols, type, acl_context, MEMORY_ALIGN); + aclmat_src.upload(mat_src, MEMORY_ALIGN); + ret = test.Test_Diff(aclmat_src, mat_src, MEMORY_ALIGN); + ASSERT_TRUE(ret); + } } - clog << "Test_constructor_ALIGN: -> aclMat(rows, cols, type, acl_context, config, policy) <- is success" << endl; + } + clog << "Test_constructor_ALIGN: -> aclMat(rows, cols, type, acl_context, " + "config, policy) <- is success" + << endl; - for (type = 0; type < typeMax; type++) { - for (rows = 1; rows < rowsMax; rows++) { - for (cols = 1; cols < colsMax; cols++) { - Mat mat_src(cv::Size(cols, rows), type); - test.SetDataRange(mat_src, 32); - aclMat aclmat_src(cv::Size(cols, rows), type, acl_context, MEMORY_ALIGN); - aclmat_src.upload(mat_src, MEMORY_ALIGN); - ret = test.Test_Diff(aclmat_src, mat_src, MEMORY_ALIGN); - ASSERT_TRUE(ret); - } - } + for (type = 0; type < typeMax; type++) { + for (rows = 1; rows < rowsMax; rows++) { + for (cols = 1; cols < colsMax; cols++) { + Mat mat_src(cv::Size(cols, rows), type); + test.SetDataRange(mat_src, 32); + aclMat aclmat_src(cv::Size(cols, rows), type, acl_context, + MEMORY_ALIGN); + aclmat_src.upload(mat_src, MEMORY_ALIGN); + ret = test.Test_Diff(aclmat_src, mat_src, MEMORY_ALIGN); + ASSERT_TRUE(ret); + } } - clog << "Test_constructor_ALIGN: -> aclMat(size, type, acl_context, config, policy) <- is success" << endl; - - + } + clog << "Test_constructor_ALIGN: -> aclMat(size, type, acl_context, config, " + "policy) <- is success" + << endl; } void AclMat_Test::Test_constructor(aclCxt *acl_context_0) { - Common_Test test; - int rows, cols, type; - bool ret; - const int rowsMax = 128; - const int colsMax = 128; - const int typeMax = 7; + Common_Test test; + int rows, cols, type; + bool ret; + const int rowsMax = 128; + const int colsMax = 128; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) { - for (rows = 1; rows < rowsMax; rows++) { - for (cols = 1; cols < colsMax; cols++) { - aclMat aclmat_src(rows, cols, type, acl_context_0); - aclMat aclmat_dest(aclmat_src); - ret = test.Test_Diff(aclmat_src, aclmat_dest); - ASSERT_TRUE(ret); - } - } + for (type = 0; type < typeMax; type++) { + for (rows = 1; rows < rowsMax; rows++) { + for (cols = 1; cols < colsMax; cols++) { + aclMat aclmat_src(rows, cols, type, acl_context_0); + aclMat aclmat_dest(aclmat_src); + ret = test.Test_Diff(aclmat_src, aclmat_dest); + ASSERT_TRUE(ret); + } } - clog << "Test_constructor: -> aclMat(aclmat_src) <- is success" << endl; + } + clog << "Test_constructor: -> aclMat(aclmat_src) <- is success" << endl; - for (type = 0; type < typeMax; type++) { - for (rows = 1; rows < rowsMax; rows++) { - for (cols = 1; cols < colsMax; cols++) { - aclMat aclmat_src(cv::Size(cols, rows), type, acl_context_0, MEMORY_ALIGN); - aclMat aclmat_dest(aclmat_src); - ret = test.Test_Diff(aclmat_src, aclmat_dest); - ASSERT_TRUE(ret); - } - } + for (type = 0; type < typeMax; type++) { + for (rows = 1; rows < rowsMax; rows++) { + for (cols = 1; cols < colsMax; cols++) { + aclMat aclmat_src(cv::Size(cols, rows), type, acl_context_0, + MEMORY_ALIGN); + aclMat aclmat_dest(aclmat_src); + ret = test.Test_Diff(aclmat_src, aclmat_dest); + ASSERT_TRUE(ret); + } } - clog << "Test_constructor: -> aclMat(const aclMat& other) <- is success" << endl; + } + clog << "Test_constructor: -> aclMat(const aclMat& other) <- is success" + << endl; } void AclMat_Test::Test_constructor_DATA(aclCxt *acl_context_0) { - Common_Test test; - int rows, cols, type; - bool ret; - const int rowsMax = 128; - const int colsMax = 128; - const int typeMax = 7; + Common_Test test; + int rows, cols, type; + bool ret; + const int rowsMax = 128; + const int colsMax = 128; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) { - for (rows = 1; rows < rowsMax; rows++) { - for (cols = 1; cols < colsMax; cols++) { - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); + for (type = 0; type < typeMax; type++) { + for (rows = 1; rows < rowsMax; rows++) { + for (cols = 1; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); + test.SetDataRange(mat_src); - aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); - aclmat_src.download(mat_dest); - ret = test.Test_Diff(mat_src, mat_dest); - ASSERT_TRUE(ret); - } - } + aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); + aclmat_src.download(mat_dest); + ret = test.Test_Diff(mat_src, mat_dest); + ASSERT_TRUE(ret); + } } - cerr << "Test_constructor_DATA: -> aclMat(rows, cols, type, data, acl_context)) <- is success" << endl; + } + cerr << "Test_constructor_DATA: -> aclMat(rows, cols, type, data, " + "acl_context)) <- is success" + << endl; - for (type = 0; type < typeMax; type++) { - for (rows = 1; rows < rowsMax; rows++) { - for (cols = 1; cols < colsMax; cols++) { - Mat mat_src(cv::Size(cols, rows), type); - Mat mat_dest(cv::Size(cols, rows), type); - test.SetDataRange(mat_src); + for (type = 0; type < typeMax; type++) { + for (rows = 1; rows < rowsMax; rows++) { + for (cols = 1; cols < colsMax; cols++) { + Mat mat_src(cv::Size(cols, rows), type); + Mat mat_dest(cv::Size(cols, rows), type); + test.SetDataRange(mat_src); - aclMat aclmat_src(cv::Size(cols, rows), type, mat_src.data, acl_context_0); - aclmat_src.download(mat_dest); - ret = test.Test_Diff(mat_src, mat_dest); - ASSERT_TRUE(ret); - } - } + aclMat aclmat_src(cv::Size(cols, rows), type, mat_src.data, + acl_context_0); + aclmat_src.download(mat_dest); + ret = test.Test_Diff(mat_src, mat_dest); + ASSERT_TRUE(ret); + } } + } - cerr << "Test_constructor_DATA: -> aclMat(size, type, data, acl_context)) <- is success" << endl; + cerr << "Test_constructor_DATA: -> aclMat(size, type, data, acl_context)) <- " + "is success" + << endl; } void AclMat_Test::Test_constructor_RANGE(aclCxt *acl_context_0) { - Common_Test test; - int type; - bool ret; - int rangerows, rangecols; - int rows = 64, cols = 64; - const int rangerowsMax = 64; - const int rangecolsMax = 64; - const int typeMax = 7; + Common_Test test; + int type; + bool ret; + int rangerows, rangecols; + int rows = 64, cols = 64; + const int rangerowsMax = 64; + const int rangecolsMax = 64; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) { - for (rangerows = 4; rangerows < rangerowsMax; rangerows++) { - for (rangecols = 4; rangecols < rangecolsMax; rangecols++) { - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + for (type = 0; type < typeMax; type++) { + for (rangerows = 4; rangerows < rangerowsMax; rangerows++) { + for (rangecols = 4; rangecols < rangecolsMax; rangecols++) { + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); - Mat mat_rangesrc(mat_src, cv::Range(2, rangerows), cv::Range(2, rangecols)); - Mat mat_rangedest(mat_dest, cv::Range(2, rangerows), cv::Range(2, rangecols)); - aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); - aclMat aclmat_range(aclmat_src, cv::Range(2, rangerows), cv::Range(2, rangecols)); - aclmat_range.download(mat_rangedest); - ret = test.Test_Diff(mat_rangesrc, mat_rangedest); - ASSERT_TRUE(ret); - } - } + Mat mat_rangesrc(mat_src, cv::Range(2, rangerows), + cv::Range(2, rangecols)); + Mat mat_rangedest(mat_dest, cv::Range(2, rangerows), + cv::Range(2, rangecols)); + aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); + aclMat aclmat_range(aclmat_src, cv::Range(2, rangerows), + cv::Range(2, rangecols)); + aclmat_range.download(mat_rangedest); + ret = test.Test_Diff(mat_rangesrc, mat_rangedest); + ASSERT_TRUE(ret); + } } - clog << "Test_constructor_RANGE: -> aclMat(aclmat_src, rowragne, colrange)) <- is success" << endl; - + } + clog << "Test_constructor_RANGE: -> aclMat(aclmat_src, rowragne, colrange)) " + "<- is success" + << endl; } void AclMat_Test::Test_constructor_ROI(aclCxt *acl_context_0) { - Common_Test test; - { - int rows = 6, cols = 8; - int type = CV_8UC1; - cv::Rect roi(2, 2, 1, 1); - bool ret; - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); + Common_Test test; + { + int rows = 6, cols = 8; + int type = CV_8UC1; + cv::Rect roi(2, 2, 1, 1); + bool ret; + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); - Mat mat_roi1(mat_src, roi); - Mat mat_roi(mat_dest, roi); + Mat mat_roi1(mat_src, roi); + Mat mat_roi(mat_dest, roi); - aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); - aclMat aclmat_roi(aclmat_src, roi); - aclmat_roi.download(mat_roi); - ret = test.Test_Diff(mat_roi1, mat_roi); - ASSERT_TRUE(ret); - } + aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); + aclMat aclmat_roi(aclmat_src, roi); + aclmat_roi.download(mat_roi); + ret = test.Test_Diff(mat_roi1, mat_roi); + ASSERT_TRUE(ret); + } - { - int rows = 12, cols = 61; - int type = CV_16UC3; - cv::Rect roi(8, 8, 2, 2); - bool ret; - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); + { + int rows = 12, cols = 61; + int type = CV_16UC3; + cv::Rect roi(8, 8, 2, 2); + bool ret; + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); - Mat mat_roi1(mat_src, roi); - Mat mat_roi(mat_dest, roi); + Mat mat_roi1(mat_src, roi); + Mat mat_roi(mat_dest, roi); - aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); - aclMat aclmat_roi(aclmat_src, roi); - aclmat_roi.download(mat_roi); - ret = test.Test_Diff(mat_roi1, mat_roi); - ASSERT_TRUE(ret); - } + aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); + aclMat aclmat_roi(aclmat_src, roi); + aclmat_roi.download(mat_roi); + ret = test.Test_Diff(mat_roi1, mat_roi); + ASSERT_TRUE(ret); + } - { - int rows = 16, cols = 80; - int type = CV_32FC3; - cv::Rect roi(8, 4, 1, 3); - bool ret; - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); + { + int rows = 16, cols = 80; + int type = CV_32FC3; + cv::Rect roi(8, 4, 1, 3); + bool ret; + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); - Mat mat_roi1(mat_src, roi); - Mat mat_roi(mat_dest, roi); + Mat mat_roi1(mat_src, roi); + Mat mat_roi(mat_dest, roi); - aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); - aclMat aclmat_roi(aclmat_src, roi); - aclmat_roi.download(mat_roi); - ret = test.Test_Diff(mat_roi1, mat_roi); - ASSERT_TRUE(ret); - } + aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); + aclMat aclmat_roi(aclmat_src, roi); + aclmat_roi.download(mat_roi); + ret = test.Test_Diff(mat_roi1, mat_roi); + ASSERT_TRUE(ret); + } - clog << "Test_constructor_ROI: -> aclMat(aclmat_src, roi)) <- is success" << endl; + clog << "Test_constructor_ROI: -> aclMat(aclmat_src, roi)) <- is success" + << endl; } void AclMat_Test::Test_constructor_MAT(aclCxt *acl_context_0) { - Common_Test test; - int rows, cols, type; - bool ret; - const int rowsMax = 1048; - const int colsMax = 1048; - const int typeMax = 7; + Common_Test test; + int rows, cols, type; + bool ret; + const int rowsMax = 1048; + const int colsMax = 1048; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) { - for (rows = 1000; rows < rowsMax; rows++) { - for (cols = 1000; cols < colsMax; cols++) { - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); + for (type = 0; type < typeMax; type++) { + for (rows = 1000; rows < rowsMax; rows++) { + for (cols = 1000; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); + test.SetDataRange(mat_src); - aclMat aclmat_src(mat_src, acl_context_0); - aclmat_src.download(mat_dest); - ret = test.Test_Diff(mat_src, mat_dest); - ASSERT_TRUE(ret); - } - } + aclMat aclmat_src(mat_src, acl_context_0); + aclmat_src.download(mat_dest); + ret = test.Test_Diff(mat_src, mat_dest); + ASSERT_TRUE(ret); + } } - clog << "Test_constructor_MAT: -> aclMat(mat_src, acl_context_0)) <- is success" << endl; - + } + clog << "Test_constructor_MAT: -> aclMat(mat_src, acl_context_0)) <- is " + "success" + << endl; } void AclMat_Test::Test_DATA_TRANSFER(aclCxt *acl_context_0) { - Common_Test test; - int rows, cols, type; - bool ret; - const int rowsMax = 1048; - const int colsMax = 1048; - const int typeMax = 7; + Common_Test test; + int rows, cols, type; + bool ret; + const int rowsMax = 1048; + const int colsMax = 1048; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) - { - for (rows = 1000; rows < rowsMax; rows++) - { - for (cols = 1000; cols < colsMax; cols++) - { - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); - - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + for (type = 0; type < typeMax; type++) { + for (rows = 1000; rows < rowsMax; rows++) { + for (cols = 1000; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); - aclMat aclmat_src(rows, cols, type, acl_context_0); - aclmat_src.upload(mat_src); - aclmat_src.download(mat_dest); - ret = test.Test_Diff(mat_src, mat_dest); - ASSERT_TRUE(ret); - } - } + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); + + aclMat aclmat_src(rows, cols, type, acl_context_0); + aclmat_src.upload(mat_src); + aclmat_src.download(mat_dest); + ret = test.Test_Diff(mat_src, mat_dest); + ASSERT_TRUE(ret); + } } - clog << "Test_DATA_TRANSFER_UNALIGNED: -> upload(), download() <- is success" << endl; + } + clog << "Test_DATA_TRANSFER_UNALIGNED: -> upload(), download() <- is success" + << endl; - for (type = 0; type < typeMax; type++) - { - for (rows = 1000; rows < rowsMax; rows++) - { - for (cols = 1000; cols < colsMax; cols++) - { - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); + for (type = 0; type < typeMax; type++) { + for (rows = 1000; rows < rowsMax; rows++) { + for (cols = 1000; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); - aclMat aclmat_src(rows, cols, type, acl_context_0, MEMORY_ALIGN); - aclmat_src.upload(mat_src, MEMORY_ALIGN); - aclmat_src.download(mat_dest, MEMORY_ALIGN); - ret = test.Test_Diff(mat_src, mat_dest); - ASSERT_TRUE(ret); - } - } + aclMat aclmat_src(rows, cols, type, acl_context_0, MEMORY_ALIGN); + aclmat_src.upload(mat_src, MEMORY_ALIGN); + aclmat_src.download(mat_dest, MEMORY_ALIGN); + ret = test.Test_Diff(mat_src, mat_dest); + ASSERT_TRUE(ret); + } } - clog << "Test_DATA_TRANSFER_ALIGN: -> upload(), download() <- is success" << endl; + } + clog << "Test_DATA_TRANSFER_ALIGN: -> upload(), download() <- is success" + << endl; } void AclMat_Test::Test_DATA_TRANSFERASYNC(aclCxt *acl_context_0) { - Common_Test test; - int rows, cols, type; - bool ret; - const int rowsMax = 1048; - const int colsMax = 1048; - const int typeMax = 7; + Common_Test test; + int rows, cols, type; + bool ret; + const int rowsMax = 1048; + const int colsMax = 1048; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) - { - for (rows = 1000; rows < rowsMax; rows++) - { - for (cols = 1000; cols < colsMax; cols++) - { - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); + for (type = 0; type < typeMax; type++) { + for (rows = 1000; rows < rowsMax; rows++) { + for (cols = 1000; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); - aclMat aclmat_src(rows, cols, type, acl_context_0); - aclmat_src.upload(mat_src, aclmat_src.acl_context->get_stream(0)); - aclmat_src.download(mat_dest, aclmat_src.acl_context->get_stream(0)); - ret = test.Test_Diff(mat_src, mat_dest); - ASSERT_TRUE(ret); - } - } + aclMat aclmat_src(rows, cols, type, acl_context_0); + aclmat_src.upload(mat_src, aclmat_src.acl_context->get_stream(0)); + aclmat_src.download(mat_dest, aclmat_src.acl_context->get_stream(0)); + ret = test.Test_Diff(mat_src, mat_dest); + ASSERT_TRUE(ret); + } } - clog << "Test_DATA_TRANSFERASYNC_UNALIGNED: -> upload(), download() <- is success" << endl; + } + clog << "Test_DATA_TRANSFERASYNC_UNALIGNED: -> upload(), download() <- is " + "success" + << endl; - for (type = 0; type < typeMax; type++) - { - for (rows = 1000; rows < rowsMax; rows++) - { - for (cols = 1000; cols < colsMax; cols++) - { - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); + for (type = 0; type < typeMax; type++) { + for (rows = 1000; rows < rowsMax; rows++) { + for (cols = 1000; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); - aclMat aclmat_src(rows, cols, type, acl_context_0, MEMORY_ALIGN); - aclmat_src.upload(mat_src, aclmat_src.acl_context->get_stream(0), MEMORY_ALIGN); - aclmat_src.download(mat_dest, aclmat_src.acl_context->get_stream(0), MEMORY_ALIGN); - ret = test.Test_Diff(mat_src, mat_dest); - ASSERT_TRUE(ret); - } - } + aclMat aclmat_src(rows, cols, type, acl_context_0, MEMORY_ALIGN); + aclmat_src.upload(mat_src, aclmat_src.acl_context->get_stream(0), + MEMORY_ALIGN); + aclmat_src.download(mat_dest, aclmat_src.acl_context->get_stream(0), + MEMORY_ALIGN); + ret = test.Test_Diff(mat_src, mat_dest); + ASSERT_TRUE(ret); + } } - clog << "Test_DATA_TRANSFERASYNC_ALIGN: -> upload(), download() <- is success" << endl; - + } + clog << "Test_DATA_TRANSFERASYNC_ALIGN: -> upload(), download() <- is success" + << endl; } -static inline void dataSwap(int& data1, int& data2) { - Common_Test test; - int temp; - if (data1 < data2) { - temp = data1; - data1 = data2; - data2 = temp; - } +static inline void dataSwap(int &data1, int &data2) { + Common_Test test; + int temp; + if (data1 < data2) { + temp = data1; + data1 = data2; + data2 = temp; + } } void AclMat_Test::Test_locateROI(aclCxt *acl_context_0) { - Common_Test test; - int rows = 256, cols = 256; - int type = CV_8UC1; - int rangex, rangey; - int rangex1, rangey1; - cv::Size size, size1; - cv::Point ofs, ofs1; + Common_Test test; + int rows = 256, cols = 256; + int type = CV_8UC1; + int rangex, rangey; + int rangex1, rangey1; + cv::Size size, size1; + cv::Point ofs, ofs1; - for (int x = 0; x < rows * cols; ++x) - { - rangex = (rangex = test.RandDom_()) > 0 ? rangex : 1; - rangey = (rangey = test.RandDom_()) > 0 ? rangey : 1; - rangex1 = (rangex1 = test.RandDom_()) > 0 ? rangex1 : 1; - rangey1 = (rangey1 = test.RandDom_()) > 0 ? rangey1 : 1; + for (int x = 0; x < rows * cols; ++x) { + rangex = (rangex = test.RandDom_()) > 0 ? rangex : 1; + rangey = (rangey = test.RandDom_()) > 0 ? rangey : 1; + rangex1 = (rangex1 = test.RandDom_()) > 0 ? rangex1 : 1; + rangey1 = (rangey1 = test.RandDom_()) > 0 ? rangey1 : 1; - dataSwap(rangex, rangex1); - dataSwap(rangey, rangey1); + dataSwap(rangex, rangex1); + dataSwap(rangey, rangey1); - Mat mat_src(rows, cols, type); - Mat mat_range(mat_src, cv::Range(rangex1, rangex+1), cv::Range(rangey1, rangey+1)); - mat_range.locateROI(size, ofs); + Mat mat_src(rows, cols, type); + Mat mat_range(mat_src, cv::Range(rangex1, rangex + 1), + cv::Range(rangey1, rangey + 1)); + mat_range.locateROI(size, ofs); - aclMat aclmat_src(rows, cols, type, acl_context_0); - aclMat aclmat_range(aclmat_src, cv::Range(rangex1, rangex+1), cv::Range(rangey1, rangey+1)); - aclmat_range.locateROI(size1, ofs1); + aclMat aclmat_src(rows, cols, type, acl_context_0); + aclMat aclmat_range(aclmat_src, cv::Range(rangex1, rangex + 1), + cv::Range(rangey1, rangey + 1)); + aclmat_range.locateROI(size1, ofs1); - ASSERT_EQ(size.height, size1.height); - ASSERT_EQ(size.width, size1.width); - ASSERT_EQ(ofs.x, ofs1.x); - ASSERT_EQ(ofs.y, ofs1.y); - } - clog << "Test_loacteROI: -> locateROI() <- is success" << endl; - + ASSERT_EQ(size.height, size1.height); + ASSERT_EQ(size.width, size1.width); + ASSERT_EQ(ofs.x, ofs1.x); + ASSERT_EQ(ofs.y, ofs1.y); + } + clog << "Test_loacteROI: -> locateROI() <- is success" << endl; } void AclMat_Test::Test_swap(aclCxt *acl_context_0) { - Common_Test test; - int rows, cols, type; - bool ret; - const int rowsMax = 1048; - const int colsMax = 1048; - const int typeMax = 7; + Common_Test test; + int rows, cols, type; + bool ret; + const int rowsMax = 1048; + const int colsMax = 1048; + const int typeMax = 7; - for (type = 0; type < typeMax; type++) - { - for (rows = 1024; rows < rowsMax; rows++) - { - for (cols = 1024; cols < colsMax; cols++) - { - Mat mat_src(rows, cols, type); - Mat mat_dest(rows, cols, type); + for (type = 0; type < typeMax; type++) { + for (rows = 1024; rows < rowsMax; rows++) { + for (cols = 1024; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type); + Mat mat_dest(rows, cols, type); - test.SetDataRange(mat_src); - test.SetDataRange(mat_dest); + test.SetDataRange(mat_src); + test.SetDataRange(mat_dest); - Mat mat_dest1(rows, cols, type); - Mat mat_dest2(rows, cols, type); + Mat mat_dest1(rows, cols, type); + Mat mat_dest2(rows, cols, type); - aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); - aclMat aclmat_src1(rows, cols, type, mat_dest.data, acl_context_0); - aclmat_src.swap(aclmat_src1); + aclMat aclmat_src(rows, cols, type, mat_src.data, acl_context_0); + aclMat aclmat_src1(rows, cols, type, mat_dest.data, acl_context_0); + aclmat_src.swap(aclmat_src1); - aclmat_src.download(mat_dest1); - aclmat_src1.download(mat_dest2); + aclmat_src.download(mat_dest1); + aclmat_src1.download(mat_dest2); - ret = test.Test_Diff(mat_dest1, mat_dest); - ASSERT_TRUE(ret); + ret = test.Test_Diff(mat_dest1, mat_dest); + ASSERT_TRUE(ret); - ret = test.Test_Diff(mat_dest2, mat_src); - ASSERT_TRUE(ret); - } - } + ret = test.Test_Diff(mat_dest2, mat_src); + ASSERT_TRUE(ret); + } } - clog << "Test_Swap: -> swap() <- is success" << endl; + } + clog << "Test_Swap: -> swap() <- is success" << endl; } void AclMat_Test::Test_operator_add(aclCxt *acl_context) { - Common_Test test; - int rows, cols; - bool ret; - const int rowsMax = 1048; - const int colsMax = 1048; + Common_Test test; + int rows, cols; + bool ret; + const int rowsMax = 1048; + const int colsMax = 1048; - vector type{CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3, CV_32SC1, CV_32SC3}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Correctness test: Functoin: operator+=()", type[i]); - for (rows = 1024; rows < rowsMax; rows++) - { - for (cols = 1024; cols < colsMax; cols++) - { - Mat mat_src(rows, cols, type[i]); - Mat mat_dest(rows, cols, type[i]); - Mat mat_dest1(rows, cols, type[i]); + vector type{CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3, CV_32SC1, CV_32SC3}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Correctness test: Functoin: operator+=()", type[i]); + for (rows = 1024; rows < rowsMax; rows++) { + for (cols = 1024; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type[i]); + Mat mat_dest(rows, cols, type[i]); + Mat mat_dest1(rows, cols, type[i]); - test.SetDataRange(mat_src, 32); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context, MEMORY_ALIGN); - aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context, MEMORY_ALIGN); + aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context, + MEMORY_ALIGN); + aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context, + MEMORY_ALIGN); - mat_dest += mat_src; + mat_dest += mat_src; - aclmat_dest += aclmat_src; - wait_stream(acl_context); - aclmat_dest.download(mat_dest1, MEMORY_ALIGN); + aclmat_dest += aclmat_src; + wait_stream(acl_context); + aclmat_dest.download(mat_dest1, MEMORY_ALIGN); - ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - } - } + ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + } } - + } } void AclMat_Test::Test_operator_sub(aclCxt *acl_context) { - Common_Test test; - int rows, cols; - bool ret; - const int rowsMax = 1048; - const int colsMax = 1048; + Common_Test test; + int rows, cols; + bool ret; + const int rowsMax = 1048; + const int colsMax = 1048; - vector type{CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3, CV_32SC1, CV_32SC3, CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Correctness test: Functoin: operator-=()", type[i]); - for (rows = 1024; rows < rowsMax; rows++) - { - for (cols = 1024; cols < colsMax; cols++) - { - Mat mat_src(rows, cols, type[i], Scalar(1, 2, 3)); - Mat mat_dest(rows, cols, type[i], Scalar(4, 6, 8)); - Mat mat_dest1(rows, cols, type[i]); + vector type{CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3, + CV_32SC1, CV_32SC3, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Correctness test: Functoin: operator-=()", type[i]); + for (rows = 1024; rows < rowsMax; rows++) { + for (cols = 1024; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type[i], Scalar(1, 2, 3)); + Mat mat_dest(rows, cols, type[i], Scalar(4, 6, 8)); + Mat mat_dest1(rows, cols, type[i]); - aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context, MEMORY_ALIGN); - aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context, MEMORY_ALIGN); + aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context, + MEMORY_ALIGN); + aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context, + MEMORY_ALIGN); - mat_dest -= mat_src; + mat_dest -= mat_src; - aclmat_dest -= aclmat_src; - wait_stream(acl_context); - aclmat_dest.download(mat_dest1, MEMORY_ALIGN); + aclmat_dest -= aclmat_src; + wait_stream(acl_context); + aclmat_dest.download(mat_dest1, MEMORY_ALIGN); - ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - } - } + ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + } } - + } } void AclMat_Test::Test_operator_div(aclCxt *acl_context) { - Common_Test test; - int rows, cols; - bool ret; - const int rowsMax = 1048; - const int colsMax = 1048; + Common_Test test; + int rows, cols; + bool ret; + const int rowsMax = 1048; + const int colsMax = 1048; - vector type{CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3, CV_32SC1, CV_32SC3, CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Correctness test: Functoin: operator/=()", type[i]); - for (rows = 1024; rows < rowsMax; rows++) - { - for (cols = 1024; cols < colsMax; cols++) - { - Mat mat_src(rows, cols, type[i], Scalar(1, 2, 4)); - Mat mat_dest(rows, cols, type[i], Scalar(4, 6, 8)); - Mat mat_dest1(rows, cols, type[i]); + vector type{CV_8UC1, CV_8UC3, CV_32FC1, CV_32FC3, + CV_32SC1, CV_32SC3, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Correctness test: Functoin: operator/=()", type[i]); + for (rows = 1024; rows < rowsMax; rows++) { + for (cols = 1024; cols < colsMax; cols++) { + Mat mat_src(rows, cols, type[i], Scalar(1, 2, 4)); + Mat mat_dest(rows, cols, type[i], Scalar(4, 6, 8)); + Mat mat_dest1(rows, cols, type[i]); - aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context, MEMORY_ALIGN); - aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context, MEMORY_ALIGN); + aclMat aclmat_src(rows, cols, type[i], mat_src.data, acl_context, + MEMORY_ALIGN); + aclMat aclmat_dest(rows, cols, type[i], mat_dest.data, acl_context, + MEMORY_ALIGN); - mat_dest /= mat_src; + mat_dest /= mat_src; - aclmat_dest /= aclmat_src; - wait_stream(acl_context); - aclmat_dest.download(mat_dest1, MEMORY_ALIGN); + aclmat_dest /= aclmat_src; + wait_stream(acl_context); + aclmat_dest.download(mat_dest1, MEMORY_ALIGN); - ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - } - } + ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + } } + } } void AclMat_Test::Test_operator_mul(aclCxt *acl_context) { - Common_Test test; - int val; - bool ret; - const int valMax = 1048; + Common_Test test; + int val; + bool ret; + const int valMax = 1048; - vector type{CV_32FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Correctness test: Functoin: operator*=()", type[i]); - for (val = 1024; val < valMax; val++) - { - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); + vector type{CV_32FC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Correctness test: Functoin: operator*=()", type[i]); + for (val = 1024; val < valMax; val++) { + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src, 32); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - mat_dest *= mat_src; + mat_dest *= mat_src; - aclmat_dest *= aclmat_src; - wait_stream(acl_context); - aclmat_dest.download(mat_dest1); + aclmat_dest *= aclmat_src; + wait_stream(acl_context); + aclmat_dest.download(mat_dest1); - ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - } + ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); } - + } } - - - - diff --git a/acl/test/test_correctness.hpp b/acl/test/test_correctness.hpp index 490cc19..17b0fca 100644 --- a/acl/test/test_correctness.hpp +++ b/acl/test/test_correctness.hpp @@ -2,39 +2,50 @@ #define __OPENCV_CORRECTNESS_HPP__ #include "test_precomp.hpp" + +using namespace cv; +using namespace cv::acl; +using namespace cvtest; +using namespace testing; +using namespace std; + class CV_EXPORTS AclMat_Test { - public: - AclMat_Test(); - ~AclMat_Test(); - /* test set_device() */ - CV_EXPORTS void Test_set_device(); - /* test aclMat(int rows, int cols, int type, aclCxt *acl_context, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST) */ - CV_EXPORTS void Test_constructor_UNALIGNED(aclCxt *acl_context); - CV_EXPORTS void Test_constructor_ALIGN(aclCxt *acl_context); + public: + AclMat_Test(); + ~AclMat_Test(); + /* test set_device() */ + CV_EXPORTS void Test_set_device(); + /* test aclMat(int rows, int cols, int type, aclCxt *acl_context, + * aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST) */ + CV_EXPORTS void Test_constructor_UNALIGNED(aclCxt *acl_context); + CV_EXPORTS void Test_constructor_ALIGN(aclCxt *acl_context); - /* test aclMat(const aclMat &m) */ - CV_EXPORTS void Test_constructor(aclCxt *acl_context); - /* test aclMat(int rows, int cols, int type, void *data, aclCxt* acl_context, size_t step = Mat::AUTO_STEP) */ - CV_EXPORTS void Test_constructor_DATA(aclCxt *acl_context); - /* test aclMat(const aclMat &m, const Range &rowRange, const Range &colRange = Range::all()) */ - CV_EXPORTS void Test_constructor_RANGE(aclCxt *acl_context); - /* test aclMat(const aclMat &m, const Rect &roi) */ - CV_EXPORTS void Test_constructor_ROI(aclCxt *acl_context); - /* test aclMat (const Mat &m, aclCxt* acl_context, aclrtMemMallocPolicy policy = ACL_MEM_MALLOC_HUGE_FIRST) */ - CV_EXPORTS void Test_constructor_MAT(aclCxt *acl_context); - /* test upload download*/ - CV_EXPORTS void Test_DATA_TRANSFER(aclCxt *acl_context); - /* test upload_2d download_2d */ - CV_EXPORTS void Test_DATA_TRANSFERASYNC(aclCxt *acl_context); - /* test locateROI adjustROI */ - CV_EXPORTS void Test_locateROI(aclCxt *acl_context); - /* test swap */ - CV_EXPORTS void Test_swap(aclCxt *acl_context); + /* test aclMat(const aclMat &m) */ + CV_EXPORTS void Test_constructor(aclCxt *acl_context); + /* test aclMat(int rows, int cols, int type, void *data, aclCxt* acl_context, + * size_t step = Mat::AUTO_STEP) */ + CV_EXPORTS void Test_constructor_DATA(aclCxt *acl_context); + /* test aclMat(const aclMat &m, const Range &rowRange, const Range &colRange = + * Range::all()) */ + CV_EXPORTS void Test_constructor_RANGE(aclCxt *acl_context); + /* test aclMat(const aclMat &m, const Rect &roi) */ + CV_EXPORTS void Test_constructor_ROI(aclCxt *acl_context); + /* test aclMat (const Mat &m, aclCxt* acl_context, aclrtMemMallocPolicy policy + * = ACL_MEM_MALLOC_HUGE_FIRST) */ + CV_EXPORTS void Test_constructor_MAT(aclCxt *acl_context); + /* test upload download*/ + CV_EXPORTS void Test_DATA_TRANSFER(aclCxt *acl_context); + /* test upload_2d download_2d */ + CV_EXPORTS void Test_DATA_TRANSFERASYNC(aclCxt *acl_context); + /* test locateROI adjustROI */ + CV_EXPORTS void Test_locateROI(aclCxt *acl_context); + /* test swap */ + CV_EXPORTS void Test_swap(aclCxt *acl_context); - CV_EXPORTS void Test_operator_add(aclCxt *acl_context); - CV_EXPORTS void Test_operator_sub(aclCxt *acl_context); - CV_EXPORTS void Test_operator_mul(aclCxt *acl_context); - CV_EXPORTS void Test_operator_div(aclCxt *acl_context); + CV_EXPORTS void Test_operator_add(aclCxt *acl_context); + CV_EXPORTS void Test_operator_sub(aclCxt *acl_context); + CV_EXPORTS void Test_operator_mul(aclCxt *acl_context); + CV_EXPORTS void Test_operator_div(aclCxt *acl_context); }; void thread_handler(void); diff --git a/acl/test/test_gemm.cpp b/acl/test/test_gemm.cpp index 4332c56..8d0c8b2 100644 --- a/acl/test/test_gemm.cpp +++ b/acl/test/test_gemm.cpp @@ -1,113 +1,111 @@ #include "test_common.hpp" #include "test_perf.hpp" -void PERF_TEST::Test_MatMul(aclCxt *acl_context) -{ - int val, n; - int valmax = 4096; - int cycle_index = 10;//100; - double begin, end, time, acltime; - Common_Test test; - vector type{CV_32FC1}; +using namespace cv; +using namespace cv::acl; +using namespace cvtest; +using namespace testing; +using namespace std; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - Mat mat_src(val, val, type[i]); - Mat mat_src1(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); +void PERF_TEST::Test_MatMul(aclCxt *acl_context) { + int val, n; + int valmax = 4096; + int cycle_index = 10; // 100; + double begin, end, time, acltime; + Common_Test test; + vector type{CV_32FC1}; - test.SetDataRange(mat_src, 32); - test.SetDataRange(mat_src1, 32); - test.SetDataRange(mat_dest, 32); + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + Mat mat_src(val, val, type[i]); + Mat mat_src1(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_src1(val, val, type[i], mat_src1.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_src1, 32); + test.SetDataRange(mat_dest, 32); - n = cycle_index; - begin = static_cast(getTickCount()); - while (n--) - mat_dest = mat_src * mat_src1; - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_src1(val, val, type[i], mat_src1.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - n = (cycle_index - 1); - MatMul(aclmat_src1, aclmat_src, aclmat_dest, 0); - wait_stream(acl_context, 0); - begin = static_cast(getTickCount()); - while (n--) - MatMul(aclmat_src1, aclmat_src, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = cycle_index; + begin = static_cast(getTickCount()); + while (n--) mat_dest = mat_src * mat_src1; + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + n = (cycle_index - 1); + MatMul(aclmat_src1, aclmat_src, aclmat_dest, 0); + wait_stream(acl_context, 0); + begin = static_cast(getTickCount()); + while (n--) MatMul(aclmat_src1, aclmat_src, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } -void PERF_TEST::Test_Convolution(aclCxt *acl_context) -{ - int val, n; - int valmax = 4096; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - vector type{CV_32FC1}; +void PERF_TEST::Test_Convolution(aclCxt *acl_context) { + int val, n; + int valmax = 4096; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; + vector type{CV_32FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - Mat mat_src(val, val, type[i], Scalar{1, 2}); - Mat mat_kernel(3, 3, type[i], Scalar(1, 4)); - Mat mat_dest(val, val, type[i], Scalar{6}); + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + Mat mat_src(val, val, type[i], Scalar{1, 2}); + Mat mat_kernel(3, 3, type[i], Scalar(1, 4)); + Mat mat_dest(val, val, type[i], Scalar{6}); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_kernel(3, 3, type[i], mat_kernel.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_kernel(3, 3, type[i], mat_kernel.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - n = cycle_index; - begin = static_cast(getTickCount()); - while (n--) - filter2D(mat_src, mat_dest, -1, mat_kernel); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + n = cycle_index; + begin = static_cast(getTickCount()); + while (n--) filter2D(mat_src, mat_dest, -1, mat_kernel); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - vector strides{1, 1, 1, 1}; - vector pads{1, 1, 1, 1}; - n = (cycle_index - 1); - Convolution(aclmat_src, aclmat_kernel, aclmat_dest, strides, pads, 0); - wait_stream(acl_context, 0); - begin = static_cast(getTickCount()); - while (n--) - Convolution(aclmat_src, aclmat_kernel, aclmat_dest, strides, pads, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - Mat mat_dest1(aclmat_dest.rows, aclmat_dest.cols, type[i]); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + vector strides{1, 1, 1, 1}; + vector pads{1, 1, 1, 1}; + n = (cycle_index - 1); + Convolution(aclmat_src, aclmat_kernel, aclmat_dest, strides, pads, 0); + wait_stream(acl_context, 0); + begin = static_cast(getTickCount()); + while (n--) + Convolution(aclmat_src, aclmat_kernel, aclmat_dest, strides, pads, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + Mat mat_dest1(aclmat_dest.rows, aclmat_dest.cols, type[i]); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - /* - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - */ - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + /* + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + */ + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } \ No newline at end of file diff --git a/acl/test/test_main.cpp b/acl/test/test_main.cpp index 93e4d28..5b9fb4f 100644 --- a/acl/test/test_main.cpp +++ b/acl/test/test_main.cpp @@ -1,10 +1,10 @@ // This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. +// It is subject to the license terms in the LICENSE file found in the top-level +// directory of this distribution and at http://opencv.org/license.html. #include "test_precomp.hpp" #if defined(HAVE_HPX) - #include +#include #endif CV_TEST_MAIN("cv") diff --git a/acl/test/test_mathfuncs.cpp b/acl/test/test_mathfuncs.cpp index 5f100b4..f5ea676 100644 --- a/acl/test/test_mathfuncs.cpp +++ b/acl/test/test_mathfuncs.cpp @@ -1,481 +1,446 @@ #include "test_common.hpp" #include "test_perf.hpp" -void PERF_TEST::Test_Abs(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; +using namespace cv; +using namespace cv::acl; +using namespace cvtest; +using namespace testing; +using namespace std; - //vector type{CV_32FC1}; - vector type{CV_32FC1,CV_32SC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Perf test : Function: Abs()", type[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i], Scalar{-2}); - Mat mat_dest(val, val, type[i], Scalar{-4}); - Mat mat_dest1(val, val, type[i], Scalar{-6}); +void PERF_TEST::Test_Abs(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + // vector type{CV_32FC1}; + vector type{CV_32FC1, CV_32SC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Perf test : Function: Abs()", type[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i], Scalar{-2}); + Mat mat_dest(val, val, type[i], Scalar{-4}); + Mat mat_dest1(val, val, type[i], Scalar{-6}); - begin = static_cast(getTickCount()); - while (n--) - mat_dest = abs(mat_src); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - n = (cycle_index - 1); - aclmat_dest = abs(aclmat_src, 0); - wait_stream(acl_context, 0); - begin = static_cast(getTickCount()); - while (n--) - aclmat_dest = abs(aclmat_src, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + begin = static_cast(getTickCount()); + while (n--) mat_dest = abs(mat_src); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + n = (cycle_index - 1); + aclmat_dest = abs(aclmat_src, 0); + wait_stream(acl_context, 0); + begin = static_cast(getTickCount()); + while (n--) aclmat_dest = abs(aclmat_src, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } -void PERF_TEST::Test_Pow(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; +void PERF_TEST::Test_Pow(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; - //vector type{CV_32FC1}; - vector type{CV_8UC1, CV_32FC1,CV_32SC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Perf test : Function: Pow()", type[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - int power = test.RandDom_(6); - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); + // vector type{CV_32FC1}; + vector type{CV_8UC1, CV_32FC1, CV_32SC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Perf test : Function: Pow()", type[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + int power = test.RandDom_(6); + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_src, 32); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - pow(mat_src, power, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) pow(mat_src, power, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - pow(aclmat_src, power, aclmat_dest, 0); - wait_stream(acl_context, 0); - begin = static_cast(getTickCount()); - while (n--) - pow(aclmat_src, power, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + pow(aclmat_src, power, aclmat_dest, 0); + wait_stream(acl_context, 0); + begin = static_cast(getTickCount()); + while (n--) pow(aclmat_src, power, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } -void PERF_TEST::Test_Sqrt(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - //vector type{CV_32FC1}; - vector type{CV_32FC1,CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); +void PERF_TEST::Test_Sqrt(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; + // vector type{CV_32FC1}; + vector type{CV_32FC1, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src, 32); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - sqrt(mat_src, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) sqrt(mat_src, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - sqrt(aclmat_src, aclmat_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - sqrt(aclmat_src, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + sqrt(aclmat_src, aclmat_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) sqrt(aclmat_src, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } -void PERF_TEST::Test_Add(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - //vector type{CV_32FC1}; - vector type{CV_8UC1,CV_32FC1, CV_32SC1, CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src1(val, val, type[i]); - Mat mat_src2(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); +void PERF_TEST::Test_Add(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; + // vector type{CV_32FC1}; + vector type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src1(val, val, type[i]); + Mat mat_src2(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src1, 32); - test.SetDataRange(mat_src2, 32); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src1, 32); + test.SetDataRange(mat_src2, 32); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src1(val, val, type[i], mat_src1.data, acl_context); - aclMat aclmat_src2(val, val, type[i], mat_src2.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src1(val, val, type[i], mat_src1.data, acl_context); + aclMat aclmat_src2(val, val, type[i], mat_src2.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - add(mat_src1, mat_src2, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) add(mat_src1, mat_src2, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - add(aclmat_src1, aclmat_src2, aclmat_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - add(aclmat_src1, aclmat_src2, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + add(aclmat_src1, aclmat_src2, aclmat_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) add(aclmat_src1, aclmat_src2, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } -void PERF_TEST::Test_Divide(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - //vector type{CV_32FC1}; - vector type{CV_8UC1,CV_32FC1, CV_32SC1}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src1(val, val, type[i]); - Mat mat_src2(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); +void PERF_TEST::Test_Divide(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; + // vector type{CV_32FC1}; + vector type{CV_8UC1, CV_32FC1, CV_32SC1}; + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src1(val, val, type[i]); + Mat mat_src2(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src1, 32); - test.SetDataRange(mat_src2, 4); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src1, 32); + test.SetDataRange(mat_src2, 4); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src1(val, val, type[i], mat_src1.data, acl_context); - aclMat aclmat_src2(val, val, type[i], mat_src2.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src1(val, val, type[i], mat_src1.data, acl_context); + aclMat aclmat_src2(val, val, type[i], mat_src2.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - divide(mat_src1, mat_src2, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) divide(mat_src1, mat_src2, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - divide(aclmat_src1, aclmat_src2, aclmat_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - divide(aclmat_src1, aclmat_src2, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + divide(aclmat_src1, aclmat_src2, aclmat_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) divide(aclmat_src1, aclmat_src2, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - // bool ret = test.Test_Diff(mat_dest, mat_dest1); - // ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + // bool ret = test.Test_Diff(mat_dest, mat_dest1); + // ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } -void PERF_TEST::Test_Exp(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - - //vector type{CV_32FC1}; - vector type{CV_32FC1,CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); +void PERF_TEST::Test_Exp(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; - test.SetDataRange(mat_src, 32); - test.SetDataRange(mat_dest, 2); + // vector type{CV_32FC1}; + vector type{CV_32FC1, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_dest, 2); - begin = static_cast(getTickCount()); - while (n--) - exp(mat_src, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - n = (cycle_index - 1); - exp(aclmat_src, aclmat_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - exp(aclmat_src, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + begin = static_cast(getTickCount()); + while (n--) exp(mat_src, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - aclmat_dest.download(mat_dest1); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + n = (cycle_index - 1); + exp(aclmat_src, aclmat_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) exp(aclmat_src, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + + aclmat_dest.download(mat_dest1); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } -void PERF_TEST::Test_Log(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - //vector type{CV_32FC1}; - vector type{CV_32FC1,CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); +void PERF_TEST::Test_Log(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; + // vector type{CV_32FC1}; + vector type{CV_32FC1, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src, 32); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - log(mat_src, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) log(mat_src, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - log(aclmat_src, aclmat_dest, 1); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - log(aclmat_src, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + log(aclmat_src, aclmat_dest, 1); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) log(aclmat_src, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } -void PERF_TEST::Test_Max(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - // vector type{CV_32FC2}; - vector type{CV_32FC2,CV_32SC2, CV_64FC2}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src1(val, val, type[i]); - Mat mat_src2(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); +void PERF_TEST::Test_Max(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; + // vector type{CV_32FC2}; + vector type{CV_32FC2, CV_32SC2, CV_64FC2}; + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src1(val, val, type[i]); + Mat mat_src2(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src1, 32); - test.SetDataRange(mat_src2, 32); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src1, 32); + test.SetDataRange(mat_src2, 32); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src1(val, val, type[i], mat_src2.data, acl_context); - aclMat aclmat_src2(val, val, type[i], mat_src1.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src1(val, val, type[i], mat_src2.data, acl_context); + aclMat aclmat_src2(val, val, type[i], mat_src1.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - cv::max(mat_src1, mat_src2, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) cv::max(mat_src1, mat_src2, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - cv::acl::max(aclmat_src1, aclmat_src2, aclmat_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - cv::acl::max(aclmat_src1, aclmat_src2, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + cv::acl::max(aclmat_src1, aclmat_src2, aclmat_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) cv::acl::max(aclmat_src1, aclmat_src2, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } -void PERF_TEST::Test_Min(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; - //vector type{CV_32FC3}; - vector type{CV_32FC3,CV_32SC3, CV_64FC3}; - for (size_t i = 0; i < type.size(); ++i) - { - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src1(val, val, type[i]); - Mat mat_src2(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); +void PERF_TEST::Test_Min(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; + // vector type{CV_32FC3}; + vector type{CV_32FC3, CV_32SC3, CV_64FC3}; + for (size_t i = 0; i < type.size(); ++i) { + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src1(val, val, type[i]); + Mat mat_src2(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src1, 32); - test.SetDataRange(mat_src2, 32); - test.SetDataRange(mat_dest, 32); + test.SetDataRange(mat_src1, 32); + test.SetDataRange(mat_src2, 32); + test.SetDataRange(mat_dest, 32); - aclMat aclmat_src1(val, val, type[i], mat_src2.data, acl_context); - aclMat aclmat_src2(val, val, type[i], mat_src1.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src1(val, val, type[i], mat_src2.data, acl_context); + aclMat aclmat_src2(val, val, type[i], mat_src1.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - cv::min(mat_src1, mat_src2, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) cv::min(mat_src1, mat_src2, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - cv::acl::min(aclmat_src1, aclmat_src2, aclmat_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - cv::acl::min(aclmat_src1, aclmat_src2, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + cv::acl::min(aclmat_src1, aclmat_src2, aclmat_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) cv::acl::min(aclmat_src1, aclmat_src2, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } \ No newline at end of file diff --git a/acl/test/test_matrices.cpp b/acl/test/test_matrices.cpp index e2df35f..d05f025 100644 --- a/acl/test/test_matrices.cpp +++ b/acl/test/test_matrices.cpp @@ -1,278 +1,239 @@ #include "test_common.hpp" #include "test_perf.hpp" -/* -//disable -void PERF_TEST::Test_Lookuptable(aclCxt *acl_context_0) -{ - int type = CV_8UC1; - Common_Test test; - Mat mat_src(1, 256, type); - Mat mat_dest(1, 256, type); - Mat lookuptable(1, 256, type); +using namespace cv; +using namespace cv::acl; +using namespace cvtest; +using namespace testing; +using namespace std; - test.SetDataRange(mat_src, 32); - test.SetDataRange(lookuptable, 32); +void PERF_TEST::Test_Merge(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; - aclMat aclmat_src(1, 256, type, mat_src.data, acl_context_0); - aclMat aclmat_dest(1, 256, type, mat_dest.data, acl_context_0); - aclMat lut(1, 256, type, lookuptable.data, acl_context_0); - // LUT(mat_src, lookuptable, mat_dest); - lookUpTable(aclmat_src, lut, aclmat_dest); - cout << mat_src << endl; - cout << lookuptable << endl; - cout << mat_dest << endl; -} -*/ + vector srcType{CV_8UC1, CV_32FC1, CV_32SC1}; + // vector destType{CV_32FC3}; + vector destType{CV_8UC3, CV_32FC3, CV_32SC3}; + for (size_t i = 0; i < srcType.size(); ++i) { + test.PrintLog("Perf test : Function: merge()", srcType[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src1(val, val, srcType[i], Scalar(1)); + Mat mat_src2(val, val, srcType[i], Scalar(2)); + Mat mat_src3(val, val, srcType[i], Scalar(3)); + Mat mat_dest(val, val, destType[i]); + Mat mat_dest1(val, val, destType[i]); -void PERF_TEST::Test_Merge(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; + test.SetDataRange(mat_src1, 32); + test.SetDataRange(mat_src2, 32); + test.SetDataRange(mat_src3, 32); - - vector srcType{CV_8UC1,CV_32FC1, CV_32SC1}; - - //vector destType{CV_32FC3}; - vector destType{CV_8UC3,CV_32FC3, CV_32SC3}; - for (size_t i = 0; i < srcType.size(); ++i) - { - test.PrintLog("Perf test : Function: merge()", srcType[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src1(val, val, srcType[i], Scalar(1)); - Mat mat_src2(val, val, srcType[i], Scalar(2)); - Mat mat_src3(val, val, srcType[i], Scalar(3)); - Mat mat_dest(val, val, destType[i]); - Mat mat_dest1(val, val, destType[i]); + aclMat aclmat_src1(val, val, srcType[i], mat_src1.data, acl_context); + aclMat aclmat_src2(val, val, srcType[i], mat_src2.data, acl_context); + aclMat aclmat_src3(val, val, srcType[i], mat_src3.data, acl_context); + aclMat aclmat_dest(val, val, destType[i], mat_dest.data, acl_context); - test.SetDataRange(mat_src1, 32); - test.SetDataRange(mat_src2, 32); - test.SetDataRange(mat_src3, 32); + vector src; + src.emplace_back(mat_src1); + src.emplace_back(mat_src2); + src.emplace_back(mat_src3); - aclMat aclmat_src1(val, val, srcType[i], mat_src1.data, acl_context); - aclMat aclmat_src2(val, val, srcType[i], mat_src2.data, acl_context); - aclMat aclmat_src3(val, val, srcType[i], mat_src3.data, acl_context); - aclMat aclmat_dest(val, val, destType[i], mat_dest.data, acl_context); + vector acl_src; + acl_src.emplace_back(aclmat_src1); + acl_src.emplace_back(aclmat_src2); + acl_src.emplace_back(aclmat_src3); - vector src; - src.emplace_back(mat_src1); - src.emplace_back(mat_src2); - src.emplace_back(mat_src3); + begin = static_cast(getTickCount()); + while (n--) merge(src, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - vector acl_src; - acl_src.emplace_back(aclmat_src1); - acl_src.emplace_back(aclmat_src2); - acl_src.emplace_back(aclmat_src3); - - begin = static_cast(getTickCount()); - while (n--) - merge(src, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; - - n = (cycle_index - 1); - merge(acl_src, aclmat_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - merge(acl_src, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + n = (cycle_index - 1); + merge(acl_src, aclmat_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) merge(acl_src, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } +void PERF_TEST::Test_Transpose(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; -void PERF_TEST::Test_Transpose(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; + // vector type{CV_32FC1}; + vector type{CV_32FC1, CV_32SC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Perf test : Function: transpose()", type[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - //vector type{CV_32FC1}; - vector type{CV_32FC1,CV_32SC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Perf test : Function: transpose()", type[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); + test.SetDataRange(mat_src, 32); - test.SetDataRange(mat_src, 32); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + begin = static_cast(getTickCount()); + while (n--) transpose(mat_src, mat_dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - begin = static_cast(getTickCount()); - while (n--) - transpose(mat_src, mat_dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + n = (cycle_index - 1); + transpose(aclmat_src, aclmat_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) transpose(aclmat_src, aclmat_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - n = (cycle_index - 1); - transpose(aclmat_src, aclmat_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - transpose(aclmat_src, aclmat_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } -void PERF_TEST::Test_Split(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 10; - double begin, end, time, acltime; - Common_Test test; +void PERF_TEST::Test_Split(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 10; + double begin, end, time, acltime; + Common_Test test; - //vector srcType{CV_32FC3}; - vector srcType{CV_8UC3,CV_32FC3, CV_32SC3}; - vector destType{CV_8UC1,CV_32FC1, CV_32SC1}; - for (size_t i = 0; i < srcType.size(); ++i) - { - test.PrintLog("Perf test : Function: split()", srcType[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, srcType[i]); - Mat mat_dest1(val, val, destType[i]); - Mat mat_dest2(val, val, destType[i]); - Mat mat_dest3(val, val, destType[i]); + // vector srcType{CV_32FC3}; + vector srcType{CV_8UC3, CV_32FC3, CV_32SC3}; + vector destType{CV_8UC1, CV_32FC1, CV_32SC1}; + for (size_t i = 0; i < srcType.size(); ++i) { + test.PrintLog("Perf test : Function: split()", srcType[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, srcType[i]); + Mat mat_dest1(val, val, destType[i]); + Mat mat_dest2(val, val, destType[i]); + Mat mat_dest3(val, val, destType[i]); - test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_src, 32); - aclMat aclmat_src(val, val, srcType[i], mat_src.data, acl_context); - aclMat aclmat_dest1; - aclMat aclmat_dest2; - aclMat aclmat_dest3; + aclMat aclmat_src(val, val, srcType[i], mat_src.data, acl_context); + aclMat aclmat_dest1; + aclMat aclmat_dest2; + aclMat aclmat_dest3; - vector dest; - dest.emplace_back(mat_dest1); - dest.emplace_back(mat_dest2); - dest.emplace_back(mat_dest3); + vector dest; + dest.emplace_back(mat_dest1); + dest.emplace_back(mat_dest2); + dest.emplace_back(mat_dest3); - vector acl_dest; - acl_dest.emplace_back(aclmat_dest1); - acl_dest.emplace_back(aclmat_dest2); - acl_dest.emplace_back(aclmat_dest3); + vector acl_dest; + acl_dest.emplace_back(aclmat_dest1); + acl_dest.emplace_back(aclmat_dest2); + acl_dest.emplace_back(aclmat_dest3); - begin = static_cast(getTickCount()); - while (n--) - split(mat_src, dest); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) split(mat_src, dest); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - split(aclmat_src, acl_dest); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - split(aclmat_src, acl_dest, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + n = (cycle_index - 1); + split(aclmat_src, acl_dest); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) split(aclmat_src, acl_dest, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - (acl_dest.data())[0].download(mat_dest1); - (acl_dest.data())[1].download(mat_dest2); - (acl_dest.data())[2].download(mat_dest3); + (acl_dest.data())[0].download(mat_dest1); + (acl_dest.data())[1].download(mat_dest2); + (acl_dest.data())[2].download(mat_dest3); - bool ret = test.Test_Diff((dest.data())[0], mat_dest1); - ret &= test.Test_Diff((dest.data())[1], mat_dest2); - ret &= test.Test_Diff((dest.data())[2], mat_dest3); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - - } + bool ret = test.Test_Diff((dest.data())[0], mat_dest1); + ret &= test.Test_Diff((dest.data())[1], mat_dest2); + ret &= test.Test_Diff((dest.data())[2], mat_dest3); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } - + } } -void PERF_TEST::Test_Flip(aclCxt *acl_context) -{ - int val, n; - int valmax = 8192; - int cycle_index = 100; - double begin, end, time, acltime; - Common_Test test; +void PERF_TEST::Test_Flip(aclCxt *acl_context) { + int val, n; + int valmax = 8192; + int cycle_index = 100; + double begin, end, time, acltime; + Common_Test test; - vector type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1}; - for (size_t i = 0; i < type.size(); ++i) - { - test.PrintLog("Perf test : Function: flip()", type[i]); - for (val = 8; val <= valmax; val *= 2) - { - n = cycle_index; - Mat mat_src(val, val, type[i]); - Mat mat_dest(val, val, type[i]); - Mat mat_dest1(val, val, type[i]); + vector type{CV_8UC1, CV_32FC1, CV_32SC1, CV_64FC1}; + for (size_t i = 0; i < type.size(); ++i) { + test.PrintLog("Perf test : Function: flip()", type[i]); + for (val = 8; val <= valmax; val *= 2) { + n = cycle_index; + Mat mat_src(val, val, type[i]); + Mat mat_dest(val, val, type[i]); + Mat mat_dest1(val, val, type[i]); - test.SetDataRange(mat_src, 32); + test.SetDataRange(mat_src, 32); - aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); - aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); + aclMat aclmat_src(val, val, type[i], mat_src.data, acl_context); + aclMat aclmat_dest(val, val, type[i], mat_dest.data, acl_context); - begin = static_cast(getTickCount()); - while (n--) - flip(mat_src, mat_dest, 0); - end = static_cast(getTickCount()); - time = (end - begin) / getTickFrequency() / cycle_index; + begin = static_cast(getTickCount()); + while (n--) flip(mat_src, mat_dest, 0); + end = static_cast(getTickCount()); + time = (end - begin) / getTickFrequency() / cycle_index; - n = (cycle_index - 1); - flip(aclmat_src, aclmat_dest, 0); - wait_stream(acl_context); - begin = static_cast(getTickCount()); - while (n--) - flip(aclmat_src, aclmat_dest, 0, 1); - wait_stream(acl_context, 1); - end = static_cast(getTickCount()); - acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); - - aclmat_dest.download(mat_dest1); - bool ret = test.Test_Diff(mat_dest, mat_dest1); - ASSERT_TRUE(ret); - if (val < 128) - cout << "Shape: " << val << " x " << val << "\t\t"; - else - cout << "Shape: " << val << " x " << val << "\t"; - cout << "CpuTimes: " << time << "\tAclTimes: " << acltime << "\tRate: " << time / acltime << endl; - } + n = (cycle_index - 1); + flip(aclmat_src, aclmat_dest, 0); + wait_stream(acl_context); + begin = static_cast(getTickCount()); + while (n--) flip(aclmat_src, aclmat_dest, 0, 1); + wait_stream(acl_context, 1); + end = static_cast(getTickCount()); + acltime = (end - begin) / getTickFrequency() / (cycle_index - 1); + + aclmat_dest.download(mat_dest1); + bool ret = test.Test_Diff(mat_dest, mat_dest1); + ASSERT_TRUE(ret); + if (val < 128) + cout << "Shape: " << val << " x " << val << "\t\t"; + else + cout << "Shape: " << val << " x " << val << "\t"; + cout << "CpuTimes: " << time << "\tAclTimes: " << acltime + << "\tRate: " << time / acltime << endl; } + } } \ No newline at end of file diff --git a/acl/test/test_perf.hpp b/acl/test/test_perf.hpp index 4c47b11..db49144 100644 --- a/acl/test/test_perf.hpp +++ b/acl/test/test_perf.hpp @@ -3,31 +3,30 @@ #include "test_precomp.hpp" -class PERF_TEST -{ -public: - CV_EXPORTS void Test_operator_add_perf(aclCxt *acl_context); - CV_EXPORTS void Test_operator_sub_perf(aclCxt *acl_context); - CV_EXPORTS void Test_operator_div_perf(aclCxt *acl_context); - CV_EXPORTS void Test_operator_mul_perf(aclCxt *acl_context); - CV_EXPORTS void Test_Abs(aclCxt *acl_context); - CV_EXPORTS void Test_Pow(aclCxt *acl_context); - CV_EXPORTS void Test_Sqrt(aclCxt *acl_context); - CV_EXPORTS void Test_Add(aclCxt *acl_context); - CV_EXPORTS void Test_Divide(aclCxt *acl_context); - CV_EXPORTS void Test_Exp(aclCxt *acl_context); - CV_EXPORTS void Test_Log(aclCxt *acl_context); - CV_EXPORTS void Test_Max(aclCxt *acl_context); - CV_EXPORTS void Test_Min(aclCxt *acl_context); +class PERF_TEST { + public: + CV_EXPORTS void Test_operator_add_perf(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_operator_sub_perf(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_operator_div_perf(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_operator_mul_perf(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Abs(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Pow(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Sqrt(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Add(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Divide(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Exp(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Log(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Max(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Min(cv::acl::aclCxt *acl_context); - CV_EXPORTS void Test_MatMul(aclCxt *acl_context); - CV_EXPORTS void Test_Convolution(aclCxt *acl_context); + CV_EXPORTS void Test_MatMul(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Convolution(cv::acl::aclCxt *acl_context); - CV_EXPORTS void Test_Lookuptable(aclCxt *acl_context); - CV_EXPORTS void Test_Merge(aclCxt *acl_context); - CV_EXPORTS void Test_Split(aclCxt *acl_context); - CV_EXPORTS void Test_Transpose(aclCxt *acl_context); - CV_EXPORTS void Test_Flip(aclCxt *acl_context); + CV_EXPORTS void Test_Lookuptable(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Merge(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Split(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Transpose(cv::acl::aclCxt *acl_context); + CV_EXPORTS void Test_Flip(cv::acl::aclCxt *acl_context); }; #endif \ No newline at end of file diff --git a/acl/test/test_precomp.hpp b/acl/test/test_precomp.hpp index 7dc74f3..09256ed 100644 --- a/acl/test/test_precomp.hpp +++ b/acl/test/test_precomp.hpp @@ -1,27 +1,21 @@ // This file is part of OpenCV project. -// It is subject to the license terms in the LICENSE file found in the top-level directory -// of this distribution and at http://opencv.org/license.html. +// It is subject to the license terms in the LICENSE file found in the top-level +// directory of this distribution and at http://opencv.org/license.html. #ifndef __OPENCV_TEST_PRECOMP_HPP__ #define __OPENCV_TEST_PRECOMP_HPP__ +#include #include #include #include -#include -#include "opencv2/core.hpp" -#include "opencv2/ts.hpp" -#include "opencv2/imgproc.hpp" -#include "opencv2/highgui.hpp" -#include "opencv2/videoio.hpp" -#include "sys/time.h" -#include "opencv2/acl/acl.hpp" #include "acl/acl.h" #include "acl/acl_op_compiler.h" - -using namespace cv; -using namespace cv::acl; -using namespace cvtest; -using namespace testing; -using namespace std; +#include "opencv2/acl/acl.hpp" +#include "opencv2/core.hpp" +#include "opencv2/highgui.hpp" +#include "opencv2/imgproc.hpp" +#include "opencv2/ts.hpp" +#include "opencv2/videoio.hpp" +#include "sys/time.h" #endif