Accelerate utest.

For some test cases which include more than one kernel, the current
implementation always build the program for a new sub test case.

That wastes a lot of time. This patch introduce a new macro
MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM which has an extra parameter
to specify whether to keep the previous program and avoid the extra
build. The normal usage is:

MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(fn1, true);
MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(fn2, true);
MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(fn3, true);
MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(fn4, true);
MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(fn5, false);

The scenario is that the above fn1-5 are included in the same kernel
file and we define the sub cases in the same cpp file. We already
have some examples of this usage in the compiler_abs.cpp, compiler_abs_diff.cpp
compiler_basic_arithmetic.cpp, compiler_vector_load_store.cpp, etc.

This patch reduces 2/3 of the utests execution time.

v2: should always destroy the program when run one specific test case.

Signed-off-by: Zhigang Gong <zhigang.gong@intel.com>
Reviewed-by: "Song, Ruiling" <ruiling.song@intel.com>

13 files changed, 127 insertions, 88 deletions

diff --git a/utests/compiler_abs.cpp b/utests/compiler_abs.cpp
index 9457b9bd..3f477a80 100644
--- a/utests/compiler_abs.cpp
+++ b/utests/compiler_abs.cpp
@@ -166,13 +166,16 @@ template <typename T, typename U> static void compiler_abs_with_type(void)
     }
 }
 
