Remove runtime unit test dependency on aoc

Author: sophimao

test/CMakeLists.txt

@@ -52,7 +52,10 @@ target_link_libraries(acl_test PRIVATE
   )
 add_test(NAME acl_test COMMAND acl_test -v)
 set_property(TEST acl_test PROPERTY ENVIRONMENT
-  "AOCL_BOARD_PACKAGE_ROOT=${CMAKE_CURRENT_SOURCE_DIR}/board/a10_ref"
+  "\
+AOCL_BOARD_PACKAGE_ROOT=${CMAKE_CURRENT_SOURCE_DIR}/board/a10_ref;\
+ACL_TEST_EXAMPLE_BINARY=${CMAKE_CURRENT_SOURCE_DIR}/example_binary\
+"
   )
 
 add_subdirectory(fake_bsp)

test/acl_program_test.cpp

@@ -844,7 +844,7 @@ MT_TEST_GROUP(from_source) {
 
   void load(int compiler_mode =
                 CL_CONTEXT_COMPILER_MODE_OFFLINE_CREATE_EXE_LIBRARY_INTELFPGA,
-            const char *compile_command = 0, bool print_notify = true) {
+            std::string compile_command = "", bool print_notify = true) {
     unload();
     CHECK_EQUAL(CL_SUCCESS, clGetPlatformIDs(1, &m_platform, 0));
     CHECK(acl_platform_is_valid(m_platform));
@@ -853,14 +853,31 @@ MT_TEST_GROUP(from_source) {
                                &m_device[0], &m_num_devices));
     CHECK(m_num_devices > 0);
 
+    // Check if there is precompiled binaries, if envvar set, use that instead
+    const char *envvar_example_binary = "ACL_TEST_EXAMPLE_BINARY";
+    const char *example_binary_root = acl_getenv(envvar_example_binary);
+    if (example_binary_root) {
+      // Precompiled binaries exist, emulate the compile by copying the
+      // precompiled binaries to the current directory.
+#ifdef _WIN32
+      std::string bin_file =
+          std::string(example_binary_root) + "/windows/foo.aocr";
+#else
+      std::string bin_file =
+          std::string(example_binary_root) + "/linux/foo.aocr";
+#endif
+      compile_command = "cp " + bin_file + " ./kernels.aocr && echo ";
+    }
+
     cl_int status = CL_INVALID_DEVICE;
     cl_context_properties props[] = {
         CL_CONTEXT_PROGRAM_EXE_LIBRARY_ROOT_INTELFPGA,
         (cl_context_properties)m_basedir.c_str(),
         CL_CONTEXT_COMPILER_MODE_INTELFPGA,
         compiler_mode,
-        (compile_command ? CL_CONTEXT_COMPILE_COMMAND_INTELFPGA : 0),
-        (cl_context_properties)compile_command,
+        (compile_command != "" ? CL_CONTEXT_COMPILE_COMMAND_INTELFPGA : 0),
+        (cl_context_properties)(compile_command != "" ? compile_command.c_str()
+                                                      : 0),
         0,
         0};
     m_context =
@@ -949,7 +966,8 @@ MT_TEST(from_source, make_prog_dir_and_build_command) {
 
   // Default arguments, just turning off printing of errors for invalid calls to
   // be tested below
-  load(CL_CONTEXT_COMPILER_MODE_OFFLINE_CREATE_EXE_LIBRARY_INTELFPGA, 0, false);
+  load(CL_CONTEXT_COMPILER_MODE_OFFLINE_CREATE_EXE_LIBRARY_INTELFPGA, "",
+       false);
   load_program();
 
   // Before build. No executable.
@@ -1082,11 +1100,9 @@ MT_TEST(from_source, online_mode) {
   ACL_LOCKED(CHECK(acl_realpath_existing(check_str) != ""));
   check_str = m_hashdir + std::string("/build.cmd");
   ACL_LOCKED(CHECK(acl_realpath_existing(check_str) != ""));
-  // Since we invoked compiler with -rtl, we only get an .aoco and .aocr
+  // If we have invoked compiler with -rtl, we should get an .aocr
   check_str = m_hashdir + std::string("/kernels.aocr");
   ACL_LOCKED(CHECK(acl_realpath_existing(check_str) != ""));
-  check_str = m_hashdir + std::string("/kernels/kernels.v");
-  ACL_LOCKED(CHECK(acl_realpath_existing(check_str) != ""));
 
   // Check the build log.
   size_t size_ret;

test/acl_test.cpp

@@ -218,91 +218,140 @@ const unsigned char *acl_test_get_example_binary(size_t *binary_len) {
 }
 
 static void l_load_example_binary(void) {
-  const char *envvar_offline_device = "CL_CONTEXT_OFFLINE_DEVICE_INTELFPGA";
-  const char *envvar_program_lib =
-      "CL_CONTEXT_PROGRAM_EXE_LIBRARY_ROOT_INTELFPGA";
-  const char *offline_old_value = acl_getenv(envvar_offline_device);
-  const char *program_lib_old_value = acl_getenv(envvar_program_lib);
-  int system_ret = -1;
-  enum { MAX_DEVICES = 100 };
-  cl_platform_id platform;
-  cl_device_id device[MAX_DEVICES];
-  cl_context context;
-  cl_program program;
-  cl_int status;
-
-  acl_test_setenv(envvar_offline_device, ACLTEST_DEFAULT_BOARD);
-  acl_test_setenv(envvar_program_lib, ".acltest_builtin_prog");
-  system_ret = system("rm -rf .acltest_builtin_prog");
-  assert(system_ret != -1);
-
-  ACL_LOCKED(acl_test_setup_generic_system());
-
   // Since this runs before the CppUTest runner is set up, we can't use
   // the CHECK* macros.
   // Just use asserts.
 
-  assert(CL_SUCCESS == clGetPlatformIDs(1, &platform, 0));
-  assert(CL_SUCCESS == clGetDeviceIDs(platform, CL_DEVICE_TYPE_ACCELERATOR,
-                                      MAX_DEVICES, device, 0));
+  const char *envvar_example_binary = "ACL_TEST_EXAMPLE_BINARY";
+  const char *example_binary_root = acl_getenv(envvar_example_binary);
+  if (example_binary_root) {
+    // Precompiled binaries exist, just read its content
+    ACL_LOCKED(acl_test_setup_generic_system());
+#ifdef _WIN32
+    std::string bin_file =
+        std::string(example_binary_root) + "/windows/example.aocr";
+#else
+    std::string bin_file =
+        std::string(example_binary_root) + "/linux/example.aocr";
+#endif
+    FILE *infile = fopen(bin_file.c_str(), "rb");
+    assert(infile && "Cannot open example binary example.aocr, make sure "
+                     "ACL_TEST_EXAMPLE_BINARY is set to the correct path");
+
+    // Get binary length
+    assert(fseek(infile, 0, SEEK_END) == 0);
+    long int position = ftell(infile);
+    assert(position != -1L);
+    acl_test_example_binary_len = (size_t)position;
+    // Return to beginning of file
+    assert(fseek(infile, 0, SEEK_SET) == 0);
+
+    // Read binary
+    acl_test_example_binary =
+        (unsigned char *)acl_malloc(acl_test_example_binary_len);
+    assert(acl_test_example_binary);
+    assert(fread(acl_test_example_binary, sizeof(char),
+                 acl_test_example_binary_len,
+                 infile) == acl_test_example_binary_len);
+    assert(fclose(infile) == 0);
+  } else {
+    // Precompiled binaries don't exist, do an actual compile with the
+    // aoc compiler and store the binary as test example binary.
+    const char *envvar_offline_device = "CL_CONTEXT_OFFLINE_DEVICE_INTELFPGA";
+    const char *envvar_program_lib =
+        "CL_CONTEXT_PROGRAM_EXE_LIBRARY_ROOT_INTELFPGA";
+    const char *offline_old_value = acl_getenv(envvar_offline_device);
+    const char *program_lib_old_value = acl_getenv(envvar_program_lib);
+    int system_ret = -1;
+    enum { MAX_DEVICES = 100 };
+    cl_platform_id platform;
+    cl_device_id device[MAX_DEVICES];
+    cl_context context;
+    cl_program program;
+    cl_int status;
+
+    acl_test_setenv(envvar_offline_device, ACLTEST_DEFAULT_BOARD);
+    acl_test_setenv(envvar_program_lib, ".acltest_builtin_prog");
+    system_ret = system("rm -rf .acltest_builtin_prog");
+    assert(system_ret != -1);
 
-  cl_context_properties props[] = {
-      CL_CONTEXT_COMPILER_MODE_INTELFPGA,
-      CL_CONTEXT_COMPILER_MODE_OFFLINE_CREATE_EXE_LIBRARY_INTELFPGA, 0};
-  context = clCreateContext(props, 1, device, acl_test_notify_print, 0, 0);
-  assert(context);
-
-  const char *src =
-      "kernel void vecaccum(global int*A, global int*B) {\n"
-      "   size_t gid = get_global_id(0);\n"
-      "   A[gid] += B[gid];\n"
-      "};\n"
-      // This one has two constant arguments.
-      "kernel void vecsum(global int*A, constant int*B, constant int*C) {\n"
-      "   size_t gid = get_global_id(0);\n"
-      "   A[gid] = B[gid] + C[gid];\n"
-      "};\n"
-
-      // This has a printf.
-      "kernel void printit(global int*A) {\n"
-      "   printf(\"Hello world! %d\\n\", A[0]);\n"
-      "};\n";
-
-  program = clCreateProgramWithSource(context, 1, &src, 0, 0);
-  assert(program);
-
-  status = clBuildProgram(program, 1, device, "-cl-kernel-arg-info", 0, 0);
-  if (status != CL_SUCCESS) {
-    printf("Compilation failed.  Kernel source is:\n-----\n%s\n----\n", src);
+    ACL_LOCKED(acl_test_setup_generic_system());
+
+    assert(CL_SUCCESS == clGetPlatformIDs(1, &platform, 0));
+    assert(CL_SUCCESS == clGetDeviceIDs(platform, CL_DEVICE_TYPE_ACCELERATOR,
+                                        MAX_DEVICES, device, 0));
+
+    cl_context_properties props[] = {
+        CL_CONTEXT_COMPILER_MODE_INTELFPGA,
+        CL_CONTEXT_COMPILER_MODE_OFFLINE_CREATE_EXE_LIBRARY_INTELFPGA, 0};
+    context = clCreateContext(props, 1, device, acl_test_notify_print, 0, 0);
+    assert(context);
+
+    const char *src =
+        "kernel void vecaccum(global int*A, global int*B) {\n"
+        "   size_t gid = get_global_id(0);\n"
+        "   A[gid] += B[gid];\n"
+        "};\n"
+        // This one has two constant arguments.
+        "kernel void vecsum(global int*A, constant int*B, constant int*C) {\n"
+        "   size_t gid = get_global_id(0);\n"
+        "   A[gid] = B[gid] + C[gid];\n"
+        "};\n"
+
+        // This has a printf.
+        "kernel void printit(global int*A) {\n"
+        "   printf(\"Hello world! %d\\n\", A[0]);\n"
+        "};\n";
+
+    program = clCreateProgramWithSource(context, 1, &src, 0, 0);
+    assert(program);
+
+    status = clBuildProgram(program, 1, device, "-cl-kernel-arg-info", 0, 0);
+    if (status != CL_SUCCESS) {
+      printf("Compilation failed.  Kernel source is:\n-----\n%s\n----\n", src);
+      size_t log_size = 0;
+      clGetProgramBuildInfo(program, device[0], CL_PROGRAM_BUILD_LOG, 0, 0,
+                            &log_size);
+      char *log = (char *)acl_malloc(log_size);
+      clGetProgramBuildInfo(program, device[0], CL_PROGRAM_BUILD_LOG, log_size,
+                            log, 0);
+      if (log)
+        printf("Build log is:\n-----\n%s\n----\n", log);
+      exit(1);
+    }
+
+    // The build log should not be empty
     size_t log_size = 0;
+    size_t empty_log_size = 1;
     clGetProgramBuildInfo(program, device[0], CL_PROGRAM_BUILD_LOG, 0, 0,
                           &log_size);
-    char *log = (char *)acl_malloc(log_size);
-    clGetProgramBuildInfo(program, device[0], CL_PROGRAM_BUILD_LOG, log_size,
-                          log, 0);
-    if (log)
-      printf("Build log is:\n-----\n%s\n----\n", log);
-    exit(1);
+    assert(log_size > empty_log_size);
+
+    acl_test_example_binary_len = 0;
+    assert(CL_SUCCESS == clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES,
+                                          sizeof(size_t),
+                                          &acl_test_example_binary_len, 0));
+    acl_test_example_binary =
+        (unsigned char *)acl_malloc(acl_test_example_binary_len);
+    assert(acl_test_example_binary);
+    assert(CL_SUCCESS == clGetProgramInfo(program, CL_PROGRAM_BINARIES,
+                                          sizeof(acl_test_example_binary),
+                                          &acl_test_example_binary, 0));
+
+    // Don't leak
+    clReleaseProgram(program);
+    clReleaseContext(context);
+
+    acl_test_unsetenv(envvar_offline_device);
+    if (offline_old_value) {
+      acl_test_setenv(envvar_offline_device, offline_old_value);
+    }
+    acl_test_unsetenv(envvar_program_lib);
+    if (program_lib_old_value) {
+      acl_test_setenv(envvar_program_lib, program_lib_old_value);
+    }
   }
 
-  // The build log should not be empty
-  size_t log_size = 0;
-  size_t empty_log_size = 1;
-  clGetProgramBuildInfo(program, device[0], CL_PROGRAM_BUILD_LOG, 0, 0,
-                        &log_size);
-  assert(log_size > empty_log_size);
-
-  acl_test_example_binary_len = 0;
-  assert(CL_SUCCESS == clGetProgramInfo(program, CL_PROGRAM_BINARY_SIZES,
-                                        sizeof(size_t),
-                                        &acl_test_example_binary_len, 0));
-  acl_test_example_binary =
-      (unsigned char *)acl_malloc(acl_test_example_binary_len);
-  assert(acl_test_example_binary);
-  assert(CL_SUCCESS == clGetProgramInfo(program, CL_PROGRAM_BINARIES,
-                                        sizeof(acl_test_example_binary),
-                                        &acl_test_example_binary, 0));
-
   // Save the derived sysdef for later tests.
   {
     acl_pkg_file_t pkg;
@@ -334,19 +383,6 @@ static void l_load_example_binary(void) {
     acl_pkg_close_file(pkg);
   }
 
-  // Don't leak
-  clReleaseProgram(program);
-  clReleaseContext(context);
-
-  acl_test_unsetenv(envvar_offline_device);
-  if (offline_old_value) {
-    acl_test_setenv(envvar_offline_device, offline_old_value);
-  }
-  acl_test_unsetenv(envvar_program_lib);
-  if (program_lib_old_value) {
-    acl_test_setenv(envvar_program_lib, program_lib_old_value);
-  }
-
   ACL_LOCKED(acl_test_teardown_generic_system());
 }
 

test/example_binary/README.md

@@ -0,0 +1,38 @@
+# Precompiled Binaries for Runtime Unit Tests
+
+This directory contains precompiled binaries that the runtime unit tests could use.
+
+When the environment variable `ACL_TEST_EXAMPLE_BINARY` is set, precompiled binaries
+will be used for the unit tests, instead of compiling with aoc in-time. The environment
+variable is set to this directory by default by the unit test CMake configuration.
+
+## Unit Tests Using AOC compiler
+
+During setup, the runtime loads an example binary that may be obtained and used by
+any runtime unit tests. The loading is done in the function `l_load_example_binary`
+of acl_test.cpp, and the loaded binary can be obtained by calling the function
+`acl_test_get_example_binary`.
+
+Other than this, the program `from_source` test group contains two tests that either
+requires the aoc compiler, or the precompiled binaries to be present:
+
+- `make_prog_dir_and_build_command`
+- `online_mode`
+
+## Overriding the Binaries to be Used
+
+To use precompiled binaries contained in another directory, set `ACL_TEST_EXAMPLE_BINARY`
+to the root of that directory, and make sure there is a `linux` subdirectory for linux
+precompiled binaries and a `windows` subdirectory for windows precompile binaries.
+
+## Updating the Binaries
+
+In case binaries have to be updated, make sure the aoc compiler is available, and
+run the compile scripts contained in each of the corresponding OS subdirectories:
+
+```
+# On Linux
+sh linux/compile_aocr.sh
+# On Windows
+windows\compile_aocr.sh
+```

test/example_binary/linux/compile_aocr.sh

@@ -0,0 +1,38 @@
+#!/bin/bash
+# Copyright (C) 2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+
+set -eux -o pipefail
+
+if ! command -v aoc &> /dev/null
+then
+    echo "Error: aoc could not be found on PATH"
+    exit 1
+fi
+
+scripthome=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+AOCL_BOARD_PACKAGE_ROOT=$(readlink -f "$scripthome/../../board/a10_ref")
+export AOCL_BOARD_PACKAGE_ROOT
+
+# First compile example.cl
+kernel='example'
+board='a10_ref_small'
+compile_arg='-cl-kernel-arg-info'
+compute_hash='f3effd06c681436a828f7e11c6c1b037807ddba0'
+src=$(readlink -f "$scripthome/../src/$kernel.cl")
+dest="$scripthome/$kernel.aocr"
+
+aoc -rtl -tidy -board="$board" -hash="$compute_hash" "$src" "$compile_arg" -o "$dest"
+
+# Then compile foo.cl
+kernel='foo'
+board='a10_ref_small'
+compile_arg=''
+compute_hash='7128ac1c937694f5b54a12229f19e4ca3a494c16'
+src=$(readlink -f "$scripthome/../src/$kernel.cl")
+dest="$scripthome/$kernel.aocr"
+
+aoc -rtl -tidy -board="$board" -hash="$compute_hash" "$src" "$compile_arg" -o "$dest"
+
+# Clean up
+rm -rf "$scripthome"/*.temp "$scripthome"/*.bc