Add files using upload-large-folder tool

.gitattributes

@@ -98,3 +98,4 @@ miniCUDA124/bin/nvrtc-builtins64_124.dll filter=lfs diff=lfs merge=lfs -text
 miniCUDA124/bin/nvjpeg64_12.dll filter=lfs diff=lfs merge=lfs -text
 ffmpeg/bin/avfilter-10.dll filter=lfs diff=lfs merge=lfs -text
 ComfyUI-YoloWorld-EfficientSAM/efficient_sam_s_cpu.jit filter=lfs diff=lfs merge=lfs -text
+miniCUDA124/lib/x64/cudadevrt.lib filter=lfs diff=lfs merge=lfs -text

miniCUDA124/lib/cmake/cccl/cccl-config-version.cmake

@@ -0,0 +1,22 @@
+set(CCCL_VERSION_MAJOR 2)
+set(CCCL_VERSION_MINOR 3)
+set(CCCL_VERSION_PATCH 2)
+set(CCCL_VERSION_TWEAK 0)
+
+set(CCCL_VERSION "${CCCL_VERSION_MAJOR}.${CCCL_VERSION_MINOR}.${CCCL_VERSION_PATCH}.${CCCL_VERSION_TWEAK}")
+
+set(PACKAGE_VERSION ${CCCL_VERSION})
+set(PACKAGE_VERSION_COMPATIBLE FALSE)
+set(PACKAGE_VERSION_EXACT FALSE)
+set(PACKAGE_VERSION_UNSUITABLE FALSE)
+
+# Semantic versioning:
+if(PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION)
+  if(CCCL_VERSION_MAJOR VERSION_EQUAL PACKAGE_FIND_VERSION_MAJOR)
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+
+  if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()

miniCUDA124/lib/cmake/cccl/cccl-config.cmake

@@ -0,0 +1,103 @@
+#
+# find_package(CCCL) config file.
+#
+# Imports the Thrust, CUB, and libcudacxx components of the NVIDIA
+# CUDA/C++ Core Libraries.
+
+set(cccl_cmake_dir "${CMAKE_CURRENT_LIST_DIR}")
+
+if (${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+  set(cccl_quiet_flag "QUIET")
+else()
+  set(cccl_quiet_flag "")
+endif()
+
+if (DEFINED ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS AND
+    ${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS)
+  set(components ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS})
+else()
+  set(components Thrust CUB libcudacxx)
+endif()
+
+if (NOT TARGET CCCL::CCCL)
+  add_library(CCCL::CCCL INTERFACE IMPORTED GLOBAL)
+endif()
+
+foreach(component IN LISTS components)
+  string(TOLOWER "${component}" component_lower)
+
+  unset(req)
+  if (${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${component})
+    set(cccl_comp_required_flag "REQUIRED")
+  endif()
+
+  if(component_lower STREQUAL "libcudacxx")
+    find_package(libcudacxx ${CCCL_VERSION} EXACT CONFIG
+      ${cccl_quiet_flag}
+      ${cccl_comp_required_flag}
+      NO_DEFAULT_PATH # Only check the explicit HINTS below:
+      HINTS
+        "${cccl_cmake_dir}/../../../libcudacxx/lib/cmake/" # Source layout (GitHub)
+        "${cccl_cmake_dir}/.."                             # Install layout
+    )
+    # Can't alias other alias targets, so use the uglified target name instead
+    # of libcudacxx::libcudacxx:
+    if (TARGET _libcudacxx_libcudacxx AND NOT TARGET CCCL::libcudacxx)
+      add_library(CCCL::libcudacxx ALIAS _libcudacxx_libcudacxx)
+      target_link_libraries(CCCL::CCCL INTERFACE CCCL::libcudacxx)
+    endif()
+  elseif(component_lower STREQUAL "cub")
+    find_package(CUB ${CCCL_VERSION} EXACT CONFIG
+      ${cccl_quiet_flag}
+      ${cccl_comp_required_flag}
+      NO_DEFAULT_PATH # Only check the explicit HINTS below:
+      HINTS
+        "${cccl_cmake_dir}/../../../cub/cub/cmake/" # Source layout (GitHub)
+        "${cccl_cmake_dir}/.."                      # Install layout
+    )
+    # Can't alias other alias targets, so use the uglified target name instead
+    # of CUB::CUB:
+    if (TARGET _CUB_CUB AND NOT TARGET CCCL::CUB)
+      add_library(CCCL::CUB ALIAS _CUB_CUB)
+      target_link_libraries(CCCL::CCCL INTERFACE CCCL::CUB)
+    endif()
+  elseif(component_lower STREQUAL "thrust")
+    find_package(Thrust ${CCCL_VERSION} EXACT CONFIG
+      ${cccl_quiet_flag}
+      ${cccl_comp_required_flag}
+      NO_DEFAULT_PATH # Only check the explicit HINTS below:
+      HINTS
+        "${cccl_cmake_dir}/../../../thrust/thrust/cmake/" # Source layout (GitHub)
+        "${cccl_cmake_dir}/.."                            # Install layout
+    )
+
+    if (TARGET Thrust::Thrust AND NOT TARGET CCCL::Thrust)
+      # By default, configure a CCCL::Thrust target with host=cpp device=cuda
+      option(CCCL_ENABLE_DEFAULT_THRUST_TARGET
+        "Create a CCCL::Thrust target using CCCL_THRUST_[HOST|DEVICE]_SYSTEM."
+        ON
+      )
+      mark_as_advanced(CCCL_ENABLE_DEFAULT_THRUST_TARGET)
+      if (CCCL_ENABLE_DEFAULT_THRUST_TARGET)
+        thrust_create_target(CCCL::Thrust FROM_OPTIONS
+          HOST_OPTION CCCL_THRUST_HOST_SYSTEM
+          DEVICE_OPTION CCCL_THRUST_DEVICE_SYSTEM
+          HOST_OPTION_DOC
+            "Host system for CCCL::Thrust target."
+          DEVICE_OPTION_DOC
+            "Device system for CCCL::Thrust target."
+          ADVANCED
+        )
+        target_link_libraries(CCCL::CCCL INTERFACE CCCL::Thrust)
+      endif()
+    endif()
+  else()
+    message(FATAL_ERROR "Invalid CCCL component requested: '${component}'")
+  endif()
+endforeach()
+
+include(FindPackageHandleStandardArgs)
+if (NOT CCCL_CONFIG)
+  set(CCCL_CONFIG "${CMAKE_CURRENT_LIST_FILE}")
+endif()
+find_package_handle_standard_args(CCCL CONFIG_MODE)

miniCUDA124/lib/cmake/cub/cub-config-version.cmake

@@ -0,0 +1,24 @@
+# Parse version information from version.cuh:
+include("${CMAKE_CURRENT_LIST_DIR}/cub-header-search.cmake")
+
+set(CUB_VERSION_MAJOR 2)
+set(CUB_VERSION_MINOR 3)
+set(CUB_VERSION_PATCH 2)
+set(CUB_VERSION_TWEAK 0)
+set(CUB_VERSION "${CUB_VERSION_MAJOR}.${CUB_VERSION_MINOR}.${CUB_VERSION_PATCH}.${CUB_VERSION_TWEAK}")
+
+set(PACKAGE_VERSION ${CUB_VERSION})
+set(PACKAGE_VERSION_COMPATIBLE FALSE)
+set(PACKAGE_VERSION_EXACT FALSE)
+set(PACKAGE_VERSION_UNSUITABLE FALSE)
+
+if(PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION)
+  if(CUB_VERSION_MAJOR VERSION_EQUAL PACKAGE_FIND_VERSION_MAJOR AND
+     CUB_VERSION_MINOR VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MINOR)
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+
+  if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()

miniCUDA124/lib/cmake/cub/cub-config.cmake

@@ -0,0 +1,126 @@
+#
+# find_package(CUB) config file.
+#
+# Defines a CUB::CUB target that may be linked from user projects to include
+# CUB.
+
+if (TARGET CUB::CUB)
+  return()
+endif()
+
+# Minimum supported libcudacxx version:
+set(cub_libcudacxx_version "${CUB_VERSION}")
+
+function(_cub_declare_interface_alias alias_name ugly_name)
+  # 1) Only IMPORTED and ALIAS targets can be placed in a namespace.
+  # 2) When an IMPORTED library is linked to another target, its include
+  #    directories are treated as SYSTEM includes.
+  # 3) nvcc will automatically check the CUDA Toolkit include path *before* the
+  #    system includes. This means that the Toolkit CUB will *always* be used
+  #    during compilation, and the include paths of an IMPORTED CUB::CUB
+  #    target will never have any effect.
+  # 4) This behavior can be fixed by setting the property NO_SYSTEM_FROM_IMPORTED
+  #    on EVERY target that links to CUB::CUB. This would be a burden and a
+  #    footgun for our users. Forgetting this would silently pull in the wrong CUB!
+  # 5) A workaround is to make a non-IMPORTED library outside of the namespace,
+  #    configure it, and then ALIAS it into the namespace (or ALIAS and then
+  #    configure, that seems to work too).
+  add_library(${ugly_name} INTERFACE)
+  add_library(${alias_name} ALIAS ${ugly_name})
+endfunction()
+
+#
+# Setup some internal cache variables
+#
+
+# Pull in the include dir detected by cub-config-version.cmake
+set(_CUB_INCLUDE_DIR "${_CUB_VERSION_INCLUDE_DIR}"
+  CACHE INTERNAL "Location of CUB headers."
+  FORCE
+)
+unset(_CUB_VERSION_INCLUDE_DIR CACHE) # Clear tmp variable from cache
+
+if (${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+  set(_CUB_QUIET ON CACHE INTERNAL "Quiet mode enabled for CUB find_package calls." FORCE)
+  set(_CUB_QUIET_FLAG "QUIET" CACHE INTERNAL "" FORCE)
+else()
+  set(_CUB_QUIET OFF CACHE INTERNAL "Quiet mode enabled for CUB find_package calls." FORCE)
+  set(_CUB_QUIET_FLAG "" CACHE INTERNAL "" FORCE)
+endif()
+
+#
+# Setup dependencies
+#
+
+if (NOT TARGET CUB::libcudacxx)
+  if (TARGET Thrust::libcudacxx)
+    # Prefer the same libcudacxx as Thrust, if available:
+    _cub_declare_interface_alias(CUB::libcudacxx _CUB_libcudacxx)
+    target_link_libraries(_CUB_libcudacxx INTERFACE Thrust::libcudacxx)
+  else()
+    if (NOT TARGET libcudacxx::libcudacxx)
+      # First do a non-required search for any co-packaged versions.
+      # These are preferred.
+      find_package(libcudacxx ${cub_libcudacxx_version} CONFIG
+        ${_CUB_QUIET_FLAG}
+        NO_DEFAULT_PATH # Only check the explicit HINTS below:
+        HINTS
+          "${_CUB_INCLUDE_DIR}/../libcudacxx"           # Source layout
+          "${_CUB_CMAKE_DIR}/.."                        # Install layout
+      )
+
+      # A second required search allows externally packaged to be used and fails if
+      # no suitable package exists.
+      find_package(libcudacxx ${cub_libcudacxx_version} CONFIG
+        REQUIRED
+        ${_CUB_QUIET_FLAG}
+      )
+    endif()
+    _cub_declare_interface_alias(CUB::libcudacxx _CUB_libcudacxx)
+    target_link_libraries(_CUB_libcudacxx INTERFACE libcudacxx::libcudacxx)
+  endif()
+endif()
+
+#
+# Setup targets
+#
+
+_cub_declare_interface_alias(CUB::CUB _CUB_CUB)
+target_include_directories(_CUB_CUB INTERFACE "${_CUB_INCLUDE_DIR}")
+target_link_libraries(_CUB_CUB INTERFACE CUB::libcudacxx)
+
+if (CUB_IGNORE_DEPRECATED_API OR THRUST_IGNORE_DEPRECATED_API)
+  target_compile_definitions(_CUB_CUB INTERFACE "CUB_IGNORE_DEPRECATED_API")
+endif()
+
+if (CUB_IGNORE_DEPRECATED_CPP_DIALECT OR
+    THRUST_IGNORE_DEPRECATED_CPP_DIALECT)
+  target_compile_definitions(_CUB_CUB INTERFACE "CUB_IGNORE_DEPRECATED_CPP_DIALECT")
+endif()
+
+if (CUB_IGNORE_DEPRECATED_CPP_11 OR
+    THRUST_IGNORE_DEPRECATED_CPP_11)
+  target_compile_definitions(_CUB_CUB INTERFACE "CUB_IGNORE_DEPRECATED_CPP_11")
+endif()
+
+if (CUB_IGNORE_DEPRECATED_COMPILER OR
+    THRUST_IGNORE_DEPRECATED_COMPILER)
+  target_compile_definitions(_CUB_CUB INTERFACE "CUB_IGNORE_DEPRECATED_COMPILER")
+endif()
+
+#
+# Standardize version info
+#
+
+set(CUB_VERSION ${${CMAKE_FIND_PACKAGE_NAME}_VERSION} CACHE INTERNAL "" FORCE)
+set(CUB_VERSION_MAJOR ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_MAJOR} CACHE INTERNAL "" FORCE)
+set(CUB_VERSION_MINOR ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_MINOR} CACHE INTERNAL "" FORCE)
+set(CUB_VERSION_PATCH ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_PATCH} CACHE INTERNAL "" FORCE)
+set(CUB_VERSION_TWEAK ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_TWEAK} CACHE INTERNAL "" FORCE)
+set(CUB_VERSION_COUNT ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_COUNT} CACHE INTERNAL "" FORCE)
+
+include(FindPackageHandleStandardArgs)
+if (NOT CUB_CONFIG)
+  set(CUB_CONFIG "${CMAKE_CURRENT_LIST_FILE}")
+endif()
+find_package_handle_standard_args(CUB CONFIG_MODE)

miniCUDA124/lib/cmake/cub/cub-header-search.cmake

