MEGA MERGE

m/common/base/sys-devices.nix

@@ -6,4 +6,10 @@
     "/sys/devices/system/cpu"
     "/sys/devices/system/node"
   ];
+
+  # similar to cudaSupport, this can be used to activate certain features
+  # conditionally.
+  nixpkgs.overlays = [
+    (final: prev: { sysDevicesSupport = true; })
+  ];
 }

overlay.nix

@@ -1,14 +1,50 @@
 final: /* Future last stage */
 prev:  /* Previous stage */
 
-with final.lib;
-
 let
+
+  inherit (prev) lib;
+  inherit (lib) collect filterAttrs isDerivation mapAttrs;
+
   callPackage = final.callPackage;
 
-  bscPkgs = {
+  mkStrict = drv: if (isDerivation drv && drv ? overrideAttrs && !(drv ? strictDeps))
+    then drv.overrideAttrs { strictDeps = true; }
+    else drv;
+
+  bscPkgs = mapAttrs (_: mkStrict) {
+
+    # override stdenv to add a sentinel to know if a derivation comes
+    # from unfree sources.
+    stdenv = prev.stdenv // {
+      mkDerivation =
+        args:
+        let
+          originalDrv = prev.stdenv.mkDerivation args;
+          checkLicense = l: if builtins.isAttrs l then !(l.free or true) else false;
+
+          licenses = if builtins.isList args.meta.license then args.meta.license else [ args.meta.license ];
+
+          hasUnfreeLicense =
+            if args ? meta && args.meta ? license then builtins.any checkLicense licenses else false;
+        in
+        if hasUnfreeLicense then
+          builtins.traceVerbose "adding nix-support/private to ${originalDrv.name or originalDrv.pname}" (
+          originalDrv.overrideAttrs (old: {
+            postInstall = (old.postInstall or "") + ''
+              mkdir -p $out/nix-support
+              touch $out/nix-support/private
+            '';
+          }))
+        else
+          originalDrv;
+    };
+
     agenix = prev.callPackage ./pkgs/agenix/default.nix { };
     amd-uprof = prev.callPackage ./pkgs/amd-uprof/default.nix { };
+    aoccUnwrapped = callPackage ./pkgs/aocc/unwrapped.nix { };
+    aocc = callPackage ./pkgs/aocc/default.nix { };
+    stdenvAocc = final.overrideCC final.stdenv final.aocc;
     bench6 = callPackage ./pkgs/bench6/default.nix { };
     bigotes = callPackage ./pkgs/bigotes/default.nix { };
     clangOmpss2 = callPackage ./pkgs/llvm-ompss2/default.nix { };
@@ -17,6 +53,7 @@ let
     clangOmpss2NodesOmpv = callPackage ./pkgs/llvm-ompss2/default.nix { ompss2rt = final.nodes; openmp = final.openmpv; };
     clangOmpss2Unwrapped = callPackage ./pkgs/llvm-ompss2/clang.nix { };
     cudainfo = prev.callPackage ./pkgs/cudainfo/default.nix { };
+    clsparse = callPackage ./pkgs/clsparse/package.nix { };
     #extrae = callPackage ./pkgs/extrae/default.nix { }; # Broken and outdated
     gpi-2 = callPackage ./pkgs/gpi-2/default.nix { };
     intel-apt = callPackage ./pkgs/intel-oneapi/packages.nix { };
@@ -53,6 +90,7 @@ let
     ovni = callPackage ./pkgs/ovni/default.nix { };
     ovniGit = final.ovni.override { useGit = true; };
     paraverKernel = callPackage ./pkgs/paraver/kernel.nix { };
+    pocl = callPackage ./pkgs/pocl/default.nix { };
     prometheus-slurm-exporter = prev.callPackage ./pkgs/slurm-exporter/default.nix { };
     #pscom = callPackage ./pkgs/parastation/pscom.nix { }; # Unmaintaned
     #psmpi = callPackage ./pkgs/parastation/psmpi.nix { }; # Unmaintaned
@@ -62,11 +100,13 @@ let
     stdenvClangOmpss2Nanos6 = final.stdenv.override { cc = final.clangOmpss2Nanos6; allowedRequisites = null; };
     stdenvClangOmpss2Nodes = final.stdenv.override { cc = final.clangOmpss2Nodes; allowedRequisites = null; };
     stdenvClangOmpss2NodesOmpv = final.stdenv.override { cc = final.clangOmpss2NodesOmpv; allowedRequisites = null; };
+    tacuda = callPackage ./pkgs/tacuda/default.nix { };
     tagaspi = callPackage ./pkgs/tagaspi/default.nix { };
     tampi = callPackage ./pkgs/tampi/default.nix { };
     tasycl = callPackage ./pkgs/tasycl/default.nix { };
     tasycl-acpp = callPackage ./pkgs/tasycl/default.nix { useIntel = false; };
     upc-qaire-exporter = prev.callPackage ./pkgs/upc-qaire-exporter/default.nix { };
+    taopencl = callPackage ./pkgs/taopencl/default.nix { };
     wxparaver = callPackage ./pkgs/paraver/default.nix { };
 
     gromacs = callPackage ./pkgs/gromacs/default.nix { enableSYCL = true; };
@@ -112,6 +152,8 @@ let
     clangNosvOmpv-ld = callPackage ./test/compilers/clang-openmp-ld.nix {
       stdenv = final.stdenvClangOmpss2NodesOmpv;
     };
+
+    pocl = callPackage ./test/compilers/pocl.nix { };
   };
 
   # For now, only build toplevel packages in CI/Hydra
