Simplify findMatch in intel-oneapi 2023

This should be a noop

overlay.nix

@@ -19,9 +19,14 @@ let
     clangOmpss2Unwrapped = callPackage ./pkgs/llvm-ompss2/clang.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 { };
     intelPackages_2023 = callPackage ./pkgs/intel-oneapi/2023.nix { };
+    intelPackages_2024 = final.intel-apt.hpckit_2024;
+    intelPackages_2025 = final.intel-apt.hpckit_2025;
+    intelPackages = final.intelPackages_2025;
+    oneMath = callPackage ./pkgs/onemath/default.nix { };
     jemallocNanos6 = callPackage ./pkgs/nanos6/jemalloc.nix { };
-    #lmbench = callPackage ./pkgs/lmbench/default.nix { }; # Broken
+    lmbench = callPackage ./pkgs/lmbench/default.nix { };
     mcxx = callPackage ./pkgs/mcxx/default.nix { };
     nanos6 = callPackage ./pkgs/nanos6/default.nix { };
     nanos6Debug = final.nanos6.override { enableDebug = true; };
@@ -46,6 +51,8 @@ let
     stdenvClangOmpss2NodesOmpv = final.stdenv.override { cc = final.clangOmpss2NodesOmpv; allowedRequisites = null; };
     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; };
     wxparaver = callPackage ./pkgs/paraver/default.nix { };
   };
 
@@ -60,6 +67,8 @@ in bscPkgs // {
       #sigsegv = callPackage ./test/reproducers/sigsegv.nix { };
       hello-c = callPackage ./test/compilers/hello-c.nix { };
       hello-cpp = callPackage ./test/compilers/hello-cpp.nix { };
+      hello-sycl = callPackage ./test/compilers/hello-sycl.nix { };
+      hello-syclompss = callPackage ./test/compilers/icpx-ompss2.nix { };
       lto = callPackage ./test/compilers/lto.nix { };
       asan = callPackage ./test/compilers/asan.nix { };
       intel2023-icx-c   = hello-c.override   { stdenv = final.intelPackages_2023.stdenv; };
@@ -69,6 +78,15 @@ in bscPkgs // {
       intel2023-ifort   = callPackage ./test/compilers/hello-f.nix {
         stdenv = final.intelPackages_2023.stdenv-ifort;
       };
+
+      intel2024-icx-c   = hello-c.override   { stdenv = final.intelPackages_2024.stdenv; };
+      intel2025-icx-c   = hello-c.override   { stdenv = final.intelPackages_2025.stdenv; };
+      intel2024-icx-cpp = hello-cpp.override { stdenv = final.intelPackages_2024.stdenv; };
+      intel2025-icx-cpp = hello-cpp.override { stdenv = final.intelPackages_2025.stdenv; };
+      intel2023-sycl    = hello-sycl.override { intelPackages = final.intelPackages_2023; };
+      intel2024-sycl    = hello-sycl.override { intelPackages = final.intelPackages_2024; };
+      intel2025-sycl    = hello-sycl.override { intelPackages = final.intelPackages_2025; };
+
       clangOmpss2-lto   = lto.override       { stdenv = final.stdenvClangOmpss2Nanos6; };
       clangOmpss2-asan  = asan.override      { stdenv = final.stdenvClangOmpss2Nanos6; };
       clangOmpss2-task  = callPackage ./test/compilers/ompss2.nix {

pkgs/intel-oneapi/2023.nix

@@ -47,40 +47,31 @@ let
     installPhase = ''
       awk -F': ' '\
         BEGIN   { print "[ {" } \
-        NR>1 && /^Package: / { print "} {"; } \
+        NF==0 { empty=1; } \
+        NF && empty { print "} {"; empty=0; } \
         /: /    { printf "%s = \"%s\";\n", $1, $2 } \
         END     { print "} ]" }' $srcs > $out
     '';
   };
 
-  aptPackages = import aptPackageIndex;
-
-  apthost = "https://apt.repos.intel.com/oneapi/";
-
-  getSum = pkgList: name:
+  findMatch = name:
   let
-    matches = lib.filter (x: name == x.Package) pkgList;
-    #n = lib.length matches;
-    #match = builtins.trace (name + " -- ${builtins.toString n}") (lib.elemAt matches 0);
-    match = lib.elemAt matches 0;
-  in
-    match.SHA256;
-
-  getUrl = pkgList: name:
-  let
-    matches = lib.filter (x: name == x.Package) pkgList;
-    #match = assert lib.length matches == 1; lib.elemAt matches 0;
+    aptPackages = import aptPackageIndex;
+    matches = lib.filter (x: name == x.Package) aptPackages;
     n = lib.length matches;
-    match =
-      #builtins.trace (name + " -- n=${builtins.toString n}")
-      (lib.elemAt matches 0);
+    match = builtins.traceVerbose (name + " -- ${builtins.toString n}") (builtins.head matches);
+
+    apthost = "https://apt.repos.intel.com/oneapi/";
   in
