Merge pull request #260 from maleadt/tb/optimize

Optimizations

Author: maleadt

.github/workflows/ci.yml

@@ -65,7 +65,9 @@ jobs:
           julia --project=deps -e 'using Pkg; Pkg.instantiate()'
           julia --project=deps deps/build_local.jl
       # test
-      - uses: julia-actions/julia-runtest@v1
+      - name: Run tests
+        run: |
+          julia --project -e 'using Pkg; Pkg.test(; julia_args=`-g2`)'
       # process results
       - uses: julia-actions/julia-processcoverage@v1
       - uses: codecov/codecov-action@v1

src/core/basicblock.jl

@@ -5,7 +5,7 @@ export BasicBlock, unsafe_delete!,
 @checked struct BasicBlock <: Value
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMBasicBlockValueKind}) = BasicBlock
+register(BasicBlock, API.LLVMBasicBlockValueKind)
 
 BasicBlock(ref::API.LLVMBasicBlockRef) = BasicBlock(API.LLVMBasicBlockAsValue(ref))
 Base.unsafe_convert(::Type{API.LLVMBasicBlockRef}, bb::BasicBlock) = API.LLVMValueAsBasicBlock(bb)

src/core/function.jl

@@ -5,7 +5,7 @@ export unsafe_delete!,
        entry
 
 # forward declaration of Function in src/core/basicblock.jl
-identify(::Type{Value}, ::Val{API.LLVMFunctionValueKind}) = Function
+register(Function, API.LLVMFunctionValueKind)
 
 Function(mod::Module, name::String, ft::FunctionType) =
     Function(API.LLVMAddFunction(mod, name, ft))
@@ -81,7 +81,7 @@ export Argument, parameters
 @checked struct Argument <: Value
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMArgumentValueKind}) = Argument
+register(Argument, API.LLVMArgumentValueKind)
 
 struct FunctionParameterSet <: AbstractVector{Argument}
     f::Function
@@ -115,24 +115,39 @@ end
 
 export blocks
 
-struct FunctionBlockSet
+struct FunctionBlockSet <: AbstractVector{BasicBlock}
     f::Function
+    cache::Vector{API.LLVMValueRef}
+
+    FunctionBlockSet(f::Function) = new(f, BasicBlock[])
 end
 
 blocks(f::Function) = FunctionBlockSet(f)
 
-Base.eltype(::FunctionBlockSet) = BasicBlock
-
-function Base.iterate(iter::FunctionBlockSet, state=API.LLVMGetFirstBasicBlock(iter.f))
-    state == C_NULL ? nothing : (BasicBlock(state), API.LLVMGetNextBasicBlock(state))
-end
+Base.size(iter::FunctionBlockSet) = (Int(API.LLVMCountBasicBlocks(iter.f)),)
 
 Base.first(iter::FunctionBlockSet) = BasicBlock(API.LLVMGetFirstBasicBlock(iter.f))
 Base.last(iter::FunctionBlockSet) = BasicBlock(API.LLVMGetLastBasicBlock(iter.f))
 
-Base.isempty(iter::FunctionBlockSet) = length(iter) == 0
+function Base.iterate(iter::FunctionBlockSet, state=API.LLVMGetFirstBasicBlock(iter.f))
+    state == C_NULL ? nothing : (BasicBlock(state), API.LLVMGetNextBasicBlock(state))
+end
 
-Base.length(iter::FunctionBlockSet) = API.LLVMCountBasicBlocks(iter.f)
+# provide a random access interface by maintaining a cache of blocks
+function Base.getindex(iter::FunctionBlockSet, i::Int)
+    i <= 0 && throw(BoundsError(iter, i))
+    i == 1 && return first(iter)
+    while i > length(iter.cache)
+        next = if isempty(iter.cache)
+            iterate(iter)
+        else
+            iterate(iter, iter.cache[end])
+        end
+        next === nothing && throw(BoundsError(iter, i))
+        push!(iter.cache, next[2])
+    end
+    return BasicBlock(iter.cache[i-1])
+end
 
 # NOTE: optimized `collect`
 function Base.collect(iter::FunctionBlockSet)

src/core/instructions.jl