@@ -122,7 +164,7 @@ let
     (isDerivation pkg) &&
     # Must be defined explicitly
     (pkg.meta.cross or false) &&
-    (meta.availableOn platform pkg);
+    (lib.meta.availableOn platform pkg);
 
   # For now only RISC-V
   crossSet = { riscv64 = final.pkgsCross.riscv64.bsc.pkgsTopLevel; };
@@ -144,7 +186,7 @@ let
   allList = buildList' "ci-all" [ pkgsList testsList ];
   # For now only RISC-V
   crossList = buildList "ci-cross"
-    (filter
+    (lib.filter
       (canCrossCompile final.pkgsCross.riscv64.stdenv.hostPlatform)
         (builtins.attrValues crossSet.riscv64));
 

pkgs/aocc/default.nix

@@ -0,0 +1,16 @@
+{ wrapCCWith
+, aoccUnwrapped
+}:
+
+let
+  cc = aoccUnwrapped;
+in wrapCCWith {
+  inherit cc;
+
+  extraBuildCommands = ''
+    echo "-isystem ${cc}/include" >> $out/nix-support/cc-cflags
+
+    wrap aocc   $wrapper $ccPath/clang
+    wrap aocc++ $wrapper $ccPath/clang++
+  '';
+}

pkgs/aocc/unwrapped.nix

@@ -0,0 +1,51 @@
+{ lib
+, fetchurl
+, stdenv
+, autoPatchelfHook
+, rocmPackages
+, zlib
+, libffi
+, elfutils
+}:
+
+let
+  # in newer nixpkgs the runtime is hsakmt
+  rocmRuntime =
+    if rocmPackages ? hsakmt then
+      rocmPackages.hsakmt
+    else
+      rocmPackages.rocm-runtime;
+in
+stdenv.mkDerivation {
+  pname = "aocc-compiler";
+  version = "5.0.0";
+
+  src = fetchurl {
+    url = "https://download.amd.com/developer/eula/aocc/aocc-5-0/aocc-compiler-5.0.0.tar";
+    sha256 = "sha256-lm+sLSx1np3m6WnBCtp6ezBsET9/HgfqN2gp7IY4Dao=";
+  };
+
+  nativeBuildInputs = [ autoPatchelfHook ];
+  buildInputs = [
+    elfutils
+    zlib
+    rocmRuntime
+    stdenv.cc.cc.lib
+  ];
+  phases = [ "unpackPhase" "installPhase" "fixupPhase" ];
+  dontStrip = true;
+
+  installPhase = ''
+    mkdir -p $out
+    cp -a . $out/
+
+    ln -s ${lib.getLib libffi}/lib/libffi.so $out/lib/libffi.so.6
+  '';
+
+  passthru = {
+    inherit rocmRuntime;
+    isClang = true; # Needed for wrapCCWith
+  };
+
+  meta.mainProgram = "clang";
+}

pkgs/clsparse/install_target.patch

@@ -0,0 +1,53 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 3d139ed..15ffc14 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -176,32 +179,22 @@ if( BUILD_clSPARSE OR BUILD_SAMPLES )
+   if( BUILD_clSPARSE )
+     message( STATUS "Setting up clSPARSE external..." )
+ 
+-    if ( BUILD_SAMPLES )
+-      # If the user elects to build samples, then we must build and install clSPARSE
+-      # The install location is set as a subdirectory of the SuperBuild
+-      ExternalProject_Add(
+-        clSPARSE
+-        DEPENDS ${clSPARSE.Dependencies}
+-        SOURCE_DIR ${PROJECT_SOURCE_DIR}/src
+-        BINARY_DIR clSPARSE-build
+-        INSTALL_DIR clSPARSE-package
+-        CMAKE_ARGS ${clSPARSE.Cmake.Args} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+-        -DBUILD_CLVERSION=${BUILD_CLVERSION} -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
+-        -DUSE_SYSTEM_CL2HPP:BOOL=${USE_SYSTEM_CL2HPP}
+-      )
+-    else( )
+-      # If the user does not want to build samples, then build clSPARSE but don't automatically
+-      # install it
+-      ExternalProject_Add(
+-        clSPARSE
+-        DEPENDS ${clSPARSE.Dependencies}
+-        SOURCE_DIR ${PROJECT_SOURCE_DIR}/src
+-        BINARY_DIR clSPARSE-build
+-        CMAKE_ARGS ${clSPARSE.Cmake.Args} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+-        -DBUILD_CLVERSION=${BUILD_CLVERSION} -DUSE_SYSTEM_CL2HPP:BOOL=${USE_SYSTEM_CL2HPP}
+-        INSTALL_COMMAND ""
+-      )
+-    endif( )
++    ExternalProject_Add(
++      clSPARSE
++      DEPENDS ${clSPARSE.Dependencies}
++      SOURCE_DIR ${PROJECT_SOURCE_DIR}/src
++      BINARY_DIR clSPARSE-build
++      INSTALL_DIR clSPARSE-package
++      CMAKE_ARGS ${clSPARSE.Cmake.Args} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
++      -DBUILD_CLVERSION=${BUILD_CLVERSION} -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
++      -DUSE_SYSTEM_CL2HPP:BOOL=${USE_SYSTEM_CL2HPP}
++    )
++
++    install(
++      DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/clSPARSE-package/
++      DESTINATION ${CMAKE_INSTALL_PREFIX}
++      USE_SOURCE_PERMISSIONS
++    )
+ 
+   endif( )
+ 

pkgs/clsparse/package.nix

@@ -0,0 +1,70 @@
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  fetchpatch,
+  boost,
+  gtest,
+  ocl-icd,
+  opencl-headers,
+  opencl-clhpp,
+  cmake,
+}:
+
+stdenv.mkDerivation rec {
+  pname = "clsparse";
+  version = "0.10.2.0";
+
+  src = fetchFromGitHub {
+    owner = "clMathLibraries";
+    repo = "clSPARSE";
+    rev = "v${version}";
+    hash = "sha256-jIauCtUyPEIx7pFI3qH0WagV+t/fvro0OsGgONBJm0s=";
+  };
+
+  patches = [
+    ./pass_include_dir.patch
+    ./install_target.patch
+    (fetchpatch {
+      name = "remove-gettypecode.patch";
+      url = "https://patch-diff.githubusercontent.com/raw/clMathLibraries/clSPARSE/pull/210.patch";
+      hash = "sha256-9Q+tk7RMdWE4MCnbvWlsI0MIgBYKIWR2jIC1bICtIjU=";
+    })
+  ];
+
+  postInstallPhase = ''
+    mv $installDir/lib64 lib
+    ln -s lib/ lib64
+  '';
+
+  env.NIX_CFLAGS_COMPILE = "-std=c++17";
+
+  nativeBuildInputs = [
+    cmake
+  ];
+
+  buildInputs = [
+    boost
+    ocl-icd
+    opencl-headers
+    opencl-clhpp
+  ];
+
+  cmakeFlags = [
+    "-DBUILD_Boost=OFF"
+    "-DBUILD_gMock=OFF"
+    "-DBUILD_MTX=OFF"
+    "-DBUILD_SAMPLES=OFF"
+    "-DUSE_SYSTEM_CL2HPP=ON"
+    "-DGMOCK_ROOT=${gtest}"
+    "-DGTEST_INCLUDE_DIR=${gtest.src}/googletest/include"
+  ];
+
+  meta = {
+    description = "A software library containing Sparse functions written in OpenCL";
+    homepage = "https://github.com/clMathLibraries/clSPARSE";
+    license = lib.licenses.asl20;
+    maintainers = with lib.maintainers; [ leixb ];
+    platforms = lib.platforms.all;
+  };
+}

