At present, the broadcast in julia is always lazy, no matter the inputs’ axes.
I think, at least for numeric calcution, if both the input(s) and output are scalar, we could perform the calculation immediately, as the storage of Intermediate variable is always negligible. In other words we might merge the scalars during the broadcasted chain.
At present, a pre-defined function could merge const scalars well, like:
julia> a = randn(1000); b = randn(1000); c = similar(a,(1000,1000));
julia> f(x,y) = sin(exp(2pi)*x*y);
julia> @btime @. $c = f($a,$b');
16.042 ms (0 allocations: 0 bytes)
while, a nested Broadcasted object not:
julia> @btime @. $c = sin(exp(2pi)*$a*$b');
38.451 ms (0 allocations: 0 bytes)
Of course, we could avoid it by merge the scalars ourselves, like:
julia> temp = exp(2pi); @btime @. $c = sin($temp*$a*$b');
16.034 ms (0 allocations: 0 bytes)
But I think such operation could be done during the broadcasted chain, just add a muti-dispatch like:
const AbstractScalar = Union{Number,AbstractArray{<:Number,0}}
broadcasted(::S, f, args::Vararg{AbstractScalar}) where {S<:BroadcastStyle}=
combine_eltypes(f, args) <: Number ? f(map(first,args)...) : Broadcasted{S}(f, args)
and
@btime @. $c = sin(exp(2pi)*$a*$b');
16.306 ms (0 allocations: 0 bytes)
Since a * b * c will be transformed to *(a,b,c), the broadcasteded call for these expandable funtion should be expanded at once, i.e.
for op in (:+, :*, :&, :|, :xor, :min, :max, :kron)
@eval begin
@inline broadcasted(::typeof($op),x,y) = begin
x′ = broadcastable(x)
y′ = broadcastable(y)
broadcasted(combine_styles(x′,y′), $op, x′, y′)
end
broadcasted(::typeof($op),x,y,args...) = begin
temp = broadcasted($op,x,y)
broadcasted($op,temp,args...)
end
end
end