@@ -4,17 +4,26 @@ export Instruction, unsafe_delete!,
        predicate_int, predicate_real
 
 # forward definition of Instruction in src/core/value/constant.jl
-identify(::Type{Value}, ::Val{API.LLVMInstructionValueKind}) = Instruction
-
-identify(::Type{Instruction}, ref::API.LLVMValueRef) =
-    identify(Instruction, Val{API.LLVMGetInstructionOpcode(ref)}())
-identify(::Type{Instruction}, ::Val{K}) where {K} = error("Unknown instruction kind $K")
+register(Instruction, API.LLVMInstructionValueKind)
+
+const instruction_opcodes = Vector{Type}(fill(Nothing, typemax(API.LLVMOpcode)+1))
+function identify(::Type{Instruction}, ref::API.LLVMValueRef)
+    opcode = API.LLVMGetInstructionOpcode(ref)
+    typ = @inbounds instruction_opcodes[opcode+1]
+    typ === Nothing && error("Unknown type opcode $opcode")
+    return typ
+end
+function register(T::Type{<:Instruction}, opcode::API.LLVMOpcode)
+    instruction_opcodes[opcode+1] = T
+end
 
-@inline function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Instruction
+function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Instruction
     ref==C_NULL && throw(UndefRefError())
-    T′ = identify(Instruction, ref)
-    if T != T′
-        error("invalid conversion of $T′ instruction reference to $T")
+    if Base.JLOptions().debug_level >= 2
+        T′ = identify(Instruction, ref)
+        if T != T′
+            error("invalid conversion of $T′ instruction reference to $T")
+        end
     end
 end
 
@@ -115,7 +124,7 @@ for op in opcodes
         @checked struct $typename <: Instruction
             ref::API.LLVMValueRef
         end
-        identify(::Type{Instruction}, ::Val{API.$enum}) = $typename
+        register($typename, API.$enum)
     end
 end
 

src/core/metadata.jl

@@ -5,15 +5,24 @@ abstract type Metadata end
 
 Base.unsafe_convert(::Type{API.LLVMMetadataRef}, md::Metadata) = md.ref
 
-identify(::Type{Metadata}, ref::API.LLVMMetadataRef) =
-    identify(Metadata, Val{API.LLVMGetMetadataKind(ref)}())
-identify(::Type{Metadata}, ::Val{K}) where {K} = error("Unknown metadata kind $K")
+const metadata_kinds = Vector{Type}(fill(Nothing, typemax(API.LLVMMetadataKind)+1))
+function identify(::Type{Metadata}, ref::API.LLVMMetadataRef)
+    kind = API.LLVMGetMetadataKind(ref)
+    typ = @inbounds metadata_kinds[kind+1]
+    typ === Nothing && error("Unknown metadata kind $kind")
+    return typ
+end
+function register(T::Type{<:Metadata}, kind::API.LLVMMetadataKind)
+    metadata_kinds[kind+1] = T
+end
 
-@inline function refcheck(::Type{T}, ref::API.LLVMMetadataRef) where T<:Metadata
+function refcheck(::Type{T}, ref::API.LLVMMetadataRef) where T<:Metadata
     ref==C_NULL && throw(UndefRefError())
-    T′ = identify(Metadata, ref)
-    if T != T′
-        error("invalid conversion of $T′ metadata reference to $T")
+    if Base.JLOptions().debug_level >= 2
+        T′ = identify(Metadata, ref)
+        if T != T′
+            error("invalid conversion of $T′ metadata reference to $T")
+        end
     end
 end
 
@@ -37,7 +46,7 @@ end
 @checked struct MetadataAsValue <: Value
     ref::API.LLVMValueRef
 end
-identify(::Type{Value}, ::Val{API.LLVMMetadataAsValueValueKind}) = MetadataAsValue
+register(MetadataAsValue, API.LLVMMetadataAsValueValueKind)
 
 Value(md::Metadata; ctx::Context) = MetadataAsValue(API.LLVMMetadataAsValue(ctx, md))
 
