是否可以在编译时检查包含枚举的语句

Question

I am writing a "error-check" function whose only task is to check single if statement. This function is overloaded for 7 different error types, but first let me present my code:

ErrorCheck.h: (whole file)

#pragma once
#ifndef __ERROR_CHECK_H__
#define __ERROR_CHECK_H__
// Header does not #include <***> anything. For obvious reasons.

// The function:
template <typename T>
bool errchk(const T check, const char* file, unsigned int line, const char* from, const char* func);

// How To call it:
#define ERRCHK(_check) \
    errchk(_check, __FILE__, __LINE__, __FUNC__, #_check)

#endif // !__ERROR_CHECK_H__

ErrorCheck.cpp: (simplified version)

// Include:
#include <cuda.h>
#include <cuda_runtime_api.h>
#include <cufft.h>
#include <cublas.h>
#include <curand_kernel.h>
#include <cusolver_common.h>
#include "cusparse.h"
#include "ErrorCheck.h"

// Functions bellow are overloaded 7 times for every error type from headers included above
const char * getErrorName(const Type & error) { /* ... */ };
const char * getErrorString(const Type & error) { /* ... */ };

// The function:
template <typename T, T successValue>
bool errchk(const T check, const char* file, unsigned int line, const char* from, const char* func)
{
    if (check != successValue) {
        // Report Error
        return true; // Error was found.
    }
    return false; // No error.
}

// Instantiations:
template bool errchk <bool            > (const bool             check, const char * file, unsigned int line, const char * from, const char * func);
template bool errchk <cudaError_t     > (const cudaError_t      check, const char * file, unsigned int line, const char * from, const char * func);
template bool errchk <cufftResult_t   > (const cufftResult_t    check, const char * file, unsigned int line, const char * from, const char * func);
template bool errchk <cublasStatus_t  > (const cublasStatus_t   check, const char * file, unsigned int line, const char * from, const char * func);
template bool errchk <curandStatus_t  > (const curandStatus_t   check, const char * file, unsigned int line, const char * from, const char * func);
template bool errchk <cusolverStatus_t> (const cusolverStatus_t check, const char * file, unsigned int line, const char * from, const char * func);
template bool errchk <cusparseStatus_t> (const cusparseStatus_t check, const char * file, unsigned int line, const char * from, const char * func);

Question: #1
Is it possible to optimize if statement inside bool errchk <***> (***)
I know that this function is meant to be called at run time, but if we give it a second thought, we will see that we are comparing two enums. And therefore meaby could we force compiler to check every possible outcome of if statement, and then just run the right one at run-time?

Question: #2
Does it even need to be optimized??
With the #include <chrono> lib I have calculated that this code will take up to 40 nanoseconds when "success" value is detected. And up to 400 milliseconds when "error" value is detected.

Answer 1

Is it possible to optimize if statement inside bool errchk <***> (***) ?

It is possible for the compiler in some cases, but not for you. You're writing a function that cannot make compile-time assumptions regarding the value of check . The compiler, however, might notice that you call, say errchk(cudaSuccess, whatever, etc, etc) ; and it can choose to inline the function, in which case it can notice the if (check != successValue) is always true, and simply optimize away the entire call.

Does it even need to be optimized??

Probably not. If you have this code in a performance-critical tight loop, you should just take it out of the loop; and if you have it elsewhere, 40 ns are not such a big deal. But - you need to profile your code to know what you should be optimizing. Don't waste your time optimizing things that take up just a small fraction of the execution time.

Speaking of profiling, CUDA offers a profiling facility which can also be used for host-side code. You could also consider using it via my C++ish wrappers for the CUDA Runtime API ( here are the profiling-specific API wrappers).

---

PS: In my opinion, you should probably not be writing an errchk function at all. You're working with C++, remember? Instead of this awful inbreeding of macros and templates - use exceptions ; and you'll no longer have to remember to check the return value after every call. Exceptions will also let you distinguish types of errors by their class; to nest errors within errors; to express error information using more than just a single number etc.