pkgs/clsparse/pass_include_dir.patch

@@ -0,0 +1,14 @@
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 3d139ed..b7ea2d3 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -132,6 +132,9 @@ else( )
+       set( GMOCK_ROOT "$ENV{GMOCK_ROOT}" )
+     endif( )
+     list( APPEND clSPARSE.Cmake.Args -DGTEST_ROOT=${GMOCK_ROOT} )
++    if( DEFINED GTEST_INCLUDE_DIR )
++      list( APPEND clSPARSE.Cmake.Args -DGTEST_INCLUDE_DIR=${GTEST_INCLUDE_DIR} )
++    endif( )
+   endif( )
+ endif( )
+ 

pkgs/intel-oneapi/2023.nix

@@ -62,11 +62,15 @@ let
     nativeBuildInputs = [ dpkg ];
     phases = [ "installPhase" ];
     installPhase = ''
+      runHook preInstall
+
       mkdir -p $out
       for src in $srcs; do
         echo "unpacking $src"
         dpkg -x $src $out
       done
+
+      runHook postInstall
     '';
 
     inherit meta;
@@ -102,6 +106,8 @@ let
     phases = [ "installPhase" "fixupPhase" ];
     dontStrip = true;
     installPhase = ''
+      runHook preInstall
+
       mkdir -p $out/{bin,etc,lib,include}
       mkdir -p $out/share/man
 
@@ -118,6 +124,8 @@ let
         # Broken due missing libze_loader.so.1
         rsync -a --exclude IMB-MPI1-GPU bin/ $out/bin/
       popd
+
+      runHook postInstall
     '';
     preFixup = ''
       for i in $out/bin/mpi* ; do