-#define ABS_TEST_TYPE(TYPE, UTYPE) \
+#define ABS_TEST_TYPE_1(TYPE, UTYPE, KEEP_PROGRAM) \
 	static void compiler_abs_##TYPE (void) \
         { \
            OCL_CALL (cl_kernel_init, "compiler_abs.cl", "compiler_abs_"#TYPE, SOURCE, NULL);  \
            compiler_abs_with_type<TYPE, UTYPE>(); \
         } \
-	MAKE_UTEST_FROM_FUNCTION(compiler_abs_##TYPE);
+	MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_abs_##TYPE, KEEP_PROGRAM);
+
+#define ABS_TEST_TYPE(TYPE, UTYPE) ABS_TEST_TYPE_1(TYPE, UTYPE, true)
+#define ABS_TEST_TYPE_END(TYPE, UTYPE) ABS_TEST_TYPE_1(TYPE, UTYPE, false)
 
 typedef unsigned char uchar;
 typedef unsigned short ushort;
@@ -248,4 +251,4 @@ ABS_TEST_TYPE(ushort2, ushort2)
 ABS_TEST_TYPE(ushort3, ushort3)
 ABS_TEST_TYPE(ushort4, ushort4)
 ABS_TEST_TYPE(ushort8, ushort8)
-ABS_TEST_TYPE(ushort16, ushort16)
+ABS_TEST_TYPE_END(ushort16, ushort16)
diff --git a/utests/compiler_abs_diff.cpp b/utests/compiler_abs_diff.cpp
index 71881b17..15a1f90d 100644
--- a/utests/compiler_abs_diff.cpp
+++ b/utests/compiler_abs_diff.cpp
@@ -183,26 +183,29 @@ template <typename T, typename U> static void compiler_abs_diff_with_type(void)
 }
 
 
-#define ABS_TEST_DIFF_TYPE_2(TYPE, CLTYPE, UTYPE) \
+#define ABS_TEST_DIFF_TYPE_2(TYPE, CLTYPE, UTYPE, KEEP_PROGRAM) \
 	static void compiler_abs_diff_##CLTYPE (void) \
         { \
            OCL_CALL (cl_kernel_init, "compiler_abs_diff.cl", "compiler_abs_diff_"#CLTYPE, SOURCE, NULL);  \
            compiler_abs_diff_with_type<TYPE, UTYPE>(); \
         } \
-	MAKE_UTEST_FROM_FUNCTION(compiler_abs_diff_##CLTYPE);
+	MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_abs_diff_##CLTYPE, KEEP_PROGRAM);
+
+#define ABS_TEST_DIFF_TYPE(TYPE, UTYPE) ABS_TEST_DIFF_TYPE_2(TYPE, TYPE, UTYPE, true)
+
+#define ABS_TEST_DIFF_TYPE_END(TYPE, UTYPE) ABS_TEST_DIFF_TYPE_2(TYPE, TYPE, UTYPE, false)
 
-#define ABS_TEST_DIFF_TYPE(TYPE, UTYPE) ABS_TEST_DIFF_TYPE_2(TYPE, TYPE, UTYPE)
 
 typedef unsigned char uchar;
 typedef unsigned short ushort;
 typedef unsigned int uint;
 typedef uint64_t ulong64;
 ABS_TEST_DIFF_TYPE(int, uint)
-ABS_TEST_DIFF_TYPE_2(int64_t, long, ulong64)
+ABS_TEST_DIFF_TYPE_2(int64_t, long, ulong64, true)
 ABS_TEST_DIFF_TYPE(short, ushort)
 ABS_TEST_DIFF_TYPE(char, uchar)
 ABS_TEST_DIFF_TYPE(uint, uint)
-ABS_TEST_DIFF_TYPE_2(ulong64, ulong, ulong64)
+ABS_TEST_DIFF_TYPE_2(ulong64, ulong, ulong64, true)
 ABS_TEST_DIFF_TYPE(ushort, ushort)
 ABS_TEST_DIFF_TYPE(uchar, uchar)
 
@@ -289,4 +292,4 @@ ABS_TEST_DIFF_TYPE(ushort2, ushort2)
 ABS_TEST_DIFF_TYPE(ushort3, ushort3)
 ABS_TEST_DIFF_TYPE(ushort4, ushort4)
 ABS_TEST_DIFF_TYPE(ushort8, ushort8)
-ABS_TEST_DIFF_TYPE(ushort16, ushort16)
+ABS_TEST_DIFF_TYPE_END(ushort16, ushort16)
diff --git a/utests/compiler_basic_arithmetic.cpp b/utests/compiler_basic_arithmetic.cpp
index dcdd0849..0e5ec41a 100644
--- a/utests/compiler_basic_arithmetic.cpp
+++ b/utests/compiler_basic_arithmetic.cpp
@@ -61,52 +61,56 @@ std::cout <<"kernel name: " << kernel_name << std::endl;
   buf_data[0] = buf_data[1] = NULL;
 }
 
-#define DECL_TEST_SUB(type, alias) \
+#define DECL_TEST_SUB(type, alias, keep_program) \
 static void compiler_sub_ ##alias(void)\
 {\
   test_exec<type, TEST_OP_SUB>("compiler_sub_" # alias);\
 }\
-MAKE_UTEST_FROM_FUNCTION(compiler_sub_ ## alias)
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_sub_ ## alias, keep_program)
 
-#define DECL_TEST_ADD(type, alias) \
+#define DECL_TEST_ADD(type, alias, keep_program) \
 static void compiler_add_ ##alias(void)\
 {\
   test_exec<type, TEST_OP_ADD>("compiler_add_" # alias);\
 }\
-MAKE_UTEST_FROM_FUNCTION(compiler_add_ ## alias)
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_add_ ## alias, keep_program)
 
-#define DECL_TEST_MUL(type, alias) \
+#define DECL_TEST_MUL(type, alias, keep_program) \
 static void compiler_mul_ ##alias(void)\
 {\
   test_exec<type, TEST_OP_MUL>("compiler_mul_" # alias);\
 }\
-MAKE_UTEST_FROM_FUNCTION(compiler_mul_ ## alias)
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_mul_ ## alias, keep_program)
 
-#define DECL_TEST_DIV(type, alias) \
+#define DECL_TEST_DIV(type, alias, keep_program) \
 static void compiler_div_ ##alias(void)\
 {\
   test_exec<type, TEST_OP_DIV>("compiler_div_" # alias);\
 }\
-MAKE_UTEST_FROM_FUNCTION(compiler_div_ ## alias)
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_div_ ## alias, keep_program)
 
-#define DECL_TEST_REM(type, alias) \
+#define DECL_TEST_REM(type, alias, keep_program) \
 static void compiler_rem_ ##alias(void)\
 {\
   test_exec<type, TEST_OP_REM>("compiler_rem_" # alias);\
 }\
-MAKE_UTEST_FROM_FUNCTION(compiler_rem_ ## alias)
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_rem_ ## alias, keep_program)
 
-#define DECL_TEST_FOR_ALL_TYPE(op)\
-DECL_TEST_##op(int8_t, char) \
-DECL_TEST_##op(uint8_t, uchar) \
-DECL_TEST_##op(int16_t, short) \
-DECL_TEST_##op(uint16_t, ushort) \
-DECL_TEST_##op(int32_t, int) \
-DECL_TEST_##op(uint32_t, uint)
+#define _DECL_TEST_FOR_ALL_TYPE(op, keep_program) \
+DECL_TEST_##op(int8_t, char, true) \
+DECL_TEST_##op(uint8_t, uchar, true) \
+DECL_TEST_##op(int16_t, short, true) \
+DECL_TEST_##op(uint16_t, ushort, true) \
+DECL_TEST_##op(int32_t, int, true) \
+DECL_TEST_##op(uint32_t, uint, keep_program)
+
+#define DECL_TEST_FOR_ALL_TYPE(op) _DECL_TEST_FOR_ALL_TYPE(op, true)
+
+#define DECL_TEST_FOR_ALL_TYPE_END(op) _DECL_TEST_FOR_ALL_TYPE(op, false)
 
 DECL_TEST_FOR_ALL_TYPE(SUB)
 DECL_TEST_FOR_ALL_TYPE(ADD)
 DECL_TEST_FOR_ALL_TYPE(MUL)
 DECL_TEST_FOR_ALL_TYPE(DIV)
-DECL_TEST_FOR_ALL_TYPE(REM)
+DECL_TEST_FOR_ALL_TYPE_END(REM)
 #undef DECL_TEST_FOR_ALL_TYPE
diff --git a/utests/compiler_global_constant.cpp b/utests/compiler_global_constant.cpp
index a2d0172e..88f98529 100644
--- a/utests/compiler_global_constant.cpp
+++ b/utests/compiler_global_constant.cpp
@@ -98,7 +98,7 @@ void compiler_global_constant3(void)
   OCL_UNMAP_BUFFER(0);
 }
 
-MAKE_UTEST_FROM_FUNCTION(compiler_global_constant);
-MAKE_UTEST_FROM_FUNCTION(compiler_global_constant1);
-MAKE_UTEST_FROM_FUNCTION(compiler_global_constant2);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_global_constant, true);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_global_constant1, true);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_global_constant2, true);
 MAKE_UTEST_FROM_FUNCTION(compiler_global_constant3);
diff --git a/utests/compiler_group_size.cpp b/utests/compiler_group_size.cpp
index 0c8881c5..8ad83f03 100644
--- a/utests/compiler_group_size.cpp
+++ b/utests/compiler_group_size.cpp
@@ -134,8 +134,8 @@ void compiler_group_size4(void)
     OCL_UNMAP_BUFFER(1);
   }
 }
-MAKE_UTEST_FROM_FUNCTION(compiler_group_size1);
-MAKE_UTEST_FROM_FUNCTION(compiler_group_size2);
-MAKE_UTEST_FROM_FUNCTION(compiler_group_size3);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_group_size1, true);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_group_size2, true);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_group_size3, true);
 MAKE_UTEST_FROM_FUNCTION(compiler_group_size4);
 
diff --git a/utests/compiler_long_cmp.cpp b/utests/compiler_long_cmp.cpp
index 37755564..35d4c4f8 100644
--- a/utests/compiler_long_cmp.cpp
+++ b/utests/compiler_long_cmp.cpp
@@ -47,6 +47,7 @@ void compiler_long_cmp(void)
     OCL_ASSERT(x == dest[i]);
   }
   OCL_UNMAP_BUFFER(2);
+  OCL_DESTROY_KERNEL_KEEP_PROGRAM(true);
 
   OCL_CREATE_KERNEL_FROM_FILE("compiler_long_cmp", "compiler_long_cmp_le");
   OCL_SET_ARG(0, sizeof(cl_mem), &buf[0]);
@@ -60,6 +61,7 @@ void compiler_long_cmp(void)
     OCL_ASSERT(x == dest[i]);
   }
   OCL_UNMAP_BUFFER(2);
+  OCL_DESTROY_KERNEL_KEEP_PROGRAM(true);
 
   OCL_CREATE_KERNEL_FROM_FILE("compiler_long_cmp", "compiler_long_cmp_g");
   OCL_SET_ARG(0, sizeof(cl_mem), &buf[0]);
@@ -73,6 +75,7 @@ void compiler_long_cmp(void)
     OCL_ASSERT(x == dest[i]);
   }
   OCL_UNMAP_BUFFER(2);
