module __init__() is called multiple times

[orenbenmeir]

In the documentation it is the init() function will be called only one time in the lifecycle of a module. I've cases were it is being called multiple times.

# a.jl
module a
function __init__()
	println("$(@__MODULE__)::__init")
end
end

# b.jl
module b
function __init__()
	println("$(@__MODULE__)::__init")
end
end

# c.jl
module c
import a
import b
end

# d.jl
module d
import c
import b
end


julia> using d
[ Info: Precompiling d [top-level]
a::__init
b::__init
b::__init
a::__init
b::__init
a::__init

This will happen only the first time when the module is not precompiled. Consecutive calls will call __init() only once for each module.
I've a case were the pre-compilation is broken due to dependencies with old packages and it is causing the multiple invocations cause other problems.
I've tested it both with Julia 1.0.3 and with version 1.1

[yuyichao]

This is as expected. The module's init is called once per load of module including during precompilation, as documented (edit: read the doc wrong, the correct quote of the relavant doc below):

It will be called after the module is loaded into a process, including if it is being loaded into an incremental compile (--output-incremental=yes), but not if it is being loaded into a full-compilation process.

So when you do using d, it will do

original process (0): load d
    process 1: precompiling d
    process 1: load c
        process 2: precompiling c
        process 2: load a
            process 3: precompiling a (and finish)
        process 2: done load a, print a::init
        process 2: load b
            process 4: precompiling b (and finish)
        process 2: done load b, print b::init
        process 2: finish compiling c
    process 1: loading c, which loads a and b and print b::init and a::init (not actually sure when this order was reversed.... but that shouldn't matter)
    process 1: finish compiling d
process 0: load d, which loads a and b and print b::init and a::init

[JeffBezanson]

Yichao is correct; the invocations are happening in separate processes. Have you seen a case where the same __init__ is called twice in the same process?

[yuyichao]

(I added a $(getpid()) to the code above and confirmed that they are happening in each process once)

[yuyichao]

I quoted the wrong doc above and is now fixed. Since this is clearly documented and the behavior is expected I don't think there's anything else to fix here.

I'm not sure why your code break. If you expect the __init__ to be called once EVER, that's just not possible. If your code break for other reason, you should probably post the original problem in a different issue.

[orenbenmeir]

I was not aware to the pre-compilation is happening on other process. Is there a way to know that the init is called as part of precompile and not as part of the main Julia process?

[yuyichao]

Why do you care about that?

[orenbenmeir]

Initialization may be quite heavy and I will need to take extra care if they can happen multiple times due to single invocation of Julia. I would like to spare that and initialize only in the main process which where the module is going to be actually in use.

[mind6]

It would be nice to have a verbose print out option of module loading and initialization so people aren't puzzled by this.