@@ -52,12 +61,12 @@ abstract type ValueAsMetadata <: Metadata end
 @checked struct ConstantAsMetadata <: ValueAsMetadata
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMConstantAsMetadataMetadataKind}) = ConstantAsMetadata
+register(ConstantAsMetadata, API.LLVMConstantAsMetadataMetadataKind)
 
 @checked struct LocalAsMetadata <: ValueAsMetadata
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMLocalAsMetadataMetadataKind}) = LocalAsMetadata
+register(LocalAsMetadata, API.LLVMLocalAsMetadataMetadataKind)
 
 # NOTE: this can be used to both pack e.g. constants as metadata, and to extract the
 #       metadata from an MetadataAsValue, so we don't type-assert narrowly here
@@ -73,7 +82,7 @@ export MDString
 @checked struct MDString <: Metadata
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMMDStringMetadataKind}) = MDString
+register(MDString, API.LLVMMDStringMetadataKind)
 
 MDString(val::String; ctx::Context) =
     MDString(API.LLVMMDStringInContext2(ctx, val, length(val)))
@@ -106,7 +115,7 @@ export MDTuple
 @checked struct MDTuple <: MDNode
     ref::API.LLVMMetadataRef
 end
-identify(::Type{Metadata}, ::Val{API.LLVMMDTupleMetadataKind}) = MDTuple
+register(MDTuple, API.LLVMMDTupleMetadataKind)
 
 # MDTuples are commonly referred to as MDNodes, so keep that name
 MDNode(mds::Vector{<:Metadata}; ctx::Context) =

src/core/type.jl

@@ -7,15 +7,24 @@ Base.eltype(typ::LLVMType) = Any
 
 Base.unsafe_convert(::Type{API.LLVMTypeRef}, typ::LLVMType) = typ.ref
 
-identify(::Type{LLVMType}, ref::API.LLVMTypeRef) =
-    identify(LLVMType, Val{API.LLVMGetTypeKind(ref)}())
-identify(::Type{LLVMType}, ::Val{K}) where {K} = error("Unknown type kind $K")
+const type_kinds = Vector{Type}(fill(Nothing, typemax(API.LLVMTypeKind)+1))
+function identify(::Type{LLVMType}, ref::API.LLVMTypeRef)
+    kind = API.LLVMGetTypeKind(ref)
+    typ = @inbounds type_kinds[kind+1]
+    typ === Nothing && error("Unknown type kind $kind")
+    return typ
+end
+function register(T::Type{<:LLVMType}, kind::API.LLVMTypeKind)
+    type_kinds[kind+1] = T
+end
 
-@inline function refcheck(::Type{T}, ref::API.LLVMTypeRef) where T<:LLVMType
+function refcheck(::Type{T}, ref::API.LLVMTypeRef) where T<:LLVMType
     ref==C_NULL && throw(UndefRefError())
-    T′ = identify(LLVMType, ref)
-    if T != T′
-        error("invalid conversion of $T′ type reference to $T")
+    if Base.JLOptions().debug_level >= 2
+        T′ = identify(LLVMType, ref)
+        if T != T′
+            error("invalid conversion of $T′ type reference to $T")
+        end
     end
 end
 
@@ -45,7 +54,7 @@ export width
 @checked struct IntegerType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMIntegerTypeKind}) = IntegerType
+register(IntegerType, API.LLVMIntegerTypeKind)
 
 for T in [:Int1, :Int8, :Int16, :Int32, :Int64, :Int128]
     jl_fname = Symbol(T, :Type)
@@ -79,7 +88,7 @@ for T in [:Half, :Float, :Double]
         @checked struct $api_typename <: FloatingPointType
             ref::API.LLVMTypeRef
         end
-        identify(::Type{LLVMType}, ::Val{API.$enumkind}) = $api_typename
+        register($api_typename, API.$enumkind)
 
         $jl_fname(ctx::Context) =
             $api_typename(API.$(Symbol(api_fname, :InContext))(ctx))
@@ -94,7 +103,7 @@ export isvararg, return_type, parameters
 @checked struct FunctionType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMFunctionTypeKind}) = FunctionType
+register(FunctionType, API.LLVMFunctionTypeKind)
 
 FunctionType(rettyp::LLVMType, params::Vector{<:LLVMType}=LLVMType[];
              vararg::Core.Bool=false) =