+  OCL_DESTROY_KERNEL_KEEP_PROGRAM(true);
 
   OCL_CREATE_KERNEL_FROM_FILE("compiler_long_cmp", "compiler_long_cmp_ge");
   OCL_SET_ARG(0, sizeof(cl_mem), &buf[0]);
@@ -86,6 +89,7 @@ void compiler_long_cmp(void)
     OCL_ASSERT(x == dest[i]);
   }
   OCL_UNMAP_BUFFER(2);
+  OCL_DESTROY_KERNEL_KEEP_PROGRAM(true);
 
   OCL_CREATE_KERNEL_FROM_FILE("compiler_long_cmp", "compiler_long_cmp_eq");
   OCL_SET_ARG(0, sizeof(cl_mem), &buf[0]);
@@ -99,6 +103,7 @@ void compiler_long_cmp(void)
     OCL_ASSERT(x == dest[i]);
   }
   OCL_UNMAP_BUFFER(2);
+  OCL_DESTROY_KERNEL_KEEP_PROGRAM(true);
 
   OCL_CREATE_KERNEL_FROM_FILE("compiler_long_cmp", "compiler_long_cmp_neq");
   OCL_SET_ARG(0, sizeof(cl_mem), &buf[0]);
diff --git a/utests/compiler_long_convert.cpp b/utests/compiler_long_convert.cpp
index 827a45bd..ada6926c 100644
--- a/utests/compiler_long_convert.cpp
+++ b/utests/compiler_long_convert.cpp
@@ -65,7 +65,7 @@ void compiler_long_convert(void)
   OCL_UNMAP_BUFFER(5);
 }
 
