Further Optimization of Rate Coefficient Calculations

[mjohnson541]

#31 made a lot of improvements, but I believe there's still some performance improvements possible independent of better differentiation algorithms, perhaps related to how I handled broadcasting. It could use a new set of eyes. See the Julia performance tips: https://docs.julialang.org/en/v1/manual/performance-tips/index.html. This package is handy: https://github.com/kimikage/ProfileSVG.jl.

[ChrisRackauckas]

What be helpful is if I could take a look at the generated code.

[mjohnson541]

So the first pinch point is vectorized Arrhenius calculations:
arr.A and arr.n and arr.Ea are vectors of Float64, and R is Float64, T is a scalar input
@inline (arr::Arrheniusvec)(T::Q;P::N=0.0,C::S=0.0) where {Q<:Real,N<:Real,S<:Real} = @fastmath @inbounds arr.A.*exp.(arr.n.*log(T).-arr.Ea.*(1.0/(R*T)))

For T::Float64 @code_typed gives:

CodeInfo(
1 ─── %1   = Base.getfield(arr, :A)::Array{Float64,1}
│     %2   = Base.getfield(arr, :n)::Array{Float64,1}
│     %3   = $(Expr(:foreigncall, :(Core.tuple("log", Base.FastMath.libm)), Float64, svec(Float64), 0, :(:ccall), :(T), :(T)))::Float64
│     %4   = Base.getfield(arr, :Ea)::Array{Float64,1}
│     %5   = ReactionMechanismSimulator.R::Float64
│     %6   = Base.FastMath.mul_float_fast(%5, T)::Float64
│     %7   = Base.FastMath.div_float_fast(1.0, %6)::Float64
│     %8   = Base.arraysize(%1, 1)::Int64
│     %9   = Base.slt_int(%8, 0)::Bool
│     %10  = Base.ifelse(%9, 0, %8)::Int64
│     %11  = %new(Base.OneTo{Int64}, %10)::Base.OneTo{Int64}
│     %12  = Base.arraysize(%2, 1)::Int64
│     %13  = Base.slt_int(%12, 0)::Bool
│     %14  = Base.ifelse(%13, 0, %12)::Int64
│     %15  = %new(Base.OneTo{Int64}, %14)::Base.OneTo{Int64}
│     %16  = Base.arraysize(%4, 1)::Int64
│     %17  = Base.slt_int(%16, 0)::Bool
│     %18  = Base.ifelse(%17, 0, %16)::Int64
│     %19  = %new(Base.OneTo{Int64}, %18)::Base.OneTo{Int64}
│     %20  = (%18 === %14)::Bool
│     %21  = Base.and_int(true, %20)::Bool
└────        goto #3 if not %21
2 ───        goto #4
3 ─── %24  = (%14 === 1)::Bool
└────        goto #4
4 ┄── %26  = φ (#2 => %21, #3 => %24)::Bool
└────        goto #6 if not %26
5 ───        goto #12
6 ─── %29  = (%14 === %18)::Bool
│     %30  = Base.and_int(true, %29)::Bool
└────        goto #8 if not %30
7 ───        goto #9
8 ─── %33  = (%18 === 1)::Bool
└────        goto #9
9 ┄── %35  = φ (#7 => %30, #8 => %33)::Bool
└────        goto #11 if not %35
10 ──        goto #12
11 ── %38  = invoke Base.print_to_string("arrays could not be broadcast to a common size; got a dimension with lengths "::String, %14::Vararg{Any,N} where N, " and ", %18)::String
│     %39  = %new(Base.DimensionMismatch, %38)::DimensionMismatch
│            Base.Broadcast.throw(%39)::Union{}
└────        $(Expr(:unreachable))::Union{}
12 ┄─ %42  = φ (#5 => %18, #10 => %14)::Int64
│     %43  = φ (#5 => %18, #10 => %14)::Int64
│     %44  = φ (#5 => %18, #10 => %14)::Int64
│     %45  = φ (#5 => %18, #10 => %14)::Int64
│     %46  = φ (#5 => %18, #10 => %14)::Int64
│     %47  = φ (#5 => %18, #10 => %14)::Int64
│     %48  = φ (#5 => %18, #10 => %14)::Int64
│     %49  = φ (#5 => %18, #10 => %14)::Int64
│     %50  = φ (#5 => %18, #10 => %14)::Int64
│     %51  = φ (#5 => %19, #10 => %15)::Base.OneTo{Int64}
└────        goto #13
13 ──        goto #14
14 ──        goto #15
15 ──        goto #16
16 ──        goto #17
17 ──        goto #18
18 ──        goto #19
19 ──        goto #20
20 ── %60  = (%42 === %10)::Bool
│     %61  = Base.and_int(true, %60)::Bool
└────        goto #22 if not %61
21 ──        goto #23
22 ── %64  = (%10 === 1)::Bool
└────        goto #23
23 ┄─ %66  = φ (#21 => %61, #22 => %64)::Bool
└────        goto #25 if not %66
24 ──        goto #31
25 ── %69  = (%10 === %43)::Bool
│     %70  = Base.and_int(true, %69)::Bool
└────        goto #27 if not %70
26 ──        goto #28
27 ── %73  = (%44 === 1)::Bool
└────        goto #28
28 ┄─ %75  = φ (#26 => %70, #27 => %73)::Bool
└────        goto #30 if not %75
29 ──        goto #31
30 ── %78  = invoke Base.print_to_string("arrays could not be broadcast to a common size; got a dimension with lengths "::String, %10::Vararg{Any,N} where N, " and ", %45)::String
│     %79  = %new(Base.DimensionMismatch, %78)::DimensionMismatch
│            Base.Broadcast.throw(%79)::Union{}
└────        $(Expr(:unreachable))::Union{}
31 ┄─ %82  = φ (#24 => %46, #29 => %10)::Int64
│     %83  = φ (#24 => %47, #29 => %10)::Int64
│     %84  = φ (#24 => %48, #29 => %10)::Int64
│     %85  = φ (#24 => %49, #29 => %10)::Int64
│     %86  = φ (#24 => %50, #29 => %10)::Int64
│     %87  = φ (#24 => %51, #29 => %11)::Base.OneTo{Int64}
│     %88  = Core.tuple(%87)::Tuple{Base.OneTo{Int64}}
└────        goto #32
32 ──        goto #33
33 ──        goto #34
34 ──        goto #35
35 ── %93  = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), 0, :(:ccall), Array{Float64,1}, :(%82), :(%82)))::Array{Float64,1}
│     %94  = Base.arraysize(%93, 1)::Int64
│     %95  = Base.slt_int(%94, 0)::Bool
│     %96  = Base.ifelse(%95, 0, %94)::Int64
│     %97  = (%96 === %83)::Bool
│     %98  = Base.and_int(true, %97)::Bool
│     %99  = (%98 === false)::Bool
└────        goto #37 if not %99
36 ──        goto #38
37 ──        goto #38
38 ┄─ %103 = φ (#36 => false, #37 => true)::Bool
└────        goto #39
39 ──        goto #117 if not %103
40 ── %106 = (%93 === %1)::Bool
└────        goto #42 if not %106
41 ──        goto #51
42 ── %109 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %110 = Base.not_int(%109)::Bool
└────        goto #46 if not %110
43 ── %112 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %113 = Base.not_int(%112)::Bool
└────        goto #45 if not %113
44 ── %115 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%93)))::Ptr{Float64}
│     %116 = Core.bitcast(Core.UInt, %115)::UInt64
│     %117 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%1)))::Ptr{Float64}
│     %118 = Core.bitcast(Core.UInt, %117)::UInt64
│     %119 = (%116 === %118)::Bool
│     %120 = Base.not_int(%119)::Bool
│     %121 = Base.not_int(%120)::Bool
└────        goto #47
45 ──        goto #47
46 ──        goto #47
47 ┄─ %125 = φ (#44 => %121, #45 => false, #46 => false)::Bool
└────        goto #49 if not %125
48 ── %127 = $(Expr(:foreigncall, :(:jl_array_copy), Ref{Array{Float64,1}}, svec(Any), 0, :(:ccall), :(%1)))::Array{Float64,1}
└────        goto #50
49 ──        goto #50
50 ┄─ %130 = φ (#48 => %127, #49 => %1)::Array{Float64,1}
└────        goto #51
51 ┄─ %132 = φ (#41 => %1, #50 => %130)::Array{Float64,1}
│     %133 = Base.arraysize(%132, 1)::Int64
│     %134 = Base.slt_int(%133, 0)::Bool
│     %135 = Base.ifelse(%134, 0, %133)::Int64
│     %136 = (%135 === 1)::Bool
│     %137 = Base.not_int(%136)::Bool
│     %138 = Core.tuple(%137)::Tuple{Bool}
│     %139 = %new(Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}, %132, %138, (1,))::Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}
└────        goto #52
52 ── %141 = (%93 === %2)::Bool
└────        goto #54 if not %141
53 ──        goto #63
54 ── %144 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %145 = Base.not_int(%144)::Bool
└────        goto #58 if not %145
55 ── %147 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %148 = Base.not_int(%147)::Bool
└────        goto #57 if not %148
56 ── %150 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%93)))::Ptr{Float64}
│     %151 = Core.bitcast(Core.UInt, %150)::UInt64
│     %152 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%2)))::Ptr{Float64}
│     %153 = Core.bitcast(Core.UInt, %152)::UInt64
│     %154 = (%151 === %153)::Bool
│     %155 = Base.not_int(%154)::Bool
│     %156 = Base.not_int(%155)::Bool
└────        goto #59
57 ──        goto #59
58 ──        goto #59
59 ┄─ %160 = φ (#56 => %156, #57 => false, #58 => false)::Bool
└────        goto #61 if not %160
60 ── %162 = $(Expr(:foreigncall, :(:jl_array_copy), Ref{Array{Float64,1}}, svec(Any), 0, :(:ccall), :(%2)))::Array{Float64,1}
└────        goto #62
61 ──        goto #62
62 ┄─ %165 = φ (#60 => %162, #61 => %2)::Array{Float64,1}
└────        goto #63
63 ┄─ %167 = φ (#53 => %2, #62 => %165)::Array{Float64,1}
│     %168 = Base.arraysize(%167, 1)::Int64
│     %169 = Base.slt_int(%168, 0)::Bool
│     %170 = Base.ifelse(%169, 0, %168)::Int64
│     %171 = (%170 === 1)::Bool
│     %172 = Base.not_int(%171)::Bool
│     %173 = Core.tuple(%172)::Tuple{Bool}
│     %174 = %new(Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}, %167, %173, (1,))::Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}
└────        goto #64
64 ── %176 = (%93 === %3)::Bool
└────        goto #66 if not %176
65 ──        goto #67
66 ──        goto #67
67 ┄─ %180 = φ (#65 => %3, #66 => %3)::Float64
└────        goto #68
68 ──        goto #69
69 ── %183 = Core.tuple(%174, %180)::Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}
└────        goto #70
70 ── %185 = %new(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}, *, %183, nothing)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}
└────        goto #71
71 ── %187 = (%93 === %4)::Bool
└────        goto #73 if not %187
72 ──        goto #82
73 ── %190 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %191 = Base.not_int(%190)::Bool
└────        goto #77 if not %191
74 ── %193 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %194 = Base.not_int(%193)::Bool
└────        goto #76 if not %194
75 ── %196 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%93)))::Ptr{Float64}
│     %197 = Core.bitcast(Core.UInt, %196)::UInt64
│     %198 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%4)))::Ptr{Float64}
│     %199 = Core.bitcast(Core.UInt, %198)::UInt64
│     %200 = (%197 === %199)::Bool
│     %201 = Base.not_int(%200)::Bool
│     %202 = Base.not_int(%201)::Bool
└────        goto #78
76 ──        goto #78
77 ──        goto #78
78 ┄─ %206 = φ (#75 => %202, #76 => false, #77 => false)::Bool
└────        goto #80 if not %206
79 ── %208 = $(Expr(:foreigncall, :(:jl_array_copy), Ref{Array{Float64,1}}, svec(Any), 0, :(:ccall), :(%4)))::Array{Float64,1}
└────        goto #81
80 ──        goto #81
81 ┄─ %211 = φ (#79 => %208, #80 => %4)::Array{Float64,1}
└────        goto #82
82 ┄─ %213 = φ (#72 => %4, #81 => %211)::Array{Float64,1}
│     %214 = Base.arraysize(%213, 1)::Int64
│     %215 = Base.slt_int(%214, 0)::Bool
│     %216 = Base.ifelse(%215, 0, %214)::Int64
│     %217 = (%216 === 1)::Bool
│     %218 = Base.not_int(%217)::Bool
│     %219 = Core.tuple(%218)::Tuple{Bool}
│     %220 = %new(Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}, %213, %219, (1,))::Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}
└────        goto #83
83 ── %222 = (%93 === %7)::Bool
└────        goto #85 if not %222
84 ──        goto #86
85 ──        goto #86
86 ┄─ %226 = φ (#84 => %7, #85 => %7)::Float64
└────        goto #87
87 ──        goto #88
88 ── %229 = Core.tuple(%220, %226)::Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}
└────        goto #89
89 ── %231 = %new(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}, *, %229, nothing)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}
└────        goto #90
90 ──        goto #91
91 ── %234 = Core.tuple(%185, %231)::Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}
└────        goto #92
92 ── %236 = %new(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}, -, %234, nothing)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}
└────        goto #93
93 ── %238 = Core.tuple(%236)::Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}
└────        goto #94
94 ── %240 = %new(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}, Base.FastMath.exp_fast, %238, nothing)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}
└────        goto #95
95 ──        goto #96
96 ── %243 = Core.tuple(%139, %240)::Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}}
└────        goto #97
97 ── %245 = %new(Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}}}, *, %243, %88)::Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}}}
└────        goto #98
98 ──        goto #116 if not true
99 ── %248 = Base.slt_int(0, %84)::Bool
└────        goto #115 if not %248
100 ─        nothing::Nothing
101 ┄ %251 = φ (#100 => 0, #114 => %290)::Int64
│     %252 = Base.slt_int(%251, %84)::Bool
└────        goto #115 if not %252
102 ─ %254 = Base.add_int(%251, 1)::Int64
└────        goto #106 if not false
103 ─ %256 = Base.slt_int(0, %254)::Bool
│     %257 = Base.sle_int(%254, %85)::Bool
│     %258 = Base.and_int(%256, %257)::Bool
└────        goto #105 if not %258
104 ─        goto #106
105 ─        invoke Base.throw_boundserror(%87::Base.OneTo{Int64}, %254::Int64)::Union{}
└────        $(Expr(:unreachable))::Union{}
106 ┄        goto #107
107 ─        goto #108
108 ─        goto #113 if not false
109 ─ %266 = Base.sle_int(1, %254)::Bool
│     %267 = Base.sle_int(%254, %86)::Bool
│     %268 = Base.and_int(%266, %267)::Bool
│     %269 = Base.and_int(%268, true)::Bool
└────        goto #111 if not %269
110 ─        goto #112
111 ─ %272 = Base.throw_boundserror::typeof(Base.throw_boundserror)
│     %273 = Core.tuple(%254)::Tuple{Int64}
│            invoke %272(%245::Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(-),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}}}, %273::Tuple{Int64})::Union{}
└────        $(Expr(:unreachable))::Union{}
112 ┄        nothing::Nothing
113 ┄ %277 = Base.Broadcast.ifelse(%137, %254, 1)::Int64
│     %278 = Base.arrayref(false, %132, %277)::Float64
│     %279 = Base.Broadcast.ifelse(%172, %254, 1)::Int64
│     %280 = Base.arrayref(false, %167, %279)::Float64
│     %281 = Base.mul_float(%280, %180)::Float64
│     %282 = Base.Broadcast.ifelse(%218, %254, 1)::Int64
│     %283 = Base.arrayref(false, %213, %282)::Float64
│     %284 = Base.mul_float(%283, %226)::Float64
│     %285 = Base.sub_float(%281, %284)::Float64
│     %286 = invoke Base.FastMath.exp(%285::Float64)::Float64
│     %287 = Base.mul_float(%278, %286)::Float64
└────        goto #114
114 ─        Base.arrayset(false, %93, %287, %254)::Array{Float64,1}
│     %290 = Base.add_int(%251, 1)::Int64
│            $(Expr(:loopinfo, Symbol("julia.simdloop"), nothing))::Any
└────        goto #101
115 ┄        nothing::Nothing
116 ┄        goto #118
117 ─ %295 = Base.arraysize(%93, 1)::Int64
│     %296 = Base.slt_int(%295, 0)::Bool
│     %297 = Base.ifelse(%296, 0, %295)::Int64
│     %298 = %new(Base.OneTo{Int64}, %297)::Base.OneTo{Int64}
│     %299 = Core.tuple(%298)::Tuple{Base.OneTo{Int64}}
│            invoke Base.Broadcast.throwdm(%299::Tuple{Base.OneTo{Int64}}, %88::Tuple{Base.OneTo{Int64}})::Union{}
└────        $(Expr(:unreachable))::Union{}
118 ┄        goto #119
119 ─        goto #120
120 ─        goto #121
121 ─        goto #123
122 ─        $(Expr(:meta, :nkw, 2))
123 ┄        return %93
) => Array{Float64,1}```

[mjohnson541]

The second pinch point is equilibrium coefficient calculation. This can be done either reaction by reaction summing up 2-4 Gs values for each reaction and then converting that into a Kc, or you can do the sums all at once by matrix multiplication. I found it to be fastest using a sparse matrix multiplication.
ph.stoichmatrix is a sparse matrix, ph.Nrp is a vector, Gs is a vector, T is an input scalar

@inline function getKcs(ph::U,T::Z,Gs::Q) where {U<:AbstractPhase,Q,Z<:Real}
    return @fastmath @inbounds exp.(ph.stoichmatrix*(Gs./(R*T)) .+ ph.Nrp.*log(1.0e5/(R*T)));
end

@code_typed for T::Float64 gives:

CodeInfo(
1 ─── %1   = Base.getfield(ph, :stoichmatrix)::SparseArrays.SparseMatrixCSC{Float64,Int64}
│     %2   = ReactionMechanismSimulator.R::Core.Compiler.Const(8.314, false)
│     %3   = Base.FastMath.mul_float_fast(%2, T)::Float64
│     %4   = Base.arraysize(Gs, 1)::Int64
│     %5   = Base.slt_int(%4, 0)::Bool
│     %6   = Base.ifelse(%5, 0, %4)::Int64
│     %7   = %new(Base.OneTo{Int64}, %6)::Base.OneTo{Int64}
│     %8   = Core.tuple(%7)::Tuple{Base.OneTo{Int64}}
│     %9   = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), 0, :(:ccall), Array{Float64,1}, :(%6), :(%6)))::Array{Float64,1}
│     %10  = Base.arraysize(%9, 1)::Int64
│     %11  = Base.slt_int(%10, 0)::Bool
│     %12  = Base.ifelse(%11, 0, %10)::Int64
│     %13  = (%12 === %6)::Bool
│     %14  = Base.and_int(true, %13)::Bool
│     %15  = (%14 === false)::Bool
└────        goto #3 if not %15
2 ───        goto #4
3 ───        goto #4
4 ┄── %19  = φ (#2 => false, #3 => true)::Bool
└────        goto #5
5 ───        goto #44 if not %19
6 ─── %22  = (%9 === Gs)::Bool
└────        goto #8 if not %22
7 ───        goto #17
8 ─── %25  = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %26  = Base.not_int(%25)::Bool
└────        goto #12 if not %26
9 ─── %28  = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %29  = Base.not_int(%28)::Bool
└────        goto #11 if not %29
10 ── %31  = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%9)))::Ptr{Float64}
│     %32  = Core.bitcast(Core.UInt, %31)::UInt64
│     %33  = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(Gs)))::Ptr{Float64}
│     %34  = Core.bitcast(Core.UInt, %33)::UInt64
│     %35  = (%32 === %34)::Bool
│     %36  = Base.not_int(%35)::Bool
│     %37  = Base.not_int(%36)::Bool
└────        goto #13
11 ──        goto #13
12 ──        goto #13
13 ┄─ %41  = φ (#10 => %37, #11 => false, #12 => false)::Bool
└────        goto #15 if not %41
14 ── %43  = $(Expr(:foreigncall, :(:jl_array_copy), Ref{Array{Float64,1}}, svec(Any), 0, :(:ccall), :(Gs)))::Array{Float64,1}
└────        goto #16
15 ──        goto #16
16 ┄─ %46  = φ (#14 => %43, #15 => _4)::Array{Float64,1}
└────        goto #17
17 ┄─ %48  = φ (#7 => _4, #16 => %46)::Array{Float64,1}
│     %49  = Base.arraysize(%48, 1)::Int64
│     %50  = Base.slt_int(%49, 0)::Bool
│     %51  = Base.ifelse(%50, 0, %49)::Int64
│     %52  = (%51 === 1)::Bool
│     %53  = Base.not_int(%52)::Bool
│     %54  = Core.tuple(%53)::Tuple{Bool}
│     %55  = %new(Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}, %48, %54, (1,))::Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}
└────        goto #18
18 ── %57  = (%9 === %3)::Bool
└────        goto #20 if not %57
19 ──        goto #21
20 ──        goto #21
21 ┄─ %61  = φ (#19 => %3, #20 => %3)::Float64
└────        goto #22
22 ──        goto #23
23 ── %64  = Core.tuple(%55, %61)::Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}
└────        goto #24
24 ── %66  = %new(Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(/),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}, /, %64, %8)::Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(/),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}
└────        goto #25
25 ──        goto #43 if not true
26 ── %69  = Base.slt_int(0, %6)::Bool
└────        goto #42 if not %69
27 ──        nothing::Nothing
28 ┄─ %72  = φ (#27 => 0, #41 => %103)::Int64
│     %73  = Base.slt_int(%72, %6)::Bool
└────        goto #42 if not %73
29 ── %75  = Base.add_int(%72, 1)::Int64
└────        goto #33 if not false
30 ── %77  = Base.slt_int(0, %75)::Bool
│     %78  = Base.sle_int(%75, %6)::Bool
│     %79  = Base.and_int(%77, %78)::Bool
└────        goto #32 if not %79
31 ──        goto #33
32 ──        invoke Base.throw_boundserror(%7::Base.OneTo{Int64}, %75::Int64)::Union{}
└────        $(Expr(:unreachable))::Union{}
33 ┄─        goto #34
34 ──        goto #35
35 ──        goto #40 if not false
36 ── %87  = Base.sle_int(1, %75)::Bool
│     %88  = Base.sle_int(%75, %6)::Bool
│     %89  = Base.and_int(%87, %88)::Bool
│     %90  = Base.and_int(%89, true)::Bool
└────        goto #38 if not %90
37 ──        goto #39
38 ── %93  = Base.throw_boundserror::typeof(Base.throw_boundserror)
│     %94  = Core.tuple(%75)::Tuple{Int64}
│            invoke %93(%66::Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(/),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}, %94::Tuple{Int64})::Union{}
└────        $(Expr(:unreachable))::Union{}
39 ┄─        nothing::Nothing
40 ┄─ %98  = Base.Broadcast.ifelse(%53, %75, 1)::Int64
│     %99  = Base.arrayref(false, %48, %98)::Float64
│     %100 = Base.div_float(%99, %61)::Float64
└────        goto #41
41 ──        Base.arrayset(false, %9, %100, %75)::Array{Float64,1}
│     %103 = Base.add_int(%72, 1)::Int64
│            $(Expr(:loopinfo, Symbol("julia.simdloop"), nothing))::Any
└────        goto #28
42 ┄─        nothing::Nothing
43 ┄─        goto #45
44 ── %108 = Base.arraysize(%9, 1)::Int64
│     %109 = Base.slt_int(%108, 0)::Bool
│     %110 = Base.ifelse(%109, 0, %108)::Int64
│     %111 = %new(Base.OneTo{Int64}, %110)::Base.OneTo{Int64}
│     %112 = Core.tuple(%111)::Tuple{Base.OneTo{Int64}}
│            invoke Base.Broadcast.throwdm(%112::Tuple{Base.OneTo{Int64}}, %8::Tuple{Base.OneTo{Int64}})::Union{}
└────        $(Expr(:unreachable))::Union{}
45 ┄─        goto #46
46 ──        goto #47
47 ──        goto #48
48 ── %118 = SparseArrays.getfield(%1, :m)::Int64
│     %119 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), 0, :(:ccall), Array{Float64,1}, :(%118), :(%118)))::Array{Float64,1}
│     %120 = invoke SparseArrays.mul!(%119::Array{Float64,1}, %1::SparseArrays.SparseMatrixCSC{Float64,Int64}, %9::Array{Float64,1}, true::Bool, false::Bool)::Array{Float64,1}
│     %121 = Base.getfield(ph, :Nrp)::Array{Float64,1}
│     %122 = ReactionMechanismSimulator.R::Core.Compiler.Const(8.314, false)
│     %123 = Base.FastMath.mul_float_fast(%122, T)::Float64
│     %124 = Base.FastMath.div_float_fast(100000.0, %123)::Float64
│     %125 = $(Expr(:foreigncall, :(Core.tuple("log", Base.FastMath.libm)), Float64, svec(Float64), 0, :(:ccall), :(%124), :(%124)))::Float64
│     %126 = Base.arraysize(%120, 1)::Int64
│     %127 = Base.slt_int(%126, 0)::Bool
│     %128 = Base.ifelse(%127, 0, %126)::Int64
│     %129 = %new(Base.OneTo{Int64}, %128)::Base.OneTo{Int64}
│     %130 = Base.arraysize(%121, 1)::Int64
│     %131 = Base.slt_int(%130, 0)::Bool
│     %132 = Base.ifelse(%131, 0, %130)::Int64
│     %133 = %new(Base.OneTo{Int64}, %132)::Base.OneTo{Int64}
│     %134 = (%132 === %128)::Bool
│     %135 = Base.and_int(true, %134)::Bool
└────        goto #50 if not %135
49 ──        goto #51
50 ── %138 = (%128 === 1)::Bool
└────        goto #51
51 ┄─ %140 = φ (#49 => %135, #50 => %138)::Bool
└────        goto #53 if not %140
52 ──        goto #59
53 ── %143 = (%128 === %132)::Bool
│     %144 = Base.and_int(true, %143)::Bool
└────        goto #55 if not %144
54 ──        goto #56
55 ── %147 = (%132 === 1)::Bool
└────        goto #56
56 ┄─ %149 = φ (#54 => %144, #55 => %147)::Bool
└────        goto #58 if not %149
57 ──        goto #59
58 ── %152 = invoke Base.print_to_string("arrays could not be broadcast to a common size; got a dimension with lengths "::String, %128::Vararg{Any,N} where N, " and ", %132)::String
│     %153 = %new(Base.DimensionMismatch, %152)::DimensionMismatch
│            Base.Broadcast.throw(%153)::Union{}
└────        $(Expr(:unreachable))::Union{}
59 ┄─ %156 = φ (#52 => %132, #57 => %128)::Int64
│     %157 = φ (#52 => %132, #57 => %128)::Int64
│     %158 = φ (#52 => %132, #57 => %128)::Int64
│     %159 = φ (#52 => %132, #57 => %128)::Int64
│     %160 = φ (#52 => %132, #57 => %128)::Int64
│     %161 = φ (#52 => %133, #57 => %129)::Base.OneTo{Int64}
│     %162 = Core.tuple(%161)::Tuple{Base.OneTo{Int64}}
└────        goto #60
60 ──        goto #61
61 ──        goto #62
62 ──        goto #63
63 ──        goto #64
64 ──        goto #65
65 ──        goto #66
66 ── %170 = $(Expr(:foreigncall, :(:jl_alloc_array_1d), Array{Float64,1}, svec(Any, Int64), 0, :(:ccall), Array{Float64,1}, :(%156), :(%156)))::Array{Float64,1}
│     %171 = Base.arraysize(%170, 1)::Int64
│     %172 = Base.slt_int(%171, 0)::Bool
│     %173 = Base.ifelse(%172, 0, %171)::Int64
│     %174 = (%173 === %157)::Bool
│     %175 = Base.and_int(true, %174)::Bool
│     %176 = (%175 === false)::Bool
└────        goto #68 if not %176
67 ──        goto #69
68 ──        goto #69
69 ┄─ %180 = φ (#67 => false, #68 => true)::Bool
└────        goto #70
70 ──        goto #126 if not %180
71 ── %183 = (%170 === %120)::Bool
└────        goto #73 if not %183
72 ──        goto #82
73 ── %186 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %187 = Base.not_int(%186)::Bool
└────        goto #77 if not %187
74 ── %189 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %190 = Base.not_int(%189)::Bool
└────        goto #76 if not %190
75 ── %192 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%170)))::Ptr{Float64}
│     %193 = Core.bitcast(Core.UInt, %192)::UInt64
│     %194 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%120)))::Ptr{Float64}
│     %195 = Core.bitcast(Core.UInt, %194)::UInt64
│     %196 = (%193 === %195)::Bool
│     %197 = Base.not_int(%196)::Bool
│     %198 = Base.not_int(%197)::Bool
└────        goto #78
76 ──        goto #78
77 ──        goto #78
78 ┄─ %202 = φ (#75 => %198, #76 => false, #77 => false)::Bool
└────        goto #80 if not %202
79 ── %204 = $(Expr(:foreigncall, :(:jl_array_copy), Ref{Array{Float64,1}}, svec(Any), 0, :(:ccall), :(%120)))::Array{Float64,1}
└────        goto #81
80 ──        goto #81
81 ┄─ %207 = φ (#79 => %204, #80 => %120)::Array{Float64,1}
└────        goto #82
82 ┄─ %209 = φ (#72 => %120, #81 => %207)::Array{Float64,1}
│     %210 = Base.arraysize(%209, 1)::Int64
│     %211 = Base.slt_int(%210, 0)::Bool
│     %212 = Base.ifelse(%211, 0, %210)::Int64
│     %213 = (%212 === 1)::Bool
│     %214 = Base.not_int(%213)::Bool
│     %215 = Core.tuple(%214)::Tuple{Bool}
│     %216 = %new(Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}, %209, %215, (1,))::Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}
└────        goto #83
83 ── %218 = (%170 === %121)::Bool
└────        goto #85 if not %218
84 ──        goto #94
85 ── %221 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %222 = Base.not_int(%221)::Bool
└────        goto #89 if not %222
86 ── %224 = Base.getfield(Array{Float64,1}, :isbitstype)::Bool
│     %225 = Base.not_int(%224)::Bool
└────        goto #88 if not %225
87 ── %227 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%170)))::Ptr{Float64}
│     %228 = Core.bitcast(Core.UInt, %227)::UInt64
│     %229 = $(Expr(:foreigncall, :(:jl_array_ptr), Ptr{Float64}, svec(Any), 0, :(:ccall), :(%121)))::Ptr{Float64}
│     %230 = Core.bitcast(Core.UInt, %229)::UInt64
│     %231 = (%228 === %230)::Bool
│     %232 = Base.not_int(%231)::Bool
│     %233 = Base.not_int(%232)::Bool
└────        goto #90
88 ──        goto #90
89 ──        goto #90
90 ┄─ %237 = φ (#87 => %233, #88 => false, #89 => false)::Bool
└────        goto #92 if not %237
91 ── %239 = $(Expr(:foreigncall, :(:jl_array_copy), Ref{Array{Float64,1}}, svec(Any), 0, :(:ccall), :(%121)))::Array{Float64,1}
└────        goto #93
92 ──        goto #93
93 ┄─ %242 = φ (#91 => %239, #92 => %121)::Array{Float64,1}
└────        goto #94
94 ┄─ %244 = φ (#84 => %121, #93 => %242)::Array{Float64,1}
│     %245 = Base.arraysize(%244, 1)::Int64
│     %246 = Base.slt_int(%245, 0)::Bool
│     %247 = Base.ifelse(%246, 0, %245)::Int64
│     %248 = (%247 === 1)::Bool
│     %249 = Base.not_int(%248)::Bool
│     %250 = Core.tuple(%249)::Tuple{Bool}
│     %251 = %new(Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}, %244, %250, (1,))::Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}}
└────        goto #95
95 ── %253 = (%170 === %125)::Bool
└────        goto #97 if not %253
96 ──        goto #98
97 ──        goto #98
98 ┄─ %257 = φ (#96 => %125, #97 => %125)::Float64
└────        goto #99
99 ──        goto #100
100 ─ %260 = Core.tuple(%251, %257)::Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}
└────        goto #101
101 ─ %262 = %new(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}, *, %260, nothing)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}
└────        goto #102
102 ─        goto #103
103 ─ %265 = Core.tuple(%216, %262)::Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}
└────        goto #104
104 ─ %267 = %new(Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(+),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}, +, %265, nothing)::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(+),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}
└────        goto #105
105 ─ %269 = Core.tuple(%267)::Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(+),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}
└────        goto #106
106 ─ %271 = %new(Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(+),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}, Base.FastMath.exp_fast, %269, %162)::Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(+),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}
└────        goto #107
107 ─        goto #125 if not true
108 ─ %274 = Base.slt_int(0, %158)::Bool
└────        goto #124 if not %274
109 ─        nothing::Nothing
110 ┄ %277 = φ (#109 => 0, #123 => %312)::Int64
│     %278 = Base.slt_int(%277, %158)::Bool
└────        goto #124 if not %278
111 ─ %280 = Base.add_int(%277, 1)::Int64
└────        goto #115 if not false
112 ─ %282 = Base.slt_int(0, %280)::Bool
│     %283 = Base.sle_int(%280, %159)::Bool
│     %284 = Base.and_int(%282, %283)::Bool
└────        goto #114 if not %284
113 ─        goto #115
114 ─        invoke Base.throw_boundserror(%161::Base.OneTo{Int64}, %280::Int64)::Union{}
└────        $(Expr(:unreachable))::Union{}
115 ┄        goto #116
116 ─        goto #117
117 ─        goto #122 if not false
118 ─ %292 = Base.sle_int(1, %280)::Bool
│     %293 = Base.sle_int(%280, %160)::Bool
│     %294 = Base.and_int(%292, %293)::Bool
│     %295 = Base.and_int(%294, true)::Bool
└────        goto #120 if not %295
119 ─        goto #121
120 ─ %298 = Base.throw_boundserror::typeof(Base.throw_boundserror)
│     %299 = Core.tuple(%280)::Tuple{Int64}
│            invoke %298(%271::Base.Broadcast.Broadcasted{Nothing,Tuple{Base.OneTo{Int64}},typeof(Base.FastMath.exp_fast),Tuple{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(+),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1},Nothing,typeof(*),Tuple{Base.Broadcast.Extruded{Array{Float64,1},Tuple{Bool},Tuple{Int64}},Float64}}}}}}, %299::Tuple{Int64})::Union{}
└────        $(Expr(:unreachable))::Union{}
121 ┄        nothing::Nothing
122 ┄ %303 = Base.Broadcast.ifelse(%214, %280, 1)::Int64
│     %304 = Base.arrayref(false, %209, %303)::Float64
│     %305 = Base.Broadcast.ifelse(%249, %280, 1)::Int64
│     %306 = Base.arrayref(false, %244, %305)::Float64
│     %307 = Base.mul_float(%306, %257)::Float64
│     %308 = Base.add_float(%304, %307)::Float64
│     %309 = invoke Base.FastMath.exp(%308::Float64)::Float64
└────        goto #123
123 ─        Base.arrayset(false, %170, %309, %280)::Array{Float64,1}
│     %312 = Base.add_int(%277, 1)::Int64
│            $(Expr(:loopinfo, Symbol("julia.simdloop"), nothing))::Any
└────        goto #110
124 ┄        nothing::Nothing
125 ┄        goto #127
126 ─ %317 = Base.arraysize(%170, 1)::Int64
│     %318 = Base.slt_int(%317, 0)::Bool
│     %319 = Base.ifelse(%318, 0, %317)::Int64
│     %320 = %new(Base.OneTo{Int64}, %319)::Base.OneTo{Int64}
│     %321 = Core.tuple(%320)::Tuple{Base.OneTo{Int64}}
│            invoke Base.Broadcast.throwdm(%321::Tuple{Base.OneTo{Int64}}, %162::Tuple{Base.OneTo{Int64}})::Union{}
└────        $(Expr(:unreachable))::Union{}
127 ┄        goto #128
128 ─        goto #129
129 ─        goto #130
130 ─        return %170
) => Array{Float64,1}

[ChrisRackauckas]

I'd be a little scared of @fastmath there, but it looks like it's lowering well and SIMD'ing well, though you'll want to be writing this into a cache.

[mjohnson541]

We're actually not very sensitive to the results of these calculations (in fact ab initio based kinetics would be virtually impossible if we were sensitive beyond 4-5 digits). There are a few papers that got high speed ups using cheap approximations of the exponential or by approximating these functions directly with piecewise polynomials: https://www.sciencedirect.com/science/article/pii/S0010218018301652. We would probably want to be able to toggle these approximations on and off.

I played with their exponential approximation a while ago, but I couldn't get the reinterpretation they do competitive with julia's exp function, I'm not exactly sure how efficient the fortran exp function they're comparing to is though.

[ChrisRackauckas]

Then you might want to try https://discourse.julialang.org/t/betterexp-0-1-0/44747 https://github.com/oscardssmith/BetterExp.jl . But, if exp is only calculated to 3ulp, abstol=1e-16 doesn't make much sense and abstol=1e-13 would be a better choice.