@@ -133,7 +142,7 @@ Base.eltype(typ::SequentialType) = LLVMType(API.LLVMGetElementType(typ))
 @checked struct PointerType <: SequentialType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMPointerTypeKind}) = PointerType
+register(PointerType, API.LLVMPointerTypeKind)
 
 function PointerType(eltyp::LLVMType, addrspace=0)
     return PointerType(API.LLVMPointerType(eltyp, addrspace))
@@ -146,7 +155,7 @@ addrspace(ptrtyp::PointerType) =
 @checked struct ArrayType <: SequentialType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMArrayTypeKind}) = ArrayType
+register(ArrayType, API.LLVMArrayTypeKind)
 
 function ArrayType(eltyp::LLVMType, count)
     return ArrayType(API.LLVMArrayType(eltyp, count))
@@ -160,7 +169,7 @@ Base.isempty(@nospecialize(T::ArrayType)) = length(T) == 0 || isempty(eltype(T))
 @checked struct VectorType <: SequentialType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMVectorTypeKind}) = VectorType
+register(VectorType, API.LLVMVectorTypeKind)
 
 function VectorType(eltyp::LLVMType, count)
     return VectorType(API.LLVMVectorType(eltyp, count))
@@ -176,7 +185,7 @@ export name, ispacked, isopaque, elements!
 @checked struct StructType <: SequentialType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMStructTypeKind}) = StructType
+register(StructType, API.LLVMStructTypeKind)
 
 function StructType(name::String; ctx::Context)
     return StructType(API.LLVMStructCreateNamed(ctx, name))
@@ -237,28 +246,28 @@ end
 @checked struct VoidType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMVoidTypeKind}) = VoidType
+register(VoidType, API.LLVMVoidTypeKind)
 
 VoidType(ctx::Context) = VoidType(API.LLVMVoidTypeInContext(ctx))
 
 @checked struct LabelType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMLabelTypeKind}) = LabelType
+register(LabelType, API.LLVMLabelTypeKind)
 
 LabelType(ctx::Context) = LabelType(API.LLVMLabelTypeInContext(ctx))
 
 @checked struct MetadataType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMMetadataTypeKind}) = MetadataType
+register(MetadataType, API.LLVMMetadataTypeKind)
 
 MetadataType(ctx::Context) = MetadataType(API.LLVMMetadataTypeInContext(ctx))
 
 @checked struct TokenType <: LLVMType
     ref::API.LLVMTypeRef
 end
-identify(::Type{LLVMType}, ::Val{API.LLVMTokenTypeKind}) = TokenType
+register(TokenType, API.LLVMTokenTypeKind)
 
 TokenType(ctx::Context) = TokenType(API.LLVMTokenTypeInContext(ctx))
 

src/core/value.jl

@@ -8,15 +8,24 @@ abstract type Value end
 
 Base.unsafe_convert(::Type{API.LLVMValueRef}, val::Value) = val.ref
 
-identify(::Type{Value}, ref::API.LLVMValueRef) =
-    identify(Value, Val{API.LLVMGetValueKind(ref)}())
-identify(::Type{Value}, ::Val{K}) where {K} = error("Unknown value kind $K")
+const value_kinds = Vector{Type}(fill(Nothing, typemax(API.LLVMValueKind)+1))
+function identify(::Type{Value}, ref::API.LLVMValueRef)
+    kind = API.LLVMGetValueKind(ref)
+    typ = @inbounds value_kinds[kind+1]
+    typ === Nothing && error("Unknown value kind $kind")
+    return typ
+end
+function register(T::Type{<:Value}, kind::API.LLVMValueKind)
+    value_kinds[kind+1] = T
+end
 
-@inline function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Value
+function refcheck(::Type{T}, ref::API.LLVMValueRef) where T<:Value
     ref==C_NULL && throw(UndefRefError())
-    T′ = identify(Value, ref)
-    if T != T′
-        error("invalid conversion of $T′ value reference to $T")
+    if Base.JLOptions().debug_level >= 2
+        T′ = identify(Value, ref)
+        if T != T′
+            error("invalid conversion of $T′ value reference to $T")
+        end
     end
 end