-    apthost + match.Filename;
+    {
+      url = apthost + match.Filename;
+      sha256 = match.SHA256;
+    };
 
   uncompressDebs = debs: name: stdenv.mkDerivation {
     name = name;
     srcs = debs;
-    buildInputs = [ dpkg ];
+    nativeBuildInputs = [ dpkg ];
     phases = [ "installPhase" ];
     installPhase = ''
       mkdir -p $out
@@ -93,10 +84,7 @@ let
 
   joinDebs = name: names:
   let
-    urls = builtins.map (x: getUrl aptPackages x) names;
-    sums = builtins.map (x: getSum aptPackages x) names;
-    getsrc = url: sha256: builtins.fetchurl { inherit url sha256; };
-    debs = lib.zipListsWith getsrc urls sums;
+    debs = builtins.map (x: builtins.fetchurl (findMatch x)) names;
   in
     uncompressDebs debs "${name}-source";
 
@@ -313,6 +301,9 @@ let
       "intel-oneapi-compiler-dpcpp-cpp-and-cpp-classic-common-${version}"
       "intel-oneapi-compiler-dpcpp-cpp-and-cpp-classic-runtime-${version}"
       "intel-oneapi-compiler-dpcpp-cpp-classic-fortran-shared-runtime-${version}"
+      "intel-oneapi-compiler-shared-${version}"
+      "intel-oneapi-compiler-shared-common-${version}"
+      "intel-oneapi-compiler-shared-runtime-${version}"
     ];
     # From https://aur.archlinux.org/packages/intel-oneapi-compiler:
     # - intel-oneapi-compiler-cpp-eclipse-cfg-2023.0.0-25370_all.deb
@@ -329,9 +320,9 @@ let
     # - intel-oneapi-compiler-fortran-common-2023.0.0-2023.0.0-25370_all.deb
     # - intel-oneapi-compiler-fortran-runtime-2023.0.0-2023.0.0-25370_amd64.deb
     # - intel-oneapi-compiler-fortran-runtime-2023.0.0-25370_amd64.deb
-    # - intel-oneapi-compiler-shared-2023.0.0-2023.0.0-25370_amd64.deb
-    # - intel-oneapi-compiler-shared-common-2023.0.0-2023.0.0-25370_all.deb
-    # - intel-oneapi-compiler-shared-runtime-2023.0.0-2023.0.0-25370_amd64.deb
+    # + intel-oneapi-compiler-shared-2023.0.0-2023.0.0-25370_amd64.deb
+    # + intel-oneapi-compiler-shared-common-2023.0.0-2023.0.0-25370_all.deb
+    # + intel-oneapi-compiler-shared-runtime-2023.0.0-2023.0.0-25370_amd64.deb
     # - intel-oneapi-dpcpp-cpp-2023.0.0-2023.0.0-25370_amd64.deb
     # - intel-oneapi-openmp-2023.0.0-2023.0.0-25370_amd64.deb
     # - intel-oneapi-openmp-common-2023.0.0-2023.0.0-25370_all.deb
@@ -398,6 +389,15 @@ let
         echo "-L${intel-compiler-shared}/lib" >> $out/nix-support/cc-ldflags
         echo "-L${cc}/lib" >> $out/nix-support/cc-ldflags
 
+        echo "--gcc-toolchain=${mygcc.cc}" >> $out/nix-support/libcxx-cxxflags
+
+        for dir in ${mygcc.cc}/include/c++/*; do
+          echo "-isystem $dir" >> $out/nix-support/libcxx-cxxflags
+        done
+        for dir in ${mygcc.cc}/include/c++/*/${targetConfig}; do
+          echo "-isystem $dir" >> $out/nix-support/libcxx-cxxflags
+        done
+
         # Need the gcc in the path
         echo 'export "PATH=${mygcc}/bin:$PATH"' >> $out/nix-support/cc-wrapper-hook
 
@@ -441,7 +441,7 @@ let
     '';
   };
 