@@ -156,6 +164,8 @@ let
     autoPatchelfIgnoreMissingDeps = [ "libhwloc.so.5" ];
 
     installPhase = ''
+      runHook preInstall
+
       mkdir -p $out/lib
 
       cd $src
@@ -164,6 +174,8 @@ let
         # Libraries
         rsync -a lib/intel64/gcc4.8/ $out/lib/
       popd
+
+      runHook postInstall
     '';
 
     inherit meta;
@@ -199,6 +211,8 @@ let
     autoPatchelfIgnoreMissingDeps = [ "libsycl.so.6" ];
 
     installPhase = ''
+      runHook preInstall
+
       mkdir -p $out/{bin,lib,include}
       mkdir -p $out/share/man
 
@@ -223,6 +237,8 @@ let
           rsync -a compiler/include/ $out/include/
         popd
       popd
+
+      runHook postInstall
     '';
 
     inherit meta;
@@ -264,6 +280,8 @@ let
     dontStrip = true;
 
     installPhase = ''
+      runHook preInstall
+
       mkdir -p $out/{bin,lib,include}
       mkdir -p $out/share/man
 
@@ -289,7 +307,10 @@ let
 
         # Fix lib_lin
         ln -s $out/lib $out/lib_lin
+
       popd
+
+      runHook postInstall
     '';
 
     inherit meta;
@@ -352,6 +373,8 @@ let
     dontStrip = true;
 
     installPhase = ''
+      runHook preInstall
+
       mkdir -p $out/{bin,lib}
       mkdir -p $out/share/man
 
@@ -379,6 +402,8 @@ let
         # Manuals
         rsync -a documentation/en/man/common/ $out/share/man/
       popd
+
+      runHook postInstall
     '';
 
     inherit meta;

pkgs/paraver/default.nix

