@debug allocate even when not in DEBUG mode

General Usage Performance
7

Note that you can also just write your own @debug-like macro.

Parse-time version

When should_print_pt is set to false, println will not be put into the Julia code.

const should_print_pt = false

macro debug_pt(ex)
    should_print_pt ? esc(:(println($ex))) : nothing
end

function foo_debug_pt()
    @debug_pt "Hello"
    return 0
end

function loop_foo_debug_pt()
    for _ in 1:1000
        foo_debug_pt()
    end
end

julia> @code_lowered foo_debug_pt()
CodeInfo(
1 ─     return 0
)

julia> @btime loop_foo_debug_pt()  # (No idea why we don't get 1.2 ns like in the loop_foo case on my machine)
  16.316 ns (0 allocations: 0 bytes)

julia> @code_llvm loop_foo_debug_pt()
; Function Signature: loop_foo_debug_pt()
;  @ REPL[4]:1 within `loop_foo_debug_pt`
; Function Attrs: uwtable
define void @julia_loop_foo_debug_pt_7305() #0 {
top:
;  @ REPL[4]:4 within `loop_foo_debug_pt`
  ret void
}

The downside is that this is not flexible at all: to set should_print_pt to true you have to reload the code.

julia> const should_print_pt = true
WARNING: redefinition of constant Main.should_print_pt. This may fail, cause incorrect answers, or produce other errors.
true

julia> foo_debug_pt()  # Does not print
0

julia> macro debug_pt(ex)
           should_print_pt ? esc(:(println($ex))) : nothing
       end;

julia> function foo_debug_pt()
           @debug_pt "Hello"
           return 0
       end;

julia> foo_debug_pt()
Hello
0
Compile-time version

When should_print_ct is the false function, println will be put into the Julia code, but gets compiled away.

should_print_ct() = false

macro debug_ct(ex)
    esc(:((should_print_ct() && println($ex)); nothing))
end

function foo_debug_ct()
    @debug_ct "Hello"
    return 0
end

function loop_foo_debug_ct()
    for _ in 1:1000
        foo_debug_ct()
    end
end

julia> @code_lowered foo_debug_ct()  # Still has a println
CodeInfo(
1 ─ %1 = Main.should_print_ct()
└──      goto #3 if not %1
2 ─      Main.println("Hello")
└──      goto #3
3 ┄      Main.nothing
└──      return 0
)

julia> @btime loop_foo_debug_ct() 
  1.200 ns (0 allocations: 0 bytes)

julia> @code_llvm loop_foo_debug_ct()  # No more println
; Function Signature: loop_foo_debug_ct()
;  @ REPL[4]:1 within `loop_foo_debug_ct`
; Function Attrs: uwtable
define void @julia_loop_foo_debug_ct_7774() #0 {
top:
;  @ REPL[4]:4 within `loop_foo_debug_ct`
  ret void
}

Changing should_print_ct will automatically trigger recompilation of foo_debug_pt, making this more flexible, at the cost of recompilations.

julia> foo_debug_ct()  # We still have should_print_ct() = false
0

julia> @time begin should_print_ct() = true; foo_debug_ct() end
Hello
  0.003950 seconds (751 allocations: 36.633 KiB, 93.69% compilation time: 100% of which was recompilation)
0
Runtime version

The println will always remain in the compiled code, but will not be executed when !should_print_rt[]. This will make this version a bit slower.

const should_print_rt = Ref(false)

macro debug_rt(ex)
    esc(:((should_print_rt[] && println($ex)); nothing))
end

function foo_debug_rt()
    @debug_rt "Hello"
    return 0
end

function loop_foo_debug_rt()
    for _ in 1:1000
        foo_debug_rt()
    end
end

julia> @code_llvm foo_debug_rt()
; Function Signature: foo_debug_rt()
;  @ REPL[3]:1 within `foo_debug_rt`
; Function Attrs: uwtable
define i64 @julia_foo_debug_rt_7422() #0 {
top:
;  @ REPL[3]:2 within `foo_debug_rt`
; ┌ @ refvalue.jl:59 within `getindex`
; │┌ @ Base.jl:49 within `getproperty`
    %0 = load i8, ptr @"jl_global#7426.jit", align 16
    %1 = and i8 %0, 1
    %.x.not = icmp eq i8 %1, 0
; └└
  br i1 %.x.not, label %L5, label %L4

L4:                                               ; preds = %top
  call void @j_println_7428(ptr nonnull @"jl_global#7429.jit")
  br label %L5

L5:                                               ; preds = %L4, %top
;  @ REPL[3]:3 within `foo_debug_rt`
  ret i64 0
}

julia> @btime loop_foo_debug_rt()
  255.251 ns (0 allocations: 0 bytes)

So this is still much faster than the full @debug, mainly because we’re using a RefValue{Bool} instead of the ENV dictionary.

Altering should_print_rt[] does not have any cost, making this the most flexible.

julia> foo_debug_rt()  # should_print_rt[] == false
0

julia> @time begin should_print_rt[] = true; foo_debug_rt() end
Hello
  0.000162 seconds (5 allocations: 80 bytes)
0