@@ -22,6 +22,7 @@
 #include "Framework/SHA1.h"
 #include "utils/timer.h"
 
+#include <algorithm>
 #include <array>
 #include <cstdio>
 #include <cstring>
@@ -148,26 +149,40 @@ static void compile(const GPUSettingsProcessing& proc, uint32_t nCompile, const
   }
 }
 
-class Cache // RTC cache file (if rtc.cacheOutput), locked while the object exists. Usage: if (!cache.load(...)) { compile; cache.store(...); }
+class Cache // RTC cache file <cacheFolder>/rtc.<backend>.cache.<id> (no id with rtctech.ignoreCacheValid) (if rtc.cacheOutput), id from the SHAs of the inputs, locked per backend while the object exists. Usage: if (!cache.load(...)) { compile; cache.store(...); }
 {
  public:
   static constexpr uint32_t N_SHA = 6;
   using Inputs = std::array<std::string_view, N_SHA>; // source, param, command line, kernel definitions, launch bounds, compiler versions
 
-  Cache(const GPUSettingsProcessing& proc, const char* cacheName, const Inputs& inputs) : mProc(proc), mFile(proc.rtctech.cacheFolder + "/" + cacheName)
+  Cache(const GPUSettingsProcessing& proc, const char* backend, const Inputs& inputs) : mProc(proc), mPrefix(std::string("rtc.") + backend + ".cache.")
   {
     if (!mProc.rtc.cacheOutput) {
       return;
     }
+    char shaSettings[21]; // Only for the id, the settings are compared with operator== on load (the raw bytes include padding)
     for (uint32_t i = 0; i < N_SHA; i++) {
       o2::framework::internal::SHA1(mSHA[i], inputs[i].data(), inputs[i].size());
     }
+    o2::framework::internal::SHA1(shaSettings, (const char*)&mProc.rtc, sizeof(mProc.rtc));
+    uint64_t id = 0;
+    for (uint32_t i = 0; i <= N_SHA; i++) {
+      for (uint32_t j = 0; j < 20; j += 5) { // XOR of all SHAs in 5-byte blocks
+        uint64_t block = 0;
+        memcpy(&block, (i < N_SHA ? mSHA[i] : shaSettings) + j, 5);
+        id ^= block;
+      }
+    }
+    char idStr[11];
+    snprintf(idStr, sizeof(idStr), "%010llX", (unsigned long long)id);
+    mFileName = mProc.rtctech.ignoreCacheValid ? mPrefix.substr(0, mPrefix.size() - 1) : (mPrefix + idStr); // Without id for ignoreCacheValid, to find the cache file for any input
+    mFile = mProc.rtctech.cacheFolder + "/" + mFileName;
     if (mProc.rtctech.cacheFolder != ".") {
       std::filesystem::create_directories(mProc.rtctech.cacheFolder);
     }
     if (mProc.rtctech.cacheMutex) {
       mode_t mask = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
-      mFd = open((mProc.rtctech.cacheFolder + "/cache.lock").c_str(), O_RDWR | O_CREAT | O_CLOEXEC, mask);
+      mFd = open((mProc.rtctech.cacheFolder + "/cache_" + backend + ".lock").c_str(), O_RDWR | O_CREAT | O_CLOEXEC, mask);
       if (mFd == -1) {
         throw std::runtime_error("Error opening rtc cache mutex lock file");
       }
@@ -204,6 +219,8 @@ class Cache // RTC cache file (if rtc.cacheOutput), locked while the object exis
     fclose(fp);
     if (retVal) {
       GPUInfo("Using RTC cache file");
+      std::error_code ec;
+      std::filesystem::last_write_time(mFile, std::filesystem::file_time_type::clock::now(), ec); // Mark as recently used for removeOldFiles()
     }
     return retVal;
   }
@@ -245,9 +262,32 @@ class Cache // RTC cache file (if rtc.cacheOutput), locked while the object exis
       }
     }
     fclose(fp);