@@ -0,0 +1,19 @@
+# Parse version information from version.h:
+unset(_CUB_VERSION_INCLUDE_DIR CACHE) # Clear old result to force search
+
+# Find CMAKE_INSTALL_INCLUDEDIR=include directory"
+set(from_install_prefix "lib/cmake/cub")
+
+# Transform to a list of directories, replace each directoy with "../"
+# and convert back to a string
+string(REGEX REPLACE "/" ";" from_install_prefix "${from_install_prefix}")
+list(TRANSFORM from_install_prefix REPLACE ".+" "../")
+list(JOIN from_install_prefix "" from_install_prefix)
+
+find_path(_CUB_VERSION_INCLUDE_DIR cub/version.cuh
+  NO_CMAKE_FIND_ROOT_PATH # Don't allow CMake to re-root the search
+  NO_DEFAULT_PATH # Only search explicit paths below:
+  PATHS
+    "${CMAKE_CURRENT_LIST_DIR}/${from_install_prefix}/include"
+)
+set_property(CACHE _CUB_VERSION_INCLUDE_DIR PROPERTY TYPE INTERNAL)

miniCUDA124/lib/cmake/libcudacxx/libcudacxx-config-version.cmake

@@ -0,0 +1,34 @@
+# Parse version information from version header:
+include("${CMAKE_CURRENT_LIST_DIR}/libcudacxx-header-search.cmake")
+
+set(libcudacxx_VERSION_MAJOR 2)
+set(libcudacxx_VERSION_MINOR 3)
+set(libcudacxx_VERSION_PATCH 2)
+set(libcudacxx_VERSION_TWEAK 0)
+
+set(libcudacxx_VERSION
+  "${libcudacxx_VERSION_MAJOR}.${libcudacxx_VERSION_MINOR}.${libcudacxx_VERSION_PATCH}.${libcudacxx_VERSION_TWEAK}"
+)
+
+set(PACKAGE_VERSION ${libcudacxx_VERSION})
+set(PACKAGE_VERSION_COMPATIBLE FALSE)
+set(PACKAGE_VERSION_EXACT FALSE)
+set(PACKAGE_VERSION_UNSUITABLE FALSE)
+
+if(PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION)
+  # Semantic version check:
+  if(libcudacxx_VERSION_MAJOR VERSION_EQUAL PACKAGE_FIND_VERSION_MAJOR)
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+
+  # Special case: Major version 1->2 was bumped to sync with other CCCL
+  # libraries. There was no break, and requests for 1 are compatible with 2.
+  if(PACKAGE_FIND_VERSION VERSION_EQUAL 1 AND
+     libcudacxx_VERSION_MAJOR VERSION_EQUAL 2)
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+
+    if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()

miniCUDA124/lib/cmake/libcudacxx/libcudacxx-config.cmake

@@ -0,0 +1,58 @@
+#
+# find_package(libcudacxx) config file.
+#
+# Defines a libcudacxx::libcudacxx target that may be linked from user projects to include
+# libcudacxx.
+
+if (TARGET libcudacxx::libcudacxx)
+  return()
+endif()
+
+function(_libcudacxx_declare_interface_alias alias_name ugly_name)
+  # 1) Only IMPORTED and ALIAS targets can be placed in a namespace.
+  # 2) When an IMPORTED library is linked to another target, its include
+  #    directories are treated as SYSTEM includes.
+  # 3) nvcc will automatically check the CUDA Toolkit include path *before* the
+  #    system includes. This means that the Toolkit libcudacxx will *always* be used
+  #    during compilation, and the include paths of an IMPORTED libcudacxx::libcudacxx
+  #    target will never have any effect.
+  # 4) This behavior can be fixed by setting the property NO_SYSTEM_FROM_IMPORTED
+  #    on EVERY target that links to libcudacxx::libcudacxx. This would be a burden and a
+  #    footgun for our users. Forgetting this would silently pull in the wrong libcudacxx!
+  # 5) A workaround is to make a non-IMPORTED library outside of the namespace,
+  #    configure it, and then ALIAS it into the namespace (or ALIAS and then
+  #    configure, that seems to work too).
+  add_library(${ugly_name} INTERFACE)
+
+  add_library(${alias_name} INTERFACE IMPORTED GLOBAL)
+  target_link_libraries(${alias_name} INTERFACE ${ugly_name})
+endfunction()
+
+#
+# Setup targets
+#
+
+_libcudacxx_declare_interface_alias(libcudacxx::libcudacxx _libcudacxx_libcudacxx)
+# Pull in the include dir detected by libcudacxx-config-version.cmake
+set(_libcudacxx_INCLUDE_DIR "${_libcudacxx_VERSION_INCLUDE_DIR}"
+  CACHE INTERNAL "Location of libcudacxx headers."
+)
+unset(_libcudacxx_VERSION_INCLUDE_DIR CACHE) # Clear tmp variable from cache
+target_include_directories(_libcudacxx_libcudacxx INTERFACE "${_libcudacxx_INCLUDE_DIR}")
+
+#
+# Standardize version info
+#
+
+set(LIBCUDACXX_VERSION ${${CMAKE_FIND_PACKAGE_NAME}_VERSION} CACHE INTERNAL "")
+set(LIBCUDACXX_VERSION_MAJOR ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_MAJOR} CACHE INTERNAL "")
+set(LIBCUDACXX_VERSION_MINOR ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_MINOR} CACHE INTERNAL "")
+set(LIBCUDACXX_VERSION_PATCH ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_PATCH} CACHE INTERNAL "")
+set(LIBCUDACXX_VERSION_TWEAK ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_TWEAK} CACHE INTERNAL "")
+set(LIBCUDACXX_VERSION_COUNT ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_COUNT} CACHE INTERNAL "")
+
+include(FindPackageHandleStandardArgs)
+if (NOT libcudacxx_CONFIG)
+  set(libcudacxx_CONFIG "${CMAKE_CURRENT_LIST_FILE}")
+endif()
+find_package_handle_standard_args(libcudacxx CONFIG_MODE)

miniCUDA124/lib/cmake/libcudacxx/libcudacxx-header-search.cmake

@@ -0,0 +1,13 @@
+# Parse version information from version header:
+unset(_libcudacxx_VERSION_INCLUDE_DIR CACHE) # Clear old result to force search
+
+# Find CMAKE_INSTALL_INCLUDEDIR=include directory"
+set(from_install_prefix "../../../")
+
+find_path(_libcudacxx_VERSION_INCLUDE_DIR cuda/std/detail/__config
+  NO_CMAKE_FIND_ROOT_PATH # Don't allow CMake to re-root the search
+  NO_DEFAULT_PATH # Only search explicit paths below:
+  PATHS
+    "${CMAKE_CURRENT_LIST_DIR}/${from_install_prefix}/include" # Install tree
+)
+set_property(CACHE _libcudacxx_VERSION_INCLUDE_DIR PROPERTY TYPE INTERNAL)

miniCUDA124/lib/cmake/thrust/FindTBB.cmake

