/* * Copyright 1993-2006 NVIDIA Corporation. All rights reserved. * * NOTICE TO USER: * * This source code is subject to NVIDIA ownership rights under U.S. and * international Copyright laws. * * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE * CODE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR * IMPLIED WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. * IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE * OR PERFORMANCE OF THIS SOURCE CODE. * * U.S. Government End Users. This source code is a "commercial item" as * that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of * "commercial computer software" and "commercial computer software * documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) * and is provided to the U.S. Government only as a commercial end item. * Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through * 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the * source code with only those rights set forth herein. */ /* CUda UTility Library */ #ifndef _CUTIL_H_ #define _CUTIL_H_ #include #ifdef _WIN32 # pragma warning( disable : 4996 ) // disable deprecated warning #endif #ifdef __cplusplus extern "C" { #endif // helper typedefs for building DLL #ifdef _WIN32 # ifdef BUILD_DLL # define DLL_MAPPING __declspec(dllexport) # else # define DLL_MAPPING __declspec(dllimport) # endif #else # define DLL_MAPPING #endif #ifdef _WIN32 #define CUTIL_API __stdcall #else #define CUTIL_API #endif //////////////////////////////////////////////////////////////////////////// //! CUT bool type //////////////////////////////////////////////////////////////////////////// enum CUTBoolean { CUTFalse = 0, CUTTrue = 1 }; //////////////////////////////////////////////////////////////////////////// //! Deallocate memory allocated within Cutil //! @param pointer to memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING void CUTIL_API cutFree( void* ptr); //////////////////////////////////////////////////////////////////////////// //! Helper for bank conflict checking (should only be used with the //! CUT_BANK_CHECKER macro) //! @param tidx thread id in x dimension of block //! @param tidy thread id in y dimension of block //! @param tidz thread id in z dimension of block //! @param bdimx block size in x dimension //! @param bdimy block size in y dimension //! @param bdimz block size in z dimension //! @param file name of the source file where the access takes place //! @param line line in the source file where the access takes place //! @param aname name of the array which is accessed //! @param index index into the array //////////////////////////////////////////////////////////////////////////// DLL_MAPPING void CUTIL_API cutCheckBankAccess( unsigned int tidx, unsigned int tidy, unsigned int tidz, unsigned int bdimx, unsigned int bdimy, unsigned int bdimz, const char* file, const int line, const char* aname, const int index); //////////////////////////////////////////////////////////////////////////// //! Find the path for a filename within a hardcoded set of paths //! @return the path if succeeded, otherwise 0 //! @param filename name of the file //! @param executablePath optional absolute path of the executable //////////////////////////////////////////////////////////////////////////// DLL_MAPPING char* CUTIL_API cutFindFilePath(const char* filename, const char* executablePath); //////////////////////////////////////////////////////////////////////////// //! Find the path for a filename within a specified directory tree //! @return the path if succeeded, otherwise 0 //! @param filename name of the file //! @param executablePath optional absolute path of the executable //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutFindFile(char * outputPath, const char * startDir, const char * dirName); //////////////////////////////////////////////////////////////////////////// //! Find the path for a filename within a specified directory tree //! @return the path if succeeded, otherwise 0 //! @param filename name of the file //! @param executablePath optional absolute path of the executable //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutFindDir(char * outputPath, const char * startDir, const char * dirName); //////////////////////////////////////////////////////////////////////////// //! Read file \filename containing single precision floating point data //! @return CUTTrue if reading the file succeeded, otherwise false //! @param filename name of the source file //! @param data uninitialized pointer, returned initialized and pointing to //! the data read //! @param len number of data elements in data, -1 on error //! @note If a NULL pointer is passed to this function and it is //! initialized within Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutReadFilef( const char* filename, float** data, unsigned int* len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Read file \filename containing double precision floating point data //! @return CUTTrue if reading the file succeeded, otherwise false //! @param filename name of the source file //! @param data uninitialized pointer, returned initialized and pointing to //! the data read //! @param len number of data elements in data, -1 on error //! @note If a NULL pointer is passed to this function and it is //! initialized within Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutReadFiled( const char* filename, double** data, unsigned int* len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Read file \filename containing integer data //! @return CUTTrue if reading the file succeeded, otherwise false //! @param filename name of the source file //! @param data uninitialized pointer, returned initialized and pointing to //! the data read //! @param len number of data elements in data, -1 on error //! @note If a NULL pointer is passed to this function and it is //! initialized within Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutReadFilei( const char* filename, int** data, unsigned int* len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Read file \filename containing unsigned integer data //! @return CUTTrue if reading the file succeeded, otherwise false //! @param filename name of the source file //! @param data uninitialized pointer, returned initialized and pointing to //! the data read //! @param len number of data elements in data, -1 on error //! @note If a NULL pointer is passed to this function and it is //! initialized within Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutReadFileui( const char* filename, unsigned int** data, unsigned int* len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Read file \filename containing char / byte data //! @return CUTTrue if reading the file succeeded, otherwise false //! @param filename name of the source file //! @param data uninitialized pointer, returned initialized and pointing to //! the data read //! @param len number of data elements in data, -1 on error //! @note If a NULL pointer is passed to this function and it is //! initialized within Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutReadFileb( const char* filename, char** data, unsigned int* len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Read file \filename containing unsigned char / byte data //! @return CUTTrue if reading the file succeeded, otherwise false //! @param filename name of the source file //! @param data uninitialized pointer, returned initialized and pointing to //! the data read //! @param len number of data elements in data, -1 on error //! @note If a NULL pointer is passed to this function and it is //! initialized within Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutReadFileub( const char* filename, unsigned char** data, unsigned int* len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Write a data file \filename containing single precision floating point //! data //! @return CUTTrue if writing the file succeeded, otherwise false //! @param filename name of the file to write //! @param data pointer to data to write //! @param len number of data elements in data, -1 on error //! @param epsilon epsilon for comparison //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutWriteFilef( const char* filename, const float* data, unsigned int len, const float epsilon, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Write a data file \filename containing double precision floating point //! data //! @return CUTTrue if writing the file succeeded, otherwise false //! @param filename name of the file to write //! @param data pointer to data to write //! @param len number of data elements in data, -1 on error //! @param epsilon epsilon for comparison //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutWriteFiled( const char* filename, const float* data, unsigned int len, const double epsilon, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Write a data file \filename containing integer data //! @return CUTTrue if writing the file succeeded, otherwise false //! @param filename name of the file to write //! @param data pointer to data to write //! @param len number of data elements in data, -1 on error //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutWriteFilei( const char* filename, const int* data, unsigned int len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Write a data file \filename containing unsigned integer data //! @return CUTTrue if writing the file succeeded, otherwise false //! @param filename name of the file to write //! @param data pointer to data to write //! @param len number of data elements in data, -1 on error //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutWriteFileui( const char* filename,const unsigned int* data, unsigned int len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Write a data file \filename containing char / byte data //! @return CUTTrue if writing the file succeeded, otherwise false //! @param filename name of the file to write //! @param data pointer to data to write //! @param len number of data elements in data, -1 on error //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutWriteFileb( const char* filename, const char* data, unsigned int len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Write a data file \filename containing unsigned char / byte data //! @return CUTTrue if writing the file succeeded, otherwise false //! @param filename name of the file to write //! @param data pointer to data to write //! @param len number of data elements in data, -1 on error //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutWriteFileub( const char* filename,const unsigned char* data, unsigned int len, bool verbose = false); //////////////////////////////////////////////////////////////////////////// //! Load PGM image file (with unsigned char as data element type) //! @return CUTTrue if reading the file succeeded, otherwise false //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //! @note If a NULL pointer is passed to this function and it is //! initialized within Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutLoadPGMub( const char* file, unsigned char** data, unsigned int *w,unsigned int *h); //////////////////////////////////////////////////////////////////////////// //! Load PPM image file (with unsigned char as data element type) //! @return CUTTrue if reading the file succeeded, otherwise false //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutLoadPPMub( const char* file, unsigned char** data, unsigned int *w,unsigned int *h); //////////////////////////////////////////////////////////////////////////// //! Load PPM image file (with unsigned char as data element type), padding //! 4th component //! @return CUTTrue if reading the file succeeded, otherwise false //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutLoadPPM4ub( const char* file, unsigned char** data, unsigned int *w,unsigned int *h); //////////////////////////////////////////////////////////////////////////// //! Load PGM image file (with unsigned int as data element type) //! @return CUTTrue if reading the file succeeded, otherwise false //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //! @note If a NULL pointer is passed to this function and it is //! initialized within Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutLoadPGMi( const char* file, unsigned int** data, unsigned int* w, unsigned int* h); //////////////////////////////////////////////////////////////////////////// //! Load PGM image file (with unsigned short as data element type) //! @return CUTTrue if reading the file succeeded, otherwise false //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //! @note If a NULL pointer is passed to this function and it is //! initialized withing Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutLoadPGMs( const char* file, unsigned short** data, unsigned int* w, unsigned int* h); //////////////////////////////////////////////////////////////////////////// //! Load PGM image file (with float as data element type) //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //! @note If a NULL pointer is passed to this function and it is //! initialized withing Cutil then cutFree() has to be used to //! deallocate the memory //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutLoadPGMf( const char* file, float** data, unsigned int* w, unsigned int* h); //////////////////////////////////////////////////////////////////////////// //! Save PGM image file (with unsigned char as data element type) //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutSavePGMub( const char* file, unsigned char* data, unsigned int w, unsigned int h); //////////////////////////////////////////////////////////////////////////// //! Save PPM image file (with unsigned char as data element type) //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutSavePPMub( const char* file, unsigned char *data, unsigned int w, unsigned int h); //////////////////////////////////////////////////////////////////////////// //! Save PPM image file (with unsigned char as data element type, padded to //! 4 bytes) //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutSavePPM4ub( const char* file, unsigned char *data, unsigned int w, unsigned int h); //////////////////////////////////////////////////////////////////////////// //! Save PGM image file (with unsigned int as data element type) //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutSavePGMi( const char* file, unsigned int* data, unsigned int w, unsigned int h); //////////////////////////////////////////////////////////////////////////// //! Save PGM image file (with unsigned short as data element type) //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutSavePGMs( const char* file, unsigned short* data, unsigned int w, unsigned int h); //////////////////////////////////////////////////////////////////////////// //! Save PGM image file (with float as data element type) //! @param file name of the image file //! @param data handle to the data read //! @param w width of the image //! @param h height of the image //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutSavePGMf( const char* file, float* data, unsigned int w, unsigned int h); //////////////////////////////////////////////////////////////////////////// // Command line arguments: General notes // * All command line arguments begin with '--' followed by the token; // token and value are seperated by '='; example --samples=50 // * Arrays have the form --model=[one.obj,two.obj,three.obj] // (without whitespaces) //////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// //! Check if command line argument \a flag-name is given //! @return CUTTrue if command line argument \a flag_name has been given, //! otherwise 0 //! @param argc argc as passed to main() //! @param argv argv as passed to main() //! @param flag_name name of command line flag //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutCheckCmdLineFlag( const int argc, const char** argv, const char* flag_name); //////////////////////////////////////////////////////////////////////////// //! Get the value of a command line argument of type int //! @return CUTTrue if command line argument \a arg_name has been given and //! is of the requested type, otherwise CUTFalse //! @param argc argc as passed to main() //! @param argv argv as passed to main() //! @param arg_name name of the command line argument //! @param val value of the command line argument //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutGetCmdLineArgumenti( const int argc, const char** argv, const char* arg_name, int* val); //////////////////////////////////////////////////////////////////////////// //! Get the value of a command line argument of type float //! @return CUTTrue if command line argument \a arg_name has been given and //! is of the requested type, otherwise CUTFalse //! @param argc argc as passed to main() //! @param argv argv as passed to main() //! @param arg_name name of the command line argument //! @param val value of the command line argument //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutGetCmdLineArgumentf( const int argc, const char** argv, const char* arg_name, float* val); //////////////////////////////////////////////////////////////////////////// //! Get the value of a command line argument of type string //! @return CUTTrue if command line argument \a arg_name has been given and //! is of the requested type, otherwise CUTFalse //! @param argc argc as passed to main() //! @param argv argv as passed to main() //! @param arg_name name of the command line argument //! @param val value of the command line argument //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutGetCmdLineArgumentstr( const int argc, const char** argv, const char* arg_name, char** val); //////////////////////////////////////////////////////////////////////////// //! Get the value of a command line argument list those element are strings //! @return CUTTrue if command line argument \a arg_name has been given and //! is of the requested type, otherwise CUTFalse //! @param argc argc as passed to main() //! @param argv argv as passed to main() //! @param arg_name name of the command line argument //! @param val command line argument list //! @param len length of the list / number of elements //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutGetCmdLineArgumentListstr( const int argc, const char** argv, const char* arg_name, char** val, unsigned int* len); //////////////////////////////////////////////////////////////////////////// //! Extended assert //! @return CUTTrue if the condition \a val holds, otherwise CUTFalse //! @param val condition to test //! @param file __FILE__ macro //! @param line __LINE__ macro //! @note This function should be used via the CONDITION(val) macro //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutCheckCondition( int val, const char* file, const int line); //////////////////////////////////////////////////////////////////////////// //! Compare two float arrays //! @return CUTTrue if \a reference and \a data are identical, //! otherwise CUTFalse //! @param reference handle to the reference data / gold image //! @param data handle to the computed data //! @param len number of elements in reference and data //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutComparef( const float* reference, const float* data, const unsigned int len); //////////////////////////////////////////////////////////////////////////// //! Compare two integer arrays //! @return CUTTrue if \a reference and \a data are identical, //! otherwise CUTFalse //! @param reference handle to the reference data / gold image //! @param data handle to the computed data //! @param len number of elements in reference and data //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutComparei( const int* reference, const int* data, const unsigned int len ); //////////////////////////////////////////////////////////////////////////// //! Compare two unsigned char arrays //! @return CUTTrue if \a reference and \a data are identical, //! otherwise CUTFalse //! @param reference handle to the reference data / gold image //! @param data handle to the computed data //! @param len number of elements in reference and data //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutCompareub( const unsigned char* reference, const unsigned char* data, const unsigned int len ); //////////////////////////////////////////////////////////////////////////////// //! Compare two integer arrays witha n epsilon tolerance for equality //! @return CUTTrue if \a reference and \a data are identical, //! otherwise CUTFalse //! @param reference handle to the reference data / gold image //! @param data handle to the computed data //! @param len number of elements in reference and data //! @param epsilon epsilon to use for the comparison //////////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutCompareube( const unsigned char* reference, const unsigned char* data, const unsigned int len, const int epsilon ); //////////////////////////////////////////////////////////////////////////// //! Compare two float arrays with an epsilon tolerance for equality //! @return CUTTrue if \a reference and \a data are identical, //! otherwise CUTFalse //! @param reference handle to the reference data / gold image //! @param data handle to the computed data //! @param len number of elements in reference and data //! @param epsilon epsilon to use for the comparison //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutComparefe( const float* reference, const float* data, const unsigned int len, const float epsilon ); //////////////////////////////////////////////////////////////////////////// //! Compare two float arrays using L2-norm with an epsilon tolerance for //! equality //! @return CUTTrue if \a reference and \a data are identical, //! otherwise CUTFalse //! @param reference handle to the reference data / gold image //! @param data handle to the computed data //! @param len number of elements in reference and data //! @param epsilon epsilon to use for the comparison //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutCompareL2fe( const float* reference, const float* data, const unsigned int len, const float epsilon ); //////////////////////////////////////////////////////////////////////////// //! Timer functionality //////////////////////////////////////////////////////////////////////////// //! Create a new timer //! @return CUTTrue if a time has been created, otherwise false //! @param name of the new timer, 0 if the creation failed //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutCreateTimer( unsigned int* name); //////////////////////////////////////////////////////////////////////////// //! Delete a timer //! @return CUTTrue if a time has been deleted, otherwise false //! @param name of the timer to delete //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutDeleteTimer( unsigned int name); //////////////////////////////////////////////////////////////////////////// //! Start the time with name \a name //! @param name name of the timer to start //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutStartTimer( const unsigned int name); //////////////////////////////////////////////////////////////////////////// //! Stop the time with name \a name. Does not reset. //! @param name name of the timer to stop //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutStopTimer( const unsigned int name); //////////////////////////////////////////////////////////////////////////// //! Resets the timer's counter. //! @param name name of the timer to reset. //////////////////////////////////////////////////////////////////////////// DLL_MAPPING CUTBoolean CUTIL_API cutResetTimer( const unsigned int name); //////////////////////////////////////////////////////////////////////////// //! Returns total execution time in milliseconds for the timer over all //! runs since the last reset or timer creation. //! @param name name of the timer to return the time of //////////////////////////////////////////////////////////////////////////// DLL_MAPPING float CUTIL_API cutGetTimerValue( const unsigned int name); //////////////////////////////////////////////////////////////////////////// //! Return the average time in milliseconds for timer execution as the //! total time for the timer dividied by the number of completed (stopped) //! runs the timer has made. //! Excludes the current running time if the timer is currently running. //! @param name name of the timer to return the time of //////////////////////////////////////////////////////////////////////////// DLL_MAPPING float CUTIL_API cutGetAverageTimerValue( const unsigned int name); //////////////////////////////////////////////////////////////////////////// //! Macros #ifdef _DEBUG #if __DEVICE_EMULATION__ // Interface for bank conflict checker #define CUT_BANK_CHECKER( array, index) \ (cutCheckBankAccess( threadIdx.x, threadIdx.y, threadIdx.z, blockDim.x, \ blockDim.y, blockDim.z, \ __FILE__, __LINE__, #array, index ), \ array[index]) #else #define CUT_BANK_CHECKER( array, index) array[index] #endif # define CU_SAFE_CALL_NO_SYNC( call ) do { \ CUresult err = call; \ if( CUDA_SUCCESS != err) { \ fprintf(stderr, "Cuda driver error %x in file '%s' in line %i.\n", \ err, __FILE__, __LINE__ ); \ exit(EXIT_FAILURE); \ } } while (0) # define CU_SAFE_CALL( call ) do { \ CU_SAFE_CALL_NO_SYNC(call); \ CUresult err = cuCtxSynchronize(); \ if( CUDA_SUCCESS != err) { \ fprintf(stderr, "Cuda driver error %x in file '%s' in line %i.\n", \ err, __FILE__, __LINE__ ); \ exit(EXIT_FAILURE); \ } } while (0) # define CUDA_SAFE_CALL_NO_SYNC( call) do { \ cudaError err = call; \ if( cudaSuccess != err) { \ fprintf(stderr, "Cuda error in file '%s' in line %i : %s.\n", \ __FILE__, __LINE__, cudaGetErrorString( err) ); \ exit(EXIT_FAILURE); \ } } while (0) # define CUDA_SAFE_CALL( call) do { \ CUDA_SAFE_CALL_NO_SYNC(call); \ cudaError err = cudaThreadSynchronize(); \ if( cudaSuccess != err) { \ fprintf(stderr, "Cuda error in file '%s' in line %i : %s.\n", \ __FILE__, __LINE__, cudaGetErrorString( err) ); \ exit(EXIT_FAILURE); \ } } while (0) # define CUFFT_SAFE_CALL( call) do { \ cufftResult err = call; \ if( CUFFT_SUCCESS != err) { \ fprintf(stderr, "CUFFT error in file '%s' in line %i.\n", \ __FILE__, __LINE__); \ exit(EXIT_FAILURE); \ } } while (0) # define CUT_SAFE_CALL( call) \ if( CUTTrue != call) { \ fprintf(stderr, "Cut error in file '%s' in line %i.\n", \ __FILE__, __LINE__); \ exit(EXIT_FAILURE); \ } //! Check for CUDA error # define CUT_CHECK_ERROR(errorMessage) do { \ cudaError_t err = cudaGetLastError(); \ if( cudaSuccess != err) { \ fprintf(stderr, "Cuda error: %s in file '%s' in line %i : %s.\n", \ errorMessage, __FILE__, __LINE__, cudaGetErrorString( err) );\ exit(EXIT_FAILURE); \ } \ err = cudaThreadSynchronize(); \ if( cudaSuccess != err) { \ fprintf(stderr, "Cuda error: %s in file '%s' in line %i : %s.\n", \ errorMessage, __FILE__, __LINE__, cudaGetErrorString( err) );\ exit(EXIT_FAILURE); \ } } while (0) //! Check for malloc error # define CUT_SAFE_MALLOC( mallocCall ) do{ \ if( !(mallocCall)) { \ fprintf(stderr, "Host malloc failure in file '%s' in line %i\n", \ __FILE__, __LINE__); \ exit(EXIT_FAILURE); \ } } while(0); //! Check if conditon is true (flexible assert) # define CUT_CONDITION( val) \ if( CUTFalse == cutCheckCondition( val, __FILE__, __LINE__)) { \ exit(EXIT_FAILURE); \ } #else // not DEBUG #define CUT_BANK_CHECKER( array, index) array[index] // void macros for performance reasons # define CUT_CHECK_ERROR(errorMessage) # define CUT_CHECK_ERROR_GL() # define CUT_CONDITION( val) # define CU_SAFE_CALL_NO_SYNC( call) call # define CU_SAFE_CALL( call) call # define CUDA_SAFE_CALL_NO_SYNC( call) call # define CUDA_SAFE_CALL( call) call # define CUT_SAFE_CALL( call) call # define CUFFT_SAFE_CALL( call) call # define CUT_SAFE_MALLOC( mallocCall ) mallocCall #endif #if __DEVICE_EMULATION__ # define CUT_DEVICE_INIT(ARGC, ARGV) #else # define CUT_DEVICE_INIT(ARGC, ARGV) { \ int deviceCount; \ CUDA_SAFE_CALL_NO_SYNC(cudaGetDeviceCount(&deviceCount)); \ if (deviceCount == 0) { \ fprintf(stderr, "cutil error: no devices supporting CUDA.\n"); \ exit(EXIT_FAILURE); \ } \ int dev = 0; \ cutGetCmdLineArgumenti(ARGC, (const char **) ARGV, "device", &dev); \ if (dev > deviceCount-1) dev = deviceCount - 1; \ cudaDeviceProp deviceProp; \ CUDA_SAFE_CALL_NO_SYNC(cudaGetDeviceProperties(&deviceProp, dev)); \ if (deviceProp.major < 1) { \ fprintf(stderr, "cutil error: device does not support CUDA.\n"); \ exit(EXIT_FAILURE); \ } \ if (cutCheckCmdLineFlag(ARGC, (const char **) ARGV, "quiet") == CUTFalse) \ fprintf(stderr, "Using device %d: %s\n", dev, deviceProp.name); \ CUDA_SAFE_CALL(cudaSetDevice(dev)); \ } #endif # define CUT_DEVICE_INIT_DRV(cuDevice, ARGC, ARGV) { \ cuDevice = 0; \ int deviceCount = 0; \ CUresult err = cuInit(0); \ if (CUDA_SUCCESS == err) \ CU_SAFE_CALL_NO_SYNC(cuDeviceGetCount(&deviceCount)); \ if (deviceCount == 0) { \ fprintf(stderr, "cutil error: no devices supporting CUDA\n"); \ exit(EXIT_FAILURE); \ } \ int dev = 0; \ cutGetCmdLineArgumenti(ARGC, (const char **) ARGV, "device", &dev); \ if (dev > deviceCount-1) dev = deviceCount - 1; \ CU_SAFE_CALL_NO_SYNC(cuDeviceGet(&cuDevice, dev)); \ char name[100]; \ cuDeviceGetName(name, 100, cuDevice); \ if (cutCheckCmdLineFlag(ARGC, (const char **) ARGV, "quiet") == CUTFalse) \ fprintf(stderr, "Using device %d: %s\n", dev, name); \ } #define CUT_EXIT(argc, argv) \ if (!cutCheckCmdLineFlag(argc, (const char**)argv, "noprompt")) { \ printf("\nPress ENTER to exit...\n"); \ fflush( stdout); \ fflush( stderr); \ getchar(); \ } \ exit(EXIT_SUCCESS); #ifdef __cplusplus } #endif // #ifdef _DEBUG (else branch) #endif // #ifndef _CUTIL_H_