-  ifort-wrapper = wrapIntel rec {
+  ifort-wrapper = wrapIntel {
     cc = intel-compiler-fortran;
     mygcc = gcc;
     extraBuild = ''

pkgs/intel-oneapi/packages.nix

@@ -0,0 +1,205 @@
+{ lib
+, stdenv
+, callPackage
+, dpkg
+, fetchurl
+, recurseIntoAttrs
+
+, sqlite
+, elfutils
+}:
+
+let
+  inherit (builtins)
+    elem attrNames attrValues concatMap filter fromJSON getAttr groupBy head isNull listToAttrs map mapAttrs readFile replaceStrings splitVersion ;
+  inherit (lib)
+    converge findFirst groupBy' hasPrefix optional pipe take toInt toList versionAtLeast versionOlder ;
+
+  aptData = fromJSON (readFile ./packages.json);
+
+  # Compare versions in debian control file syntax
+  # See: https://www.debian.org/doc/debian-policy/ch-relationships.html#syntax-of-relationship-fields
+  #
+  # NOTE: this is not a proper version comparison
+  #
+  # A proper version solver, should aggregate dependencies with the same name
+  # and compute the constraint (e.g. a (>= 2) a (<< 5) -> 2 <= a << 5)
+  #
+  # But in the intel repo, there are no such "duplicated" dependencies to specify
+  # upper limits, which leads to issues when intel-hpckit-2021 depends on things
+  # like intel-basekit >= 2021.1.0-2403 and we end up installing the newest
+  # basekit instead of the one from 2021.
+  #
+  # To mitigate this, >= is set to take the latest version with matching major
+  # and minor (only revision and patch are allowed to change)
+  compareVersions = got: kind: want:
+    let
+      g0 = take 2 (splitVersion got);
+      w0 = take 2 (splitVersion want);
+    in if isNull want then true
+    else if kind == "=" then got == want
+    else if kind == "<<" then versionOlder got want
+    else if kind == "<=" then versionAtLeast want got
+    else if kind == ">>" then versionOlder want got
+    else if kind == ">=" then (g0 == w0) && versionAtLeast got want # always match major version
+    else throw "unknown operation: ${kind}";
+
+  findMatching = { pname, kind, version }:
+    findFirst (x: pname == x.pname && compareVersions x.version kind version) null aptData;
+
+  isIntel = pkg: (hasPrefix "intel-" pkg.pname);
+
+  expandDeps = pkg: (map findMatching (filter isIntel pkg.dependencies)) ++ (optional (pkg.size != 0) pkg);
+
+  # get the oldest by major version. If they have the same major version, take
+  # the newest. This prevents most issues with resolutions
+  # versionOlder b a -> true if b is older than a (b `older` a)
+  getNewerInMajor = a: b: let
+    va = a.version;
+    vb = b.version;
+    va0 = head (splitVersion va);
+    vb0 = head (splitVersion vb);
+  in
+  if isNull a then b
+  else if va0 != vb0 then
+    if va0 > vb0 then b else a
+  else if versionOlder vb va then a else b;
+  removeDups = l: attrValues (groupBy' getNewerInMajor null (getAttr "provides") l);
+
+  _resolveDeps = converge (l: removeDups (concatMap expandDeps l));
+  resolveDeps = pkg: let deps = _resolveDeps (toList pkg);
+      namedDeps = (map (x: "${x.pname}-${x.version}") deps);
+    in builtins.traceVerbose (builtins.deepSeq namedDeps namedDeps) deps;
+
+  blacklist = [
+    "intel-basekit-env"
+    "intel-basekit-getting-started"
+    "intel-hpckit-env"
+    "intel-hpckit-getting-started"
+    "intel-oneapi-advisor"
+    "intel-oneapi-common-licensing"
+    "intel-oneapi-common-oneapi-vars"
+    "intel-oneapi-common-vars"
+    "intel-oneapi-compiler-cpp-eclipse-cfg"
+    "intel-oneapi-compiler-dpcpp-eclipse-cfg"
+    "intel-oneapi-condaindex"
+    "intel-oneapi-dev-utilities-eclipse-cfg"
+    "intel-oneapi-dpcpp-ct-eclipse-cfg"
+    "intel-oneapi-eclipse-ide"
+    "intel-oneapi-hpc-toolkit-getting-started"
+    "intel-oneapi-icc-eclipse-plugin-cpp"
+    "intel-oneapi-vtune"
+    "intel-oneapi-vtune-eclipse-plugin-vtune"
+  ];
+
+  isInBlacklist = pkg: elem pkg.provides blacklist;
+  removeBlacklist = filter (e: !(isInBlacklist e));
+
+  dpkgExtractAll = pname: version: {srcs, deps}: stdenv.mkDerivation {
+    inherit pname version srcs;
+
+    nativeBuildInputs = [ dpkg ];
+    phases = [ "installPhase" ];
+
+    passthru = { inherit deps; };
+
+    installPhase = ''
+      mkdir -p $out
+      for src in $srcs; do
+        echo "Unpacking $src"
+        dpkg -x $src $out
+      done
+    '';
+  };
+
+  apthost = "https://apt.repos.intel.com/oneapi/";
+  fetchDeb = p: fetchurl { url = apthost + p.filename; inherit (p) sha256; };
+
+  buildIntel = pkg: pipe pkg [
+    resolveDeps
+    removeBlacklist
+    (l: {srcs = map fetchDeb l; deps = l; })
+    (dpkgExtractAll "${pkg.provides}-extracted" pkg.version)
+  ];
+
+  findHpcKit = year: findMatching { pname = "intel-hpckit"; kind = "<<"; version = toString (year+1); };
+  years = map toInt (attrNames components);
+
+  patchIntel = callPackage ./patch_intel.nix { };
+
+  # Version information for each hpckit. This is used to normalize the paths
+  # so that files are in $out/{bin,lib,include...} instead of all over the place
+  # in $out/opt/intel/oneapi/*/*/{...}.
+  #
+  # The most important is the compiler component, which is used to build the
+  # stdenv for the hpckit.
+  #
+  # NOTE: this have to be manually specified, so we can avoid IFD. To add a
+  # new version, add a new field with an empty attrset, (e.g. "2026" = {}; ),
+  # build hpckit_2026.unpatched and use the values from
+  # result/opt/intel/oneapi/* to populate the attrset.
+  #
+  # WARN: if there are more than one version in the folders of the unpatched
+  # components, our dependency resolution hacks have probably failed and the
+  # package set may be broken.
+  components = {
+    "2025" = {
+      ishmem = "1.3";
+      pti = "0.12";
+      tcm = "1.3";
+      umf = "0.10";
+
+      ccl = "2021.15";
+      compiler = "2025.1";
+      dal = "2025.5";
+      debugger = "2025.1";
+      dev-utilities = "2025.1";
+      dnnl = "2025.1";
+      dpcpp-ct = "2025.1";
+      dpl = "2022.8";
+      ipp = "2022.1";
+      ippcp = "2025.1";
+      mkl = "2025.1";
+      mpi = "2021.15";
+      tbb = "2022.1";
+    };
+    "2024" = {
+      tcm = "1.1";
+
+      ccl = "2021.13";
+      compiler = "2024.2";
+      dal = "2024.6";
+      debugger = "2024.2";
+      dev-utilities = "2024.2";
+      diagnostics = "2024.2";
+      dnnl = "2024.2";
+      dpcpp-ct = "2024.2";
+      dpl = "2022.6";
+      ipp = "2021.12";
+      ippcp = "2021.12";
+      mkl = "2024.2";
+      mpi = "2021.13";
+      tbb = "2021.13";
+
+      extraPackages = [
+        sqlite
+        elfutils
+      ];
+    };
+  };
+
+  replaceDots = replaceStrings ["."] ["_"];
+
+in recurseIntoAttrs (listToAttrs (map (year: let
+      year_str = toString year;
+    in {
+      name = "hpckit_${year_str}";
+      value = patchIntel {unpatched = buildIntel (findHpcKit year); components = components.${year_str}; };
+  }) years)) // {
+  apt = pipe aptData [
+    (groupBy (p: replaceDots p.provides))
+    (mapAttrs (_: l: listToAttrs (map (pkg: { name = replaceDots ("v" + pkg.version); value = pkg; }) l)))
+  ] ;
+
+  inherit resolveDeps patchIntel buildIntel;
+}

pkgs/intel-oneapi/patch_intel.nix

@@ -0,0 +1,163 @@
+{ stdenv
+, stdenvNoCC
+, lib
+, symlinkJoin
+, autoPatchelfHook
+, wrapCCWith
+, overrideCC
+, gcc
+, hwloc
+, libelf
+, libffi_3_3
+, libpsm2
+, libuuid
+, libxml2
+, numactl
+, ocl-icd
+, openssl
+, python3
+, rdma-core
+, ucx
+, zlib
+, makeOverridable
+, recurseIntoAttrs
+}:
+
+makeOverridable (
+{
+  unpatched,
+  components ? { },
+  extraPackages ? components.extraPackages or []
+}:
+
+let
+  inherit (builtins) attrValues filter mapAttrs removeAttrs;
+
+  __components = removeAttrs components ["extraPackages"];
+  _components = __components;
+  # _components = lib.traceSeqN 2 {
+  #   inherit unpatched __components;
+  #   deps = builtins.map (x: "${x.pname}-${x.version}") unpatched.deps;
+  # } __components;
+
+  wrapIntel = { cc, extraBuildCommands ? "", extraInstall ? "", ... }@args:
+    let
+      targetConfig = stdenv.targetPlatform.config;
+    in (wrapCCWith {
+      inherit cc;
+      extraBuildCommands = ''
+        echo "-isystem ${cc}/include" >> $out/nix-support/cc-cflags
+        echo "-isystem ${cc}/include/intel64" >> $out/nix-support/cc-cflags
+
+        echo "-L${gcc.cc}/lib/gcc/${targetConfig}/${gcc.version}" >> $out/nix-support/cc-ldflags
+        echo "-L${gcc.cc.lib}/lib" >> $out/nix-support/cc-ldflags
+        echo "-L${cc}/lib" >> $out/nix-support/cc-ldflags
+
+        echo "--gcc-toolchain=${gcc.cc}" >> $out/nix-support/libcxx-cxxflags
+
+        for dir in ${gcc.cc}/include/c++/*; do
+          echo "-isystem $dir" >> $out/nix-support/libcxx-cxxflags
+        done
+        for dir in ${gcc.cc}/include/c++/*/${targetConfig}; do
+          echo "-isystem $dir" >> $out/nix-support/libcxx-cxxflags
+        done
+
+        # Need the gcc in the path
+        echo 'export "PATH=${gcc}/bin:$PATH"' >> $out/nix-support/cc-wrapper-hook
+
+        # Disable hardening by default
+        echo "" > $out/nix-support/add-hardening.sh
+
+        # For some reason, If we don't resolve the realpath things go wrong
+        for stddef in ${cc}/lib/clang/*/include/stddef.h ; do
+          dir=$(dirname $(realpath "$stddef"))
+          echo "-isystem $dir" >> $out/nix-support/cc-cflags
+        done
+
+      '' + extraBuildCommands;
+    } // (removeAttrs args ["cc" "extraBuildCommands" "extraInstall"])
+    ).overrideAttrs (old: {
+      installPhase = old.installPhase + extraInstall;
+    });
+
+in
+stdenvNoCC.mkDerivation (finalAttrs: {
+  pname = lib.removeSuffix "-extracted" unpatched.pname;
+  inherit (unpatched) version;
+  src = unpatched;
+
+  phases = [ "installPhase" "fixupPhase" ];
+  buildInputs = [
+    libffi_3_3
+    libelf
+    libxml2
+    hwloc
+    numactl
+    libuuid
+    libpsm2
+    zlib
+    ocl-icd
+    rdma-core
+    ucx
+    openssl
+    python3
+    stdenv.cc.cc.lib
+  ] ++ extraPackages;
+
+  autoPatchelfIgnoreMissingDeps = [ "libhwloc.so.5" "libcuda.so.1" "libze_loader.so.1" ];
+
+  nativeBuildInputs = [ autoPatchelfHook ];
+  installPhase = ''
+    cp -r $src/opt/intel/oneapi/ $out
+  '';
+
+  passthru = let
+    pkgs = mapAttrs
+      (folder: version: symlinkJoin {
+        pname = "intel-${folder}";
+        inherit version;
+        paths = ["${finalAttrs.finalPackage}/${folder}/${version}"];
+      })
+      _components;
+  in pkgs // {
+    inherit unpatched;
+    pkgs = recurseIntoAttrs pkgs;
+    components = _components;
+
+    # This contains all packages properly symlinked into toplevel directories
+    # in $out.
+    #
+    # NOTE: there are clashes with packages that have symlinks outside their
+    # scope (libtcm and env/vars.sh)
+    all = symlinkJoin {
+      pname = finalAttrs.finalPackage + "-symlinked";
+      inherit (finalAttrs.finalPackage) version;
+      paths = filter lib.isDerivation (attrValues finalAttrs.finalPackage.pkgs);
+    };
+
+    stdenv = overrideCC stdenv finalAttrs.finalPackage.cc;
+
+    cc = wrapIntel {
+      cc = finalAttrs.finalPackage.pkgs.compiler;
+      extraBuildCommands = ''
+        wrap icx  $wrapper $ccPath/icx
+        wrap icpx $wrapper $ccPath/icpx
+        wrap ifx  $wrapper $ccPath/ifx
+
+        ln -s $out/bin/icpx $out/bin/c++
+        ln -s $out/bin/icx  $out/bin/cc
+
+        sed -i 's/.*isCxx=0/isCxx=1/' $out/bin/icpx
+
+        ln -s ${finalAttrs.finalPackage.pkgs.compiler}/lib $out/lib
+        ln -s ${finalAttrs.finalPackage.pkgs.compiler}/include $out/include
+      '';
+      extraInstall = ''
+        export named_cc="icx"
+        export named_cxx="icpx"
+        export named_fc="ifx"
+      '';
+    };
+  };
+
+}))

pkgs/intel-oneapi/process.jq

@@ -0,0 +1,29 @@
+#!/usr/bin/env -S jq -f
+
+def extract_fields: {
+        pname : .Package,
+        version : .Version,
+        provides : .Package | sub("[0-9.-]*$"; ""),
+        filename : .Filename,
+        size : ."Installed-Size" | tonumber,
+        sha256 : .SHA256,
+        dependencies : .Depends,
+    } ;
+
+# parses dependencies into a list of [{.pname, .kind, .version}]
+# some dependencies do not have a version specified, in which case, version = version = null
+#
+# example dependencies:
+# intel-oneapi-common-vars (>= 2023.0.0-25325), intel-oneapi-common-licensing-2023.0.0
+
+def split_dependencies : map(try(.dependencies |= split(",\\s?"; "")) // .dependencies |= []) ;
+
+def match_version : capture("(?<pname>[a-zA-Z0-9_\\-.]*) *(\\((?<kind>[<>=]*) *(?<version>.*)\\))?"; "") ;
+
+def parse_dependencies : map_values(.dependencies.[] |= match_version) ;
+
+def sort_version_decreasing : sort_by(.version | split("[-.]"; "") | map(tonumber)) | reverse ;
+
+map(extract_fields) | split_dependencies | parse_dependencies | sort_version_decreasing
+
+# [.[] | select(.pname == "intel-hpckit") | .version]

pkgs/intel-oneapi/toJson.awk

@@ -0,0 +1,29 @@
+#!/usr/bin/env -S awk -f
+
+BEGIN   {
+    FS=": "
+
+    prev_empty=1
+    t="  "
+
+    print "[ {"
+}
+
+!NF { # empty line, update separator so next non empty line closes the dict
+    prev_empty=1
+    t="},\n{ "
+    next # skip line (we won't match anything else)
+}
+
+{
+    printf t "\"%s\" : \"%s\"\n", $1, $2
+
+    if (prev_empty) {
+        # we were the first after a group of empty lines, following ones have to
+        # have a comma
+        prev_empty=0
+        t=", "
+    }
+}
+
+END     { print "} ]" }

pkgs/intel-oneapi/update.sh

@@ -2,3 +2,5 @@
 
 curl https://apt.repos.intel.com/oneapi/dists/all/main/binary-amd64/Packages -o amd64-packages
 curl https://apt.repos.intel.com/oneapi/dists/all/main/binary-all/Packages -o all-packages
+
+cat amd64-packages all-packages | ./toJson.awk | ./process.jq >packages.json

pkgs/llvm-ompss2/default.nix

@@ -9,12 +9,14 @@
 , ompss2rt ? null
 }:
 
+with lib;
+
 let
   usingNodesAndOmpv = (openmp.pname == "openmp-v" && ompss2rt.pname == "nodes");
   sameNosv = openmp.nosv == ompss2rt.nosv;
 in
 
-assert lib.assertMsg (usingNodesAndOmpv -> sameNosv) "OpenMP-V and NODES must share the same nOS-V";
+assert assertMsg (usingNodesAndOmpv -> sameNosv) "OpenMP-V and NODES must share the same nOS-V";
 
 let
   homevar = if ompss2rt.pname == "nanos6" then "NANOS6_HOME" else "NODES_HOME";
@@ -34,14 +36,15 @@ let
   targetConfig = stdenv.targetPlatform.config;
   inherit gcc;
   cc = clangOmpss2Unwrapped;
+  gccVersion = with versions; let v = gcc.version; in concatStringsSep "." [(major v) (minor v) (patch v)];
 in wrapCCWith {
   inherit cc bintools;
   # extraPackages adds packages to depsTargetTargetPropagated
-  extraPackages = lib.optional (openmp != null) openmp;
+  extraPackages = optional (openmp != null) openmp;
   extraBuildCommands = ''
     echo "-target ${targetConfig}" >> $out/nix-support/cc-cflags
-    echo "-B${gcc.cc}/lib/gcc/${targetConfig}/${gcc.version}" >> $out/nix-support/cc-cflags
-    echo "-L${gcc.cc}/lib/gcc/${targetConfig}/${gcc.version}" >> $out/nix-support/cc-ldflags
+    echo "-B${gcc.cc}/lib/gcc/${targetConfig}/${gccVersion}" >> $out/nix-support/cc-cflags
+    echo "-L${gcc.cc}/lib/gcc/${targetConfig}/${gccVersion}" >> $out/nix-support/cc-ldflags
     echo "-L${gcc.cc.lib}/lib" >> $out/nix-support/cc-ldflags
 
     for dir in ${gcc.cc}/include/c++/*; do
@@ -55,12 +58,12 @@ in wrapCCWith {
 
     wrap clang++  $wrapper $ccPath/clang++
 
-  '' + lib.optionalString (openmp != null) ''
+  '' + optionalString (openmp != null) ''
     echo "export OPENMP_RUNTIME=${ompname}" >> $out/nix-support/cc-wrapper-hook
-  '' + lib.optionalString (ompss2rt != null) ''
+  '' + optionalString (ompss2rt != null) ''
     echo "export OMPSS2_RUNTIME=${rtname}" >> $out/nix-support/cc-wrapper-hook
     echo "export ${homevar}=${ompss2rt}"   >> $out/nix-support/cc-wrapper-hook
-  '' + lib.optionalString (ompss2rt != null && ompss2rt.pname == "nodes") ''
+  '' + optionalString (ompss2rt != null && ompss2rt.pname == "nodes") ''
     echo "export NOSV_HOME=${ompss2rt.nosv}" >> $out/nix-support/cc-wrapper-hook
   '';
 }

pkgs/llvm-ompss2/openmp.nix

@@ -68,6 +68,7 @@ stdenv.mkDerivation rec {
     rm -f $out/lib/libiomp*
   '' + lib.optionalString enableNosv ''
     rm -f $out/lib/libomp.*
+    rm -f $out/libllvmrt/libomp.*
   '';
 
   passthru = {

pkgs/lmbench/default.nix

@@ -1,19 +1,20 @@
 {
   lib,
   stdenv,
+  libtirpc,
   fetchFromGitHub
 }:
 
 stdenv.mkDerivation rec {
   pname = "lmbench";
-  version = "701c6c35";
+  version = "941a0dcc";
 
   # We use the intel repo as they have fixed some problems
   src = fetchFromGitHub {
     owner = "intel";
     repo = pname;
-    rev = "701c6c35b0270d4634fb1dc5272721340322b8ed";
-    sha256 = "0sf6zk03knkardsfd6qx7drpm56nhg53n885cylkggk83r38idyr";
+    rev = "941a0dcc0e7bdd9bb0dee05d7f620e77da8c43af";
+    sha256 = "sha256-SzwplRBO3V0R3m3p15n71ivYBMGoLsajFK2TapYxdqk=";
   };
 
   postUnpack = ''
@@ -24,12 +25,19 @@ stdenv.mkDerivation rec {
     sed -i "s@/bin/rm@rm@g" $(find . -name Makefile)
   '';
 
+  buildInputs = [ libtirpc ];
+  patches = [ ./fix-install.patch ];
+
   hardeningDisable = [ "all" ];
 
   enableParallelBuilding = false;
 
   preBuild = ''
-    makeFlagsArray+=(BASE=$out)
+    makeFlagsArray+=(
+      BASE=$out
+      CPPFLAGS=-I${libtirpc.dev}/include/tirpc
+      LDFLAGS=-ltirpc
+    )
   '';
 
   meta = {

pkgs/lmbench/fix-install.patch

@@ -0,0 +1,10 @@
+--- a/Makefile
++++ b/Makefile
+@@ -144,6 +144,7 @@ install-target:
+ 	if [ ! -d $(BASE)/include ]; then mkdir $(BASE)/include; fi
+ 	if [ ! -d $(BASE)/lib ]; then mkdir $(BASE)/lib; fi
+ 	cp $(EXES) $(BASE)/bin
++	cp $(OPT_EXES) $(BASE)/bin
+ 	cp $(INCS) $(BASE)/include
+ 	cp $O/lmbench.a $(BASE)/lib/libmbench.a
+ 	cd ../doc; env MAKEFLAGS="$(MAKEFLAGS)" make CC="${CC}" OS="${OS}" BASE="$(BASE)" install

pkgs/onemath/default.nix

@@ -0,0 +1,73 @@
+{ lib
+, intelPackages
+, withCFlags
+, fetchFromGitHub
+, cmake
+, cudaPackages
+, enableNvidia ? true
+, withHipTargets ? null # only one target at a time supported
+, rocmPackages
+, enableMkl ? true
+}:
+
+let
+  enableHip = withHipTargets != null;
+
+  stdenv = withCFlags (lib.optionals enableNvidia [ "--cuda-path=${cudaPackages.cudatoolkit}" ]) intelPackages.stdenv;
+in
+stdenv.mkDerivation rec {
+  pname = "oneMath";
+  version = "0.7";
+
+  src = fetchFromGitHub {
+    owner = "uxlfoundation";
+    repo = "oneMath";
+    rev = "v${version}";
+    sha256 = "sha256-De04PUmI68Jx4rJ+MRb+RepayZCapgnouCUCrAu6G38=";
+  };
+
+  cmakeFlags = [
+    (lib.cmakeBool "ENABLE_MKLCPU_BACKEND"    enableMkl)
+    (lib.cmakeBool "ENABLE_MKLGPU_BACKEND"    enableMkl)
+
+    (lib.cmakeBool "ENABLE_CUBLAS_BACKEND"    enableNvidia)
+    (lib.cmakeBool "ENABLE_CUFFT_BACKEND"     enableNvidia)
+    (lib.cmakeBool "ENABLE_CURAND_BACKEND"    enableNvidia)
+    (lib.cmakeBool "ENABLE_CUSOLVER_BACKEND"  enableNvidia)
+    (lib.cmakeBool "ENABLE_CUSPARSE_BACKEND"  enableNvidia)
+
+    (lib.cmakeBool "ENABLE_ROCBLAS_BACKEND"   enableHip)
+    (lib.cmakeBool "ENABLE_ROCFFT_BACKEND"    enableHip)
+    (lib.cmakeBool "ENABLE_ROCSOLVER_BACKEND" enableHip)
+    (lib.cmakeBool "ENABLE_ROCRAND_BACKEND"   enableHip)
+    (lib.cmakeBool "ENABLE_ROCSPARSE_BACKEND" enableHip)
+
+    (lib.cmakeBool "BUILD_FUNCTIONAL_TESTS" false)
+    (lib.cmakeBool "BUILD_EXAMPLES" false)
+  ] ++ lib.optionals enableHip [
+    (lib.cmakeFeature "HIP_TARGETS" withHipTargets)
+  ];
+
+  nativeBuildInputs = [ cmake ];
+  buildInputs = lib.optionals (enableMkl) [
+    intelPackages.mkl
+    intelPackages.tbb
+  ] ++ lib.optionals (enableHip) [
+    rocmPackages.rocmPath
+    rocmPackages.rocblas
+    rocmPackages.rocfft
+    rocmPackages.rocsolver
+    rocmPackages.rocrand
+    rocmPackages.rocsparse
+  ] ++ lib.optionals (enableNvidia) [
+    (lib.getDev cudaPackages.cuda_cudart)
+    cudaPackages.cudatoolkit
+
+    cudaPackages.libcublas
+    cudaPackages.libcurand
+    cudaPackages.libcufft
+    cudaPackages.libcusparse
+    cudaPackages.libcusolver
+  ];
+
+}

pkgs/tasycl/default.nix

@@ -0,0 +1,103 @@
+{ stdenv
+, lib
+, withCFlags
+, intelPackages
+, fetchFromGitHub
+, automake
+, autoconf
+, libtool
+, gnumake
+, autoreconfHook
+, boost
+, opensycl ? null
+, adaptivecpp ? null
+, useIntel ? true
+  # TODO: move back to main branch and release
+, useGit ? true
+, gitUrl ? "git@gitlab-internal.bsc.es:task-awareness/tasycl/tasycl.git"
+, gitBranch ? "fix/various"
+, gitCommit ? "8be4729ded0ef64f028e98eb2b2baf2ccba7ff42"
+}:
+
+assert (useIntel || opensycl != null || adaptivecpp != null);
+
+let
+  # opensycl has migrated to adaptivecpp
+  acpp-flags =
+    if adaptivecpp == null then
+      [ "-L${opensycl}/lib" "-lhipSYCL-rt" "-I${opensycl}/include" ]
+    else
+      [ "-L${adaptivecpp}/lib" "-lacpp-rt" "-I${adaptivecpp}/include" ]
+  ;
+
+  variant = if useIntel then "intel" else "acpp";
+
+  syclStdenv =
+    if useIntel then
+      # If we don't set optimization level, separateDebugInfo sets ggdb and
+      # intel disables all optimizations
+      withCFlags ["-O3"] intelPackages.stdenv
+    else
+      withCFlags acpp-flags stdenv
+  ;
+
+  release = rec {
+    version = "2.0.0";
+    src = fetchFromGitHub {
+      owner = "bsc-pm";
+      repo = "tasycl";
+      rev = version;
+      hash = "sha256-Z4d45baVBhE9NW8Ww948M78TJx7BpxTr9pGJvJO9hdI=";
+    };
+  };
+
+  git = rec {
+    version = src.shortRev;
+    src = builtins.fetchGit {
+      url = gitUrl;
+      ref = gitBranch;
+      rev = gitCommit;
+    };
+  };
+
+  source = if (useGit) then git else release;
+
+  isOldRelease = (!useGit && (builtins.compareVersions source.version "2.0.0" <= 0));
+
+in
+
+assert !isOldRelease || useIntel; # old releases only work with intel
+
+syclStdenv.mkDerivation {
+  pname = "tasycl";
+  inherit (source) src version;
+
+  enableParallelBuilding = true;
+  separateDebugInfo = true;
+
+  nativeBuildInputs = [
+    autoreconfHook
+    automake
+    autoconf
+    libtool
+    gnumake
+  ];
+
+  buildInputs = [
+    boost
+  ];
+
+  # only needed for release versions prior or equal to 2.0.0
+  configureFlags = lib.optionals isOldRelease [ "--with-sycl-include=${intelPackages.icx.cc}/include/sycl" ];
+
+  # add symlinks so we can explicitly link with tasycl-intel / tasycl-acpp
+  postInstall = ''
+    pushd $out/lib
+    for i in libtasycl* ; do
+      ln -s "$i" "''\${i/tasycl/tasycl-${variant}}"
+    done
+    popd
+  '';
+
+  hardeningDisable = [ "all" ];
+}

test/compilers/hello-sycl.nix

@@ -0,0 +1,55 @@
+{ intelPackages,  writeText, strace }:
+
+let
+  stdenv = intelPackages.stdenv;
+  hello_sycl = writeText "hello.cpp" ''
+    #include <sycl/sycl.hpp>
+
+    class hello_world;
+
+    int main(int argc, char** argv) try {
+        auto device_selector = sycl::default_selector_v;
+
+        sycl::queue queue(device_selector);
+
+        std::cout << "Running on: "
+                  << queue.get_device().get_info<sycl::info::device::name>()
+                  << std::endl;
+
+        queue.submit([&] (sycl::handler& cgh) {
+            auto os = sycl::stream{128, 128, cgh};
+            cgh.single_task<hello_world>([=]() {
+                os << "Hello World! (on device)\n";
+            });
+        });
+
+        return 0;
+    } catch (sycl::exception &e) {
+        std::cout << "SYCL exception: " << e.what() << std::endl;
+        return 0; // we excpect to fail since no devices should be available;
+    }
+  '';
+in
+
+stdenv.mkDerivation {
+  version = "0.0.1";
+  name = "hello-sycl";
+  buildInputs = [ stdenv strace ];
+  src = hello_sycl;
+  dontUnpack = true;
+  dontConfigure = true;
+  NIX_DEBUG = 0;
+  buildPhase = ''
+    cp $src hello.cpp
+    set -x
+    echo CXX=$CXX
+    command -v $CXX
+    $CXX -fsycl hello.cpp -o hello
+    ./hello
+    set +x
+  '';
+
+  installPhase = ''
+    touch $out
+  '';
+}

test/compilers/icpx-ompss2.nix

@@ -0,0 +1,71 @@
+{ writeText, intelPackages, nodes, nosv, clangOmpss2Nodes, clangOmpss2Unwrapped, clangOmpss2, strace }:
+
+let
+  hello_cpp = writeText "hello.cpp" ''
+    #include <cstdio>
+    #include <sycl/sycl.hpp>
+
+    int main(int argc, char** argv) try {
+        sycl::queue queue;
+
+        std::cout << "Running on: "
+                  << queue.get_device().get_info<sycl::info::device::name>()
+                  << std::endl;
+
+        #pragma oss task
+        queue.submit([&] (sycl::handler& cgh) {
+            auto os = sycl::stream{128, 128, cgh};
+            cgh.single_task<class hello_world>([=]() {
+                os << "Hello World! (on device)\n";
+            });
+        }).wait();
+
+        return 0;
+    } catch (sycl::exception &e) {
+        std::cout << "SYCL exception: " << e.what() << std::endl;
+        return 0; // we expect to fail since no devices should be available;
+    }
+
+  '';
+in
+
+intelPackages.stdenv.mkDerivation {
+  version = "0.0.1";
+  name = "hello-syclompss";
+
+  src = hello_cpp;
+
+  nativeBuildInputs = [
+    strace
+    nodes
+    nosv
+  ];
+
+  dontUnpack = true;
+  dontConfigure = true;
+
+  env.NODES_HOME = nodes;
+
+  NIX_DEBUG = 0;
+  buildPhase = ''
+    cp $src hello.cpp
+    set -x
+    echo CXX=$CXX
+    echo NODES_HOME=$NODES_HOME
+    command -v $CXX
+
+    icpx -fsycl \
+        -fsycl-host-compiler=${clangOmpss2Nodes}/bin/clang++ \
+        -fsycl-host-compiler-options='-fompss-2=libnodes' \
+        -lnodes -lnosv \
+        $NODES_HOME/lib/nodes-main-wrapper.o \
+        hello.cpp -o hello
+
+    ./hello
+    set +x
+  '';
+
+  installPhase = ''
+    touch $out
+  '';
+}