@@ -0,0 +1,446 @@
+# - Find ThreadingBuildingBlocks include dirs and libraries
+# Use this module by invoking find_package with the form:
+#  find_package(TBB
+#    [REQUIRED]             # Fail with error if TBB is not found
+#    )                      #
+# Once done, this will define
+#
+#  TBB_FOUND - system has TBB
+#  TBB_INCLUDE_DIRS - the TBB include directories
+#  TBB_LIBRARIES - TBB libraries to be lined, doesn't include malloc or
+#                  malloc proxy
+#  TBB::tbb - imported target for the TBB library
+#
+#  TBB_VERSION - Product Version Number ("MAJOR.MINOR")
+#  TBB_VERSION_MAJOR - Major Product Version Number
+#  TBB_VERSION_MINOR - Minor Product Version Number
+#  TBB_INTERFACE_VERSION - Engineering Focused Version Number
+#  TBB_COMPATIBLE_INTERFACE_VERSION - The oldest major interface version
+#                                     still supported. This uses the engineering
+#                                     focused interface version numbers.
+#
+#  TBB_MALLOC_FOUND - system has TBB malloc library
+#  TBB_MALLOC_INCLUDE_DIRS - the TBB malloc include directories
+#  TBB_MALLOC_LIBRARIES - The TBB malloc libraries to be lined
+#  TBB::malloc - imported target for the TBB malloc library
+#
+#  TBB_MALLOC_PROXY_FOUND - system has TBB malloc proxy library
+#  TBB_MALLOC_PROXY_INCLUDE_DIRS = the TBB malloc proxy include directories
+#  TBB_MALLOC_PROXY_LIBRARIES - The TBB malloc proxy libraries to be lined
+#  TBB::malloc_proxy - imported target for the TBB malloc proxy library
+#
+#
+# This module reads hints about search locations from variables:
+#  ENV TBB_ARCH_PLATFORM - for eg. set it to "mic" for Xeon Phi builds
+#  ENV TBB_ROOT or just TBB_ROOT - root directory of tbb installation
+#  ENV TBB_BUILD_PREFIX - specifies the build prefix for user built tbb
+#                         libraries. Should be specified with ENV TBB_ROOT
+#                         and optionally...
+#  ENV TBB_BUILD_DIR - if build directory is different than ${TBB_ROOT}/build
+#
+#
+# Modified by Robert Maynard from the original OGRE source
+#
+#-------------------------------------------------------------------
+# This file is part of the CMake build system for OGRE
+#     (Object-oriented Graphics Rendering Engine)
+# For the latest info, see http://www.ogre3d.org/
+#
+# The contents of this file are placed in the public domain. Feel
+# free to make use of it in any way you like.
+#-------------------------------------------------------------------
+#
+#=============================================================================
+# Copyright 2010-2012 Kitware, Inc.
+# Copyright 2012      Rolf Eike Beer <eike@sf-mail.de>
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+
+#=============================================================================
+#  FindTBB helper functions and macros
+#
+
+#====================================================
+# Fix the library path in case it is a linker script
+#====================================================
+function(tbb_extract_real_library library real_library)
+  if(NOT UNIX OR NOT EXISTS ${library})
+    set(${real_library} "${library}" PARENT_SCOPE)
+    return()
+  endif()
+
+  #Read in the first 4 bytes and see if they are the ELF magic number
+  set(_elf_magic "7f454c46")
+  file(READ ${library} _hex_data OFFSET 0 LIMIT 4 HEX)
+  if(_hex_data STREQUAL _elf_magic)
+    #we have opened a elf binary so this is what
+    #we should link to
+    set(${real_library} "${library}" PARENT_SCOPE)
+    return()
+  endif()
+
+  file(READ ${library} _data OFFSET 0 LIMIT 1024)
+  if("${_data}" MATCHES "INPUT \\(([^(]+)\\)")
+    #extract out the .so name from REGEX MATCH command
+    set(_proper_so_name "${CMAKE_MATCH_1}")
+
+    #construct path to the real .so which is presumed to be in the same directory
+    #as the input file
+    get_filename_component(_so_dir "${library}" DIRECTORY)
+    set(${real_library} "${_so_dir}/${_proper_so_name}" PARENT_SCOPE)
+  else()
+    #unable to determine what this library is so just hope everything works
+    #and pass it unmodified.
+    set(${real_library} "${library}" PARENT_SCOPE)
+  endif()
+endfunction()
+
+#===============================================
+# Do the final processing for the package find.
+#===============================================
+macro(findpkg_finish PREFIX TARGET_NAME)
+  if (${PREFIX}_INCLUDE_DIR AND ${PREFIX}_LIBRARY)
+    set(${PREFIX}_FOUND TRUE)
+    set (${PREFIX}_INCLUDE_DIRS ${${PREFIX}_INCLUDE_DIR})
+    set (${PREFIX}_LIBRARIES ${${PREFIX}_LIBRARY})
+  else ()
+    if (${PREFIX}_FIND_REQUIRED)
+      message(FATAL_ERROR "Required library ${PREFIX} not found.")
+    elseif (NOT ${PREFIX}_FIND_QUIETLY)
+      message("Library ${PREFIX} not found.")
+    endif()
+    return()
+  endif ()
+
+  if (NOT TARGET "TBB::${TARGET_NAME}")
+    if (${PREFIX}_LIBRARY_RELEASE)
+      tbb_extract_real_library(${${PREFIX}_LIBRARY_RELEASE} real_release)
+    endif ()
+    if (${PREFIX}_LIBRARY_DEBUG)
+      tbb_extract_real_library(${${PREFIX}_LIBRARY_DEBUG} real_debug)
+    endif ()
+    add_library(TBB::${TARGET_NAME} UNKNOWN IMPORTED)
+    set_target_properties(TBB::${TARGET_NAME} PROPERTIES
+      INTERFACE_INCLUDE_DIRECTORIES "${${PREFIX}_INCLUDE_DIR}")
+    if (${PREFIX}_LIBRARY_DEBUG AND ${PREFIX}_LIBRARY_RELEASE)
+      set_target_properties(TBB::${TARGET_NAME} PROPERTIES
+        IMPORTED_LOCATION "${real_release}"
+        IMPORTED_LOCATION_DEBUG "${real_debug}"
+        IMPORTED_LOCATION_RELEASE "${real_release}")
+    elseif (${PREFIX}_LIBRARY_RELEASE)
+      set_target_properties(TBB::${TARGET_NAME} PROPERTIES
+        IMPORTED_LOCATION "${real_release}")
+    elseif (${PREFIX}_LIBRARY_DEBUG)
+      set_target_properties(TBB::${TARGET_NAME} PROPERTIES
+        IMPORTED_LOCATION "${real_debug}")
+    endif ()
+  endif ()
+
+  #mark the following variables as internal variables
+  mark_as_advanced(${PREFIX}_INCLUDE_DIR
+                   ${PREFIX}_LIBRARY
+                   ${PREFIX}_LIBRARY_DEBUG
+                   ${PREFIX}_LIBRARY_RELEASE)
+endmacro()
+
+#===============================================
+# Generate debug names from given release names
+#===============================================
+macro(get_debug_names PREFIX)
+  foreach(i ${${PREFIX}})
+    set(${PREFIX}_DEBUG ${${PREFIX}_DEBUG} ${i}d ${i}D ${i}_d ${i}_D ${i}_debug ${i})
+  endforeach()
+endmacro()
+
+#===============================================
+# See if we have env vars to help us find tbb
+#===============================================
+macro(getenv_path VAR)
+   set(ENV_${VAR} $ENV{${VAR}})
+   # replace won't work if var is blank
+   if (ENV_${VAR})
+     string( REGEX REPLACE "\\\\" "/" ENV_${VAR} ${ENV_${VAR}} )
+   endif ()
+endmacro()
+
+#===============================================
+# Couple a set of release AND debug libraries
+#===============================================
+macro(make_library_set PREFIX)
+  if (${PREFIX}_RELEASE AND ${PREFIX}_DEBUG)
+    set(${PREFIX} optimized ${${PREFIX}_RELEASE} debug ${${PREFIX}_DEBUG})
+  elseif (${PREFIX}_RELEASE)
+    set(${PREFIX} ${${PREFIX}_RELEASE})
+  elseif (${PREFIX}_DEBUG)
+    set(${PREFIX} ${${PREFIX}_DEBUG})
+  endif ()
+endmacro()
+
+
+#=============================================================================
+#  Now to actually find TBB
+#
+
+# Get path, convert backslashes as ${ENV_${var}}
+getenv_path(TBB_ROOT)
+
+# initialize search paths
+set(TBB_PREFIX_PATH ${TBB_ROOT} ${ENV_TBB_ROOT})
+set(TBB_INC_SEARCH_PATH "")
+set(TBB_LIB_SEARCH_PATH "")
+
+
+# If user built from sources
+set(TBB_BUILD_PREFIX $ENV{TBB_BUILD_PREFIX})
+if (TBB_BUILD_PREFIX AND ENV_TBB_ROOT)
+  getenv_path(TBB_BUILD_DIR)
+  if (NOT ENV_TBB_BUILD_DIR)
+    set(ENV_TBB_BUILD_DIR ${ENV_TBB_ROOT}/build)
+  endif ()
+
+  # include directory under ${ENV_TBB_ROOT}/include
+  list(APPEND TBB_LIB_SEARCH_PATH
+    ${ENV_TBB_BUILD_DIR}/${TBB_BUILD_PREFIX}_release
+    ${ENV_TBB_BUILD_DIR}/${TBB_BUILD_PREFIX}_debug)
+endif ()
+
+
+# For Windows, let's assume that the user might be using the precompiled
+# TBB packages from the main website. These use a rather awkward directory
+# structure (at least for automatically finding the right files) depending
+# on platform and compiler, but we'll do our best to accommodate it.
+# Not adding the same effort for the precompiled linux builds, though. Those
+# have different versions for CC compiler versions and linux kernels which
+# will never adequately match the user's setup, so there is no feasible way
+# to detect the "best" version to use. The user will have to manually
+# select the right files. (Chances are the distributions are shipping their
+# custom version of tbb, anyway, so the problem is probably nonexistent.)
+if (WIN32 AND MSVC)
+  set(COMPILER_PREFIX "vc7.1")
+  if (MSVC_VERSION EQUAL 1400)
+    set(COMPILER_PREFIX "vc8")
+  elseif(MSVC_VERSION EQUAL 1500)
+    set(COMPILER_PREFIX "vc9")
+  elseif(MSVC_VERSION EQUAL 1600)
+    set(COMPILER_PREFIX "vc10")
+  elseif(MSVC_VERSION EQUAL 1700)
+    set(COMPILER_PREFIX "vc11")
+  elseif(MSVC_VERSION EQUAL 1800)
+    set(COMPILER_PREFIX "vc12")
+  elseif(MSVC_VERSION GREATER_EQUAL 1900 AND MSVC_VERSION LESS_EQUAL 1939)
+      # 1900-1925 actually spans three Visual Studio versions:
+      # 1900      = VS 14.0 (v140 toolset) a.k.a. MSVC 2015
+      # 1910-1919 = VS 15.0 (v141 toolset) a.k.a. MSVC 2017
+      # 1920-1929 = VS 16.0 (v142 toolset) a.k.a. MSVC 2019
+      # 1930-1939 = VS 17.0 (v143 toolset) a.k.a. MSVC 2022
+      #
+      # But these are binary compatible and TBB's open source distribution only
+      # ships a single vs14 lib (as of 2020.0)
+    set(COMPILER_PREFIX "vc14")
+  else()
+    # The next poor soul who finds themselves having to decode visual studio
+    # version conventions may find these helpful:
+    # - https://cmake.org/cmake/help/latest/variable/MSVC_VERSION.html
+    # - https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Internal_version_numbering
+    message(AUTHOR_WARNING
+      "Unrecognized MSVC version (${MSVC_VERSION}). "
+      "Please update FindTBB.cmake. "
+      "Some TBB_* CMake variables may need to be set manually."
+    )
+  endif ()
+
+  # for each prefix path, add ia32/64\${COMPILER_PREFIX}\lib to the lib search path
+  foreach (dir IN LISTS TBB_PREFIX_PATH)
+    if (CMAKE_CL_64)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia64/${COMPILER_PREFIX}/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia64/${COMPILER_PREFIX})
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/${COMPILER_PREFIX}/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64/${COMPILER_PREFIX})
+    else ()
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/${COMPILER_PREFIX}/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32/${COMPILER_PREFIX})
+    endif ()
+  endforeach ()
+endif ()
+
+# For OS X binary distribution, choose libc++ based libraries for Mavericks (10.9)
+# and above and AppleClang
+if (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND
+    NOT CMAKE_SYSTEM_VERSION VERSION_LESS 13.0)
+  set (USE_LIBCXX OFF)
+  cmake_policy(GET CMP0025 POLICY_VAR)
+
+  if (POLICY_VAR STREQUAL "NEW")
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+      set (USE_LIBCXX ON)
+    endif ()
+  else ()
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+      set (USE_LIBCXX ON)
+    endif ()
+  endif ()
+
+  if (USE_LIBCXX)
+    foreach (dir IN LISTS TBB_PREFIX_PATH)
+      list (APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/libc++ ${dir}/libc++/lib)
+    endforeach ()
+  endif ()
+endif ()
+
+# check compiler ABI
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  set(COMPILER_PREFIX)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
+    list(APPEND COMPILER_PREFIX "gcc4.7")
+  endif()
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.4)
+    list(APPEND COMPILER_PREFIX "gcc4.4")
+  endif()
+  list(APPEND COMPILER_PREFIX "gcc4.1")
+elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  set(COMPILER_PREFIX)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.6)
+    list(APPEND COMPILER_PREFIX "gcc4.7")
+  endif()
+  list(APPEND COMPILER_PREFIX "gcc4.4")
+else() # Assume compatibility with 4.4 for other compilers
+  list(APPEND COMPILER_PREFIX "gcc4.4")
+endif ()
+
+# if platform architecture is explicitly specified
+set(TBB_ARCH_PLATFORM $ENV{TBB_ARCH_PLATFORM})
+if (TBB_ARCH_PLATFORM)
+  foreach (dir IN LISTS TBB_PREFIX_PATH)
+    list(APPEND TBB_LIB_SEARCH_PATH ${dir}/${TBB_ARCH_PLATFORM}/lib)
+    list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/${TBB_ARCH_PLATFORM})
+  endforeach ()
+endif ()
+
+foreach (dir IN LISTS TBB_PREFIX_PATH)
+  foreach (prefix IN LISTS COMPILER_PREFIX)
+    if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/intel64/${prefix})
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/intel64/${prefix}/lib)
+    else ()
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib/ia32/${prefix})
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/lib)
+      list(APPEND TBB_LIB_SEARCH_PATH ${dir}/ia32/${prefix}/lib)
+    endif ()
+  endforeach()
+endforeach ()
+
+# add general search paths
+foreach (dir IN LISTS TBB_PREFIX_PATH)
+  list(APPEND TBB_LIB_SEARCH_PATH ${dir}/lib ${dir}/Lib ${dir}/lib/tbb
+    ${dir}/Libs)
+  list(APPEND TBB_INC_SEARCH_PATH ${dir}/include ${dir}/Include
+    ${dir}/include/tbb)
+endforeach ()
+
+set(TBB_LIBRARY_NAMES tbb)
+get_debug_names(TBB_LIBRARY_NAMES)
+
+find_path(TBB_INCLUDE_DIR
+          NAMES tbb/tbb.h
+          PATHS ${TBB_INC_SEARCH_PATH})
+
+find_library(TBB_LIBRARY_RELEASE
+             NAMES ${TBB_LIBRARY_NAMES}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+find_library(TBB_LIBRARY_DEBUG
+             NAMES ${TBB_LIBRARY_NAMES_DEBUG}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+make_library_set(TBB_LIBRARY)
+
+findpkg_finish(TBB tbb)
+
+#if we haven't found TBB no point on going any further
+if (NOT TBB_FOUND)
+  return()
+endif ()
+
+#=============================================================================
+# Look for TBB's malloc package
+set(TBB_MALLOC_LIBRARY_NAMES tbbmalloc)
+get_debug_names(TBB_MALLOC_LIBRARY_NAMES)
+
+find_path(TBB_MALLOC_INCLUDE_DIR
+          NAMES tbb/tbb.h
+          PATHS ${TBB_INC_SEARCH_PATH})
+
+find_library(TBB_MALLOC_LIBRARY_RELEASE
+             NAMES ${TBB_MALLOC_LIBRARY_NAMES}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+find_library(TBB_MALLOC_LIBRARY_DEBUG
+             NAMES ${TBB_MALLOC_LIBRARY_NAMES_DEBUG}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+make_library_set(TBB_MALLOC_LIBRARY)
+
+findpkg_finish(TBB_MALLOC tbbmalloc)
+
+#=============================================================================
+# Look for TBB's malloc proxy package
+set(TBB_MALLOC_PROXY_LIBRARY_NAMES tbbmalloc_proxy)
+get_debug_names(TBB_MALLOC_PROXY_LIBRARY_NAMES)
+
+find_path(TBB_MALLOC_PROXY_INCLUDE_DIR
+          NAMES tbb/tbbmalloc_proxy.h
+          PATHS ${TBB_INC_SEARCH_PATH})
+
+find_library(TBB_MALLOC_PROXY_LIBRARY_RELEASE
+             NAMES ${TBB_MALLOC_PROXY_LIBRARY_NAMES}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+find_library(TBB_MALLOC_PROXY_LIBRARY_DEBUG
+             NAMES ${TBB_MALLOC_PROXY_LIBRARY_NAMES_DEBUG}
+             PATHS ${TBB_LIB_SEARCH_PATH})
+make_library_set(TBB_MALLOC_PROXY_LIBRARY)
+
+findpkg_finish(TBB_MALLOC_PROXY tbbmalloc_proxy)
+
+
+#=============================================================================
+# Parse all the version numbers from tbb.
+if(NOT TBB_VERSION)
+  if(EXISTS "${TBB_INCLUDE_DIR}/tbb/version.h")
+    # The newer oneTBB provides tbb/version.h but no tbb/tbb_stddef.h.
+    set(version_file "${TBB_INCLUDE_DIR}/tbb/version.h")
+  else()
+    # Older TBB provides tbb/tbb_stddef.h but no tbb/version.h.
+    set(version_file "${TBB_INCLUDE_DIR}/tbb/tbb_stddef.h")
+  endif()
+
+  file(STRINGS
+      "${version_file}"
+      TBB_VERSION_CONTENTS
+      REGEX "VERSION")
+
+  string(REGEX REPLACE
+    ".*#define TBB_VERSION_MAJOR ([0-9]+).*" "\\1"
+    TBB_VERSION_MAJOR "${TBB_VERSION_CONTENTS}")
+
+  string(REGEX REPLACE
+    ".*#define TBB_VERSION_MINOR ([0-9]+).*" "\\1"
+    TBB_VERSION_MINOR "${TBB_VERSION_CONTENTS}")
+
+  string(REGEX REPLACE
+        ".*#define TBB_INTERFACE_VERSION ([0-9]+).*" "\\1"
+        TBB_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}")
+
+  string(REGEX REPLACE
+        ".*#define TBB_COMPATIBLE_INTERFACE_VERSION ([0-9]+).*" "\\1"
+        TBB_COMPATIBLE_INTERFACE_VERSION "${TBB_VERSION_CONTENTS}")
+
+  set(TBB_VERSION "${TBB_VERSION_MAJOR}.${TBB_VERSION_MINOR}")
+endif()

miniCUDA124/lib/cmake/thrust/README.md

@@ -0,0 +1,226 @@
+# Using Thrust with CMake
+
+Thrust provides configuration files that simplify using Thrust
+from other CMake projects. Requirements:
+
+- Thrust >= 1.9.10
+- CMake >= 3.15
+
+See the [Fixing Legacy FindThrust.cmake](#fixing-legacy-findthrustcmake)
+section for solutions that work on older Thrust versions.
+
+## User Guide
+
+#### Default Configuration (CUDA)
+
+Thrust is configured using a `thrust_create_target` CMake function that
+assembles a complete interface to the Thrust library:
+
+```cmake
+find_package(Thrust REQUIRED CONFIG)
+thrust_create_target(Thrust)
+target_link_libraries(MyProgram Thrust)
+```
+
+The first argument is the name of the interface target to create, and any
+additional options will be used to configure the target. By default,
+`thrust_create_target` will configure its result to use CUDA acceleration.
+
+If desired, `thrust_create_target` may be called multiple times to build
+several unique Thrust interface targets with different configurations, as
+detailed below.
+
+**Note:** If CMake is unable to locate Thrust, specify the path to Thrust's CMake
+configuration directory (where this README file is located) as `Thrust_DIR`.
+If cloning Thrust from github, this would be
+
+```
+$ cmake . -DThrust_DIR=<thrust git repo root>/thrust/cmake/
+```
+
+#### TBB / OpenMP
+
+To explicitly specify host/device systems, `HOST` and `DEVICE` arguments can be
+passed to `thrust_create_target`. If an explicit system is not specified, the
+target will default to using CPP for host and/or CUDA for device.
+
+```cmake
+thrust_create_target(ThrustTBB DEVICE TBB)
+thrust_create_target(ThrustOMP HOST CPP DEVICE OMP)
+```
+
+will create targets `ThrustTBB` and `ThrustOMP`. Both will use the serial `CPP`
+host system, but will find and use TBB or OpenMP for the device system.
+
+#### Configure Target from Cache Options
+
+To allow a Thrust target to be configurable easily via `cmake-gui` or
+`ccmake`, pass the `FROM_OPTIONS` flag to `thrust_create_target`. This will add
+`THRUST_HOST_SYSTEM` and `THRUST_DEVICE_SYSTEM` options to the CMake cache that
+allow selection from the systems supported by this version of Thrust.
+
+```cmake
+thrust_create_target(Thrust FROM_OPTIONS
+  [HOST_OPTION <option name>]
+  [DEVICE_OPTION <option name>]
+  [HOST_OPTION_DOC <doc string>]
+  [DEVICE_OPTION_DOC <doc string>]
+  [HOST <default host system name>]
+  [DEVICE <default device system name>]
+  [ADVANCED]
+)
+```
+
+The optional arguments have sensible defaults, but may be configured per
+`thrust_create_target` call:
+
+| Argument            | Default                 | Description                     |
+|---------------------|-------------------------|---------------------------------|
+| `HOST_OPTION`       | `THRUST_HOST_SYSTEM`    | Name of cache option for host   |
+| `DEVICE_OPTION`     | `THRUST_DEVICE_SYSTEM`  | Name of cache option for device |
+| `HOST_OPTION_DOC`   | Thrust's host system.   | Docstring for host option       |
+| `DEVICE_OPTION_DOC` | Thrust's device system. | Docstring for device option     |
+| `HOST`              | `CPP`                   | Default host system             |
+| `DEVICE`            | `CUDA`                  | Default device system           |
+| `ADVANCED`          | *N/A*                   | Mark cache options advanced     |
+
+### Specifying Thrust Version Requirements
+
+A specific version of Thrust may be required in the `find_package` call:
+
+```cmake
+find_package(Thrust 1.9.10)
+```
+
+will only consider Thrust installations with version `1.9.10.X`. An exact match
+down to the patch version can be forced by using `EXACT` matching:
+
+```cmake
+find_package(Thrust 1.9.10.1 EXACT)
+```
+
+would only match the 1.9.10.1 release.
+
+#### Using an Explicit TBB or OpenMP CMake Target
+
+When `thrust_create_target` is called, it will lazily load the requested
+systems on-demand through internal `find_package` calls. If a project already
+uses TBB or OpenMP, it may specify a CMake target for Thrust to share instead:
+
+```cmake
+thrust_set_TBB_target(MyTBBTarget)
+thrust_set_OMP_target(MyOMPTarget)
+```
+
+These functions must be called **before** the corresponding system is loaded
+through `thrust_create_target` or `find_package(Thrust COMPONENT [OMP|TBB])`.
+
+#### Using an Explicit libcu++ CMake Target
+
+In contrast to the optional TBB/OMP dependencies, there is no
+`thrust_set_libcudacxx_target` function that specifies an explicit libcu++
+target. This is because libcu++ is always required and must be found during the
+initial `find_target(Thrust)` call that defines these functions.
+
+To force Thrust to use a specific libcu++ target, ensure that either the
+`Thrust::libcudacxx` or `libcudacxx::libcudacxx` targets are defined prior to
+the first invocation of `find_package(Thrust)`. Thrust will automatically use
+these, giving preference to the `Thrust::libcudacxx` target.
+
+#### Testing for Systems
+
+The following functions check if a system has been found, either by lazy loading
+through `thrust_create_target` or as a `find_package` `COMPONENT` /
+`OPTIONAL_COMPONENT`:
+
+```cmake
+# Set var_name to TRUE or FALSE if an individual system has been found:
+thrust_is_cuda_system_found(<var_name>)
+thrust_is_cpp_system_found(<var_name>)
+thrust_is_tbb_system_found(<var_name>)
+thrust_is_omp_system_found(<var_name>)
+
+# Generic version that takes a component name from CUDA, CPP, TBB, OMP:
+thrust_is_system_found(<component_name> <var_name>)
+
+# Defines `THRUST_*_FOUND` variables in the current scope that reflect the
+# state of all known systems. Can be used to refresh these flags after
+# lazy system loading.
+thrust_update_system_found_flags()
+```
+
+#### Debugging
+
+Thrust will produce a detailed log describing its targets, cache options, and
+interfaces when `--log-level=VERBOSE` is passed to CMake 3.15.7 or newer:
+
+```
+$ cmake . --log-level=VERBOSE
+```
+
+This can be handy for inspecting interface and dependency information.
+
+## Fixing Legacy FindThrust.cmake
+
+A community-created `FindThrust.cmake` module exists and is necessary to find
+Thrust installations prior to Thrust 1.9.10. Its usage is discouraged whenever
+possible and the config files in this directory should be strongly preferred.
+However, projects that need to support old versions of Thrust may still need to
+use the legacy `FindThrust.cmake` with pre-1.9.10 installations.
+
+One popular flavor of this find module has a version parsing bug. Projects that
+rely on `FindThrust.cmake` should check for this and patch their copies as
+follows.
+
+Replace:
+
+```cmake
+string( REGEX MATCH "^[0-9]" major ${version} )
+string( REGEX REPLACE "^${major}00" "" version "${version}" )
+string( REGEX MATCH "^[0-9]" minor ${version} )
+string( REGEX REPLACE "^${minor}0" "" version "${version}" )
+```
+
+with:
+
+```cmake
+math(EXPR major "${version} / 100000")
+math(EXPR minor "(${version} / 100) % 1000")
+math(EXPR version "${version} % 100")
+```
+
+# Thrust Developer Documentation
+
+This portion of the file contains descriptions of Thrust's internal CMake target
+structure for Thrust developers. It should not be necessary for users
+who just want to use Thrust from their projects.
+
+## Internal Targets
+
+By default, `find_package(Thrust)` will only create a single `Thrust::Thrust`
+target that describes where the actual Thrust headers are located. It does not
+locate or create configurations for any dependencies; these are lazily loaded
+on-demand by calls to `create_thrust_target`, or when explicitly requested via
+`find_package`'s component mechanism.
+
+As mentioned, the basic Thrust interface is described by the `Thrust::Thrust`
+target.
+
+Each backend system (`CPP`, `CUDA`, `TBB`, `OMP`) is described by multiple
+targets:
+
+- `Thrust::${system}`
+  - Specifies an interface configured to build against all
+    dependencies for this backend (including `Thrust::Thrust`).
+  - For example, the `Thrust::CUDA` target is an interface
+    target that combines the interfaces of both Thrust and CUB.
+- `Thrust::${system}::Host`
+  - Configures an interface for using a specific host system.
+  - Multiple `::Host` targets cannot be combined in the same library/executable.
+    Attempting to do so will produce a CMake configuration error.
+  - Only defined for systems that support being used as the host.
+- `Thrust::${system}::Device`
+  - Configures an interface for using a specific device system.
+  - Multiple `::Device` targets cannot be combined in the same library/executable.
+    Attempting to do so will produce a CMake configuration error.
+  - Only defined for systems that support being used as the device.

miniCUDA124/lib/cmake/thrust/thrust-config-version.cmake

@@ -0,0 +1,24 @@
+# Parse version information from version.h:
+include("${CMAKE_CURRENT_LIST_DIR}/thrust-header-search.cmake")
+
+set(THRUST_VERSION_MAJOR 2)
+set(THRUST_VERSION_MINOR 3)
+set(THRUST_VERSION_PATCH 2) # Thrust: "subminor" CMake: "patch"
+set(THRUST_VERSION_TWEAK 0)
+set(THRUST_VERSION "${THRUST_VERSION_MAJOR}.${THRUST_VERSION_MINOR}.${THRUST_VERSION_PATCH}.${THRUST_VERSION_TWEAK}")
+
+set(PACKAGE_VERSION ${THRUST_VERSION})
+set(PACKAGE_VERSION_COMPATIBLE FALSE)
+set(PACKAGE_VERSION_EXACT FALSE)
+set(PACKAGE_VERSION_UNSUITABLE FALSE)
+
+if(PACKAGE_VERSION VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION)
+  if(THRUST_VERSION_MAJOR VERSION_EQUAL PACKAGE_FIND_VERSION_MAJOR AND
+     THRUST_VERSION_MINOR VERSION_GREATER_EQUAL PACKAGE_FIND_VERSION_MINOR)
+    set(PACKAGE_VERSION_COMPATIBLE TRUE)
+  endif()
+
+  if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+    set(PACKAGE_VERSION_EXACT TRUE)
+  endif()
+endif()

miniCUDA124/lib/cmake/thrust/thrust-config.cmake

@@ -0,0 +1,744 @@
+#
+# find_package(Thrust) config file.
+#
+# Provided by NVIDIA under the same license as the associated Thrust library.
+#
+# Reply-To: Allison Vacanti <alliepiper16@gmail.com>
+#
+# *****************************************************************************
+# **     The following is a short reference to using Thrust from CMake.      **
+# ** For more details, see the README.md in the same directory as this file. **
+# *****************************************************************************
+#
+# # General Usage:
+# find_package(Thrust REQUIRED CONFIG)
+# thrust_create_target(Thrust [options])
+# target_link_libraries(some_project_lib Thrust)
+#
+# # Create default target with: HOST=CPP DEVICE=CUDA
+# thrust_create_target(TargetName)
+#
+# # Create target with: HOST=CPP DEVICE=TBB
+# thrust_create_target(TargetName DEVICE TBB)
+#
+# # Create target with: HOST=TBB DEVICE=OMP
+# thrust_create_target(TargetName HOST TBB DEVICE OMP)
+#
+# # Create CMake cache options THRUST_[HOST|DEVICE]_SYSTEM and configure a
+# # target from them. This allows these systems to be changed by developers at
+# # configure time, per build.
+# thrust_create_target(TargetName FROM_OPTIONS
+#   [HOST_OPTION <option_name>]      # Optionally rename the host system option
+#   [DEVICE_OPTION <option_name>]    # Optionally rename the device system option
+#   [HOST_OPTION_DOC <doc_string>]   # Optionally change the cache label
+#   [DEVICE_OPTION_DOC <doc_string>] # Optionally change the cache label
+#   [HOST <default system>]          # Optionally change the default backend
+#   [DEVICE <default system>]        # Optionally change the default backend
+#   [ADVANCED]                       # Optionally mark options as advanced
+# )
+#
+# # Use a custom TBB, CUB, and/or OMP
+# # (Note that once set, these cannot be changed. This includes COMPONENT
+# # preloading and lazy lookups in thrust_create_target)
+# find_package(Thrust REQUIRED)
+# thrust_set_CUB_target(MyCUBTarget)  # MyXXXTarget contains an existing
+# thrust_set_TBB_target(MyTBBTarget)  # interface to XXX for Thrust to use.
+# thrust_set_OMP_target(MyOMPTarget)
+# thrust_create_target(ThrustWithMyCUB DEVICE CUDA)
+# thrust_create_target(ThrustWithMyTBB DEVICE TBB)
+# thrust_create_target(ThrustWithMyOMP DEVICE OMP)
+#
+# # Create target with HOST=CPP DEVICE=CUDA and some advanced flags set
+# thrust_create_target(TargetName
+#   IGNORE_DEPRECATED_API         # Silence build warnings about deprecated APIs
+#   IGNORE_DEPRECATED_CPP_DIALECT # Silence build warnings about deprecated compilers and C++ standards
+#   IGNORE_DEPRECATED_CPP_11      # Only silence deprecation warnings for C++11
+#   IGNORE_DEPRECATED_COMPILER    # Only silence deprecation warnings for old compilers
+#   IGNORE_CUB_VERSION            # Skip configure-time and compile-time CUB version checks
+# )
+#
+# # Test if a particular system has been loaded. ${var_name} is set to TRUE or
+# # FALSE to indicate if "system" is found.
+# thrust_is_system_found(<system> <var_name>)
+# thrust_is_cuda_system_found(<var_name>)
+# thrust_is_tbb_system_found(<var_name>)
+# thrust_is_omp_system_found(<var_name>)
+# thrust_is_cpp_system_found(<var_name>)
+#
+# # Define / update THRUST_${system}_FOUND flags in current scope
+# thrust_update_system_found_flags()
+#
+# # View verbose log with target and dependency information:
+# $ cmake . --log-level=VERBOSE (CMake 3.15.7 and above)
+#
+# # Print debugging output to status channel:
+# thrust_debug_internal_targets()
+# thrust_debug_target(TargetName "${THRUST_VERSION}")
+
+cmake_minimum_required(VERSION 3.15)
+
+# Minimum supported libcudacxx version:
+set(thrust_libcudacxx_version "${Thrust_VERSION}")
+
+################################################################################
+# User variables and APIs. Users can rely on these:
+#
+
+# Advertise system options:
+set(THRUST_HOST_SYSTEM_OPTIONS
+  CPP OMP TBB
+  CACHE INTERNAL "Valid Thrust host systems."
+  FORCE
+)
+set(THRUST_DEVICE_SYSTEM_OPTIONS
+  CUDA CPP OMP TBB
+  CACHE INTERNAL "Valid Thrust device systems"
+  FORCE
+)
+
+# Workaround cmake issue #20670 https://gitlab.kitware.com/cmake/cmake/-/issues/20670
+set(THRUST_VERSION ${${CMAKE_FIND_PACKAGE_NAME}_VERSION} CACHE INTERNAL "" FORCE)
+set(THRUST_VERSION_MAJOR ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_MAJOR} CACHE INTERNAL "" FORCE)
+set(THRUST_VERSION_MINOR ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_MINOR} CACHE INTERNAL "" FORCE)
+set(THRUST_VERSION_PATCH ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_PATCH} CACHE INTERNAL "" FORCE)
+set(THRUST_VERSION_TWEAK ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_TWEAK} CACHE INTERNAL "" FORCE)
+set(THRUST_VERSION_COUNT ${${CMAKE_FIND_PACKAGE_NAME}_VERSION_COUNT} CACHE INTERNAL "" FORCE)
+
+function(thrust_create_target target_name)
+  thrust_debug("Assembling target ${target_name}. Options: ${ARGN}" internal)
+  set(options
+    ADVANCED
+    FROM_OPTIONS
+    IGNORE_CUB_VERSION_CHECK
+    IGNORE_DEPRECATED_API
+    IGNORE_DEPRECATED_COMPILER
+    IGNORE_DEPRECATED_CPP_11
+    IGNORE_DEPRECATED_CPP_DIALECT
+  )
+  set(keys
+    DEVICE
+    DEVICE_OPTION
+    DEVICE_OPTION_DOC
+    HOST
+    HOST_OPTION
+    HOST_OPTION_DOC
+  )
+  cmake_parse_arguments(TCT "${options}" "${keys}" "" ${ARGN})
+  if (TCT_UNPARSED_ARGUMENTS)
+    message(AUTHOR_WARNING
+      "Unrecognized arguments passed to thrust_create_target: "
+      ${TCT_UNPARSED_ARGUMENTS}
+    )
+  endif()
+
+  # Check that the main Thrust internal target is available
+  # (functions have global scope, targets have directory scope, so this
+  # might happen)
+  if (NOT TARGET Thrust::Thrust)
+    message(AUTHOR_WARNING
+      "The `thrust_create_target` function was called outside the scope of the "
+      "thrust targets. Call find_package again to recreate targets."
+    )
+  endif()
+
+  _thrust_set_if_undefined(TCT_HOST CPP)
+  _thrust_set_if_undefined(TCT_DEVICE CUDA)
+  _thrust_set_if_undefined(TCT_HOST_OPTION THRUST_HOST_SYSTEM)
+  _thrust_set_if_undefined(TCT_DEVICE_OPTION THRUST_DEVICE_SYSTEM)
+  _thrust_set_if_undefined(TCT_HOST_OPTION_DOC "Thrust host system.")
+  _thrust_set_if_undefined(TCT_DEVICE_OPTION_DOC "Thrust device system.")
+
+  if (NOT TCT_HOST IN_LIST THRUST_HOST_SYSTEM_OPTIONS)
+    message(FATAL_ERROR
+      "Requested HOST=${TCT_HOST}; must be one of ${THRUST_HOST_SYSTEM_OPTIONS}"
+    )
+  endif()
+
+  if (NOT TCT_DEVICE IN_LIST THRUST_DEVICE_SYSTEM_OPTIONS)
+    message(FATAL_ERROR
+      "Requested DEVICE=${TCT_DEVICE}; must be one of ${THRUST_DEVICE_SYSTEM_OPTIONS}"
+    )
+  endif()
+
+  if (TCT_FROM_OPTIONS)
+    _thrust_create_cache_options(
+      ${TCT_HOST} ${TCT_DEVICE}
+      ${TCT_HOST_OPTION} ${TCT_DEVICE_OPTION}
+      ${TCT_HOST_OPTION_DOC} ${TCT_DEVICE_OPTION_DOC}
+      ${TCT_ADVANCED}
+    )
+    set(TCT_HOST ${${TCT_HOST_OPTION}})
+    set(TCT_DEVICE ${${TCT_DEVICE_OPTION}})
+    thrust_debug("Current option settings:" internal)
+    thrust_debug("  - ${TCT_HOST_OPTION}=${TCT_HOST}" internal)
+    thrust_debug("  - ${TCT_DEVICE_OPTION}=${TCT_DEVICE}" internal)
+  endif()
+
+  _thrust_find_backend(${TCT_HOST} REQUIRED)
+  _thrust_find_backend(${TCT_DEVICE} REQUIRED)
+
+  # We can just create an INTERFACE IMPORTED target here instead of going
+  # through _thrust_declare_interface_alias as long as we aren't hanging any
+  # Thrust/CUB include paths directly on ${target_name}.
+  add_library(${target_name} INTERFACE IMPORTED)
+  target_link_libraries(${target_name}
+    INTERFACE
+    Thrust::${TCT_HOST}::Host
+    Thrust::${TCT_DEVICE}::Device
+  )
+
+  # This would be nice to enforce, but breaks when using old cmake + new
+  # compiler, since cmake doesn't know what features the new compiler version
+  # supports.
+  # Leaving this here as a reminder not to add it back. Just let the
+  # compile-time checks in thrust/detail/config/cpp_dialect.h handle it.
+  #
+  #  if (NOT TCT_IGNORE_DEPRECATED_CPP_DIALECT)
+  #    if (TCT_IGNORE_DEPRECATED_CPP_11)
+  #      target_compile_features(${target_name} INTERFACE cxx_std_11)
+  #    else()
+  #      target_compile_features(${target_name} INTERFACE cxx_std_14)
+  #    endif()
+  #  endif()
+
+  if (TCT_IGNORE_DEPRECATED_CPP_DIALECT)
+    target_compile_definitions(${target_name} INTERFACE "THRUST_IGNORE_DEPRECATED_CPP_DIALECT")
+  endif()
+
+  if (TCT_IGNORE_DEPRECATED_API)
+    target_compile_definitions(${target_name} INTERFACE "THRUST_IGNORE_DEPRECATED_API")
+  endif()
+
+  if (TCT_IGNORE_DEPRECATED_CPP_11)
+    target_compile_definitions(${target_name} INTERFACE "THRUST_IGNORE_DEPRECATED_CPP_11")
+  endif()
+
+  if (TCT_IGNORE_DEPRECATED_COMPILER)
+    target_compile_definitions(${target_name} INTERFACE "THRUST_IGNORE_DEPRECATED_COMPILER")
+  endif()
+
+  if (TCT_IGNORE_CUB_VERSION_CHECK)
+    target_compile_definitions(${target_name} INTERFACE "THRUST_IGNORE_CUB_VERSION_CHECK")
+  else()
+    if (("${TCT_HOST}" STREQUAL "CUDA" OR "${TCT_DEVICE}" STREQUAL "CUDA") AND
+    (NOT THRUST_VERSION VERSION_EQUAL THRUST_CUB_VERSION))
+      message(FATAL_ERROR
+        "The version of CUB found by CMake is not compatible with this release of Thrust. "
+        "CUB is now included in the CUDA Toolkit, so you no longer need to use your own checkout of CUB. "
+        "Pass IGNORE_CUB_VERSION_CHECK to thrust_create_target to ignore. "
+        "(CUB ${THRUST_CUB_VERSION}, Thrust ${THRUST_VERSION})."
+        )
+    endif()
+  endif()
+
+  thrust_debug_target(${target_name} "Thrust ${THRUST_VERSION}"  internal)
+endfunction()
+
+function(thrust_is_system_found system var_name)
+  if (TARGET Thrust::${system})
+    set(${var_name} TRUE PARENT_SCOPE)
+  else()
+    set(${var_name} FALSE PARENT_SCOPE)
+  endif()
+endfunction()
+
+function(thrust_is_cpp_system_found var_name)
+  thrust_is_system_found(CPP ${var_name})
+  set(${var_name} ${${var_name}} PARENT_SCOPE)
+endfunction()
+
+function(thrust_is_cuda_system_found var_name)
+  thrust_is_system_found(CUDA ${var_name})
+  set(${var_name} ${${var_name}} PARENT_SCOPE)
+endfunction()
+
+function(thrust_is_tbb_system_found var_name)
+  thrust_is_system_found(TBB ${var_name})
+  set(${var_name} ${${var_name}} PARENT_SCOPE)
+endfunction()
+
+function(thrust_is_omp_system_found var_name)
+  thrust_is_system_found(OMP ${var_name})
+  set(${var_name} ${${var_name}} PARENT_SCOPE)
+endfunction()
+
+# Since components are loaded lazily, this will refresh the
+# THRUST_${component}_FOUND flags in the current scope.
+# Alternatively, check system states individually using the
+# thrust_is_system_found functions.
+macro(thrust_update_system_found_flags)
+  set(THRUST_FOUND TRUE)
+  thrust_is_system_found(CPP  THRUST_CPP_FOUND)
+  thrust_is_system_found(CUDA THRUST_CUDA_FOUND)
+  thrust_is_system_found(TBB  THRUST_TBB_FOUND)
+  thrust_is_system_found(OMP  THRUST_OMP_FOUND)
+endmacro()
+
+function(thrust_debug msg)
+  # Use the VERBOSE channel when called internally
+  # Run `cmake . --log-level=VERBOSE` to view.
+  if ("${ARGN}" STREQUAL "internal")
+    # If CMake is too old to know about the VERBOSE channel, just be silent.
+    # Users reproduce much the same output on the STATUS channel by using:
+    # thrust_create_target(Thrust [...])
+    # thrust_debug_internal_targets()
+    # thrust_debug_target(Thrust)
+    if (CMAKE_VERSION VERSION_GREATER_EQUAL "3.15.7")
+      set(channel VERBOSE)
+    else()
+      return()
+    endif()
+  else()
+    set(channel STATUS)
+  endif()
+
+  message(${channel} "Thrust: ${msg}")
+endfunction()
+
+# Print details of the specified target.
+function(thrust_debug_target target_name version)
+  if (NOT TARGET ${target_name})
+    return()
+  endif()
+
+  set(is_internal "${ARGN}")
+
+  if (version)
+    set(version "(${version})")
+  endif()
+
+  thrust_debug("TargetInfo: ${target_name}: ${version}" ${is_internal})
+
+  function(_thrust_print_prop_if_set target_name prop)
+    get_target_property(value ${target_name} ${prop})
+    if (value)
+      thrust_debug("TargetInfo: ${target_name} > ${prop}: ${value}" ${is_internal})
+    endif()
+  endfunction()
+
+  function(_thrust_print_imported_prop_if_set target_name prop)
+    get_target_property(imported ${target_name} IMPORTED)
+    get_target_property(type ${target_name} TYPE)
+    if (imported AND NOT ${type} STREQUAL "INTERFACE_LIBRARY")
+      _thrust_print_prop_if_set(${target_name} ${prop})
+    endif()
+  endfunction()
+
+  _thrust_print_prop_if_set(${target_name} ALIASED_TARGET)
+  _thrust_print_prop_if_set(${target_name} IMPORTED)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_COMPILE_DEFINITIONS)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_COMPILE_FEATURES)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_COMPILE_OPTIONS)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_INCLUDE_DIRECTORIES)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_LINK_DEPENDS)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_LINK_DIRECTORIES)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_LINK_LIBRARIES)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_LINK_OPTIONS)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_SYSTEM_INCLUDE_DIRECTORIES)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_THRUST_HOST)
+  _thrust_print_prop_if_set(${target_name} INTERFACE_THRUST_DEVICE)
+  _thrust_print_imported_prop_if_set(${target_name} IMPORTED_LOCATION)
+  _thrust_print_imported_prop_if_set(${target_name} IMPORTED_LOCATION_DEBUG)
+  _thrust_print_imported_prop_if_set(${target_name} IMPORTED_LOCATION_RELEASE)
+endfunction()
+
+function(thrust_debug_internal_targets)
+  function(_thrust_debug_backend_targets backend version)
+    thrust_debug_target(Thrust::${backend} "${version}")
+    thrust_debug_target(Thrust::${backend}::Host "${version}")
+    thrust_debug_target(Thrust::${backend}::Device "${version}")
+  endfunction()
+
+  thrust_debug_target(Thrust::Thrust "${THRUST_VERSION}")
+
+  _thrust_debug_backend_targets(CPP "Thrust ${THRUST_VERSION}")
+
+  _thrust_debug_backend_targets(OMP "${THRUST_OMP_VERSION}")
+  thrust_debug_target(OpenMP::OpenMP_CXX "${THRUST_OMP_VERSION}")
+
+  _thrust_debug_backend_targets(TBB "${THRUST_TBB_VERSION}")
+  thrust_debug_target(TBB:tbb "${THRUST_TBB_VERSION}")
+
+  _thrust_debug_backend_targets(CUDA "CUB ${THRUST_CUB_VERSION}")
+  thrust_debug_target(CUB::CUB "${THRUST_CUB_VERSION}")
+  thrust_debug_target(libcudacxx::libcudacxx "${THRUST_libcudacxx_VERSION}")
+endfunction()
+
+################################################################################
+# Internal utilities. Subject to change.
+#
+
+function(_thrust_set_if_undefined var)
+  if (NOT DEFINED ${var})
+    set(${var} ${ARGN} PARENT_SCOPE)
+  endif()
+endfunction()
+
+function(_thrust_declare_interface_alias alias_name ugly_name)
+  # 1) Only IMPORTED and ALIAS targets can be placed in a namespace.
+  # 2) When an IMPORTED library is linked to another target, its include
+  #    directories are treated as SYSTEM includes.
+  # 3) nvcc will automatically check the CUDA Toolkit include path *before* the
+  #    system includes. This means that the Toolkit Thrust will *always* be used
+  #    during compilation, and the include paths of an IMPORTED Thrust::Thrust
+  #    target will never have any effect.
+  # 4) This behavior can be fixed by setting the property NO_SYSTEM_FROM_IMPORTED
+  #    on EVERY target that links to Thrust::Thrust. This would be a burden and a
+  #    footgun for our users. Forgetting this would silently pull in the wrong thrust!
+  # 5) A workaround is to make a non-IMPORTED library outside of the namespace,
+  #    configure it, and then ALIAS it into the namespace (or ALIAS and then
+  #    configure, that seems to work too).
+  add_library(${ugly_name} INTERFACE)
+  add_library(${alias_name} ALIAS ${ugly_name})
+endfunction()
+
+# Create cache options for selecting the user/device systems with ccmake/cmake-gui.
+function(_thrust_create_cache_options host device host_option device_option host_doc device_doc advanced)
+  thrust_debug("Creating system cache options: (advanced=${advanced})" internal)
+  thrust_debug("  - Host Option=${host_option} Default=${host} Doc='${host_doc}'" internal)
+  thrust_debug("  - Device Option=${device_option} Default=${device} Doc='${device_doc}'" internal)
+  set(${host_option} ${host} CACHE STRING "${host_doc}")
+  set_property(CACHE ${host_option} PROPERTY STRINGS ${THRUST_HOST_SYSTEM_OPTIONS})
+  set(${device_option} ${device} CACHE STRING "${device_doc}")
+  set_property(CACHE ${device_option} PROPERTY STRINGS ${THRUST_DEVICE_SYSTEM_OPTIONS})
+  if (advanced)
+    mark_as_advanced(${host_option} ${device_option})
+  endif()
+endfunction()
+
+# Create Thrust::${backend}::Host and Thrust::${backend}::Device targets.
+# Assumes that `Thrust::${backend}` and `_Thrust_${backend}` have been created
+# by _thrust_declare_interface_alias and configured to bring in system
+# dependency interfaces (including Thrust::Thrust).
+function(_thrust_setup_system backend)
+  set(backend_target_alias "Thrust::${backend}")
+
+  if (backend IN_LIST THRUST_HOST_SYSTEM_OPTIONS)
+    set(host_target "_Thrust_${backend}_Host")
+    set(host_target_alias "Thrust::${backend}::Host")
+    if (NOT TARGET ${host_target_alias})
+      _thrust_declare_interface_alias(${host_target_alias} ${host_target})
+      target_compile_definitions(${host_target} INTERFACE
+        "THRUST_HOST_SYSTEM=THRUST_HOST_SYSTEM_${backend}")
+      target_link_libraries(${host_target} INTERFACE ${backend_target_alias})
+      set_property(TARGET ${host_target} PROPERTY INTERFACE_THRUST_HOST ${backend})
+      set_property(TARGET ${host_target} APPEND PROPERTY COMPATIBLE_INTERFACE_STRING THRUST_HOST)
+      thrust_debug_target(${host_target_alias} "" internal)
+    endif()
+  endif()
+
+  if (backend IN_LIST THRUST_DEVICE_SYSTEM_OPTIONS)
+    set(device_target "_Thrust_${backend}_Device")
+    set(device_target_alias "Thrust::${backend}::Device")
+    if (NOT TARGET ${device_target_alias})
+      _thrust_declare_interface_alias(${device_target_alias} ${device_target})
+      target_compile_definitions(${device_target} INTERFACE
+        "THRUST_DEVICE_SYSTEM=THRUST_DEVICE_SYSTEM_${backend}")
+      target_link_libraries(${device_target} INTERFACE ${backend_target_alias})
+      set_property(TARGET ${device_target} PROPERTY INTERFACE_THRUST_DEVICE ${backend})
+      set_property(TARGET ${device_target} APPEND PROPERTY COMPATIBLE_INTERFACE_STRING THRUST_DEVICE)
+      thrust_debug_target(${device_target_alias} "" internal)
+    endif()
+  endif()
+endfunction()
+
+# Use the provided cub_target for the CUDA backend. If Thrust::CUB already
+# exists, this call has no effect.
+function(thrust_set_CUB_target cub_target)
+  if (NOT TARGET Thrust::CUB)
+    thrust_debug("Setting CUB target to ${cub_target}" internal)
+    # Workaround cmake issue #20670 https://gitlab.kitware.com/cmake/cmake/-/issues/20670
+    set(THRUST_CUB_VERSION ${CUB_VERSION} CACHE INTERNAL
+      "CUB version used by Thrust"
+      FORCE
+    )
+    _thrust_declare_interface_alias(Thrust::CUB _Thrust_CUB)
+    target_link_libraries(_Thrust_CUB INTERFACE ${cub_target})
+    thrust_debug_target(${cub_target} "${THRUST_CUB_VERSION}" internal)
+    thrust_debug_target(Thrust::CUB "CUB ${THRUST_CUB_VERSION}" internal)
+  endif()
+endfunction()
+
+# Internal use only -- libcudacxx must be found during the initial
+# `find_package(Thrust)` call and cannot be set afterwards. See README.md in
+# this directory for details on using a specific libcudacxx target.
+function(_thrust_set_libcudacxx_target libcudacxx_target)
+  if (NOT TARGET Thrust::libcudacxx)
+    thrust_debug("Setting libcudacxx target to ${libcudacxx_target}" internal)
+    # Workaround cmake issue #20670 https://gitlab.kitware.com/cmake/cmake/-/issues/20670
+    set(THRUST_libcudacxx_VERSION ${libcudacxx_VERSION} CACHE INTERNAL
+      "libcudacxx version used by Thrust"
+      FORCE
+    )
+    _thrust_declare_interface_alias(Thrust::libcudacxx _Thrust_libcudacxx)
+    target_link_libraries(_Thrust_libcudacxx INTERFACE ${libcudacxx_target})
+    thrust_debug_target(${libcudacxx_target} "${THRUST_libcudacxx_VERSION}" internal)
+    thrust_debug_target(Thrust::libcudacxx "libcudacxx ${THRUST_libcudacxx_VERSION}" internal)
+  endif()
+endfunction()
+
+# Use the provided tbb_target for the TBB backend. If Thrust::TBB already
+# exists, this call has no effect.
+function(thrust_set_TBB_target tbb_target)
+  if (NOT TARGET Thrust::TBB)
+    thrust_debug("Setting TBB target to ${tbb_target}" internal)
+    # Workaround cmake issue #20670 https://gitlab.kitware.com/cmake/cmake/-/issues/20670
+    set(THRUST_TBB_VERSION ${TBB_VERSION} CACHE INTERNAL
+      "TBB version used by Thrust"
+      FORCE
+    )
+    _thrust_declare_interface_alias(Thrust::TBB _Thrust_TBB)
+    target_link_libraries(_Thrust_TBB INTERFACE Thrust::Thrust ${tbb_target})
+    thrust_debug_target(${tbb_target} "${THRUST_TBB_VERSION}" internal)
+    thrust_debug_target(Thrust::TBB "${THRUST_TBB_VERSION}" internal)
+    _thrust_setup_system(TBB)
+  endif()
+endfunction()
+
+# Use the provided omp_target for the OMP backend. If Thrust::OMP already
+# exists, this call has no effect.
+function(thrust_set_OMP_target omp_target)
+  if (NOT TARGET Thrust::OMP)
+    thrust_debug("Setting OMP target to ${omp_target}" internal)
+    # Workaround cmake issue #20670 https://gitlab.kitware.com/cmake/cmake/-/issues/20670
+    set(THRUST_OMP_VERSION ${OpenMP_CXX_VERSION} CACHE INTERNAL
+      "OpenMP version used by Thrust"
+      FORCE
+    )
+    _thrust_declare_interface_alias(Thrust::OMP _Thrust_OMP)
+    target_link_libraries(_Thrust_OMP INTERFACE Thrust::Thrust ${omp_target})
+    thrust_debug_target(${omp_target} "${THRUST_OMP_VERSION}" internal)
+    thrust_debug_target(Thrust::OMP "${THRUST_OMP_VERSION}" internal)
+    _thrust_setup_system(OMP)
+  endif()
+endfunction()
+
+function(_thrust_find_CPP required)
+  if (NOT TARGET Thrust::CPP)
+    thrust_debug("Generating CPP targets." internal)
+    _thrust_declare_interface_alias(Thrust::CPP _Thrust_CPP)
+    target_link_libraries(_Thrust_CPP INTERFACE Thrust::Thrust)
+    thrust_debug_target(Thrust::CPP "Thrust ${THRUST_VERSION}" internal)
+    _thrust_setup_system(CPP)
+  endif()
+endfunction()
+
+# This must be a macro instead of a function to ensure that backends passed to
+# find_package(Thrust COMPONENTS [...]) have their full configuration loaded
+# into the current scope. This provides at least some remedy for CMake issue
+# #20670 -- otherwise variables like CUB_VERSION, etc won't be in the caller's
+# scope.
+macro(_thrust_find_CUDA required)
+  if (NOT TARGET Thrust::CUB)
+    thrust_debug("Searching for CUB ${required}" internal)
+    find_package(CUB ${THRUST_VERSION} CONFIG
+      ${_THRUST_QUIET_FLAG}
+      ${required}
+      NO_DEFAULT_PATH # Only check the explicit HINTS below:
+      HINTS
+        "${_THRUST_INCLUDE_DIR}/dependencies/cub" # Source layout (GitHub)
+        "${_THRUST_INCLUDE_DIR}/../cub/cub/cmake" # Source layout (Perforce)
+        "${_THRUST_CMAKE_DIR}/.."                 # Install layout
+    )
+
+    if (TARGET CUB::CUB)
+      thrust_set_CUB_target(CUB::CUB)
+    else()
+      thrust_debug("CUB not found!" internal)
+    endif()
+  endif()
+
+  if (NOT TARGET Thrust::CUDA)
+    _thrust_declare_interface_alias(Thrust::CUDA _Thrust_CUDA)
+    _thrust_setup_system(CUDA)
+    target_link_libraries(_Thrust_CUDA INTERFACE
+      Thrust::Thrust
+      Thrust::CUB
+    )
+    thrust_debug_target(Thrust::CUDA "" internal)
+  endif()
+endmacro()
+
+# This must be a macro instead of a function to ensure that backends passed to
+# find_package(Thrust COMPONENTS [...]) have their full configuration loaded
+# into the current scope. This provides at least some remedy for CMake issue
+# #20670 -- otherwise variables like TBB_VERSION, etc won't be in the caller's
+# scope.
+macro(_thrust_find_TBB required)
+  if(NOT TARGET Thrust::TBB)
+    thrust_debug("Searching for TBB ${required}" internal)
+    # Swap in a temporary module path to make sure we use our FindTBB.cmake
+    set(_THRUST_STASH_MODULE_PATH "${CMAKE_MODULE_PATH}")
+    set(CMAKE_MODULE_PATH "${_THRUST_CMAKE_DIR}")
+
+    # Push policy CMP0074 to silence warnings about TBB_ROOT being set. This
+    # var is used unconventionally in this FindTBB.cmake module.
+    # Someday we'll have a suitable TBB cmake configuration and can avoid this.
+    cmake_policy(PUSH)
+    cmake_policy(SET CMP0074 OLD)
+    set(THRUST_TBB_ROOT "" CACHE PATH "Path to the root of the TBB installation.")
+    if (TBB_ROOT AND NOT THRUST_TBB_ROOT)
+      message(
+        "Warning: TBB_ROOT is set. "
+        "Thrust uses THRUST_TBB_ROOT to avoid issues with CMake Policy CMP0074. "
+        "Please set this variable instead when using Thrust with TBB."
+      )
+    endif()
+    set(TBB_ROOT "${THRUST_TBB_ROOT}")
+    set(_THRUST_STASH_TBB_ROOT "${TBB_ROOT}")
+
+    find_package(TBB
+      ${_THRUST_QUIET_FLAG}
+      ${required}
+    )
+
+    cmake_policy(POP)
+    set(TBB_ROOT "${_THRUST_STASH_TBB_ROOT}")
+    set(CMAKE_MODULE_PATH "${_THRUST_STASH_MODULE_PATH}")
+
+    if (TARGET TBB::tbb)
+      thrust_set_TBB_target(TBB::tbb)
+    else()
+      thrust_debug("TBB not found!" internal)
+    endif()
+  endif()
+endmacro()
+
+# Wrap the OpenMP flags for CUDA targets
+function(thrust_fixup_omp_target omp_target)
+  get_target_property(opts ${omp_target} INTERFACE_COMPILE_OPTIONS)
+  if (opts MATCHES "\\$<\\$<COMPILE_LANGUAGE:CXX>:([^>]*)>")
+    target_compile_options(${omp_target} INTERFACE
+      $<$<COMPILE_LANG_AND_ID:CUDA,NVIDIA>:-Xcompiler=${CMAKE_MATCH_1}>
+    )
+  endif()
+endfunction()
+
+# This must be a macro instead of a function to ensure that backends passed to
+# find_package(Thrust COMPONENTS [...]) have their full configuration loaded
+# into the current scope. This provides at least some remedy for CMake issue
+# #20670 -- otherwise variables like OpenMP_CXX_VERSION, etc won't be in the caller's
+# scope.
+macro(_thrust_find_OMP required)
+  if (NOT TARGET Thrust::OMP)
+    thrust_debug("Searching for OMP ${required}" internal)
+    find_package(OpenMP
+      ${_THRUST_QUIET_FLAG}
+      ${_THRUST_REQUIRED_FLAG_OMP}
+      COMPONENTS CXX
+    )
+
+    if (TARGET OpenMP::OpenMP_CXX)
+      thrust_fixup_omp_target(OpenMP::OpenMP_CXX)
+      thrust_set_OMP_target(OpenMP::OpenMP_CXX)
+    else()
+      thrust_debug("OpenMP::OpenMP_CXX not found!" internal)
+    endif()
+  endif()
+endmacro()
+
+# This must be a macro instead of a function to ensure that backends passed to
+# find_package(Thrust COMPONENTS [...]) have their full configuration loaded
+# into the current scope. This provides at least some remedy for CMake issue
+# #20670 -- otherwise variables like CUB_VERSION, etc won't be in the caller's
+# scope.
+macro(_thrust_find_backend backend required)
+  # Unfortunately, _thrust_find_${backend}(req) is not valid CMake syntax. Hence
+  # why this function exists.
+  if ("${backend}" STREQUAL "CPP")
+    _thrust_find_CPP("${required}")
+  elseif ("${backend}" STREQUAL "CUDA")
+    _thrust_find_CUDA("${required}")
+  elseif ("${backend}" STREQUAL "TBB")
+    _thrust_find_TBB("${required}")
+  elseif ("${backend}" STREQUAL "OMP")
+    _thrust_find_OMP("${required}")
+  else()
+    message(FATAL_ERROR "_thrust_find_backend: Invalid system: ${backend}")
+  endif()
+endmacro()
+
+################################################################################
+# Initialization. Executed inside find_package(Thrust) call.
+#
+
+if (${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY)
+  set(_THRUST_QUIET ON CACHE INTERNAL "Quiet mode enabled for Thrust find_package calls." FORCE)
+  set(_THRUST_QUIET_FLAG "QUIET" CACHE INTERNAL "" FORCE)
+else()
+  unset(_THRUST_QUIET CACHE)
+  unset(_THRUST_QUIET_FLAG CACHE)
+endif()
+
+set(_THRUST_CMAKE_DIR "${CMAKE_CURRENT_LIST_DIR}" CACHE INTERNAL
+  "Location of thrust-config.cmake"
+  FORCE
+)
+
+# Internal target that actually holds the Thrust interface. Used by all other Thrust targets.
+if (NOT TARGET Thrust::Thrust)
+  _thrust_declare_interface_alias(Thrust::Thrust _Thrust_Thrust)
+  # Pull in the include dir detected by thrust-config-version.cmake
+  set(_THRUST_INCLUDE_DIR "${_THRUST_VERSION_INCLUDE_DIR}"
+    CACHE INTERNAL "Location of Thrust headers."
+    FORCE
+  )
+  unset(_THRUST_VERSION_INCLUDE_DIR CACHE) # Clear tmp variable from cache
+  target_include_directories(_Thrust_Thrust INTERFACE "${_THRUST_INCLUDE_DIR}")
+  thrust_debug_target(Thrust::Thrust "${THRUST_VERSION}" internal)
+endif()
+
+# Find libcudacxx prior to locating backend-specific deps. This ensures that CUB
+# finds the same package.
+if (NOT TARGET Thrust::libcudacxx)
+  thrust_debug("Searching for libcudacxx REQUIRED" internal)
+
+  # First do a non-required search for any co-packaged versions.
+  # These are preferred.
+  find_package(libcudacxx ${thrust_libcudacxx_version} CONFIG
+    ${_THRUST_QUIET_FLAG}
+    NO_DEFAULT_PATH # Only check the explicit HINTS below:
+    HINTS
+      "${_THRUST_INCLUDE_DIR}/../libcudacxx" # Source layout
+      "${_THRUST_CMAKE_DIR}/.."              # Install layout
+  )
+
+  # A second required search allows externally packaged to be used and fails if
+  # no suitable package exists.
+  find_package(libcudacxx ${thrust_libcudacxx_version} CONFIG
+    REQUIRED
+    ${_THRUST_QUIET_FLAG}
+  )
+
+  if (TARGET libcudacxx::libcudacxx)
+    _thrust_set_libcudacxx_target(libcudacxx::libcudacxx)
+  else()
+    thrust_debug("Expected libcudacxx::libcudacxx target not found!" internal)
+  endif()
+
+  target_link_libraries(_Thrust_Thrust INTERFACE Thrust::libcudacxx)
+endif()
+
+# Handle find_package COMPONENT requests:
+foreach(component ${${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS})
+  if (NOT component IN_LIST THRUST_HOST_SYSTEM_OPTIONS AND
+      NOT component IN_LIST THRUST_DEVICE_SYSTEM_OPTIONS)
+    message(FATAL_ERROR "Invalid component requested: '${component}'")
+  endif()
+
+  unset(req)
+  if (${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${component})
+    set(req "REQUIRED")
+  endif()
+
+  thrust_debug("Preloading COMPONENT '${component}' ${req}" internal)
+  _thrust_find_backend(${component} "${req}")
+endforeach()
+
+thrust_update_system_found_flags()
+
+include(FindPackageHandleStandardArgs)
+if (NOT Thrust_CONFIG)
+  set(Thrust_CONFIG "${CMAKE_CURRENT_LIST_FILE}")
+endif()
+find_package_handle_standard_args(Thrust CONFIG_MODE)

miniCUDA124/lib/cmake/thrust/thrust-header-search.cmake

@@ -0,0 +1,19 @@
+# Parse version information from version.h:
+unset(_THRUST_VERSION_INCLUDE_DIR CACHE) # Clear old result to force search
+
+# Find CMAKE_INSTALL_INCLUDEDIR=include directory"
+set(from_install_prefix "lib/cmake/thrust")
+
+# Transform to a list of directories, replace each directoy with "../"
+# and convert back to a string
+string(REGEX REPLACE "/" ";" from_install_prefix "${from_install_prefix}")
+list(TRANSFORM from_install_prefix REPLACE ".+" "../")
+list(JOIN from_install_prefix "" from_install_prefix)
+
+find_path(_THRUST_VERSION_INCLUDE_DIR thrust/version.h
+  NO_CMAKE_FIND_ROOT_PATH # Don't allow CMake to re-root the search
+  NO_DEFAULT_PATH # Only search explicit paths below:
+  PATHS
+    "${CMAKE_CURRENT_LIST_DIR}/${from_install_prefix}/include"
+)
+set_property(CACHE _THRUST_VERSION_INCLUDE_DIR PROPERTY TYPE INTERNAL)

miniCUDA124/lib/x64/cudadevrt.lib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:962b4ff5365b2e0f922a7e482f57bd778be255b8135619f0a8e9f2c25893e8bf
+size 1604608

miniCUDA124/nvvm/include/nvvm.h

@@ -0,0 +1,351 @@
+//
+// NVIDIA_COPYRIGHT_BEGIN
+//
+// Copyright (c) 2014-2023, NVIDIA CORPORATION.  All rights reserved.
+//
+// NVIDIA CORPORATION and its licensors retain all intellectual property
+// and proprietary rights in and to this software, related documentation
+// and any modifications thereto.  Any use, reproduction, disclosure or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA CORPORATION is strictly prohibited.
+//
+// NVIDIA_COPYRIGHT_END
+//
+
+#ifndef NVVM_H
+#define NVVM_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#include <stdlib.h>
+
+
+/*****************************//**
+ *
+ * \defgroup error Error Handling
+ *
+ ********************************/
+
+
+/**
+ * \ingroup error
+ * \brief   NVVM API call result code.
+ */
+typedef enum {
+  NVVM_SUCCESS = 0,
+  NVVM_ERROR_OUT_OF_MEMORY = 1,
+  NVVM_ERROR_PROGRAM_CREATION_FAILURE = 2,
+  NVVM_ERROR_IR_VERSION_MISMATCH = 3,
+  NVVM_ERROR_INVALID_INPUT = 4,
+  NVVM_ERROR_INVALID_PROGRAM = 5,
+  NVVM_ERROR_INVALID_IR = 6,
+  NVVM_ERROR_INVALID_OPTION = 7,
+  NVVM_ERROR_NO_MODULE_IN_PROGRAM = 8,
+  NVVM_ERROR_COMPILATION = 9
+} nvvmResult;
+
+
+/**
+ * \ingroup error
+ * \brief   Get the message string for the given #nvvmResult code.
+ *
+ * \param   [in] result NVVM API result code.
+ * \return  Message string for the given #nvvmResult code.
+ */
+const char *nvvmGetErrorString(nvvmResult result);
+
+
+/****************************************//**
+ *
+ * \defgroup query General Information Query
+ *
+ *******************************************/
+
+
+/**
+ * \ingroup query
+ * \brief   Get the NVVM version.
+ *
+ * \param   [out] major NVVM major version number.
+ * \param   [out] minor NVVM minor version number.
+ * \return 
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *
+ */
+nvvmResult nvvmVersion(int *major, int *minor);
+
+
+/**
+ * \ingroup query
+ * \brief   Get the NVVM IR version.
+ *
+ * \param   [out] majorIR  NVVM IR major version number.
+ * \param   [out] minorIR  NVVM IR minor version number.
+ * \param   [out] majorDbg NVVM IR debug metadata major version number.
+ * \param   [out] minorDbg NVVM IR debug metadata minor version number.
+ * \return 
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *
+ */
+nvvmResult nvvmIRVersion(int *majorIR, int *minorIR, int *majorDbg, int *minorDbg);
+
+
+/********************************//**
+ *
+ * \defgroup compilation Compilation
+ *
+ ***********************************/
+
+/**
+ * \ingroup compilation
+ * \brief   NVVM Program.
+ *
+ * An opaque handle for a program.
+ */
+typedef struct _nvvmProgram *nvvmProgram;
+
+/**
+ * \ingroup compilation
+ * \brief   Create a program, and set the value of its handle to \p *prog.
+ *
+ * \param   [in] prog NVVM program. 
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_OUT_OF_MEMORY \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ *
+ * \see     nvvmDestroyProgram()
+ */
+nvvmResult nvvmCreateProgram(nvvmProgram *prog);
+
+
+/**
+ * \ingroup compilation
+ * \brief   Destroy a program.
+ *
+ * \param    [in] prog NVVM program. 
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ *
+ * \see     nvvmCreateProgram()
+ */
+nvvmResult nvvmDestroyProgram(nvvmProgram *prog);
+
+
+/**
+ * \ingroup compilation
+ * \brief   Add a module level NVVM IR to a program. 
+ *
+ * The \p buffer should contain an NVVM IR module.
+ * The module should have NVVM IR either in the LLVM 7.0.1 bitcode
+ * representation or in the LLVM 7.0.1 text representation. Support for reading
+ * the text representation of NVVM IR is deprecated and may be removed in a
+ * later version.
+ *
+ * \param   [in] prog   NVVM program.
+ * \param   [in] buffer NVVM IR module in the bitcode or text
+ *                      representation.
+ * \param   [in] size   Size of the NVVM IR module.
+ * \param   [in] name   Name of the NVVM IR module.
+ *                      If NULL, "<unnamed>" is used as the name.
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_OUT_OF_MEMORY \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_INPUT \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ */
+nvvmResult nvvmAddModuleToProgram(nvvmProgram prog, const char *buffer, size_t size, const char *name);
+
+/**
+ * \ingroup compilation
+ * \brief   Add a module level NVVM IR to a program. 
+ *
+ * The \p buffer should contain an NVVM IR module. The module should have NVVM
+ * IR in the LLVM 7.0.1 bitcode representation.
+ *
+ * A module added using this API is lazily loaded - the only symbols loaded
+ * are those that are required by module(s) loaded using
+ * nvvmAddModuleToProgram. It is an error for a program to have
+ * all modules loaded using this API. Compiler may also optimize entities
+ * in this module by making them internal to the linked NVVM IR module,
+ * making them eligible for other optimizations. Due to these
+ * optimizations, this API to load a module is more efficient and should
+ * be used where possible.
+ * 
+ * \param   [in] prog   NVVM program.
+ * \param   [in] buffer NVVM IR module in the bitcode representation.
+ * \param   [in] size   Size of the NVVM IR module.
+ * \param   [in] name   Name of the NVVM IR module.
+ *                      If NULL, "<unnamed>" is used as the name.
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_OUT_OF_MEMORY \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_INPUT \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ */
+nvvmResult nvvmLazyAddModuleToProgram(nvvmProgram prog, const char *buffer, size_t size, const char *name);
+
+/**
+ * \ingroup compilation
+ * \brief   Compile the NVVM program.
+ *
+ * The NVVM IR modules in the program will be linked at the IR level.
+ * The linked IR program is compiled to PTX.
+ *
+ * The target datalayout in the linked IR program is used to
+ * determine the address size (32bit vs 64bit).
+ *
+ * The valid compiler options are:
+ *
+ *   - -g (enable generation of full debugging information).
+ *        Full debug support is only valid with '-opt=0'. Debug support
+ *        requires the input module to utilize NVVM IR Debug Metadata.
+ *        Line number (line info) only generation is also enabled via NVVM IR
+ *        Debug Metadata, there is no specific libNVVM API flag for that case.
+ *   - -opt=
+ *     - 0 (disable optimizations)
+ *     - 3 (default, enable optimizations)
+ *   - -arch=
+ *     - compute_50
+ *     - compute_52 (default)
+ *     - compute_53
+ *     - compute_60
+ *     - compute_61
+ *     - compute_62
+ *     - compute_70
+ *     - compute_72
+ *     - compute_75
+ *     - compute_80
+ *     - compute_87
+ *     - compute_89
+ *     - compute_90
+ *   - -ftz=
+ *     - 0 (default, preserve denormal values, when performing
+ *          single-precision floating-point operations)
+ *     - 1 (flush denormal values to zero, when performing
+ *          single-precision floating-point operations)
+ *   - -prec-sqrt=
+ *     - 0 (use a faster approximation for single-precision
+ *          floating-point square root)
+ *     - 1 (default, use IEEE round-to-nearest mode for
+ *          single-precision floating-point square root)
+ *   - -prec-div=
+ *     - 0 (use a faster approximation for single-precision
+ *          floating-point division and reciprocals)
+ *     - 1 (default, use IEEE round-to-nearest mode for
+ *          single-precision floating-point division and reciprocals)
+ *   - -fma=
+ *     - 0 (disable FMA contraction)
+ *     - 1 (default, enable FMA contraction)
+ *   - -jump-table-density=[0-101]
+ *        Specify the case density percentage in switch statements, and use
+ *        it as a minimal threshold to determine whether jump table(brx.idx
+ *        instruction) will be used to implement a switch statement. Default
+ *        value is 101. The percentage ranges from 0 to 101 inclusively.
+ *   - -gen-lto (Generate LTO IR instead of PTX).
+ *
+ * \param   [in] prog       NVVM program.
+ * \param   [in] numOptions Number of compiler \p options passed.
+ * \param   [in] options    Compiler options in the form of C string array.
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_OUT_OF_MEMORY \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_IR_VERSION_MISMATCH \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_OPTION \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_NO_MODULE_IN_PROGRAM \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_COMPILATION \endlink
+ */
+nvvmResult nvvmCompileProgram(nvvmProgram prog, int numOptions, const char **options);   
+
+/**
+ * \ingroup compilation
+ * \brief   Verify the NVVM program.
+ *
+ * The valid compiler options are:
+ *
+ * Same as for nvvmCompileProgram().
+ *
+ * \param   [in] prog       NVVM program.
+ * \param   [in] numOptions Number of compiler \p options passed.
+ * \param   [in] options    Compiler options in the form of C string array.
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_OUT_OF_MEMORY \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_IR_VERSION_MISMATCH \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_IR \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_OPTION \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_NO_MODULE_IN_PROGRAM \endlink
+ *
+ * \see     nvvmCompileProgram()
+ */
+nvvmResult nvvmVerifyProgram(nvvmProgram prog, int numOptions, const char **options);
+
+/**
+ * \ingroup compilation
+ * \brief   Get the size of the compiled result.
+ *
+ * \param   [in]  prog          NVVM program.
+ * \param   [out] bufferSizeRet Size of the compiled result (including the
+ *                              trailing NULL).
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ */
+nvvmResult nvvmGetCompiledResultSize(nvvmProgram prog, size_t *bufferSizeRet);
+
+
+/**
+ * \ingroup compilation
+ * \brief   Get the compiled result.
+ *
+ * The result is stored in the memory pointed to by \p buffer.
+ *
+ * \param   [in]  prog   NVVM program.
+ * \param   [out] buffer Compiled result.
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ */
+nvvmResult nvvmGetCompiledResult(nvvmProgram prog, char *buffer);
+
+/**
+ * \ingroup compilation
+ * \brief   Get the Size of Compiler/Verifier Message.
+ *
+ * The size of the message string (including the trailing NULL) is stored into
+ * \p bufferSizeRet when the return value is NVVM_SUCCESS.
+ *   
+ * \param   [in]  prog          NVVM program.
+ * \param   [out] bufferSizeRet Size of the compilation/verification log
+                                (including the trailing NULL).
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ */
+nvvmResult nvvmGetProgramLogSize(nvvmProgram prog, size_t *bufferSizeRet);
+
+/**
+ * \ingroup compilation
+ * \brief   Get the Compiler/Verifier Message.
+ *
+ * The NULL terminated message string is stored in the memory pointed to by
+ * \p buffer when the return value is NVVM_SUCCESS.
+ *   
+ * \param   [in]  prog   NVVM program.
+ * \param   [out] buffer Compilation/Verification log.
+ * \return
+ *   - \link ::nvvmResult NVVM_SUCCESS \endlink
+ *   - \link ::nvvmResult NVVM_ERROR_INVALID_PROGRAM \endlink
+ */
+nvvmResult nvvmGetProgramLog(nvvmProgram prog, char *buffer);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* NVVM_H */

miniMSVC/VC/Tools/MSVC/14.42.34433/include/agile.h

@@ -0,0 +1,459 @@
+//
+// Copyright (C) Microsoft Corporation
+// All rights reserved.
+//
+// Code in Details namespace is for internal usage within the library code
+//
+
+#ifndef _PLATFORM_AGILE_H_
+#define _PLATFORM_AGILE_H_
+
+#ifdef _MSC_VER
+#pragma once
+#endif  // _MSC_VER
+
+#include <algorithm>
+#include <wrl/client.h>
+
+#if !defined(__cplusplus_winrt)
+#error agile.h can only be used with /ZW
+#endif
+
+namespace Platform
+{
+	namespace Details
+	{
+		__declspec(dllimport) IUnknown* __stdcall GetObjectContext();
+		__declspec(dllimport) HRESULT __stdcall GetProxyImpl(::IUnknown*, REFIID, ::IUnknown*, ::IUnknown**);
+		__declspec(dllimport) HRESULT __stdcall ReleaseInContextImpl(::IUnknown*, ::IUnknown*);
+
+		template <typename T>
+		__declspec(no_refcount) inline HRESULT GetProxy(T ^ObjectIn, ::IUnknown *ContextCallBack, T ^*Proxy)
+		{
+			return GetProxyImpl(*reinterpret_cast<IUnknown**>(&ObjectIn), __uuidof(T^) , ContextCallBack, reinterpret_cast< ::IUnknown**>(Proxy));
+		}
+
+		template <typename T>
+		inline HRESULT ReleaseInContext(T *ObjectIn, ::IUnknown *ContextCallBack)
+		{
+			return ReleaseInContextImpl(ObjectIn, ContextCallBack);
+		}
+
+		template <typename T>
+		class AgileHelper
+		{
+			__abi_IUnknown* _p;
+			bool _release;
+		public:
+			AgileHelper(__abi_IUnknown* p, bool release = true) : _p(p), _release(release)
+			{
+			}
+			AgileHelper(AgileHelper && other) : _p(other._p), _release(other._release)
+			{
+				_other._p = nullptr;
+				_other._release = true;
+			}
+			AgileHelper operator=(AgileHelper && other)
+			{
+				_p = other._p;
+				_release = other._release;
+				_other._p = nullptr;
+				_other._release = true;
+				return *this;
+			}
+
+			~AgileHelper()
+			{
+				if (_release && _p)
+				{
+					_p->__abi_Release();
+				}
+			}
+
+			__declspec(no_refcount) __declspec(no_release_return)
+				T^ operator->()
+			{
+				return reinterpret_cast<T^>(_p);
+			}
+
+			__declspec(no_refcount) __declspec(no_release_return)
+				operator T^()
+			{
+				return reinterpret_cast<T^>(_p);
+			}
+		private:
+			AgileHelper(const AgileHelper&);
+			AgileHelper operator=(const AgileHelper&) ;
+		};
+		template <typename T>
+		struct __remove_hat
+		{
+			typedef T type;
+		};
+		template <typename T>
+		struct __remove_hat<T^>
+		{
+			typedef T type;
+		};
+		template <typename T>
+		struct AgileTypeHelper
+		{
+			typename typedef __remove_hat<T>::type type;
+			typename typedef __remove_hat<T>::type^ agileMemberType;
+		};
+	} // namespace Details
+
+#pragma warning(push)
+#pragma warning(disable: 4451) // Usage of ref class inside this context can lead to invalid marshaling of object across contexts
+
+	template <
+		typename T,
+		bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) ||
+		__is_win_interface(typename Details::AgileTypeHelper<T>::type)
+	>
+	class Agile
+	{
+		static_assert(__is_win_class(typename Details::AgileTypeHelper<T>::type) || __is_win_interface(typename Details::AgileTypeHelper<T>::type), "Agile can only be used with ref class or interface class types");
+		typename typedef Details::AgileTypeHelper<T>::agileMemberType TypeT;
+		TypeT _object;
+		::Microsoft::WRL::ComPtr< ::IUnknown> _contextCallback;
+		ULONG_PTR _contextToken;
+
+		enum class AgileState
+		{
+			NonAgilePointer = 0,
+			AgilePointer = 1,
+			Unknown = 2
+		};
+		AgileState _agileState;
+
+		void CaptureContext()
+		{
+			_contextCallback = Details::GetObjectContext();
+			__abi_ThrowIfFailed(CoGetContextToken(&_contextToken));
+		}
+
+		void SetObject(TypeT object)
+		{
+			// Capture context before setting the pointer
+			// If context capture fails then nothing to cleanup
+			Release();
+			if (object != nullptr)
+			{
+				::Microsoft::WRL::ComPtr< ::IAgileObject> checkIfAgile;
+				HRESULT hr = reinterpret_cast< ::IUnknown*>(object)->QueryInterface(__uuidof(::IAgileObject), &checkIfAgile);
+				// Don't Capture context if object is agile
+				if (hr != S_OK)
+				{
+					_agileState = AgileState::NonAgilePointer;
+					CaptureContext();
+				}
+				else
+				{
+					_agileState = AgileState::AgilePointer;
+				}
+			}
+			_object = object;
+		}
+
+	public:
+		Agile() throw() : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
+		{
+		}
+
+		Agile(nullptr_t) throw() : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
+		{
+		}
+
+		explicit Agile(TypeT object) throw() : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
+		{
+			// Assumes that the source object is from the current context
+			SetObject(object);
+		}
+
+		Agile(const Agile& object) throw() : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
+		{
+			// Get returns pointer valid for current context
+			SetObject(object.Get());
+		}
+
+		Agile(Agile && object) throw() : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
+		{
+			// Assumes that the source object is from the current context
+			Swap(object);
+		}
+
+		~Agile() throw()
+		{
+			Release();
+		}
+
+		TypeT Get() const
+		{
+			// Agile object, no proxy required
+			if (_agileState == AgileState::AgilePointer || _object == nullptr)
+			{
+				return _object;
+			}
+
+			// Do the check for same context
+			ULONG_PTR currentContextToken;
+			__abi_ThrowIfFailed(CoGetContextToken(&currentContextToken));
+			if (currentContextToken == _contextToken)
+			{
+				return _object;
+			}
+
+			// Different context and holding on to a non agile object
+			// Do the costly work of getting a proxy
+			TypeT localObject;
+			__abi_ThrowIfFailed(Details::GetProxy(_object, _contextCallback.Get(), &localObject));
+
+			if (_agileState == AgileState::Unknown)
+			{
+				// Object is agile if it implements IAgileObject
+				// GetAddressOf captures the context with out knowing the type of object that it will hold
+				::Microsoft::WRL::ComPtr< ::IAgileObject> checkIfAgile;
+				HRESULT hr = reinterpret_cast<IUnknown*>(localObject)->QueryInterface(__uuidof(::IAgileObject), &checkIfAgile);
+				if (hr == S_OK)
+				{
+					auto pThis = const_cast<Agile*>(this);
+					pThis->_agileState = AgileState::AgilePointer;
+					pThis->_contextToken = 0;
+					pThis->_contextCallback = nullptr;
+					return _object;
+				}
+				else
+				{
+					auto pThis = const_cast<Agile*>(this);
+					pThis->_agileState = AgileState::NonAgilePointer;
+				}
+			}
+
+			return localObject;
+		}
+
+		TypeT* GetAddressOf() throw()
+		{
+			Release();
+			CaptureContext();
+			return &_object;
+		}
+
+		TypeT* GetAddressOfForInOut() throw()
+		{
+			CaptureContext();
+			return &_object;
+		}
+
+		TypeT operator->() const throw()
+		{
+			return Get();
+		}
+
+		Agile& operator=(nullptr_t) throw()
+		{
+			Release();
+			return *this;
+		}
+
+		Agile& operator=(TypeT object) throw()
+		{
+			Agile(object).Swap(*this);
+			return *this;
+		}
+
+		Agile& operator=(Agile object) throw()
+		{
+			// parameter is by copy which gets pointer valid for current context
+			object.Swap(*this);
+			return *this;
+		}
+
+		void Swap(Agile& object)
+		{
+			std::swap(_object, object._object);
+			std::swap(_contextCallback, object._contextCallback);
+			std::swap(_contextToken, object._contextToken);
+			std::swap(_agileState, object._agileState);
+		}
+
+		// Release the interface and set to NULL
+		void Release() throw()
+		{
+			if (_object)
+			{
+				// Cast to IInspectable (no QI)
+				IUnknown* pObject = *(::IUnknown**) (&_object);
+				// Set ^ to null without release
+				*(IUnknown**) (&_object) = nullptr;
+
+				ULONG_PTR currentContextToken;
+				__abi_ThrowIfFailed(CoGetContextToken(&currentContextToken));
+				if (_contextToken == 0 || _contextCallback == nullptr || _contextToken == currentContextToken)
+				{
+					pObject->Release();
+				}
+				else
+				{
+					Details::ReleaseInContext(pObject, _contextCallback.Get());
+				}
+				_contextCallback = nullptr;
+				_contextToken = 0;
+				_agileState = AgileState::Unknown;
+			}
+		}
+
+		bool operator==(nullptr_t) const throw()
+		{
+			return _object == nullptr;
+		}
+
+		bool operator==(const Agile& other) const throw()
+		{
+			return _object == other._object && _contextToken == other._contextToken;
+		}
+
+		bool operator < (const Agile& other) const throw()
+		{
+			if (reinterpret_cast<void*>(_object) < reinterpret_cast<void*>(other._object))
+			{
+				return true;
+			}
+
+			return _object == other._object && _contextToken < other._contextToken;
+		}
+	};
+
+	template <typename T>
+	class Agile<T, false>
+	{
+		static_assert(__is_win_class(typename Details::AgileTypeHelper<T>::type) || __is_win_interface(typename Details::AgileTypeHelper<T>::type), "Agile can only be used with ref class or interface class types");
+		typename typedef Details::AgileTypeHelper<T>::agileMemberType TypeT;
+		TypeT _object;
+
+	public:
+		Agile() throw() : _object(nullptr)
+		{
+		}
+
+		Agile(nullptr_t) throw() : _object(nullptr)
+		{
+		}
+
+		explicit Agile(TypeT object) throw() : _object(object)
+		{
+		}
+
+		Agile(const Agile& object) throw() : _object(object._object)
+		{
+		}
+
+		Agile(Agile && object) throw() : _object(nullptr)
+		{
+			Swap(object);
+		}
+
+		~Agile() throw()
+		{
+			Release();
+		}
+
+		TypeT Get() const
+		{
+			return _object;
+		}
+
+		TypeT* GetAddressOf() throw()
+		{
+			Release();
+			return &_object;
+		}
+
+		TypeT* GetAddressOfForInOut() throw()
+		{
+			return &_object;
+		}
+
+		TypeT operator->() const throw()
+		{
+			return Get();
+		}
+
+		Agile& operator=(nullptr_t) throw()
+		{
+			Release();
+			return *this;
+		}
+
+		Agile& operator=(TypeT object) throw()
+		{
+			if (_object != object)
+			{
+				_object = object;
+			}
+			return *this;
+		}
+
+		Agile& operator=(Agile object) throw()
+		{
+			object.Swap(*this);
+			return *this;
+		}
+
+		// Release the interface and set to NULL
+		void Release() throw()
+		{
+			_object = nullptr;
+		}
+
+		void Swap(Agile& object)
+		{
+			std::swap(_object, object._object);
+		}
+
+		bool operator==(nullptr_t) const throw()
+		{
+			return _object == nullptr;
+		}
+
+		bool operator==(const Agile& other) const throw()
+		{
+			return _object == other._object;
+		}
+
+		bool operator < (const Agile& other) const throw()
+		{
+			return reinterpret_cast<void*>(_object) < reinterpret_cast<void*>(other._object);
+		}
+	};
+
+#pragma warning(pop)
+
+	template<class U>
+	bool operator==(nullptr_t, const Agile<U>& a) throw()
+	{
+		return a == nullptr;
+	}
+
+	template<class U>
+	bool operator!=(const Agile<U>& a, nullptr_t) throw()
+	{
+		return !(a == nullptr);
+	}
+
+	template<class U>
+	bool operator!=(nullptr_t, const Agile<U>& a) throw()
+	{
+		return !(a == nullptr);
+	}
+
+	template<class U>
+	bool operator!=(const Agile<U>& a, const Agile<U>& b) throw()
+	{
+		return !(a == b);
+	}
+
+} // namespace Platform
+
+#endif // _PLATFORM_AGILE_H_