+    removeOldFiles();
   }
 
  private:
+  void removeOldFiles() const // Keeps the rtctech.cacheSize most recent cache files of this backend, including the one just written
+  {
+    if (mProc.rtctech.cacheSize == 0 || mProc.rtctech.ignoreCacheValid) {
+      return;
+    }
+    std::vector<std::pair<std::filesystem::file_time_type, std::filesystem::path>> files;
+    std::error_code ec;
+    for (const auto& entry : std::filesystem::directory_iterator(mProc.rtctech.cacheFolder)) {
+      const std::string name = entry.path().filename().string();
+      if (name.starts_with(mPrefix) && name != mFileName && entry.is_regular_file(ec)) {
+        files.emplace_back(entry.last_write_time(ec), entry.path());
+      }
+    }
+    if (files.size() < mProc.rtctech.cacheSize) {
+      return;
+    }
+    std::sort(files.begin(), files.end(), std::greater<>()); // Most recent first
+    for (uint32_t i = mProc.rtctech.cacheSize - 1; i < files.size(); i++) {
+      std::filesystem::remove(files[i].second, ec);
+    }
+  }
+
   bool read(FILE* fp, const std::string& filename, const char* binExtension, uint32_t nCompile)
   {
     static constexpr const char* names[N_SHA] = {"source", "param", "command line", "kernel definitions", "launch bounds", "compiler versions"};
@@ -301,7 +341,8 @@ class Cache // RTC cache file (if rtc.cacheOutput), locked while the object exis
   }
 
   const GPUSettingsProcessing& mProc;
-  const std::string mFile;
+  const std::string mPrefix;
+  std::string mFileName, mFile;
   char mSHA[N_SHA][21];
   int32_t mFd = -1;
 };
 
