diff --git a/.github/workflows/rocm-artifact-hashes.yml b/.github/workflows/rocm-artifact-hashes.yml new file mode 100644 index 000000000..f7ed92949 --- /dev/null +++ b/.github/workflows/rocm-artifact-hashes.yml @@ -0,0 +1,46 @@ +name: ROCm artifact hashes + +on: + workflow_dispatch: + +jobs: + hash-rocm-artifacts: + runs-on: ubuntu-latest + steps: + - uses: julia-actions/setup-julia@v2 + with: + version: "1.12" + - name: Download tarballs and compute hashes + shell: julia {0} + run: | + import Pkg + Pkg.add("ArtifactUtils") + using ArtifactUtils, Base.BinaryPlatforms + + for rocm_arch in [ + "gfx908", + "gfx90a", + "gfx94X-dcgpu", + "gfx950-dcgpu", + "gfx101X-dgpu", + "gfx103X-all", + "gfx110X-all", + "gfx1150", + "gfx1151", + "gfx1152", + "gfx120X-all", + ] + @info "Linux, $rocm_arch" + platform = Platform("x86_64", "linux", Dict("libc" => "glibc", "rocm_arch" => replace(rocm_arch, "-" => "_"))) + add_artifact!("Artifacts.toml", "ROCm", "https://repo.amd.com/rocm/tarball/therock-dist-linux-$rocm_arch-7.13.0.tar.gz"; lazy = true, platform) + + startswith(rocm_arch, "gfx9") && continue + @info "Windows, $rocm_arch" + platform = Platform("x86_64", "windows", Dict("rocm_arch" => replace(rocm_arch, "-" => "_"))) + add_artifact!("Artifacts.toml", "ROCm", "https://repo.amd.com/rocm/tarball/therock-dist-windows-$rocm_arch-7.13.0.tar.gz"; lazy = true, platform) + end + - name: Upload hash report + uses: actions/upload-artifact@v4 + with: + name: Artifacts.toml + path: Artifacts.toml diff --git a/.pkg/platform_augmentation.jl b/.pkg/platform_augmentation.jl new file mode 100644 index 000000000..1a4475cea --- /dev/null +++ b/.pkg/platform_augmentation.jl @@ -0,0 +1,285 @@ +using Base.BinaryPlatforms, Libdl + +function rocm_arch_string(target::Integer) + patch = lowercase(string(target % 100, base = 16)) + return "gfx$(div(target, 10000))$(div(target, 100) % 100)$(patch)" +end + +function rocm_arch_from_device_name(device_name::AbstractString) + device_lower = lowercase(device_name) + + if !occursin("radeon", device_lower) && !occursin("amd", device_lower) + return "" + end + + # STX Halo iGPUs (gfx1151 architecture) + # Radeon 8050S Graphics / Radeon 8060S Graphics + if occursin("8050s", device_lower) || + occursin("8060s", device_lower) || + occursin("device 1586", device_lower) + return "gfx1151" + end + + # STX Point iGPUs (gfx1150 architecture) + # Radeon 880M / 890M Graphics + if occursin("880m", device_lower) || + occursin("890m", device_lower) + return "gfx1150" + end + + # RDNA4 GPUs (gfx120X architecture) + # AMD Radeon AI PRO R9700, AMD Radeon RX 9070 XT, AMD Radeon RX 9070 GRE, + # AMD Radeon RX 9070, AMD Radeon RX 9060 XT + if occursin("r9700", device_lower) || + occursin("9060", device_lower) || + occursin("9070", device_lower) + return "gfx120X" + end + + # RDNA3 GPUs (gfx110X architecture) + # AMD Radeon PRO V710, AMD Radeon PRO W7900 Dual Slot, AMD Radeon PRO W7900, + # AMD Radeon PRO W7800 48GB, AMD Radeon PRO W7800, AMD Radeon PRO W7700, + # AMD Radeon RX 7900 XTX, AMD Radeon RX 7900 XT, AMD Radeon RX 7900 GRE, + # AMD Radeon RX 7800 XT, AMD Radeon RX 7700 XT + if occursin("7700", device_lower) || + occursin("7800", device_lower) || + occursin("7900", device_lower) || + occursin("v710", device_lower) + return "gfx110X" + end + + # RDNA2 GPUs (gfx103X architecture) + # AMD Radeon RX 6800 XT, AMD Radeon RX 6800, AMD Radeon RX 6700 XT, + # AMD Radeon RX 6700, AMD Radeon RX 6600 XT, AMD Radeon RX 6600, + # AMD Radeon RX 6500 XT, AMD Radeon RX 6500 + if occursin("6800", device_lower) || + occursin("6700", device_lower) || + occursin("6600", device_lower) || + occursin("6500", device_lower) + return "gfx103X" + end + + return "" +end + +function rocm_arch_linux() + topology_root = "/sys/class/kfd/kfd/topology/nodes/" + isdir(topology_root) || return String[] + + arch = String[] + for dir in readdir(topology_root; join = true) + props = joinpath(dir, "properties") + isfile(props) || continue + + for s in eachline(props) + m = match(r"^gfx_target_version (\d+)$", s) + m === nothing && continue + + target = parse(Int, m[1]) + target == 0 && continue + + push!(arch, rocm_arch_string(target)) + end + end + + unique!(arch) + sort!(arch; rev = true) + return arch +end + +function wmi_query_video_controllers() + ole32 = Libdl.dlopen("ole32.dll") + oleaut32 = Libdl.dlopen("oleaut32.dll") + + CoInitializeEx = Libdl.dlsym(ole32, :CoInitializeEx) + CoInitializeSecurity = Libdl.dlsym(ole32, :CoInitializeSecurity) + CoCreateInstance = Libdl.dlsym(ole32, :CoCreateInstance) + CoUninitialize = Libdl.dlsym(ole32, :CoUninitialize) + SysAllocString = Libdl.dlsym(oleaut32, :SysAllocString) + SysFreeString = Libdl.dlsym(oleaut32, :SysFreeString) + + # Helper: allocate a BSTR from a Julia string + function bstr(s::String) + ws = transcode(UInt16, s * "\0") + ccall(SysAllocString, Ptr{UInt16}, (Ptr{UInt16},), ws) + end + free_bstr(p) = ccall(SysFreeString, Cvoid, (Ptr{UInt16},), p) + + # Helper: read a BSTR pointer back to Julia String + function read_bstr(p::Ptr{UInt16}) + p == C_NULL && return "" + # BSTR length (in bytes) is stored 4 bytes before the pointer + nbytes = unsafe_load(Ptr{UInt32}(p - 4)) + nchars = nbytes ÷ 2 + buf = unsafe_wrap(Array, p, nchars; own=false) + transcode(String, buf) + end + + # CLSID_WbemLocator = {4590F811-1D3A-11D0-891F-00AA004B2E24} + # IID_IWbemLocator = {DC12A687-737F-11CF-884D-00AA004B2E24} + CLSID_WbemLocator = UInt8[ + 0x11, 0xF8, 0x90, 0x45, # Data1 (little-endian) + 0x3A, 0x1D, # Data2 (little-endian) + 0xD0, 0x11, # Data3 (little-endian) + 0x89, 0x1F, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24] + + IID_IWbemLocator = UInt8[ + 0x87, 0xA6, 0x12, 0xDC, + 0x7F, 0x73, + 0xCF, 0x11, + 0x88, 0x4D, 0x00, 0xAA, 0x00, 0x4B, 0x2E, 0x24] + + # Step 1: CoInitializeEx(0, COINIT_MULTITHREADED=0) + ccall(CoInitializeEx, Clong, (Ptr{Cvoid}, Culong), C_NULL, 0) + + # Step 2: CoInitializeSecurity(NULL, -1, NULL, NULL, + # RPC_C_AUTHN_LEVEL_DEFAULT=0, RPC_C_IMP_LEVEL_IMPERSONATE=3, + # NULL, EOAC_NONE=0, NULL) + ccall(CoInitializeSecurity, Clong, + (Ptr{Cvoid}, Clong, Ptr{Cvoid}, Ptr{Cvoid}, + Culong, Culong, Ptr{Cvoid}, Culong, Ptr{Cvoid}), + C_NULL, -1, C_NULL, C_NULL, 0, 3, C_NULL, 0, C_NULL) + + # Step 3: CoCreateInstance(&CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER=1, + # &IID_IWbemLocator, &locator) + locator = Ref{Ptr{Cvoid}}(C_NULL) + hr = ccall(CoCreateInstance, Clong, + (Ptr{UInt8}, Ptr{Cvoid}, Culong, Ptr{UInt8}, Ref{Ptr{Cvoid}}), + CLSID_WbemLocator, C_NULL, 1, IID_IWbemLocator, locator) + hr < 0 && error("CoCreateInstance failed: 0x$(string(hr % UInt32, base=16))") + + # vtable layout for IWbemLocator (inherits IUnknown): + # [0] QueryInterface [1] AddRef [2] Release [3] ConnectServer + vtbl_loc = unsafe_load(Ptr{Ptr{Ptr{Cvoid}}}(locator[])) + + resource = bstr("ROOT\\CIMV2") + services = Ref{Ptr{Cvoid}}(C_NULL) + # Step 4: locator->ConnectServer(locator, resource, NULL,NULL,NULL,0,NULL,NULL, &services) + hr = ccall(unsafe_load(vtbl_loc, 4), Clong, + (Ptr{Cvoid}, Ptr{UInt16}, Ptr{Cvoid}, Ptr{Cvoid}, + Ptr{Cvoid}, Clong, Ptr{Cvoid}, Ptr{Cvoid}, Ref{Ptr{Cvoid}}), + locator[], resource, C_NULL, C_NULL, C_NULL, 0, C_NULL, C_NULL, services) + hr < 0 && error("ConnectServer failed: 0x$(string(hr % UInt32, base=16))") + + # vtable layout for IWbemServices — ExecQuery is at index 20 (0-based) + vtbl_svc = unsafe_load(Ptr{Ptr{Ptr{Cvoid}}}(services[])) + + language = bstr("WQL") + query = bstr("SELECT Name FROM Win32_VideoController") + results = Ref{Ptr{Cvoid}}(C_NULL) + # Step 5: services->ExecQuery(services, language, query, + # WBEM_FLAG_BIDIRECTIONAL=0, NULL, &results) + hr = ccall(unsafe_load(vtbl_svc, 21), Clong, # 0-based index 20 -> 1-based 21 + (Ptr{Cvoid}, Ptr{UInt16}, Ptr{UInt16}, Clong, Ptr{Cvoid}, Ref{Ptr{Cvoid}}), + services[], language, query, 0, C_NULL, results) + hr < 0 && error("ExecQuery failed: 0x$(string(hr % UInt32, base=16))") + + # vtable layout for IEnumWbemClassObject: + # [0] QI [1] AddRef [2] Release [3] Reset [4] Next [5] NextAsync [6] Clone [7] Skip + vtbl_enum = unsafe_load(Ptr{Ptr{Ptr{Cvoid}}}(results[])) + + # vtable layout for IWbemClassObject::Get is at index 4 (0-based) + # [0] QI [1] AddRef [2] Release [3] GetQualifierSet [4] Get ... + + names = String[] + while true + result = Ref{Ptr{Cvoid}}(C_NULL) + returned = Ref{Culong}(0) + + # results->Next(results, WBEM_INFINITE=-1, 1, &result, &returned) + hr = ccall(unsafe_load(vtbl_enum, 5), Clong, # Next at 0-based 4 -> 1-based 5 + (Ptr{Cvoid}, Clong, Culong, Ref{Ptr{Cvoid}}, Ref{Culong}), + results[], -1, 1, result, returned) + (hr != 0 || returned[] == 0) && break # S_FALSE or no more objects + + vtbl_obj = unsafe_load(Ptr{Ptr{Ptr{Cvoid}}}(result[])) + + # VARIANT is 16 bytes: vt(2) + reserved(6) + value(8) + variant = zeros(UInt8, 16) + prop = bstr("Name") + + # result->Get(result, L"Name", 0, &variant, NULL, NULL) + hr = ccall(unsafe_load(vtbl_obj, 5), Clong, # Get at 0-based 4 -> 1-based 5 + (Ptr{Cvoid}, Ptr{UInt16}, Clong, Ptr{UInt8}, Ptr{Cvoid}, Ptr{Cvoid}), + result[], prop, 0, variant, C_NULL, C_NULL) + + if hr == 0 + vt = reinterpret(UInt16, variant[1:2])[1] + if vt == 8 # VT_BSTR + p = reinterpret(UInt64, variant[9:16])[1] + push!(names, read_bstr(Ptr{UInt16}(p))) + end + end + + free_bstr(prop) + ccall(unsafe_load(vtbl_obj, 3), Culong, (Ptr{Cvoid},), result[]) # Release + end + + # Cleanup — mirrors the C example exactly + ccall(unsafe_load(vtbl_enum, 3), Culong, (Ptr{Cvoid},), results[]) # results->Release + ccall(unsafe_load(vtbl_svc, 3), Culong, (Ptr{Cvoid},), services[]) # services->Release + ccall(unsafe_load(vtbl_loc, 3), Culong, (Ptr{Cvoid},), locator[]) # locator->Release + ccall(CoUninitialize, Cvoid, ()) + free_bstr(query); free_bstr(language); free_bstr(resource) + + return names +end + +function rocm_arch() + if Sys.islinux() + return rocm_arch_linux() + elseif Sys.iswindows() + arch = map(rocm_arch_from_device_name, wmi_query_video_controllers()) + filter!(!isempty, arch) + unique!(arch) + sort!(arch; rev = true) + return arch + end + + return String[] +end + +function rocm_arch_comparison_strategy(a::String, b::String, a_requested::Bool, b_requested::Bool) + a == "none" && return false + b == "none" && return false + + a_arches = split(a, ',') + b_arches = split(b, ',') + for a_arch in a_arches + for b_arch in b_arches + rocm_arch_matches(a_arch, b_arch) && return true + rocm_arch_matches(b_arch, a_arch) && return true + end + end + return false +end + +function rocm_arch_core(arch::AbstractString) + return match(r"gfx(.*)", first(split(arch, r"[_-]", limit = 2)))[1] +end + +function rocm_arch_matches(pattern::AbstractString, arch::AbstractString) + pattern = rocm_arch_core(pattern) + arch = rocm_arch_core(arch) + + length(pattern) == length(arch) || return false + for (pattern_char, arch_char) in zip(pattern, arch) + if lowercase(pattern_char) == 'x' + isxdigit(arch_char) || lowercase(arch_char) == 'x' || return false + elseif pattern_char != arch_char + return false + end + end + return true +end + +function augment_platform!(platform::Platform) + if !haskey(platform, "rocm_arch") + arch = rocm_arch() + platform["rocm_arch"] = isempty(arch) ? "none" : join(arch, ',') + end + + BinaryPlatforms.set_compare_strategy!(platform, "rocm_arch", rocm_arch_comparison_strategy) + + return platform +end diff --git a/.pkg/select_artifacts.jl b/.pkg/select_artifacts.jl new file mode 100644 index 000000000..1f150bc19 --- /dev/null +++ b/.pkg/select_artifacts.jl @@ -0,0 +1,134 @@ +push!(Base.LOAD_PATH, dirname(@__DIR__)) + +using TOML, Artifacts, Base.BinaryPlatforms +include("./platform_augmentation.jl") +artifacts_toml = joinpath(dirname(@__DIR__), "Artifacts.toml") + +# Update Base.parse to support riscv64, needed for Julia <1.12 +@static if !haskey(BinaryPlatforms.arch_mapping, "riscv64") + + BinaryPlatforms.arch_mapping["riscv64"] = "(rv64|riscv64)" + + function bbparse(::Type{Platform}, triplet::AbstractString; validate_strict::Bool = false) + arch_mapping = BinaryPlatforms.arch_mapping + os_mapping = BinaryPlatforms.os_mapping + libc_mapping = BinaryPlatforms.libc_mapping + call_abi_mapping = BinaryPlatforms.call_abi_mapping + libgfortran_version_mapping = BinaryPlatforms.libgfortran_version_mapping + cxxstring_abi_mapping = BinaryPlatforms.cxxstring_abi_mapping + libstdcxx_version_mapping = BinaryPlatforms.libstdcxx_version_mapping + + # Helper function to collapse dictionary of mappings down into a regex of + # named capture groups joined by "|" operators + c(mapping) = string("(",join(["(?<$k>$v)" for (k, v) in mapping], "|"), ")") + + # We're going to build a mondo regex here to parse everything: + triplet_regex = Regex(string( + "^", + # First, the core triplet; arch/os/libc/call_abi + c(arch_mapping), + c(os_mapping), + c(libc_mapping), + c(call_abi_mapping), + # Next, optional things, like libgfortran/libstdcxx/cxxstring abi + c(libgfortran_version_mapping), + c(cxxstring_abi_mapping), + c(libstdcxx_version_mapping), + # Finally, the catch-all for extended tags + "(?(?:-[^-]+\\+[^-]+)*)?", + "\$", + )) + + m = match(triplet_regex, triplet) + if m !== nothing + # Helper function to find the single named field within the giant regex + # that is not "nothing" for each mapping we give it. + get_field(m, mapping) = begin + for k in keys(mapping) + if m[k] !== nothing + # Convert our sentinel "nothing" values to actual "nothing" + if endswith(k, "_nothing") + return nothing + end + # Convert libgfortran/libstdcxx version numbers + if startswith(k, "libgfortran") + return VersionNumber(parse(Int,k[12:end])) + elseif startswith(k, "libstdcxx") + return VersionNumber(3, 4, parse(Int,m[k][11:end])) + else + return k + end + end + end + end + + # Extract the information we're interested in: + arch = get_field(m, arch_mapping) + os = get_field(m, os_mapping) + libc = get_field(m, libc_mapping) + call_abi = get_field(m, call_abi_mapping) + libgfortran_version = get_field(m, libgfortran_version_mapping) + libstdcxx_version = get_field(m, libstdcxx_version_mapping) + cxxstring_abi = get_field(m, cxxstring_abi_mapping) + function split_tags(tagstr) + tag_fields = filter(!isempty, split(tagstr, "-")) + if isempty(tag_fields) + return Pair{String,String}[] + end + return map(v -> Symbol(v[1]) => v[2], split.(tag_fields, "+")) + end + tags = split_tags(m["tags"]) + + # Special parsing of os version number, if any exists + function extract_os_version(os_name, pattern) + m_osvn = match(pattern, m[os_name]) + if m_osvn !== nothing + return VersionNumber(m_osvn.captures[1]) + end + return nothing + end + os_version = nothing + if os == "macos" + os_version = extract_os_version("macos", r".*darwin([\d.]+)"sa) + end + if os == "freebsd" + os_version = extract_os_version("freebsd", r".*freebsd([\d.]+)"sa) + end + if os == "openbsd" + os_version = extract_os_version("openbsd", r".*openbsd([\d.]+)"sa) + end + + return Platform( + arch, os; + validate_strict, + libc, + call_abi, + libgfortran_version, + cxxstring_abi, + libstdcxx_version, + os_version, + tags..., + ) + end + throw(ArgumentError("Platform `$(triplet)` is not an officially supported platform")) + end + +else + # riscv64 is supported, all is fine + + const bbparse = parse + +end + + +# Get "target triplet" from ARGS, if given (defaulting to the host triplet otherwise) +target_triplet = get(ARGS, 1, Base.BinaryPlatforms.host_triplet()) + +# Augment this platform object with any special tags we require +platform = augment_platform!(HostPlatform(bbparse(Platform, target_triplet))) + +# Select all downloadable artifacts that match that platform +artifacts = select_downloadable_artifacts(artifacts_toml; platform, include_lazy=true) + +# Output the result to `stdout` as a TOML dictionary +TOML.print(stdout, artifacts) diff --git a/Artifacts.toml b/Artifacts.toml new file mode 100644 index 000000000..4bf93751f --- /dev/null +++ b/Artifacts.toml @@ -0,0 +1,191 @@ +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "927a3fe95e9d836dbc762f6327159526dcaa5bc7" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx908" + + [[ROCm.download]] + sha256 = "5d84753a8d8895ff2f6137a2a922ee8f36ce9c2e01b60a99d3ee776a683bfc34" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx908-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "66ad1dc431ab06faff7baf8842e91f80548f6ea6" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx90a" + + [[ROCm.download]] + sha256 = "b2d3c49ef936b3b24b10a25bae3e60df7ccc9c5134095a080bbc721d5062b4c7" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx90a-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "148fb9883a4a104c807e2ec2448986e0f4dd40f4" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx94x_dcgpu" + + [[ROCm.download]] + sha256 = "db5543de096fb175ff2ece19dacc28b2a3201df48b38051cc505e508d84e35ab" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx94X-dcgpu-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "e32c6a1039d8704432105abb9e381892f6b66e33" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx950_dcgpu" + + [[ROCm.download]] + sha256 = "794e8292c843621f772df83bbcbb6a8d5926279803dbd273679a1b6e782e16c7" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx950-dcgpu-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "6e52a70a9284555a2eeb670077b58c484860816f" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx101x_dgpu" + + [[ROCm.download]] + sha256 = "0cb099ec837e1206d710467674a254b07119c72fec765a5316d3703161c7bfe1" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx101X-dgpu-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "2351804874d5724fa82a74007d46f9a15951a9be" +lazy = true +os = "windows" +rocm_arch = "gfx101x_dgpu" + + [[ROCm.download]] + sha256 = "0f13040ed76d00fafe0540d5e23bf7b06ee96c7f341edf13d637f176c24508cc" + url = "https://repo.amd.com/rocm/tarball/therock-dist-windows-gfx101X-dgpu-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "472b6d4f2186b8363e4621b00d6e7a3d16d4a5ea" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx103x_all" + + [[ROCm.download]] + sha256 = "7049d3d934699226ea58ce821f64f7042f41467281f4d099ca123fd912592f23" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx103X-all-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "5cc5dbbf08958113bec3e77b81ebf3254fc5e59b" +lazy = true +os = "windows" +rocm_arch = "gfx103x_all" + + [[ROCm.download]] + sha256 = "479ccc5318a092023338800cbac3fcc604afd6dd5a8582856705d558ae7f3035" + url = "https://repo.amd.com/rocm/tarball/therock-dist-windows-gfx103X-all-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "7c7e3170d31e5360030a4c8bfbab39cf7bdb230b" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx110x_all" + + [[ROCm.download]] + sha256 = "c28e6861763bd5282caf349908aef99116160d200fdbf56c3ce947033c1876c3" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx110X-all-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "b502d69d1b873444498d3c398987e664212efffa" +lazy = true +os = "windows" +rocm_arch = "gfx110x_all" + + [[ROCm.download]] + sha256 = "3a27e7aa079c1c4ccc502be3aa1d89f9d2094726e4a75b731b9d590b075abf16" + url = "https://repo.amd.com/rocm/tarball/therock-dist-windows-gfx110X-all-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "4684f33015a110d83fcfe9f52a5aa9f6c6ceb0a8" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx1150" + + [[ROCm.download]] + sha256 = "49ab239f372901fbd2975285471cf5550de55a7bcd81602044cff426904c2ade" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx1150-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "4221777696eb7833ca9fcfd4b56a7703a92f87c5" +lazy = true +os = "windows" +rocm_arch = "gfx1150" + + [[ROCm.download]] + sha256 = "7fae82e61375fdcd9c8eb83761e91d0603e26a5cf45ade62aa3aa92afd28495b" + url = "https://repo.amd.com/rocm/tarball/therock-dist-windows-gfx1150-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "4d8726c11c5fa4f406cb151a8c729cf593d99afe" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx1151" + + [[ROCm.download]] + sha256 = "6550da740ac8565ec2f1dc886f6ec6425af1df79588d773594163b0778832560" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx1151-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "e6012913f4e5b177bb61862b7d56b6037683aa47" +lazy = true +os = "windows" +rocm_arch = "gfx1151" + + [[ROCm.download]] + sha256 = "9171d4bb2fdf9f7228c9658f5de93652d9c6e95974fe14de13b66ce77e8e0999" + url = "https://repo.amd.com/rocm/tarball/therock-dist-windows-gfx1151-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "6060cf1f79c122f9ed5ccc27f43ddcac0203b7ce" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx1152" + + [[ROCm.download]] + sha256 = "125094beb4e780bf3494e3b36d334a93593207bdcce18c8afb8161c82b703e5d" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx1152-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "d557c97f913bf700e8f6125a417fb29ce313621e" +lazy = true +os = "windows" +rocm_arch = "gfx1152" + + [[ROCm.download]] + sha256 = "3aeff35172973b174c379072c51a39cfce20a1695f2679691ea0567e68ba836a" + url = "https://repo.amd.com/rocm/tarball/therock-dist-windows-gfx1152-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "8b8d69691b2469e8f890fe977fe9c01e33233b64" +lazy = true +libc = "glibc" +os = "linux" +rocm_arch = "gfx120x_all" + + [[ROCm.download]] + sha256 = "150c3ed6eb51cda451a96d588ca04a15af2c8724fd5e692b705cba30faf4efcf" + url = "https://repo.amd.com/rocm/tarball/therock-dist-linux-gfx120X-all-7.13.0.tar.gz" +[[ROCm]] +arch = "x86_64" +git-tree-sha1 = "389c9194587a0fda638ac38ff71bb5e9c9e88f34" +lazy = true +os = "windows" +rocm_arch = "gfx120x_all" + + [[ROCm.download]] + sha256 = "4496f1e4667f162b1fc03dc94a9465d139f5a8dc1cc1dc472b43e594fb8db68d" + url = "https://repo.amd.com/rocm/tarball/therock-dist-windows-gfx120X-all-7.13.0.tar.gz" diff --git a/Project.toml b/Project.toml index d2ec25a65..7b570f77c 100644 --- a/Project.toml +++ b/Project.toml @@ -7,6 +7,7 @@ authors = ["Julian P Samaroo ", "Valentin Churavy