From 70901bcf57876e0f62e7d300e13c3f8769a9ad98 Mon Sep 17 00:00:00 2001 From: Charles Kawczynski Date: Wed, 1 May 2024 09:35:37 -0400 Subject: [PATCH] Improve names and docs --- README.md | 11 +-- src/MultiBroadcastFusion.jl | 4 +- ...ed_pairs_flexible.jl => fused_assemble.jl} | 76 +++++++++++----- .../{fused_pairs.jl => fused_direct.jl} | 46 +++++++--- src/collection/macros.jl | 10 +-- src/execution/fused_kernels.jl | 4 +- .../expr_code_lowered_single_expression.jl | 2 +- test/collection/expr_errors_and_edge_cases.jl | 20 ++--- test/collection/expr_fused_assemble.jl | 88 +++++++++++++++++++ ...pr_fused_pairs.jl => expr_fused_direct.jl} | 30 +++---- test/collection/expr_materialize_args.jl | 2 +- test/collection/runtests.jl | 3 +- .../execution/bm_fused_reads_vs_hard_coded.jl | 2 +- test/execution/bm_fused_shared_reads.jl | 2 +- .../execution/bm_fused_shared_reads_writes.jl | 2 +- 15 files changed, 226 insertions(+), 76 deletions(-) rename src/collection/{fused_pairs_flexible.jl => fused_assemble.jl} (51%) rename src/collection/{fused_pairs.jl => fused_direct.jl} (67%) create mode 100644 test/collection/expr_fused_assemble.jl rename test/collection/{expr_fused_pairs.jl => expr_fused_direct.jl} (69%) diff --git a/README.md b/README.md index dbd0f12..76d0183 100644 --- a/README.md +++ b/README.md @@ -50,7 +50,7 @@ for i in eachindex(x1,x2,x3,x4,y1,y2) end ``` -With this package, we can apply `@fused` to reduce the number of reads and preserve the memory layout: +With this package, we can apply `@fused_direct` to reduce the number of reads and preserve the memory layout: ```julia import MultiBroadcastFusion as MBF @@ -62,7 +62,7 @@ y1 = rand(3,3) y2 = rand(3,3) # 4 reads, 2 writes -MBF.@fused begin +MBF.@fused_direct begin @. y1 = x1 * x2 + x3 * x4 @. y2 = x1 * x3 + x2 * x4 end @@ -76,10 +76,11 @@ Users can write custom implementations, using the `@make_type` and `@make_fused` ```julia import MultiBroadcastFusion as MBF +import MultiBroadcastFusion: fused_direct MBF.@make_type MyFusedMultiBroadcast -MBF.@make_fused MBF.fused_pairs MyFusedMultiBroadcast my_fused -# Now, `@fused` will call `Base.copyto!(::MyFusedMultiBroadcast)`. Let's define it: +MBF.@make_fused fused_direct MyFusedMultiBroadcast my_fused +# Now, `@fused_direct` will call `Base.copyto!(::MyFusedMultiBroadcast)`. Let's define it: function Base.copyto!(fmb::MyFusedMultiBroadcast) pairs = fmb.pairs destinations = map(x->x.first, pairs) @@ -117,7 +118,7 @@ end macro get_fused_multi_broadcast(expr) _pairs = gensym() quote - $_pairs = $(esc(MBF.fused_pairs(expr))) + $_pairs = $(esc(MBF.fused_direct(expr))) FusedMultiBroadcast($_pairs) end end diff --git a/src/MultiBroadcastFusion.jl b/src/MultiBroadcastFusion.jl index f73e7a8..c0dfb14 100644 --- a/src/MultiBroadcastFusion.jl +++ b/src/MultiBroadcastFusion.jl @@ -3,8 +3,8 @@ module MultiBroadcastFusion include(joinpath("collection", "utils.jl")) include(joinpath("collection", "macros.jl")) include(joinpath("collection", "code_lowered_single_expression.jl")) -include(joinpath("collection", "fused_pairs.jl")) -include(joinpath("collection", "fused_pairs_flexible.jl")) +include(joinpath("collection", "fused_direct.jl")) +include(joinpath("collection", "fused_assemble.jl")) include(joinpath("execution", "fused_kernels.jl")) diff --git a/src/collection/fused_pairs_flexible.jl b/src/collection/fused_assemble.jl similarity index 51% rename from src/collection/fused_pairs_flexible.jl rename to src/collection/fused_assemble.jl index 38a04ce..a053e85 100644 --- a/src/collection/fused_pairs_flexible.jl +++ b/src/collection/fused_assemble.jl @@ -1,47 +1,83 @@ ##### -##### Complex/flexible version +##### Fused assemble ##### # General case: do nothing (identity) -transform_flex(x, sym) = x -transform_flex(s::Symbol, sym) = s -# Expression: recursively transform_flex for Expr -function transform_flex(e::Expr, sym) +transform_assemble(x, sym) = x +transform_assemble(s::Symbol, sym) = s +# Expression: recursively transform_assemble for Expr +function transform_assemble(e::Expr, sym) if e.head == :macrocall && e.args[1] == Symbol("@__dot__") se = code_lowered_single_expression(e) margs = materialize_args(se) subexpr = :($sym = ($sym..., Pair($(margs[1]), $(margs[2])))) subexpr else - Expr(transform_flex(e.head, sym), transform_flex.(e.args, sym)...) + Expr( + transform_assemble(e.head, sym), + transform_assemble.(e.args, sym)..., + ) end end """ - fused_pairs_flexible + fused_assemble(expr::Expr) -Function that fuses broadcast expressions -that stride flow control logic. For example: +Transforms the input expressions +into a runtime assembly of a tuple +of `Pair`s, containing (firsts) +the destination of broadcast expressions +and (seconds) the broadcasted objects. +For example: ```julia import MultiBroadcastFusion as MBF -MBF.@make_type MyFusedMultiBroadcast -MBF.@make_fused fused_pairs_flexible MyFusedMultiBroadcast fused_flexible +using Test +expr_in = quote + @. y1 = x1 + x2 + x3 + x4 + @. y2 = x2 + x3 + x4 + x5 +end + +expr_out = quote + tup = () + tup = (tup..., Pair(y1, Base.broadcasted(+, x1, x2, x3, x4))) + tup = (tup..., Pair(y2, Base.broadcasted(+, x2, x3, x4, x5))) + tup +end + +@test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == + MBF.linefilter!(expr_out) +@test MBF.fused_assemble(expr_in, :tup) == expr_out ``` -To use `MultiBroadcastFusion`'s `@fused_flexible` macro: +This can be used to make a custom kernel fusion macro: ``` import MultiBroadcastFusion as MBF -x = rand(1);y = rand(1);z = rand(1); -MBF.@fused_flexible begin - @. x += y - @. z += y +import MultiBroadcastFusion: fused_assemble +MBF.@make_type MyFusedBroadcast +MBF.@make_fused fused_assemble MyFusedBroadcast my_fused + +Base.copyto!(fmb::MyFusedBroadcast) = println("You're ready to fuse!") + +x1 = rand(3,3) +y1 = rand(3,3) +y2 = rand(3,3) + +# 4 reads, 2 writes +@my_fused begin + for i in 1:3 + @. y1 = x1 + @. y2 = x1 + end end ``` + +Also see [`fused_direct`](@ref) """ -function fused_pairs_flexible(expr::Expr, sym::Symbol) - check_restrictions_flexible(expr) - e = transform_flex(expr, sym) +fused_assemble(expr::Expr) = fused_assemble(expr, gensym()) +function fused_assemble(expr::Expr, sym::Symbol) + check_restrictions_assemble(expr) + e = transform_assemble(expr, sym) @assert e.head == :block ex = Expr(:block, :($sym = ()), e.args..., sym) # Filter out LineNumberNode, as this will not be valid due to prepending `tup = ()` @@ -49,7 +85,7 @@ function fused_pairs_flexible(expr::Expr, sym::Symbol) ex end -function check_restrictions_flexible(expr::Expr) +function check_restrictions_assemble(expr::Expr) for arg in expr.args arg isa LineNumberNode && continue s_error = if arg isa QuoteNode diff --git a/src/collection/fused_pairs.jl b/src/collection/fused_direct.jl similarity index 67% rename from src/collection/fused_pairs.jl rename to src/collection/fused_direct.jl index e3ff5a6..e1449bd 100644 --- a/src/collection/fused_pairs.jl +++ b/src/collection/fused_direct.jl @@ -18,28 +18,52 @@ function transform(e::Expr) end """ - fused_pairs + fused_direct(expr::Expr) -Function that fuses broadcast expressions that -are immediately one after another. For example: +Directly transforms the input expression +into a tuple of `Pair`s, containing (firsts) +the destination of broadcast expressions and +(seconds) the broadcasted objects. +For example: ```julia import MultiBroadcastFusion as MBF -MBF.@make_type MyFusedMultiBroadcast -MBF.@make_fused fused_pairs MyFusedMultiBroadcast fused +using Test +expr_in = quote + @. y1 = x1 + x2 + x3 + x4 + @. y2 = x2 + x3 + x4 + x5 +end + +expr_out = :(tuple( + Pair(y1, Base.broadcasted(+, x1, x2, x3, x4)), + Pair(y2, Base.broadcasted(+, x2, x3, x4, x5)), +)) +@test MBF.fused_direct(expr_in) == expr_out ``` -To use `MultiBroadcastFusion`'s `@fused` macro: +This can be used to make a custom kernel fusion macro: ``` import MultiBroadcastFusion as MBF -x = rand(1);y = rand(1);z = rand(1); -MBF.@fused begin - @. x += y - @. z += y +import MultiBroadcastFusion: fused_direct +MBF.@make_type MyFusedBroadcast +MBF.@make_fused fused_direct MyFusedBroadcast my_fused + +Base.copyto!(fmb::MyFusedBroadcast) = println("You're ready to fuse!") + +x1 = rand(3,3) +y1 = rand(3,3) +y2 = rand(3,3) + +# 4 reads, 2 writes +@my_fused begin + @. y1 = x1 + @. y2 = x1 end ``` + +Also see [`fused_assemble`](@ref) """ -function fused_pairs(expr::Expr) +function fused_direct(expr::Expr) check_restrictions(expr) e = transform(expr) @assert e.head == :block diff --git a/src/collection/macros.jl b/src/collection/macros.jl index 038dd1a..c4ce9ee 100644 --- a/src/collection/macros.jl +++ b/src/collection/macros.jl @@ -14,11 +14,11 @@ macro make_type(type_name) end """ - @make_fused fusion_type type_name fused_named + @make_fused fusion_style type_name fused_named This macro - Defines a type type_name - - Defines a macro, `@fused_name`, using the fusion type `fusion_type` + - Defines a macro, `@fused_name`, using the fusion type `fusion_style` This allows users to flexibility to customize their broadcast fusion. @@ -27,7 +27,7 @@ to customize their broadcast fusion. ```julia import MultiBroadcastFusion as MBF MBF.@make_type MyFusedBroadcast -MBF.@make_fused MBF.fused_pairs MyFusedBroadcast my_fused +MBF.@make_fused MBF.fused_direct MyFusedBroadcast my_fused Base.copyto!(fmb::MyFusedBroadcast) = println("You're ready to fuse!") @@ -42,12 +42,12 @@ y2 = rand(3,3) end ``` """ -macro make_fused(fusion_type, type_name, fused_name) +macro make_fused(fusion_style, type_name, fused_name) t = esc(type_name) f = esc(fused_name) return quote macro $f(expr) - _pairs = esc($(fusion_type)(expr)) + _pairs = esc($(fusion_style)(expr)) t = $t quote Base.copyto!($t($_pairs)) diff --git a/src/execution/fused_kernels.jl b/src/execution/fused_kernels.jl index c7c90d6..7e3320e 100644 --- a/src/execution/fused_kernels.jl +++ b/src/execution/fused_kernels.jl @@ -1,6 +1,6 @@ @make_type FusedMultiBroadcast -@make_fused fused_pairs FusedMultiBroadcast fused -@make_fused fused_pairs_flexible FusedMultiBroadcast fused_flexible +@make_fused fused_direct FusedMultiBroadcast fused +@make_fused fused_assemble FusedMultiBroadcast fused_assemble struct CPU end struct GPU end diff --git a/test/collection/expr_code_lowered_single_expression.jl b/test/collection/expr_code_lowered_single_expression.jl index e94cf8e..45a6f4e 100644 --- a/test/collection/expr_code_lowered_single_expression.jl +++ b/test/collection/expr_code_lowered_single_expression.jl @@ -1,5 +1,5 @@ #= -using Revise; include(joinpath("test", "expr_code_lowered_single_expression.jl")) +using Revise; include(joinpath("test", "collection", "expr_code_lowered_single_expression.jl")) =# using Test import MultiBroadcastFusion as MBF diff --git a/test/collection/expr_errors_and_edge_cases.jl b/test/collection/expr_errors_and_edge_cases.jl index dce47f8..be31016 100644 --- a/test/collection/expr_errors_and_edge_cases.jl +++ b/test/collection/expr_errors_and_edge_cases.jl @@ -1,5 +1,5 @@ #= -using Revise; include(joinpath("test", "expr_errors_and_edge_cases.jl")) +using Revise; include(joinpath("test", "collection" "expr_errors_and_edge_cases.jl")) =# using Test import MultiBroadcastFusion as MBF @@ -21,7 +21,7 @@ import MultiBroadcastFusion as MBF end @. y1 = x1 + x2 + x3 + x4 end - @test_throws ErrorException("Loops are not allowed inside fused blocks") MBF.fused_pairs( + @test_throws ErrorException("Loops are not allowed inside fused blocks") MBF.fused_direct( expr_in, ) end @@ -47,7 +47,7 @@ struct Foo end end @test_throws ErrorException( "If-statements are not allowed inside fused blocks", - ) MBF.fused_pairs(expr_in) + ) MBF.fused_direct(expr_in) end bar() = nothing @@ -61,7 +61,7 @@ bar() = nothing end @test_throws ErrorException( "Function calls are not allowed inside fused blocks", - ) MBF.fused_pairs(expr_in) + ) MBF.fused_direct(expr_in) end @testset "Non-broadcast variable assignments" begin @@ -74,7 +74,7 @@ end end @test_throws ErrorException( "Non-broadcast assignments are not allowed inside fused blocks", - ) MBF.fused_pairs(expr_in) + ) MBF.fused_direct(expr_in) end @testset "No let-blocks" begin @@ -87,7 +87,7 @@ end end @test_throws ErrorException( "Let-blocks are not allowed inside fused blocks", - ) MBF.fused_pairs(expr_in) + ) MBF.fused_direct(expr_in) end @testset "Dangling symbols" begin @@ -99,7 +99,7 @@ end end @test_throws ErrorException( "Dangling symbols are not allowed inside fused blocks", - ) MBF.fused_pairs(expr_in) + ) MBF.fused_direct(expr_in) end @testset "quote" begin @@ -110,7 +110,7 @@ end quote end @. y1 = x1 + x2 + x3 + x4 end - @test_throws ErrorException("Quotes are not allowed inside fused blocks") MBF.fused_pairs( + @test_throws ErrorException("Quotes are not allowed inside fused blocks") MBF.fused_direct( expr_in, ) end @@ -127,10 +127,10 @@ end Pair(y1, Base.broadcasted(+, x1, x2, x3, x4)), Pair(y2, Base.broadcasted(+, x2, x3, x4, x5)), )) - @test MBF.fused_pairs(expr_in) == expr_out + @test MBF.fused_direct(expr_in) == expr_out end @testset "Empty" begin expr_in = quote end - @test MBF.fused_pairs(expr_in) == :(tuple()) + @test MBF.fused_direct(expr_in) == :(tuple()) end diff --git a/test/collection/expr_fused_assemble.jl b/test/collection/expr_fused_assemble.jl new file mode 100644 index 0000000..fc7fd8c --- /dev/null +++ b/test/collection/expr_fused_assemble.jl @@ -0,0 +1,88 @@ +#= +using Revise; include(joinpath("test", "collection", "expr_fused_assemble.jl")) +=# +using Test +import MultiBroadcastFusion as MBF + +@testset "fused_assemble - simple sequential" begin + expr_in = quote + @. y1 = x1 + x2 + x3 + x4 + @. y2 = x2 + x3 + x4 + x5 + end + + expr_out = quote + tup = () + tup = (tup..., Pair(y1, Base.broadcasted(+, x1, x2, x3, x4))) + tup = (tup..., Pair(y2, Base.broadcasted(+, x2, x3, x4, x5))) + tup + end + + @test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == + MBF.linefilter!(expr_out) + @test MBF.fused_assemble(expr_in, :tup) == expr_out +end + + +@testset "fused_assemble - loop" begin + expr_in = quote + for i in 1:10 + @. y1 = x1 + x2 + x3 + x4 + @. y2 = x2 + x3 + x4 + x5 + end + end + + expr_out = quote + tup = () + for i in 1:10 + tup = (tup..., Pair(y1, Base.broadcasted(+, x1, x2, x3, x4))) + tup = (tup..., Pair(y2, Base.broadcasted(+, x2, x3, x4, x5))) + end + tup + end + + @test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == + MBF.linefilter!(expr_out) + @test MBF.fused_assemble(expr_in, :tup) == expr_out +end + +@testset "fused_assemble - loop with @inbounds" begin + expr_in = quote + @inbounds for i in 1:10 + @. y1 = x1 + x2 + x3 + x4 + @. y2 = x2 + x3 + x4 + x5 + end + end + + expr_out = quote + tup = () + @inbounds for i in 1:10 + tup = (tup..., Pair(y1, Base.broadcasted(+, x1, x2, x3, x4))) + tup = (tup..., Pair(y2, Base.broadcasted(+, x2, x3, x4, x5))) + end + tup + end + @test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == + MBF.linefilter!(expr_out) + @test MBF.fused_assemble(expr_in, :tup) == expr_out +end + +@testset "fused_assemble - if" begin + expr_in = quote + if a && B || something(x, y, z) + @. y1 = x1 + x2 + x3 + x4 + @. y2 = x2 + x3 + x4 + x5 + end + end + + expr_out = quote + tup = () + if a && B || something(x, y, z) + tup = (tup..., Pair(y1, Base.broadcasted(+, x1, x2, x3, x4))) + tup = (tup..., Pair(y2, Base.broadcasted(+, x2, x3, x4, x5))) + end + tup + end + @test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == + MBF.linefilter!(expr_out) + @test MBF.fused_assemble(expr_in, :tup) == expr_out +end diff --git a/test/collection/expr_fused_pairs.jl b/test/collection/expr_fused_direct.jl similarity index 69% rename from test/collection/expr_fused_pairs.jl rename to test/collection/expr_fused_direct.jl index 898a946..4bf40d2 100644 --- a/test/collection/expr_fused_pairs.jl +++ b/test/collection/expr_fused_direct.jl @@ -1,10 +1,10 @@ #= -using Revise; include(joinpath("test", "expr_fused_pairs.jl")) +using Revise; include(joinpath("test", "collection", "expr_fused_direct.jl")) =# using Test import MultiBroadcastFusion as MBF -@testset "fused_pairs" begin +@testset "fused_direct" begin expr_in = quote @. y1 = x1 + x2 + x3 + x4 @. y2 = x2 + x3 + x4 + x5 @@ -14,10 +14,10 @@ import MultiBroadcastFusion as MBF Pair(y1, Base.broadcasted(+, x1, x2, x3, x4)), Pair(y2, Base.broadcasted(+, x2, x3, x4, x5)), )) - @test MBF.fused_pairs(expr_in) == expr_out + @test MBF.fused_direct(expr_in) == expr_out end -@testset "fused_pairs_flexible - simple sequential" begin +@testset "fused_assemble - simple sequential" begin expr_in = quote @. y1 = x1 + x2 + x3 + x4 @. y2 = x2 + x3 + x4 + x5 @@ -30,13 +30,13 @@ end tup end - @test MBF.linefilter!(MBF.fused_pairs_flexible(expr_in, :tup)) == + @test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == MBF.linefilter!(expr_out) - @test MBF.fused_pairs_flexible(expr_in, :tup) == expr_out + @test MBF.fused_assemble(expr_in, :tup) == expr_out end -@testset "fused_pairs_flexible - loop" begin +@testset "fused_assemble - loop" begin expr_in = quote for i in 1:10 @. y1 = x1 + x2 + x3 + x4 @@ -53,12 +53,12 @@ end tup end - @test MBF.linefilter!(MBF.fused_pairs_flexible(expr_in, :tup)) == + @test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == MBF.linefilter!(expr_out) - @test MBF.fused_pairs_flexible(expr_in, :tup) == expr_out + @test MBF.fused_assemble(expr_in, :tup) == expr_out end -@testset "fused_pairs_flexible - loop with @inbounds" begin +@testset "fused_assemble - loop with @inbounds" begin expr_in = quote @inbounds for i in 1:10 @. y1 = x1 + x2 + x3 + x4 @@ -74,12 +74,12 @@ end end tup end - @test MBF.linefilter!(MBF.fused_pairs_flexible(expr_in, :tup)) == + @test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == MBF.linefilter!(expr_out) - @test MBF.fused_pairs_flexible(expr_in, :tup) == expr_out + @test MBF.fused_assemble(expr_in, :tup) == expr_out end -@testset "fused_pairs_flexible - if" begin +@testset "fused_assemble - if" begin expr_in = quote if a && B || something(x, y, z) @. y1 = x1 + x2 + x3 + x4 @@ -95,7 +95,7 @@ end end tup end - @test MBF.linefilter!(MBF.fused_pairs_flexible(expr_in, :tup)) == + @test MBF.linefilter!(MBF.fused_assemble(expr_in, :tup)) == MBF.linefilter!(expr_out) - @test MBF.fused_pairs_flexible(expr_in, :tup) == expr_out + @test MBF.fused_assemble(expr_in, :tup) == expr_out end diff --git a/test/collection/expr_materialize_args.jl b/test/collection/expr_materialize_args.jl index a3094c9..b0ed41a 100644 --- a/test/collection/expr_materialize_args.jl +++ b/test/collection/expr_materialize_args.jl @@ -1,5 +1,5 @@ #= -using Revise; include(joinpath("test", "expr_materialize_args.jl")) +using Revise; include(joinpath("test", "collection", "expr_materialize_args.jl")) =# using Test import MultiBroadcastFusion as MBF diff --git a/test/collection/runtests.jl b/test/collection/runtests.jl index e8c1c44..14e51b7 100644 --- a/test/collection/runtests.jl +++ b/test/collection/runtests.jl @@ -7,6 +7,7 @@ using SafeTestsets #! format: off @safetestset "expr_code_lowered_single_expression" begin; @time include("expr_code_lowered_single_expression.jl"); end @safetestset "expr_materialize_args" begin; @time include("expr_materialize_args.jl"); end -@safetestset "expr_fused_pairs" begin; @time include("expr_fused_pairs.jl"); end +@safetestset "expr_fused_direct" begin; @time include("expr_fused_direct.jl"); end +@safetestset "expr_fused_assemble" begin; @time include("expr_fused_assemble.jl"); end @safetestset "expr_errors_and_edge_cases" begin; @time include("expr_errors_and_edge_cases.jl"); end #! format: on diff --git a/test/execution/bm_fused_reads_vs_hard_coded.jl b/test/execution/bm_fused_reads_vs_hard_coded.jl index 257b9f9..e215850 100644 --- a/test/execution/bm_fused_reads_vs_hard_coded.jl +++ b/test/execution/bm_fused_reads_vs_hard_coded.jl @@ -1,5 +1,5 @@ #= -using Revise; include(joinpath("test", "bm_fused_reads_vs_hard_coded.jl")) +using Revise; include(joinpath("test", "execution", "bm_fused_reads_vs_hard_coded.jl")) =# include("utils.jl") diff --git a/test/execution/bm_fused_shared_reads.jl b/test/execution/bm_fused_shared_reads.jl index 643589d..234f209 100644 --- a/test/execution/bm_fused_shared_reads.jl +++ b/test/execution/bm_fused_shared_reads.jl @@ -1,5 +1,5 @@ #= -using Revise; include(joinpath("test", "bm_fused_shared_reads.jl")) +using Revise; include(joinpath("test", "execution", "bm_fused_shared_reads.jl")) =# include("utils.jl") diff --git a/test/execution/bm_fused_shared_reads_writes.jl b/test/execution/bm_fused_shared_reads_writes.jl index f1b7c80..8b0feac 100644 --- a/test/execution/bm_fused_shared_reads_writes.jl +++ b/test/execution/bm_fused_shared_reads_writes.jl @@ -1,5 +1,5 @@ #= -using Revise; include(joinpath("test", "fused_reads_writes.jl")) +using Revise; include(joinpath("test", "execution", "fused_reads_writes.jl")) =# include("utils.jl")