Small improvements to discovery of local toolkits. (#1134)

Author: maleadt

deps/bindeps.jl

@@ -22,7 +22,7 @@ macro initialize_ref(ref, ex, hook=:())
                     if val === nothing && !(eltype($ref) <: Union{Nothing,<:Any})
                         error($"Could not find a required library")
                     end
-                    $ref[] = $ex
+                    $ref[] = val
                     if val !== nothing
                         $hook
                     end

deps/compatibility.jl

@@ -3,7 +3,7 @@
 const lowest = v"0"
 const highest = v"999"
 
-verlist(vers) = join(map(ver->"$(ver.major).$(ver.minor)", sort(collect(vers))), ", ", " and ")
+join_capabilities(vers) = join(map(ver->"$(ver.major).$(ver.minor)", sort(collect(vers))), ", ", " and ")
 
 
 ## version range
@@ -174,7 +174,7 @@ end
 
 ## high-level functions that return target and isa support
 
-export llvm_compat, cuda_compat, supported_toolchain, supported_capability
+export llvm_compat, cuda_compat, supported_toolchain
 
 function llvm_compat(version=LLVM.version())
     LLVM.InitializeNVPTXTarget()
@@ -207,16 +207,7 @@ function supported_toolchain()
     ptx_support = sort(collect(llvm_support.ptx ∩ cuda_support.ptx))
     isempty(ptx_support) && error("Your toolchain does not support any PTX ISA")
 
-    @debug("Toolchain with LLVM $(LLVM.version()), CUDA driver $(CUDA.release().major).$(CUDA.release().minor) and toolkit $(toolkit_release().major).$(toolkit_release().minor) supports devices $(verlist(target_support)); PTX $(verlist(ptx_support))")
+    @debug("Toolchain with LLVM $(LLVM.version()), CUDA driver $(CUDA.release().major).$(CUDA.release().minor) and toolkit $(toolkit_release().major).$(toolkit_release().minor) supports devices $(join_capabilities(target_support)); PTX $(join_capabilities(ptx_support))")
 
     return (cap=target_support, ptx=ptx_support)
 end
-
-# select the highest capability that is supported by both the toolchain and device
-function supported_capability(dev_cap::VersionNumber)
-    compat_caps = filter(cap -> cap <= dev_cap, supported_toolchain().cap)
-    isempty(compat_caps) &&
-        error("Device capability v$dev_cap not supported by available toolchain")
-
-    return maximum(compat_caps)
-end

deps/discovery.jl

@@ -13,13 +13,23 @@ function valid_dirs(dirs)
     filter(isdir, unique(dirs))
 end
 
+function join_versions(versions)
+    isempty(versions) && return "no specific version"
+    "version " * join(versions, " or ")
+end
+
+function join_locations(locations)
+    isempty(locations) && return "in no specific location"
+    "in " * join(locations, " or ")
+end
+
 
 ## generic discovery routines
 
 function library_versioned_names(name::String, versions::Vector=[])
     names = String[]
 
-    # always look for an unversion library first
+    # always look for an unversioned library first
     if Sys.iswindows()
         push!(names, "$(name)$(Sys.WORD_SIZE).$(Libdl.dlext)")
 
@@ -88,8 +98,6 @@ Returns the full path to the library.
 """
 function find_library(name::String, versions::Vector=[];
                       locations::Vector{String}=String[])
-    @debug "Request to look for library $name $version" locations
-
     # figure out names
     all_names = library_versioned_names(name, versions)
 
@@ -108,15 +116,16 @@ function find_library(name::String, versions::Vector=[];
         end
     end
 
-    @debug "Looking for library $(join(all_names, ", "))" locations=all_locations
+    @debug "Looking for library $name, $(join_versions(versions)), $(join_locations(locations))" all_names all_locations
     name_found = Libdl.find_library(all_names, all_locations)
     if isempty(name_found)
+        @debug "Did not find $name"
         return nothing
     end
 
     # find the full path of the library (which Libdl.find_library doesn't guarantee to return)
     path = Libdl.dlpath(name_found)
-    @debug "Found library $(basename(path)) at $(dirname(path))"
+    @debug "Found $(basename(path)) at $(dirname(path))"
     return path
 end
 
@@ -127,8 +136,6 @@ Similar to `find_library`, performs an exhaustive search for a binary in various
 subdirectories of `locations`, and finally PATH by using `Sys.which`.
 """
 function find_binary(name::String; locations::Vector{String}=String[])
-    @debug "Request to look for binary $name" locations
-
     # figure out locations
     all_locations = String[]
     for location in locations
@@ -137,20 +144,21 @@ function find_binary(name::String; locations::Vector{String}=String[])
     end
     # we look in PATH too by using `Sys.which` with unadorned names
 
-    @debug "Looking for binary $name" locations=all_locations
+    @debug "Looking for binary $name $(join_locations(locations))" all_locations
     all_paths = [name; [joinpath(location, name) for location in all_locations]]
     for path in all_paths
         try
             program_path = Sys.which(path)
             if program_path !== nothing
-                @debug "Found binary $path at $program_path"
+                @debug "Found $path at $program_path"
                 return program_path
             end
         catch
             # some system disallow `stat` on certain paths
         end
     end
 
+    @debug "Did not find $path"
     return nothing
 end
 

src/compiler/gpucompiler.jl

@@ -5,11 +5,20 @@ const DeviceProperties = @NamedTuple{cap::VersionNumber, ptx::VersionNumber,
 const __device_properties = LazyInitialized{Vector{DeviceProperties}}()
 function device_properties(dev)
     props = get!(__device_properties) do
+        toolchain = supported_toolchain()
+
         # NOTE: this doesn't initialize any context, so we can pre-compute for all devices
         val = Vector{DeviceProperties}(undef, ndevices())
         for dev in devices()
-            cap = supported_capability(capability(dev))
-            ptx = v"6.3"    # we only need 6.2, but NVPTX doesn't support that
+            # select the highest capability that is supported by both the toolchain and device
+            caps = filter(toolchain_cap -> toolchain_cap <= capability(dev), toolchain.cap)
+            isempty(caps) &&
+                error("Your $(name(dev)) GPU with capability v$(capability(dev)) is not supported by the available toolchain")
+            cap = maximum(caps)
+
+            # select the PTX ISA we assume to be available
+            # (we actually only need 6.2, but NVPTX doesn't support that)
+            ptx = v"6.3"
 
             # we need to take care emitting LLVM instructions like `unreachable`, which
             # may result in thread-divergent control flow that older `ptxas` doesn't like.