@@ -68,7 +68,7 @@ int32_t GPUReconstructionCPUDevice::genRTC(std::string& filename, uint32_t& nCom
 
   nCompile = proc.rtc.compilePerKernel ? kernels.size() : 1;
   const std::string compilerVersions = getBackendVersions();
-  rtc::Cache cache(proc, "rtc.cpudevice.cache", {rtcSource, rtcparam, baseCommand, kernelsall, launchBounds, compilerVersions});
+  rtc::Cache cache(proc, "cpudevice", {rtcSource, rtcparam, baseCommand, kernelsall, launchBounds, compilerVersions});
   if (!cache.load(filename, RTC_BIN_EXTENSION, nCompile)) {
     rtc::compile(proc, nCompile, "CPUDevice", [&](uint32_t i) {
       const std::string fileBase = filename + "_" + std::to_string(i);
 
@@ -63,7 +63,7 @@ int32_t GPUReconstructionCUDA::genRTC(std::string& filename, uint32_t& nCompile)
 
   nCompile = proc.rtc.compilePerKernel ? kernels.size() : 1;
   const std::string compilerVersions = getBackendVersions();
-  rtc::Cache cache(proc, "rtc.cuda.cache", {rtcSource, rtcparam, baseCommand, kernelsall, launchBounds, compilerVersions});
+  rtc::Cache cache(proc, "cuda", {rtcSource, rtcparam, baseCommand, kernelsall, launchBounds, compilerVersions});
   if (!cache.load(filename, mRtcBinExtension, nCompile)) {
     rtc::compile(proc, nCompile, "CUDA", [&](uint32_t i) {
       const std::string fileBase = filename + "_" + std::to_string(i);
 
@@ -238,10 +238,11 @@ EndConfig()
 BeginSubConfig(GPUSettingsProcessingRTCtechnical, rtctech, configStandalone.proc, "RTCTECH", 0, "Processing settings", proc_rtctech)
 AddOption(runTest, int32_t, 0, "", 0, "Do not run the actual benchmark, but just test RTC compilation (1 full test, 2 test only compilation)")
 AddOption(cacheMutex, bool, true, "", 0, "Use a file lock to serialize access to the cache folder")
-AddOption(ignoreCacheValid, bool, false, "", 0, "If set, allows to use RTC cached code files even if they are not valid for the current source code / parameters")
+AddOption(ignoreCacheValid, bool, false, "", 0, "If set, allows to use RTC cached code files even if they are not valid for the current source code / parameters (loads cache files without hash suffix)")
 AddOption(printLaunchBounds, int32_t, false, "", 0, "Print launch bounds used for RTC code as debugging option, 2 for exit after printing", def(1))
 AddOption(allowOptimizedSlaveReconstruction, bool, false, "", 0, "Allow RTC with slave GPUReconstruction instances with optConstexpr and optSpecialcode")
 AddOption(cacheFolder, std::string, "./rtccache/", "", 0, "Folder in which the cache file is stored")
+AddOption(cacheSize, uint32_t, 10, "", 0, "Maximum number of RTC cache files per backend in the cache folder, the oldest are removed (0 = no limit)")
 AddOption(prependCommand, std::string, "", "", 0, "Prepend RTC compilation commands by this string")
 AddOption(overrideArchitecture, std::string, "", "", 0, "Override arhcitecture part of RTC compilation command line") // Part of cmdLine, so checked against the cache
 AddOption(loadLaunchBoundsFromFile, std::string, "", "", 0, "Load a parameter object containing the launch bounds from a file")
 
@@ -10,7 +10,7 @@ Generally, RTC is enabled via the `--RTCenable` flag for the standalone benchmar
 For a list of RTC options, please see [GPUSettingsList.h](https://github.com/AliceO2Group/AliceO2/blob/80a80a17f5a1d9cb77743e2a39b15b653fe1a4f9/GPU/GPUTracking/Definitions/GPUSettingsList.h#L215).
 
 Caching the output:
-- The RTC output can be cached and reused, so that when running multiple times, compilation is not repeated. This is enabled via the `--RTCcacheOutput` setting. The folder to store the cache files can be selected via `--RTCTECHcacheFolder` and with `--RTCTECHcacheMutex` (default: enabled), a file-lock mutex can be used to synchronize access to the cache folder. The cached code is checked against the to-be-compiled source code with SHA1 hashes, and only if the code is not change the cache is used, otherwise the code is recompiled and the cache updated. It is possible to force using outdated cache files via the `--RTCTECHignoreCacheValid` option.
+- The RTC output can be cached and reused, so that when running multiple times, compilation is not repeated. This is enabled via the `--RTCcacheOutput` setting. The folder to store the cache files can be selected via `--RTCTECHcacheFolder` and with `--RTCTECHcacheMutex` (default: enabled), a file-lock mutex (`cache_<backend>.lock`, one per backend) can be used to synchronize access to the cache folder. Each backend can have multiple cache files `rtc.<backend>.cache.<id>`, where the id is derived from the SHA1 hashes below, so that switching between configurations does not require recompilation; when a new cache file is written, only the `--RTCTECHcacheSize` (default 10, 0 = no limit) most recent files of the backend are kept. The cached code is checked against the to-be-compiled source code with SHA1 hashes, and only if the code is not change the cache is used, otherwise the code is recompiled and the cache updated. It is possible to force using outdated cache files via the `--RTCTECHignoreCacheValid` option; in this case the cache file is `rtc.<backend>.cache` without id, and old cache files are not removed.
 
 For chaning the launch bounds and other parameters, please consider `--RTCTECHloadLaunchBoundsFromFile` (and `--RTCTECHprintLaunchBounds`), which can launch a parameter set which can be created via [dumpGPUDefParam.C](https://github.com/AliceO2Group/AliceO2/blob/dev/GPU/GPUTracking/Standalone/tools/dumpGPUDefParam.C). A set of default parameters is stored in `[INSTALL_FOLDER]/share/GPU`.