Write the compiled runtime in a scratch directory. (#406)

Author: maleadt

Manifest.toml

@@ -114,6 +114,12 @@ uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 [[SHA]]
 uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce"
 
+[[Scratch]]
+deps = ["Dates"]
+git-tree-sha1 = "30449ee12237627992a99d5e30ae63e4d78cd24a"
+uuid = "6c6a2e73-6563-6170-7368-637461726353"
+version = "1.2.0"
+
 [[Serialization]]
 uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
 

Project.toml

@@ -9,6 +9,7 @@ InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
 Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
+Scratch = "6c6a2e73-6563-6170-7368-637461726353"
 TimerOutputs = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 

src/GPUCompiler.jl

@@ -9,6 +9,8 @@ using ExprTools: splitdef, combinedef
 
 using Libdl
 
+using Scratch: @get_scratch!
+
 include("utils.jl")
 
 # compiler interface and implementations
@@ -43,6 +45,8 @@ _precompile_()
 
 function __init__()
     STDERR_HAS_COLOR[] = get(stderr, :color, false)
+
+    global compile_cache = @get_scratch!("compiled")
 end
 
 end # module

src/rtlib.jl

@@ -15,16 +15,6 @@ end
 # GPU run-time library
 #
 
-# get the path to a directory where we can put cache files (machine-specific, ephemeral)
-# NOTE: maybe we should use XDG_CACHE_PATH/%LOCALAPPDATA%, but other Julia cache files
-#       are put in .julia anyway so let's just follow suit for now.
-function cachedir(depot=DEPOT_PATH[1])
-    # this mimicks Base.compilecache. we can't just call the function, or we might actually
-    # _generate_ a cache file, e.g., when running with `--compiled-modules=no`.
-    entrypath, entryfile = Base.cache_file_entry(Base.PkgId(GPUCompiler))
-    abspath(depot, entrypath, entryfile)
-end
-
 
 ## higher-level functionality to work with runtime functions
 
@@ -125,30 +115,9 @@ const runtime_lock = ReentrantLock()
 
 @locked function load_runtime(@nospecialize(job::CompilerJob); ctx)
     lock(runtime_lock) do
-        # find the first existing cache directory (for when dealing with layered depots)
-        cachedirs = [cachedir(depot) for depot in DEPOT_PATH]
-        filter!(isdir, cachedirs)
-        input_dir = if isempty(cachedirs)
-            nothing
-        else
-            first(cachedirs)
-        end
-
-        # we are only guaranteed to be able to write in the current depot
-        output_dir = cachedir()
-
-        # if both aren't equal, copy pregenerated runtime libraries to our depot
-        # NOTE: we don't just lazily read from the one and write to the other, because
-        #       once we generate additional runtimes in the output dir we don't know if
-        #       it's safe to load from other layers (since those could have been invalidated)
-        if input_dir !== nothing && input_dir != output_dir
-            mkpath(dirname(output_dir))
-            cp(input_dir, output_dir)
-        end
-
         slug = runtime_slug(job)
         name = "runtime_$(slug).bc"
-        path = joinpath(output_dir, name)
+        path = joinpath(compile_cache, name)
 
         lib = try
             if ispath(path)
@@ -163,7 +132,7 @@ const runtime_lock = ReentrantLock()
 
         if lib === nothing
             @debug "Building the GPU runtime library at $path"
-            mkpath(output_dir)
+            mkpath(compile_cache)
             lib = build_runtime(job; ctx)
 
             # atomic write to disk
@@ -181,10 +150,7 @@ end
 # NOTE: call this function from global scope, so any change triggers recompilation.
 function reset_runtime()
     lock(runtime_lock) do
-        rm(cachedir(); recursive=true, force=true)
-        # create an empty cache directory. since we only ever load from the first existing cachedir,
-        # this effectively invalidates preexisting caches in lower layers of the depot.
-        mkpath(cachedir())
+        rm(compile_cache; recursive=true, force=true)
     end
 
     return