Import Intel(R) FPGA Runtime for OpenCL(TM) Software Technology

Author: pcolberg

.clang-format

@@ -0,0 +1,4 @@
+# Copyright (C) 2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+
+BasedOnStyle: LLVM

CMakeLists.txt

@@ -0,0 +1,279 @@
+# Copyright (C) 2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+
+cmake_minimum_required(VERSION 3.10)
+
+project(fpga-runtime C CXX)
+
+# Enforce keeping the source directory clean by building in a separate
+# directory. This avoids unnecessary corner cases, e.g., copying files
+# from source to binary directory with identical relative paths.
+if(PROJECT_BINARY_DIR STREQUAL PROJECT_SOURCE_DIR)
+  message(FATAL_ERROR "build directory must be different from source directory")
+endif()
+
+# We exclusively support Ninja as the generator used to build the project.
+if(NOT CMAKE_GENERATOR STREQUAL "Ninja")
+  message(FATAL_ERROR "unsupported cmake generator, please use `cmake -G Ninja`")
+endif()
+
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake/modules")
+
+find_package(Elf REQUIRED)
+find_package(ZLIB)
+find_package(Git)
+
+set(CMAKE_THREAD_PREFER_PTHREAD ON)
+find_package(Threads REQUIRED)
+
+math(EXPR ACL_TARGET_BIT "${CMAKE_SIZEOF_VOID_P} * 8")
+message(STATUS "Target pointer size in bits: ${ACL_TARGET_BIT}")
+
+################################################################################
+### Modified Default flags
+################################################################################
+# Use  "multithread-specific and DLL-specific version of the run-time library" (Windows)
+# There's a better way for CMake >= 3.15
+# See https://cmake.org/cmake/help/latest/prop_tgt/MSVC_RUNTIME_LIBRARY.html
+if(WIN32 AND "${CMAKE_BUILD_TYPE}" STREQUAL "")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MD")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MD")
+endif()
+
+# Flag for coverage scans
+option(ACL_CODE_COVERAGE "Build with coverage" OFF)
+message(STATUS "Build with coverage: ${ACL_CODE_COVERAGE}")
+if(ACL_CODE_COVERAGE)
+  if(CMAKE_COMPILER_IS_GNUCXX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage")
+  else()
+    message(FATAL_ERROR "cannot build with coverage tools due to unsupported CXX compiler")
+  endif()
+endif()
+
+################################################################################
+### Modified Debug flags
+################################################################################
+# pkg_editor_test and acl_test have trouble with the debug version of the multithread Windows runtime library
+# There's a better way for CMake >= 3.15
+# See https://cmake.org/cmake/help/latest/prop_tgt/MSVC_RUNTIME_LIBRARY.html
+string(REGEX REPLACE "/MDd" "/MD" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
+string(REGEX REPLACE "/MDd" "/MD" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+# pkg_editor_test errors out if we enable runtime error checking
+string(REGEX REPLACE "( /RTC1$|/RTC1 )" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
+string(REGEX REPLACE "( /RTC1$|/RTC1 )" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+
+# -DNDEBUG will disable calls to assert() in our unit tests
+foreach(flags
+  CMAKE_C_FLAGS_RELWITHDEBINFO
+  CMAKE_CXX_FLAGS_RELWITHDEBINFO
+  CMAKE_C_FLAGS_RELEASE
+  CMAKE_CXX_FLAGS_RELEASE
+  CMAKE_C_FLAGS_MINSIZEREL
+  CMAKE_CXX_FLAGS_MINSIZEREL
+  )
+  string(REGEX REPLACE "(^|[ \t])[/-][dD][ \t]*NDEBUG($|[ \t])" " " "${flags}" "${${flags}}")
+endforeach()
+
+# Windows debug builds frequently crash mspdbsrv.exe, resulting in fatal
+# error C1090: PDB API call failed, error code '23': (0x000006BA). Work
+# around this unresolved issue by disabling separate PDB files (`/Zi`)
+# and instead embedding debugging symbols in object files (`/Z7`).
+#
+# https://bugs.chromium.org/p/chromium/issues/detail?id=659439
+# https://developercommunity.visualstudio.com/t/c1090-pdb-api-call-failed-error-code-23/48897
+# https://docs.microsoft.com/en-us/cpp/build/reference/z7-zi-zi-debug-information-format?view=msvc-160
+if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+  foreach(flags
+    CMAKE_C_FLAGS_DEBUG
+    CMAKE_CXX_FLAGS_DEBUG
+    CMAKE_C_FLAGS_RELWITHDEBINFO
+    CMAKE_CXX_FLAGS_RELWITHDEBINFO
+    )
+    string(REGEX REPLACE "(^|[ \t])/Zi($|[ \t])" " /Z7 " "${flags}" "${${flags}}")
+  endforeach()
+endif()
+
+# https://clang.llvm.org/docs/AddressSanitizer.html
+option(ACL_WITH_ASAN "Build with address sanitizer" OFF)
+message(STATUS "Build with address sanitizer: ${ACL_WITH_ASAN}")
+if(ACL_WITH_ASAN)
+  foreach(lang C CXX)
+    if(CMAKE_${lang}_COMPILER_ID MATCHES "^(Clang|GNU)$")
+      set(CMAKE_${lang}_FLAGS "${CMAKE_${lang}_FLAGS} -fsanitize=address -fno-omit-frame-pointer")
+    else()
+      message(FATAL_ERROR "cannot build with address sanitizer due to unsupported ${lang} compiler")
+    endif()
+  endforeach()
+endif()
+
+include(CTest)
+
+# Get CMAKE_INSTALL_<dir> variables to enable custom library, binary, and include paths
+# See https://cmake.org/cmake/help/latest/module/GNUInstallDirs.html
+include(GNUInstallDirs)
+
+# acl_hostxml includes acl.h, but we don't want to create a cyclic dependency,
+# so we create a header only library here
+add_library(acl_headers INTERFACE)
+target_include_directories(acl_headers INTERFACE include)
+
+# Generate header containing the runtime version. The OUTPUT file *.phony is in
+# fact never written and ensures ninja always considers this target out of date.
+add_custom_command(
+  OUTPUT
+    "${CMAKE_BINARY_DIR}/include/acl_version.h"
+    "${CMAKE_BINARY_DIR}/include/acl_version.h.phony"
+  DEPENDS "${CMAKE_SOURCE_DIR}/include/acl_version.h.in"
+  COMMAND "${CMAKE_COMMAND}"
+    -D "ACL_VERSION_INPUT_FILE=${CMAKE_SOURCE_DIR}/include/acl_version.h.in"
+    -D "ACL_VERSION_OUTPUT_FILE=${CMAKE_BINARY_DIR}/include/acl_version.h"
+    -D "GIT_FOUND=${GIT_FOUND}"
+    -D "GIT_EXECUTABLE=${GIT_EXECUTABLE}"
+    -P "${CMAKE_CURRENT_LIST_DIR}/cmake/scripts/version.cmake"
+)
+
+add_library(acl_objs OBJECT
+  "${CMAKE_BINARY_DIR}/include/acl_version.h"
+  src/acl_auto_configure.cpp
+  src/acl_bsp_io.cpp
+  src/acl_command.cpp
+  src/acl_command_queue.cpp
+  src/acl_context.cpp
+  src/acl_device.cpp
+  src/acl_device_binary.cpp
+  src/acl_device_op.cpp
+  src/acl_device_program_info.cpp
+  src/acl_event.cpp
+  src/acl_globals.cpp
+  src/acl_hal.cpp
+  src/acl_hal_mmd.cpp
+  src/acl_hostch.cpp
+  src/acl_icd_dispatch.cpp
+  src/acl_kernel.cpp
+  src/acl_kernel_if.cpp
+  src/acl_mem.cpp
+  src/acl_offline_hal.cpp
+  src/acl_platform.cpp
+  src/acl_pll.cpp
+  src/acl_printf.cpp
+  src/acl_profiler.cpp
+  src/acl_program.cpp
+  src/acl_sampler.cpp
+  src/acl_shared_aligned_ptr.cpp
+  src/acl_support.cpp
+  src/acl_svm.cpp
+  src/acl_thread.cpp
+  src/acl_usm.cpp
+  src/check_copy_overlap.c
+  )
+set_target_properties(acl_objs PROPERTIES
+  CXX_EXTENSIONS OFF
+  POSITION_INDEPENDENT_CODE ON
+  )
+target_compile_features(acl_objs PRIVATE cxx_std_11)
+# These compile_definitions need to be public, since we're building an OBJECT library (?)
+target_compile_definitions(acl_objs PUBLIC
+  _GLIBCXX_USE_CXX11_ABI=0
+  ACL_SUPPORT_DOUBLE=0
+  ACL_HAS_STDLIB_STDIO
+  CL_USE_DEPRECATED_OPENCL_1_0_APIS=1
+  CL_USE_DEPRECATED_OPENCL_1_1_APIS=1
+  CL_USE_DEPRECATED_OPENCL_1_2_APIS=1
+  CL_TARGET_OPENCL_VERSION=200
+  )
+target_include_directories(acl_objs PUBLIC include)
+target_include_directories(acl_objs PRIVATE
+  "${CMAKE_BINARY_DIR}/include"
+  src
+  )
+# "Linking" libraries to an OBJECT library is the preferred approach, but it is supported only after CMake 3.12
+# The oldest CMake version we need to support is 3.10
+# As older OS support becomes deprecated and we don't need to worry about CMake < 3.12, we can change this
+# See: https://cmake.org/cmake/help/v3.12/command/target_link_libraries.html#linking-object-libraries
+target_include_directories(acl_objs PRIVATE
+  "${CMAKE_SOURCE_DIR}/lib/acl_check_sys_cmd/include"
+  "${CMAKE_SOURCE_DIR}/lib/acl_hash/include"
+  "${CMAKE_SOURCE_DIR}/lib/acl_threadsupport/include"
+  "${CMAKE_SOURCE_DIR}/lib/pkg_editor/include"
+  )
+
+add_library(acl SHARED $<TARGET_OBJECTS:acl_objs>)
+set_property(TARGET acl PROPERTY OUTPUT_NAME "alteracl")
+target_link_libraries(acl PRIVATE acl_check_sys_cmd acl_hash acl_threadsupport pkg_editor)
+if(UNIX)
+  # we need this flag to expose symbols, otherwise linking will fail with:
+  # "relocation against protected symbol X can not be used when making a shared object"
+  set_target_properties(acl PROPERTIES LINK_FLAGS "-Wl,-Bsymbolic")
+endif()
+
+set_property(TARGET acl PROPERTY PUBLIC_HEADER
+  include/acl.h
+  include/acl_auto.h
+  include/acl_auto_configure.h
+  include/acl_auto_configure_version.h
+  include/acl_context.h
+  include/acl_device_binary.h
+  include/acl_globals.h
+  include/acl_hal.h
+  include/acl_hal_mmd.h
+  include/acl_hostch.h
+  include/acl_icd_dispatch.h
+  include/acl_shared_aligned_ptr.h
+  include/acl_support.h
+  include/acl_thread.h
+  include/acl_types.h
+  include/acl_util.h
+  include/acl_visibility.h
+  )
+
+set_property(TARGET acl PROPERTY WINDOWS_EXPORT_ALL_SYMBOLS ON)
+
+install(TARGETS acl
+  COMPONENT acl
+  LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
+  RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
+  PUBLIC_HEADER DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  )
+
+# Workaround for CL/[name].h and MMD/[name].h headers
+# There's a better way for CMake >= 3.15
+# Change this to be a header-only library and use PUBLIC_HEADER
+# see https://cmake.org/cmake/help/latest/command/add_library.html#interface-libraries
+
+install(FILES
+    include/CL/cl.h
+    include/CL/cl_d3d10.h
+    include/CL/cl_d3d11.h
+    include/CL/cl_dx9_media_sharing.h
+    include/CL/cl_dx9_media_sharing_intel.h
+    include/CL/cl_egl.h
+    include/CL/cl_ext.h
+    include/CL/cl_ext_intel.h
+    include/CL/cl_ext_intelfpga.h
+    include/CL/cl_gl.h
+    include/CL/cl_gl_ext.h
+    include/CL/cl_half.h
+    include/CL/cl_icd.h
+    include/CL/cl_platform.h
+    include/CL/cl_va_api_media_sharing_intel.h
+    include/CL/cl_version.h
+    include/CL/opencl.h
+    include/CL/opencl.hpp
+  COMPONENT CL
+  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/CL"
+  )
+
+install(FILES
+    include/MMD/aocl_mmd.h
+    include/MMD/aocl_mmd_deprecated.h
+  COMPONENT MMD
+  DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/MMD"
+  )
+
+add_subdirectory(lib)
+add_subdirectory(test)

LICENSE

@@ -0,0 +1,44 @@
+Intel(R) FPGA Runtime for OpenCL(TM) Software Technology
+========================================================
+
+Copyright (C) 2010-2021 Intel Corporation
+SPDX-License-Identifier: BSD-3-Clause
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions 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.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may 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 COPYRIGHT HOLDER 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.
+
+Software from third parties
+===========================
+
+The Intel(R) FPGA Runtime for OpenCL(TM) Software Technology includes software
+from third parties which are subject to their respective license terms that are
+provided in either or both of these two forms:
+
+1. A separate `COPYING` or `LICENSE` file stating the license terms which
+   apply to all files in that directory and its subdirectories, with the
+   exception of files stating other license terms at the top of the file.
+
+2. The license terms are stated at the top of the file.

cmake/modules/FindElf.cmake

@@ -0,0 +1,27 @@
+# Copyright (C) 2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+
+find_path(Elf_INCLUDE_DIR NAMES libelf/libelf.h libelf.h)
+
+if(Elf_INCLUDE_DIR AND EXISTS "${Elf_INCLUDE_DIR}/libelf/libelf.h")
+  set(Elf_HAVE_LIBELF_LIBELF TRUE)
+else()
+  set(Elf_HAVE_LIBELF_LIBELF FALSE)
+endif()
+
+find_library(Elf_LIBRARY NAMES elf libelf)
+
+mark_as_advanced(Elf_INCLUDE_DIR Elf_LIBRARY)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Elf REQUIRED_VARS Elf_INCLUDE_DIR Elf_LIBRARY)
+
+if(Elf_FOUND)
+  add_library(Elf::Elf UNKNOWN IMPORTED)
+  set_target_properties(Elf::Elf PROPERTIES
+    IMPORTED_LINK_INTERFACE_LANGUAGES C
+    IMPORTED_LOCATION "${Elf_LIBRARY}"
+    INTERFACE_INCLUDE_DIRECTORIES "${Elf_INCLUDE_DIR}"
+    INTERFACE_COMPILE_DEFINITIONS "$<$<BOOL:${Elf_HAVE_LIBELF_LIBELF}>:HAVE_LIBELF_LIBELF>"
+    )
+endif()

cmake/scripts/version.cmake

@@ -0,0 +1,31 @@
+# Copyright (C) 2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+
+# This script generates a header containing the runtime version based on the
+# output of git describe, which generates a human readable name for a commit.
+
+# Use upper case to signal that this is a placeholder value.
+set(ACL_GIT_COMMIT "UNKNOWN")
+
+# The extraction of the git commit is strictly optional; if a failure occurs
+# due to any reason, the placeholder value for ACL_GIT_COMMIT must be retained.
+if(GIT_FOUND)
+  execute_process(
+    COMMAND "${GIT_EXECUTABLE}" describe --always --dirty --first-parent --long
+    RESULT_VARIABLE ACL_GIT_DESCRIBE_RESULT
+    OUTPUT_VARIABLE ACL_GIT_DESCRIBE_OUTPUT
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+  if(ACL_GIT_DESCRIBE_RESULT EQUAL 0 AND ACL_GIT_DESCRIBE_OUTPUT)
+    set(ACL_GIT_COMMIT "${ACL_GIT_DESCRIBE_OUTPUT}")
+  endif()
+endif()
+
+# This only writes the output file when the content has changed, which in turn
+# only triggers a rebuild of dependent source files when the commit changes.
+configure_file(
+  "${ACL_VERSION_INPUT_FILE}"
+  "${ACL_VERSION_OUTPUT_FILE}"
+  @ONLY
+)

include/CL/.clang-format

@@ -0,0 +1,5 @@
+# Copyright (C) 2021 Intel Corporation
+# SPDX-License-Identifier: BSD-3-Clause
+
+DisableFormat: true
+SortIncludes: false