-MAKE_UTEST_FROM_FUNCTION(compiler_long_convert);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_long_convert, true);
 
 // convert 64-bit integer to shorter integer
 void compiler_long_convert_2(void)
@@ -115,7 +115,7 @@ void compiler_long_convert_2(void)
   OCL_UNMAP_BUFFER(2);
 }
 
-MAKE_UTEST_FROM_FUNCTION(compiler_long_convert_2);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_long_convert_2, true);
 
 // convert 64-bit integer to 32-bit float
 void compiler_long_convert_to_float(void)
diff --git a/utests/compiler_step.cpp b/utests/compiler_step.cpp
index 3285dda7..b0228267 100644
--- a/utests/compiler_step.cpp
+++ b/utests/compiler_step.cpp
@@ -322,17 +322,21 @@ template <typename T> static void compiler_stepf_with_type(void)
     }
 }
 
-#define STEPF_TEST_TYPE(TYPE) \
+#define _STEPF_TEST_TYPE(TYPE, keep_program) \
 	static void compiler_stepf_##TYPE (void) \
         { \
            OCL_CALL (cl_kernel_init, "compiler_step.cl", "compiler_stepf_"#TYPE, SOURCE, NULL);  \
            compiler_stepf_with_type<TYPE>(); \
         } \
-	MAKE_UTEST_FROM_FUNCTION(compiler_stepf_##TYPE);
+	MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_stepf_##TYPE, keep_program);
+
+#define STEPF_TEST_TYPE(TYPE) _STEPF_TEST_TYPE(TYPE, true)
+#define STEPF_TEST_TYPE_END(TYPE) _STEPF_TEST_TYPE(TYPE, false)
+
 
 STEPF_TEST_TYPE(float)
 STEPF_TEST_TYPE(float2)
 STEPF_TEST_TYPE(float3)
 STEPF_TEST_TYPE(float4)
 STEPF_TEST_TYPE(float8)
-STEPF_TEST_TYPE(float16)
+STEPF_TEST_TYPE_END(float16)
diff --git a/utests/compiler_vector_load_store.cpp b/utests/compiler_vector_load_store.cpp
index f8a3dcb2..b44abc75 100644
--- a/utests/compiler_vector_load_store.cpp
+++ b/utests/compiler_vector_load_store.cpp
@@ -37,27 +37,27 @@ static void compiler_vector_load_store(int elemNum, const char *kernelName)
   OCL_UNMAP_BUFFER(1);
 }
 
-#define compiler_vector_load_store(type, n, kernel_type) \
+#define compiler_vector_load_store(type, n, kernel_type, keep_program) \
 static void compiler_vector_ ##kernel_type ##n ##_load_store(void)\
 {\
   compiler_vector_load_store<type>(n, "test_" #kernel_type #n);\
 }\
-MAKE_UTEST_FROM_FUNCTION(compiler_vector_ ## kernel_type ##n ##_load_store);
+MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(compiler_vector_ ## kernel_type ##n ##_load_store, keep_program);
 
-#define test_all_vector(type, kernel_type) \
-  compiler_vector_load_store(type, 2, kernel_type) \
-  compiler_vector_load_store(type, 3, kernel_type) \
-  compiler_vector_load_store(type, 4, kernel_type) \
-  compiler_vector_load_store(type, 8, kernel_type) \
-  compiler_vector_load_store(type, 16, kernel_type)
+#define test_all_vector(type, kernel_type, keep_program) \
+  compiler_vector_load_store(type, 2, kernel_type, true) \
+  compiler_vector_load_store(type, 3, kernel_type, true) \
+  compiler_vector_load_store(type, 4, kernel_type, true) \
+  compiler_vector_load_store(type, 8, kernel_type, true) \
+  compiler_vector_load_store(type, 16, kernel_type, keep_program)
 
-test_all_vector(int8_t, char)
-test_all_vector(uint8_t, uchar)
-test_all_vector(int16_t, short)
-test_all_vector(uint16_t, ushort)
-test_all_vector(int32_t, int)
-test_all_vector(uint32_t, uint)
-test_all_vector(float, float)
-test_all_vector(double, double)
-test_all_vector(int64_t, long)
-test_all_vector(uint64_t, ulong)
+test_all_vector(int8_t, char, true)
+test_all_vector(uint8_t, uchar, true)
+test_all_vector(int16_t, short, true)
+test_all_vector(uint16_t, ushort, true)
+test_all_vector(int32_t, int, true)
+test_all_vector(uint32_t, uint, true)
+test_all_vector(float, float, true)
+test_all_vector(double, double, true)
+test_all_vector(int64_t, long, true)
+test_all_vector(uint64_t, ulong, false)
diff --git a/utests/utest.cpp b/utests/utest.cpp
index 18d10e84..6d51598a 100644
--- a/utests/utest.cpp
+++ b/utests/utest.cpp
@@ -32,7 +32,8 @@ using namespace std;
 vector<UTest> *UTest::utestList = NULL;
 void releaseUTestList(void) { delete UTest::utestList; }
 
-UTest::UTest(Function fn, const char *name, bool haveIssue) : fn(fn), name(name), haveIssue(haveIssue) {
+UTest::UTest(Function fn, const char *name, bool haveIssue, bool needDestroyProgram)
+       : fn(fn), name(name), haveIssue(haveIssue), needDestroyProgram(needDestroyProgram) {
   if (utestList == NULL) {
     utestList = new vector<UTest>;
     atexit(releaseUTestList);
@@ -57,7 +58,7 @@ void UTest::run(const char *name) {
       std::cout << utest.name << ":" << std::endl;
       (utest.fn)();
       std::cout << std::endl;
-      cl_kernel_destroy();
+      cl_kernel_destroy(true);
       cl_buffer_destroy();
     }
   }
@@ -71,7 +72,7 @@ void UTest::runAll(void) {
     std::cout << utest.name << ":" << std::endl;
     (utest.fn)();
     std::cout << std::endl;
-    cl_kernel_destroy();
+    cl_kernel_destroy(utest.needDestroyProgram);
     cl_buffer_destroy();
   }
 }
@@ -84,7 +85,7 @@ void UTest::runAllNoIssue(void) {
     std::cout << utest.name << ":" << std::endl;
     (utest.fn)();
     std::cout << std::endl;
-    cl_kernel_destroy();
+    cl_kernel_destroy(utest.needDestroyProgram);
     cl_buffer_destroy();
   }
 }
diff --git a/utests/utest.hpp b/utests/utest.hpp
index d3a6a6fa..01d4a8ce 100644
--- a/utests/utest.hpp
+++ b/utests/utest.hpp
@@ -39,13 +39,15 @@ struct UTest
   /*! Empty test */
   UTest(void);
   /*! Build a new unit test and append it to the unit test list */
-  UTest(Function fn, const char *name, bool haveIssue = false);
+  UTest(Function fn, const char *name, bool haveIssue = false, bool needDestroyProgram = true);
   /*! Function to execute */
   Function fn;
   /*! Name of the test */
   const char *name;
   /*! Indicate whether current test cases has issue to be fixes */
   bool haveIssue;
+  /*! Indicate whether destroy kernels/program. */
+  bool needDestroyProgram;
   /*! The tests that are registered */
   static std::vector<UTest> *utestList;
   /*! Run the test with the given name */
@@ -61,6 +63,11 @@ struct UTest
 /*! Register a new unit test */
 #define UTEST_REGISTER(FN) static const UTest __##FN##__(FN, #FN);
 
+#define MAKE_UTEST_FROM_FUNCTION_KEEP_PROGRAM(FN, KEEP_PROGRAM) \
+  static void __ANON__##FN##__(void) { UTEST_EXPECT_SUCCESS(FN()); } \
+  static const UTest __##FN##__(__ANON__##FN##__, #FN, false, !(KEEP_PROGRAM));
+
+
 /*! Turn a function into a unit test */
 #define MAKE_UTEST_FROM_FUNCTION(FN) \
   static void __ANON__##FN##__(void) { UTEST_EXPECT_SUCCESS(FN()); } \
diff --git a/utests/utest_helper.cpp b/utests/utest_helper.cpp
index 65af7275..b264c1b4 100644
--- a/utests/utest_helper.cpp
+++ b/utests/utest_helper.cpp
@@ -237,30 +237,32 @@ cl_kernel_init(const char *file_name, const char *kernel_name, int format, const
   cl_file_map_t *fm = NULL;
   char *ker_path = NULL;
   cl_int status = CL_SUCCESS;
+  static const char *prevFileName = NULL;
 
   /* Load the program and build it */
-  if (program)
-    clReleaseProgram(program);
-  ker_path = cl_do_kiss_path(file_name, device);
-  if (format == LLVM)
-    program = clCreateProgramWithLLVMIntel(ctx, 1, &device, ker_path, &status);
-  else if (format == SOURCE) {
-    cl_file_map_t *fm = cl_file_map_new();
-    FATAL_IF (cl_file_map_open(fm, ker_path) != CL_FILE_MAP_SUCCESS,
-              "Failed to open file \"%s\" with kernel \"%s\". Did you properly set OCL_KERNEL_PATH variable?",
-              file_name, kernel_name);
-    const char *src = cl_file_map_begin(fm);
-    const size_t sz = cl_file_map_size(fm);
-    program = clCreateProgramWithSource(ctx, 1, &src, &sz, &status);
-    cl_file_map_delete(fm);
-  } else
-    FATAL("Not able to create program from binary");
-
-  if (status != CL_SUCCESS) {
-    fprintf(stderr, "error calling clCreateProgramWithBinary\n");
-    goto error;
+  if (!program || (program && (!prevFileName || strcmp(prevFileName, file_name)))) {
+    if (program) clReleaseProgram(program);
+    ker_path = cl_do_kiss_path(file_name, device);
+    if (format == LLVM)
+      program = clCreateProgramWithLLVMIntel(ctx, 1, &device, ker_path, &status);
+    else if (format == SOURCE) {
+      cl_file_map_t *fm = cl_file_map_new();
+      FATAL_IF (cl_file_map_open(fm, ker_path) != CL_FILE_MAP_SUCCESS,
+                "Failed to open file \"%s\" with kernel \"%s\". Did you properly set OCL_KERNEL_PATH variable?",
+                file_name, kernel_name);
+      const char *src = cl_file_map_begin(fm);
+      const size_t sz = cl_file_map_size(fm);
+      program = clCreateProgramWithSource(ctx, 1, &src, &sz, &status);
+      cl_file_map_delete(fm);
+    } else
+      FATAL("Not able to create program from binary");
+
+    if (status != CL_SUCCESS) {
+      fprintf(stderr, "error calling clCreateProgramWithBinary\n");
+      goto error;
+    }
+    prevFileName = file_name;
   }
-
   /* OCL requires to build the program even if it is created from a binary */
   OCL_CALL (clBuildProgram, program, 1, &device, build_opt, NULL, NULL);
 
@@ -278,6 +280,7 @@ exit:
   cl_file_map_delete(fm);
   return status;
 error:
+  prevFileName = NULL;
   goto exit;
 }
 
@@ -413,12 +416,16 @@ error:
 }
 
 void
-cl_kernel_destroy(void)
+cl_kernel_destroy(bool needDestroyProgram)
 {
-  if (kernel) clReleaseKernel(kernel);
-  if (program) clReleaseProgram(program);
-  kernel = NULL;
-  program = NULL;
+  if (kernel) {
+    clReleaseKernel(kernel);
+    kernel = NULL;
+  }
+  if (needDestroyProgram && program) {
+    clReleaseProgram(program);
+    program = NULL;
+  }
 }
 
 void
diff --git a/utests/utest_helper.hpp b/utests/utest_helper.hpp
index 29a21d54..8da9dcbe 100644
--- a/utests/utest_helper.hpp
+++ b/utests/utest_helper.hpp
@@ -65,6 +65,11 @@ extern EGLSurface  eglSurface;
     OCL_CALL (cl_kernel_init, NAME".cl", NAME, SOURCE, NULL); \
   } while (0)
 
+#define OCL_DESTROY_KERNEL_KEEP_PROGRAM(KEEP_PROGRAM) \
+  do { \
+    cl_kernel_destroy(!(KEEP_PROGRAM)); \
+  } while(0)
+
 #define OCL_CREATE_KERNEL_FROM_FILE(FILE_NAME, KERNEL_NAME) \
   do { \
     OCL_CALL(cl_kernel_init, FILE_NAME".cl", KERNEL_NAME, SOURCE, NULL); \
@@ -199,7 +204,7 @@ extern void cl_buffer_destroy(void);
 extern void cl_ocl_destroy(void);
 
 /* Release kernel and program */
-extern void cl_kernel_destroy(void);
+extern void cl_kernel_destroy(bool needDestroyProgram = true);
 
 /* Release everything allocated in cl_test_init */
 extern void cl_test_destroy(void);