Merge pull request #345 from JuliaGPU/tb/metal

Metal simplifications

Author: maleadt

.buildkite/pipeline.yml

@@ -43,6 +43,29 @@ steps:
     if: build.message !~ /\[skip tests\]/ && !build.pull_request.draft
     timeout_in_minutes: 60
 
+  - label: "Metal.jl"
+    plugins:
+      - JuliaCI/julia#v1:
+          version: 1.8
+      - JuliaCI/julia-coverage#v1:
+          codecov: true
+    command: |
+      julia -e 'using Pkg;
+
+                println("--- :julia: Instantiating project");
+                Pkg.develop(PackageSpec(path=pwd()));
+                Pkg.add(PackageSpec(name="Metal", rev="main",
+                                    url="https://github.com/JuliaGPU/Metal.jl.git"));
+                Pkg.build();
+
+                println("+++ :julia: Running tests");
+                Pkg.test("Metal"; coverage=true);'
+    agents:
+      queue: "juliagpu"
+      metal: "*"
+    if: build.message !~ /\[skip tests\]/ && !build.pull_request.draft
+    timeout_in_minutes: 120
+
 #  - label: "AMDGPU.jl"
 #    plugins:
 #      - JuliaCI/julia#v1:

src/interface.jl

@@ -139,20 +139,14 @@ struct CompilerJob{T,P,F}
     params::P
     entry_abi::Symbol
 
-    # metadata gathered during compilation
-    meta::Dict{Symbol,Any}
-
-    function CompilerJob(target::AbstractCompilerTarget, source::FunctionSpec,
-                         params::AbstractCompilerParams, entry_abi::Symbol)
+    function CompilerJob(target::AbstractCompilerTarget, source::FunctionSpec, params::AbstractCompilerParams, entry_abi::Symbol)
         if entry_abi ∉ (:specfunc, :func)
             error("Unknown entry_abi=$entry_abi")
         end
-        new{typeof(target), typeof(params), typeof(source)}(
-            target, source, params, entry_abi, Dict{Symbol,Any}())
+        new{typeof(target), typeof(params), typeof(source)}(target, source, params, entry_abi)
     end
 end
-CompilerJob(target::AbstractCompilerTarget, source::FunctionSpec,
-            params::AbstractCompilerParams; entry_abi=:specfunc) =
+CompilerJob(target::AbstractCompilerTarget, source::FunctionSpec, params::AbstractCompilerParams; entry_abi=:specfunc) =
     CompilerJob(target, source, params, entry_abi)
 
 Base.similar(@nospecialize(job::CompilerJob), @nospecialize(source::FunctionSpec)) =
@@ -162,20 +156,13 @@ function Base.show(io::IO, @nospecialize(job::CompilerJob{T})) where {T}
     print(io, "CompilerJob of ", job.source, " for ", T)
 end
 
-# make it possible to key on CompilerJobs, while ignoring the metadata
 function Base.hash(job::CompilerJob, h::UInt)
     h = hash(job.target, h)
     h = hash(job.source, h)
     h = hash(job.params, h)
     h = hash(job.entry_abi, h)
     h
 end
-function Base.isequal(a::CompilerJob, b::CompilerJob)
-    a.target == b.target &&
-    a.source == b.source &&
-    a.params == b.params &&
-    a.entry_abi == b.entry_abi
-end
 
 
 ## contexts

src/irgen.jl

@@ -312,42 +312,31 @@ end
     GHOST       # not passed
 end
 
-function method_argnames(m::Method)
-    argnames = ccall(:jl_uncompress_argnames, Vector{Symbol}, (Any,), m.slot_syms)
-    isempty(argnames) && return argnames
-    return argnames[1:m.nargs]
-end
-
 function classify_arguments(@nospecialize(job::CompilerJob), codegen_ft::LLVM.FunctionType)
     source_sig = typed_signature(job)
 
     source_types = [source_sig.parameters...]
-    source_method = only(method_matches(typed_signature(job); job.source.world)).method
-    source_arguments = method_argnames(source_method)
 
     codegen_types = parameters(codegen_ft)
 
     args = []
     codegen_i = 1
     for (source_i, source_typ) in enumerate(source_types)
-        source_name = source_arguments[min(source_i, length(source_arguments))]
-        # NOTE: in case of varargs, we have fewer arguments than parameters
-
         if isghosttype(source_typ) || Core.Compiler.isconstType(source_typ)
-            push!(args, (cc=GHOST, typ=source_typ, name=source_name))
+            push!(args, (cc=GHOST, typ=source_typ))
             continue
         end
 
         codegen_typ = codegen_types[codegen_i]
         if codegen_typ isa LLVM.PointerType && !issized(eltype(codegen_typ))
-            push!(args, (cc=MUT_REF, typ=source_typ, name=source_name,
+            push!(args, (cc=MUT_REF, typ=source_typ,
                          codegen=(typ=codegen_typ, i=codegen_i)))
         elseif codegen_typ isa LLVM.PointerType && issized(eltype(codegen_typ)) &&
                !(source_typ <: Ptr) && !(source_typ <: Core.LLVMPtr)
-            push!(args, (cc=BITS_REF, typ=source_typ, name=source_name,
+            push!(args, (cc=BITS_REF, typ=source_typ,
                          codegen=(typ=codegen_typ, i=codegen_i)))
         else
-            push!(args, (cc=BITS_VALUE, typ=source_typ, name=source_name,
+            push!(args, (cc=BITS_VALUE, typ=source_typ,
                          codegen=(typ=codegen_typ, i=codegen_i)))
         end
         codegen_i += 1
@@ -356,37 +345,6 @@ function classify_arguments(@nospecialize(job::CompilerJob), codegen_ft::LLVM.Fu
     return args
 end
 
-function classify_fields(julia::DataType, llvm::LLVMType)
-    nfields = fieldcount(julia)
-    fieldoffsets = [fieldoffset(julia, i) for i in 1:nfields]
-    fieldsizes = similar(fieldoffsets)
-    for i in 1:nfields
-        field_start = fieldoffsets[i]
-        field_end = i == nfields ? sizeof(julia) : fieldoffsets[i+1]
-        fieldsizes[i] = field_end - field_start
-    end
-    fieldsizes
-
-    args = []
-    codegen_i = 1
-    for source_i in 1:nfields
-        source_name = fieldname(julia, source_i)
-        source_typ = fieldtype(julia, source_i)
-        if fieldsizes[source_i] == 0
-            push!(args, (; typ=source_typ, name=source_name))
-            continue
-        end
-
-        # NOTE: a cc doesn't make sense here, so the lack of codegen field should be checked
-
-        codegen_typ = elements(llvm)[codegen_i]
-        push!(args, (typ=source_typ, name=source_name, codegen=(typ=codegen_typ, i=codegen_i)))
-        codegen_i += 1
-    end
-
-    return args
-end
-
 if VERSION >= v"1.7.0-DEV.204"
     function is_immutable_datatype(T::Type)
         isa(T,DataType) && !Base.ismutabletype(T)