@@ -1,5 +1,4 @@
-{
-  stdenv
+{ stdenv
 , lib
 , fetchFromGitHub
 , autoreconfHook
@@ -13,14 +12,17 @@
 , openssl
 , glibcLocales
 , wrapGAppsHook
+
+, enableDebug ? false
 }:
 
 let
   wx = wxGTK32;
-in
-stdenv.mkDerivation rec {
-  pname = "wxparaver";
   version = "4.12.0";
+in
+stdenv.mkDerivation {
+  pname = "wxparaver";
+  inherit version;
 
   src = fetchFromGitHub {
     owner = "bsc-performance-tools";
@@ -37,21 +39,26 @@ stdenv.mkDerivation rec {
     ./fix-boost-87.patch
   ];
 
-  hardeningDisable = [ "all" ];
-
   # Fix the PARAVER_HOME variable
   postPatch = ''
     sed -i 's@^PARAVER_HOME=.*$@PARAVER_HOME='$out'@g' docs/wxparaver
     sed -i '1aexport LOCALE_ARCHIVE="${glibcLocales}/lib/locale/locale-archive"' docs/wxparaver
   '';
 
-  dontStrip = true;
   enableParallelBuilding = true;
 
-  preConfigure = ''
-    export CFLAGS="-O3"
-    export CXXFLAGS="-O3"
-  '';
+  hardeningDisable = [ "all" ];
+
+  dontStrip = true;
+
+  env =
+    let
+      flags = if enableDebug then "-ggdb -Og" else "-O3";
+    in
+    {
+      CFLAGS = flags;
+      CXXFLAGS = flags;
+    };
 
   configureFlags = [
     "--with-boost=${boost}"
@@ -69,11 +76,11 @@ stdenv.mkDerivation rec {
 
   buildInputs = [
     boost
-    libxml2.dev
+    libxml2
     xml2
     wx
     paraverKernel
-    openssl.dev
+    openssl
   ];
 
   postInstall = ''

pkgs/paraver/kernel.nix

@@ -1,5 +1,4 @@
-{
-  stdenv
+{ stdenv
 , lib
 , fetchFromGitHub
 , autoreconfHook
@@ -10,11 +9,16 @@
 , automake
 , pkg-config
 , zlib
+
+, enableDebug ? false
 }:
 
-stdenv.mkDerivation rec {
-  pname = "paraver-kernel";
+let
   version = "4.12.0";
+in
+stdenv.mkDerivation {
+  pname = "paraver-kernel";
+  inherit version;
 
   src = fetchFromGitHub {
     owner = "bsc-performance-tools";
@@ -35,10 +39,14 @@ stdenv.mkDerivation rec {
 
   dontStrip = true;
 
-  preConfigure = ''
-    export CFLAGS="-O3 -DPARALLEL_ENABLED"
-    export CXXFLAGS="-O3 -DPARALLEL_ENABLED"
-  '';
+  env =
+    let
+      flags = "-DPARALLEL_ENABLED " + (if enableDebug then "-ggdb -Og" else "-O3");
+    in
+    {
+      CFLAGS = flags;
+      CXXFLAGS = flags;
+    };
 
   configureFlags = [
     "--with-boost=${boost}"

pkgs/pocl/0001-cmake-do-not-use-suffix.patch

@@ -0,0 +1,26 @@
+From ccf301659caac9b5e973ba1f2d32352acf617a98 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Aleix=20Bon=C3=A9?= <aleix.boneribo@bsc.es>
+Date: Tue, 2 Jul 2024 16:45:05 +0200
+Subject: [PATCH] cmake: do not use suffix
+
+---
+ cmake/LLVM.cmake                              |  3 ++
+ 1 files changed, 3 insertions(+)
+
+diff --git a/cmake/LLVM.cmake b/cmake/LLVM.cmake
+index f4dbda065..e29144dce 100644
+--- a/cmake/LLVM.cmake
++++ b/cmake/LLVM.cmake
+@@ -65,6 +65,9 @@ else()
+     message(WARNING "Cannot determine llvm binary suffix from ${LLVM_CONFIG}")
+   endif()
+   message(STATUS "LLVM binaries suffix : ${LLVM_BINARY_SUFFIX}")
++
++  # We don't want suffixes in nix
++  set(LLVM_BINARY_SUFFIX "")
+ endif()
+ 
+ get_filename_component(LLVM_CONFIG_LOCATION "${LLVM_CONFIG}" DIRECTORY)
+-- 
+2.45.1
+

pkgs/pocl/0001-cmake-native-build-tools.patch

@@ -0,0 +1,33 @@
+From f24b456c50f587b05cc8f2699c94d8cdefc5b13e Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Aleix=20Bon=C3=A9?= <aleix.boneribo@bsc.es>
+Date: Tue, 2 Jul 2024 17:11:11 +0200
+Subject: [PATCH] cmake: native build tools
+
+---
+ cmake/LLVM.cmake                    |   7 +-
+ 1 files changed, 6 insertions(+), 1 deletion(-)
+
+diff --git a/cmake/LLVM.cmake b/cmake/LLVM.cmake
+index e29144dce..b9f14ce6a 100644
+--- a/cmake/LLVM.cmake
++++ b/cmake/LLVM.cmake
+@@ -269,10 +269,15 @@ endforeach()
+ 
+ ####################################################################
+ 
++if(DEFINED LLVM_NATIVE_TOOL_DIR)
++  set(TOOL_DIR "${LLVM_NATIVE_TOOL_DIR}")
++  message(STATUS "TOOL_DIR=${TOOL_DIR}")
++endif()
++
+ macro(find_program_or_die OUTPUT_VAR PROG_NAME DOCSTRING)
+   find_program(${OUTPUT_VAR}
+     NAMES "${PROG_NAME}${LLVM_BINARY_SUFFIX}${CMAKE_EXECUTABLE_SUFFIX}"
+-    HINTS "${LLVM_BINDIR}" "${LLVM_CONFIG_LOCATION}"
++    HINTS "${TOOL_DIR}" "${LLVM_BINDIR}" "${LLVM_CONFIG_LOCATION}"
+     DOC "${DOCSTRING}"
+     NO_CMAKE_PATH
+     NO_CMAKE_ENVIRONMENT_PATH
+-- 
+2.45.1
+

pkgs/pocl/0001-cmake-use-clang-from-cmake-variable.patch

@@ -0,0 +1,48 @@
+From 4688b5ce895761c884ae15fc0234ed8d623b988b Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Aleix=20Bon=C3=A9?= <aleix.boneribo@bsc.es>
+Date: Tue, 2 Jul 2024 15:41:47 +0200
+Subject: [PATCH] cmake: use clang from cmake variable
+
+---
+ cmake/LLVM.cmake | 22 ++++++++++++++++++++--
+ 1 file changed, 20 insertions(+), 2 deletions(-)
+
+diff --git a/cmake/LLVM.cmake b/cmake/LLVM.cmake
+index 71b786dc7..f4dbda065 100644
+--- a/cmake/LLVM.cmake
++++ b/cmake/LLVM.cmake
+@@ -281,11 +281,29 @@ macro(find_program_or_die OUTPUT_VAR PROG_NAME DOCSTRING)
+   endif()
+ endmacro()
+ 
+-find_program_or_die( CLANG "clang" "clang binary")
++# -DCMAKE_C_COMPILER=riscv64-unknown-linux-gnu-clang -DCMAKE_CXX_COMPILER=riscv64-unknown-linux-gnu-clang++
++
++# if(DEFINED CLANG_EXECUTABLE)
++if(DEFINED CMAKE_C_COMPILER)
++  # set(CLANG "${CLANG_EXECUTABLE}")
++  set(CLANG "${CMAKE_C_COMPILER}")
++  message(STATUS "Using CLANG_EXECUTABLE: ${CLANG}")
++else()
++  find_program_or_die( CLANG "clang" "clang binary")
++endif()
+ execute_process(COMMAND "${CLANG}" "--version" OUTPUT_VARIABLE LLVM_CLANG_VERSION RESULT_VARIABLE CLANG_RES)
++
+ # TODO this should be optional
+-find_program_or_die( CLANGXX "clang++" "clang++ binary")
++# if(DEFINED CLANGXX_EXECUTABLE)
++if(DEFINED CMAKE_CXX_COMPILER)
++  # set(CLANGXX "${CLANGXX_EXECUTABLE}")
++  set(CLANGXX "${CMAKE_CXX_COMPILER}")
++  message(STATUS "Using CLANGXX_EXECUTABLE: ${CLANGXX}")
++else()
++  find_program_or_die( CLANGXX "clang++" "clang++ binary")
++endif()
+ execute_process(COMMAND "${CLANGXX}" "--version" OUTPUT_VARIABLE LLVM_CLANGXX_VERSION RESULT_VARIABLE CLANGXX_RES)
++
+ if(CLANGXX_RES OR CLANG_RES)
+   message(FATAL_ERROR "Failed running clang/clang++ --version")
+ endif()
+-- 
+2.45.1
+

pkgs/pocl/default.nix

@@ -0,0 +1,226 @@
+{ lib
+, llvmPackages
+, ninja
+, cmake
+, hwloc
+, ocl-icd
+, opencl-headers
+, getconf
+, pkg-config
+, spirv-llvm-translator
+, spirv-tools
+, libxml2  # required for statically linked llvm
+, python3
+, writableTmpDirAsHomeHook
+
+, fetchFromGitHub
+
+, useGit ? false
+, gitUrl ? "git@gitlab-internal.bsc.es:task-awareness/pocl/pocl.git"
+, gitBranch ? "new-device"
+, gitCommit ? "dd10c2221b31223cbb796182df6a07f11c7541f5"
+
+, staticLLVM ? true
+, enableICD ? true
+, enableSPIRV ? true
+, enableHWLOC ? true
+, enableRemoteServer ? false
+, enableRemoteClient ? false
+, enableDistroVariants ? false
+
+, lttng-ust
+, enableLTTNG ? false
+
+, tbb
+, enableTBB ? false
+
+, nosv ? null
+, ovni ? null
+, enableNOSV ? useGit
+, enableOVNI ? useGit
+
+, buildPackages
+, nix-update-script
+}:
+
+let
+
+  release = rec {
+    version = "7.1";
+    src = fetchFromGitHub {
+      owner = "pocl";
+      repo = "pocl";
+      tag = "v${version}";
+      hash = "sha256-bS6vTIjLO7YLs7qYLKW0cYYbEJ/hRS/+IjjAKbkj8ac=";
+    };
+  };
+
+  git = rec {
+    version = src.shortRev;
+    src = builtins.fetchGit {
+      url = gitUrl;
+      ref = gitBranch;
+      rev = gitCommit;
+    };
+  };
+
+  source = if (useGit) then git else release;
+
+  stdenv = llvmPackages.stdenv;
+
+  buildLlvmPackages = buildPackages.llvmPackages;
+
+  isCross = stdenv.hostPlatform != stdenv.buildPlatform;
+
+  featureList = lib.concatStringsSep "+" (
+    (lib.optionals enableICD ["icd"]) ++
+    (lib.optionals enableNOSV ["nosv"]) ++
+    (lib.optionals enableOVNI ["ovni"]) ++
+    (lib.optionals enableSPIRV ["spirv"]) ++
+    (lib.optionals enableTBB ["tbb"]) ++
+    (lib.optionals enableRemoteClient ["server"]) ++
+    (lib.optionals enableRemoteServer ["client"])
+  );
+in
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "pocl";
+  version = featureList + "-" + source.version;
+  inherit (source) src;
+
+  patches = lib.optionals useGit [
+    ./0001-cmake-use-clang-from-cmake-variable.patch
+    ./0001-cmake-do-not-use-suffix.patch
+    ./0001-cmake-native-build-tools.patch
+  ];
+
+  cmakeFlags = [
+    (lib.cmakeOptionType "filepath" "WITH_LLVM_CONFIG"    (lib.getExe' buildLlvmPackages.llvm.dev     "llvm-config"))
+    (lib.cmakeOptionType "filepath" "CLANG"               (lib.getExe' buildLlvmPackages.clangUseLLVM "clang"))
+    (lib.cmakeOptionType "filepath" "CLANGXX"             (lib.getExe' buildLlvmPackages.clangUseLLVM "clang++"))
+    (lib.cmakeOptionType "path"     "CLANG_RESOURCE_DIR" "${llvmPackages.stdenv.cc}/resource-root")
+
+    (lib.cmakeBool "ENABLE_TESTS" finalAttrs.finalPackage.doCheck)
+
+    (lib.cmakeBool "ENABLE_RELOCATION"    true)
+    (lib.cmakeBool "ENABLE_POCL_BUILDING"   true)
+    (lib.cmakeBool "POCL_ICD_ABSOLUTE_PATH" true)
+
+    (lib.cmakeBool "ENABLE_TBB_DEVICE" enableTBB)
+    (lib.cmakeBool "ENABLE_ICD"        enableICD)
+    (lib.cmakeBool "ENABLE_HWLOC"      enableHWLOC)
+    (lib.cmakeBool "ENABLE_LTTNG"      enableLTTNG)
+
+    (lib.cmakeBool "ENABLE_REMOTE_CLIENT" enableRemoteClient)
+    (lib.cmakeBool "ENABLE_REMOTE_SERVER" enableRemoteServer)
+
+    # avoid the runtime linker pulling in a different llvm e.g. from graphics drivers
+    (lib.cmakeBool "STATIC_LLVM" staticLLVM)
+  ] ++ lib.optionals (enableNOSV || enableOVNI) [
+    (lib.cmakeBool "ENABLE_NOSV"       enableNOSV)
+    (lib.cmakeBool "ENABLE_OVNI"       enableOVNI)
+  ] ++ lib.optionals (!isCross && enableDistroVariants) [
+    (lib.cmakeFeature "KERNELLIB_HOST_CPU_VARIANTS" "distro") # TODO: check if we can do it when cross compiling
+  ] ++ lib.optionals isCross [
+    (lib.cmakeFeature "CMAKE_SYSTEM_NAME" "Linux")
+    (lib.cmakeFeature "CMAKE_FIND_ROOT_PATH_MODE_PROGRAM" "NEVER")
+    (lib.cmakeFeature "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY" "ONLY")
+    (lib.cmakeFeature "CMAKE_FIND_ROOT_PATH_MODE_INCLUDE" "ONLY")
+    (lib.cmakeFeature "CMAKE_FIND_ROOT_PATH_MODE_PACKAGE" "ONLY")
+  ] ++ lib.optionals stdenv.hostPlatform.isRiscV [
+    (lib.cmakeFeature "LLC_TRIPLE"       "riscv64-unknown-linux-gnu")
+    (lib.cmakeFeature "LLC_HOST_CPU"     "rv64g")
+    (lib.cmakeFeature "CLANG_MARCH_FLAG" "-march=")
+  ];
+
+  # Fixes error: ld: cannot find -lgcc / -lgcc_s when linking from libpocl on
+  # host
+  preConfigure = ''
+    cmakeFlagsArray+=(
+      -DEXTRA_HOST_LD_FLAGS="${lib.escapeShellArg (builtins.readFile "${stdenv.cc}/nix-support/cc-ldflags")}"
+      -DEXTRA_KERNEL_FLAGS="${lib.escapeShellArg (builtins.readFile "${stdenv.cc}/nix-support/cc-ldflags")}"
+    )
+  '' + lib.optionalString stdenv.hostPlatform.isRiscV ''
+     cmakeFlagsArray+=(
+      -DEXTRA_HOST_LLC_FLAGS=${lib.escapeShellArg ([
+        "-march=rv64g"
+        "-mcpu=sifive-u74"
+      ])}
+      -DEXTRA_HOST_CLANG_FLAGS=${lib.escapeShellArg ([
+        "-mabi=lp64d"
+        "-march=rv64g"
+        "-mcpu=sifive-u74"
+        "-mtune=sifive-7-series"
+      ])}
+    )
+  '';
+
+  nativeBuildInputs = [
+    cmake
+    getconf
+    ninja
+    pkg-config
+    python3
+  ];
+
+  buildInputs = [
+    opencl-headers
+    llvmPackages.libclang
+    llvmPackages.llvm
+  ] ++ lib.optionals staticLLVM [ libxml2 ]
+  ++ lib.optionals enableNOSV   [ nosv ]
+  ++ lib.optionals enableOVNI   [ ovni ]
+  ++ lib.optionals enableHWLOC  [ hwloc ]
+  ++ lib.optionals enableTBB    [ tbb ]
+  ++ lib.optionals enableICD    [ ocl-icd ]
+  ++ lib.optionals enableLTTNG  [ lttng-ust ]
+  ++ lib.optionals enableSPIRV  [
+    (spirv-llvm-translator.override { inherit (llvmPackages) llvm; })
+    spirv-tools
+  ];
+
+  nativeInstallCheckInputs = [
+    writableTmpDirAsHomeHook
+  ];
+
+  doInstallCheck = true;
+
+  installCheckPhase = lib.optionalString enableICD ''
+    runHook preInstallCheck
+
+    export OCL_ICD_VENDORS=$out/etc/OpenCL/vendors
+    $out/bin/poclcc -o poclcc.cl.pocl $src/examples/poclcc/poclcc.cl
+
+    runHook postInstallCheck
+  '';
+
+  setupHook = ./setup-hook.sh;
+
+  passthru = {
+    updateScript = nix-update-script { };
+    git = finalAttrs.finalPackage.override { useGit = true; };
+    test = finalAttrs.finalPackage.overrideAttrs { doCheck = true; };
+  };
+
+  requiredSystemFeatures = lib.optionals (finalAttrs.finalPackage.doCheck && enableHWLOC) [ "sys-devices" ];
+
+  preCheck = ''
+    export POCL_DEBUG=error,warn
+    export NIX_DEBUG=1
+  '';
+
+  propagatedBuildInputs = [ stdenv.cc.cc ];
+
+  meta = with lib; {
+    description = "A portable open source (MIT-licensed) implementation of the OpenCL standard";
+    homepage = "http://portablecl.org";
+    license = licenses.mit;
+    maintainers = with maintainers; [
+      leixb
+      jansol
+      xddxdd
+      bsc.maintainers.leixb
+    ];
+    platforms = platforms.linux ++ platforms.darwin;
+  };
+})

pkgs/pocl/setup-hook.sh

@@ -0,0 +1,6 @@
+preCheckHooks+=('setupPoclCheck')
+preInstallCheckHooks+=('setupPoclCheck')
+
+setupPoclCheck () {
+  export OCL_ICD_VENDORS="@out@/etc/OpenCL/vendors"
+}

pkgs/tacuda/default.nix

@@ -0,0 +1,68 @@
+{ stdenv
+, fetchFromGitHub
+, automake
+, autoconf
+, libtool
+, gnumake
+, autoreconfHook
+, boost
+, cudaPackages
+
+, useGit ? false
+, gitUrl ? "git@gitlab-internal.bsc.es:task-awareness/tacuda/tacuda.git"
+, gitBranch ? "main"
+, gitCommit ? "35234f9445e6149a2bd38d119841e2485d6ee05e"
+}:
+
+let
+
+  release_ver = "2.1.0";
+  release = {
+    version = release_ver;
+    src = fetchFromGitHub {
+      owner = "bsc-pm";
+      repo = "tacuda";
+      rev = release_ver;
+      hash = "sha256-Cj3EiLVJSLvRv0ydeg7Vp4SpkniEqHkcWF+YOJQ8EcM=";
+    };
+  };
+
+  git = rec {
+    version = src.shortRev;
+    src = builtins.fetchGit {
+      url = gitUrl;
+      ref = gitBranch;
+      rev = gitCommit;
+    };
+  };
+
+  source = if (useGit) then git else release;
+
+in
+
+stdenv.mkDerivation {
+  pname = "tacuda";
+  inherit (source) src version;
+
+  enableParallelBuilding = true;
+  separateDebugInfo = true;
+
+  nativeBuildInputs = [
+    autoreconfHook
+    automake
+    autoconf
+    libtool
+    gnumake
+  ];
+
+  patches = [ ./fix_config.patch ];
+
+  configureFlags = [ "--with-cuda-include=${cudaPackages.cudatoolkit}/include" ];
+
+  buildInputs = [
+    boost
+    cudaPackages.libcublas
+    cudaPackages.cuda_cudart
+  ];
+
+}

pkgs/tacuda/fix_config.patch

@@ -0,0 +1,13 @@
+diff --git a/m4/cuda.m4 b/m4/cuda.m4
+index 23f5c94..8f9b534 100644
+--- a/m4/cuda.m4
++++ b/m4/cuda.m4
+@@ -40,7 +40,7 @@ search_libs="cuda cublas cudart"
+ required_libs=""
+ 
+ m4_foreach([function],
+-           [cuInit,
++           [
+ 	    cublasSgemm,
+             cudaStreamCreate,
+             cudaLaunchKernel,

pkgs/taopencl/default.nix

@@ -0,0 +1,46 @@
+{
+  stdenv
+, automake
+, autoconf
+, libtool
+, gnumake
+, boost
+, mpi
+, gcc
+, autoreconfHook
+, ocl-icd
+, opencl-headers
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "taopencl";
+  version = finalAttrs.src.shortRev;
+
+  src = builtins.fetchGit {
+    url = "git@gitlab-internal.bsc.es:task-awareness/taopencl/taopencl.git";
+    ref = "master";
+    rev = "c3b7b32ae8fa4af7ceff598532a881f8f1490aaf";
+  };
+
+  enableParallelBuilding = true;
+  separateDebugInfo = true;
+
+  configureFlags = [
+    "--with-opencl-lib=${ocl-icd}/lib"
+    "--with-opencl-include=${opencl-headers}/include"
+  ];
+
+  buildInputs = [
+    autoreconfHook
+    automake
+    autoconf
+    libtool
+    gnumake
+    boost
+    mpi
+    gcc
+  ];
+
+  dontDisableStatic = true;
+  hardeningDisable = [ "all" ];
+})

test/compilers/pocl.nix

@@ -0,0 +1,26 @@
+{
+  runCommand,
+  pocl,
+  clinfo,
+  writableTmpDirAsHomeHook,
+}:
+
+runCommand "clinfo-pocl"
+  {
+    nativeBuildInputs = [
+      clinfo
+      writableTmpDirAsHomeHook
+    ];
+
+    requiredSystemFeatures = [ "sys-devices" ];
+
+    env = {
+      POCL_DEBUG = "error,warn";
+      OCL_ICD_VENDORS = "${pocl}/etc/OpenCL/vendors";
+    };
+  }
+  ''
+    set -x
+    clinfo | tee $out
+    set +x
+  ''