add "project" mode to code coverage and allocation tracking

IanButterworth · IanButterworth · commit 32293c42ef3f · 2022-01-08T01:24:03.000-05:00
diff --git a/base/reflection.jl b/base/reflection.jl
@@ -245,6 +245,50 @@ Foo
 parentmodule(t::DataType) = t.name.module
 parentmodule(t::UnionAll) = parentmodule(unwrap_unionall(t))
 
+"""
+    setprojectmodule(m::Module)
+
+Set a given module and its recursive submodules as "project modules",
+marking them for inclusion when code coverage and allocation tracking is
+set to `project` mode.
+
+For instance, when starting julia with code coverage, and similarly for allocation
+tracking (`--track-allocation`):
+```
+\$ julia --code-coverage=project -e `using Foo; Base.setprojectmodule(Foo); Foo.bar()`
+```
+
+!!! compat "Julia 1.8"
+     This function requires at least Julia 1.8.
+"""
+function setprojectmodule(m::Module)
+    function _setchildmods(m)
+        for name in names(m; all = true, imported = false)
+            if name isa Module
+                setprojectmod(name, false)
+                _setchildmods(name)
+            end
+        end
+        nothing
+    end
+    setprojectmodule(m, true)
+    _setchildmods(m)
+    return
+end
+setprojectmodule(m::Module, isprimary::Bool) = ccall(:jl_set_isprojmod, Cvoid, (Any, Bool), m, isprimary)
+
+"""
+    isprojectmodule(m::Module)
+
+Check whether a given module is marked as a "project module",
+which marks it for inclusion when code coverage and allocation tracking is
+set to `project` mode.
+
+!!! compat "Julia 1.8"
+     This function requires at least Julia 1.8.
+"""
+isprojectmodule(m::Module) = ccall(:jl_isprojmod, Cint, (Any,), m) == 1
+
 """
     isconst(m::Module, s::Symbol) -> Bool
 
diff --git a/base/util.jl b/base/util.jl
@@ -192,16 +192,20 @@ function julia_cmd(julia=joinpath(Sys.BINDIR::String, julia_exename()))
         coverage_file = (opts.output_code_coverage != C_NULL) ?  unsafe_string(opts.output_code_coverage) : ""
         if isempty(coverage_file) || occursin("%p", coverage_file)
             if opts.code_coverage == 1
-                push!(addflags, "--code-coverage=user")
+                push!(addflags, "--code-coverage=project")
             elseif opts.code_coverage == 2
+                push!(addflags, "--code-coverage=user")
+            elseif opts.code_coverage == 3
                 push!(addflags, "--code-coverage=all")
             end
             isempty(coverage_file) || push!(addflags, "--code-coverage=$coverage_file")
         end
     end
     if opts.malloc_log == 1
-        push!(addflags, "--track-allocation=user")
+        push!(addflags, "--track-allocation=project")
     elseif opts.malloc_log == 2
+        push!(addflags, "--track-allocation=user")
+    elseif opts.malloc_log == 3
         push!(addflags, "--track-allocation=all")
     end
     if opts.color == 1
diff --git a/doc/man/julia.1 b/doc/man/julia.1
@@ -195,11 +195,11 @@ Generate LLVM bitcode (.bc)
 Generate an incremental output file (rather than complete)
 
 .TP
---code-coverage={none|user|all}, --code-coverage
+--code-coverage={none|project|user|all}, --code-coverage
 Count executions of source lines (omitting setting is equivalent to 'user')
 
 .TP
---track-allocation={none|user|all}, --track-allocation
+--track-allocation={none|project|user|all}, --track-allocation
 Count bytes allocated by each source line
 
 .SH FILES
diff --git a/doc/src/manual/command-line-options.md b/doc/src/manual/command-line-options.md
@@ -75,41 +75,41 @@ julia [switches] -- [programfile] [args...]
 The following is a complete list of command-line switches available when launching julia, e.g.
 
 
-|Switch                                 |Description|
-|:---                                   |:---|
-|`-v`, `--version`                      |Display version information|
-|`-h`, `--help`                         |Print command-line options (this message).|
-|`--project[={<dir>\|@.}]`              |Set `<dir>` as the home project/environment. The default `@.` option will search through parent directories until a `Project.toml` or `JuliaProject.toml` file is found.|
-|`-J`, `--sysimage <file>`              |Start up with the given system image file|
-|`-H`, `--home <dir>`                   |Set location of `julia` executable|
-|`--startup-file={yes\|no}`             |Load `~/.julia/config/startup.jl`|
-|`--handle-signals={yes\|no}`           |Enable or disable Julia's default signal handlers|
-|`--sysimage-native-code={yes\|no}`     |Use native code from system image if available|
-|`--compiled-modules={yes\|no}`         |Enable or disable incremental precompilation of modules|
-|`-e`, `--eval <expr>`                  |Evaluate `<expr>`|
-|`-E`, `--print <expr>`                 |Evaluate `<expr>` and display the result|
-|`-L`, `--load <file>`                  |Load `<file>` immediately on all processors|
-|`-t`, `--threads {N\|auto`}            |Enable N threads; `auto` currently sets N to the number of local CPU threads but this might change in the future|
-|`-p`, `--procs {N\|auto`}              |Integer value N launches N additional local worker processes; `auto` launches as many workers as the number of local CPU threads (logical cores)|
-|`--machine-file <file>`                |Run processes on hosts listed in `<file>`|
-|`-i`                                   |Interactive mode; REPL runs and `isinteractive()` is true|
-|`-q`, `--quiet`                        |Quiet startup: no banner, suppress REPL warnings|
-|`--banner={yes\|no\|auto}`             |Enable or disable startup banner|
-|`--color={yes\|no\|auto}`              |Enable or disable color text|
-|`--history-file={yes\|no}`             |Load or save history|
-|`--depwarn={yes\|no\|error}`           |Enable or disable syntax and method deprecation warnings (`error` turns warnings into errors)|
-|`--warn-overwrite={yes\|no}`           |Enable or disable method overwrite warnings|
-|`-C`, `--cpu-target <target>`          |Limit usage of CPU features up to `<target>`; set to `help` to see the available options|
-|`-O`, `--optimize={0,1,2,3}`           |Set the optimization level (default level is 2 if unspecified or 3 if used without a level)|
-|`--min-optlevel={0,1,2,3}`             |Set the lower bound on per-module optimization (default is 0)|
-|`-g`, `-g <level>`                     |Enable or set the level of debug info generation (default level is 1 if unspecified or 2 if used without a level)|
-|`--inline={yes\|no}`                   |Control whether inlining is permitted, including overriding `@inline` declarations|
-|`--check-bounds={yes\|no\|auto}`       |Emit bounds checks always, never, or respect `@inbounds` declarations|
-|`--math-mode={ieee,fast}`              |Disallow or enable unsafe floating point optimizations (overrides `@fastmath` declaration)|
-|`--code-coverage={none\|user\|all}`    |Count executions of source lines|
-|`--code-coverage`                      |equivalent to `--code-coverage=user`|
-|`--track-allocation={none\|user\|all}` |Count bytes allocated by each source line|
-|`--track-allocation`                   |equivalent to `--track-allocation=user`|
+|Switch                                             |Description|
+|:---                                               |:---|
+|`-v`, `--version`                                  |Display version information|
+|`-h`, `--help`                                     |Print command-line options (this message).|
+|`--project[={<dir>\|@.}]`                          |Set `<dir>` as the home project/environment. The default `@.` option will search through parent directories until a `Project.toml` or `JuliaProject.toml` file is found.|
+|`-J`, `--sysimage <file>`                          |Start up with the given system image file|
+|`-H`, `--home <dir>`                               |Set location of `julia` executable|
+|`--startup-file={yes\|no}`                         |Load `~/.julia/config/startup.jl`|
+|`--handle-signals={yes\|no}`                       |Enable or disable Julia's default signal handlers|
+|`--sysimage-native-code={yes\|no}`                 |Use native code from system image if available|
+|`--compiled-modules={yes\|no}`                     |Enable or disable incremental precompilation of modules|
+|`-e`, `--eval <expr>`                              |Evaluate `<expr>`|
+|`-E`, `--print <expr>`                             |Evaluate `<expr>` and display the result|
+|`-L`, `--load <file>`                              |Load `<file>` immediately on all processors|
+|`-t`, `--threads {N\|auto`}                        |Enable N threads; `auto` currently sets N to the number of local CPU threads but this might change in the future|
+|`-p`, `--procs {N\|auto`}                          |Integer value N launches N additional local worker processes; `auto` launches as many workers as the number of local CPU threads (logical cores)|
+|`--machine-file <file>`                            |Run processes on hosts listed in `<file>`|
+|`-i`                                               |Interactive mode; REPL runs and `isinteractive()` is true|
+|`-q`, `--quiet`                                    |Quiet startup: no banner, suppress REPL warnings|
+|`--banner={yes\|no\|auto}`                         |Enable or disable startup banner|
+|`--color={yes\|no\|auto}`                          |Enable or disable color text|
+|`--history-file={yes\|no}`                         |Load or save history|
+|`--depwarn={yes\|no\|error}`                       |Enable or disable syntax and method deprecation warnings (`error` turns warnings into errors)|
+|`--warn-overwrite={yes\|no}`                       |Enable or disable method overwrite warnings|
+|`-C`, `--cpu-target <target>`                      |Limit usage of CPU features up to `<target>`; set to `help` to see the available options|
+|`-O`, `--optimize={0,1,2,3}`                       |Set the optimization level (default level is 2 if unspecified or 3 if used without a level)|
+|`--min-optlevel={0,1,2,3}`                         |Set the lower bound on per-module optimization (default is 0)|
+|`-g`, `-g <level>`                                 |Enable or set the level of debug info generation (default level is 1 if unspecified or 2 if used without a level)|
+|`--inline={yes\|no}`                               |Control whether inlining is permitted, including overriding `@inline` declarations|
+|`--check-bounds={yes\|no\|auto}`                   |Emit bounds checks always, never, or respect `@inbounds` declarations|
+|`--math-mode={ieee,fast}`                          |Disallow or enable unsafe floating point optimizations (overrides `@fastmath` declaration)|
+|`--code-coverage={none\|project\|user\|all}`       |Count executions of source lines|
+|`--code-coverage`                                  |equivalent to `--code-coverage=user`|
+|`--track-allocation={none\|project\|user\|all}`    |Count bytes allocated by each source line|
+|`--track-allocation`                               |equivalent to `--track-allocation=user`|
 
 !!! compat "Julia 1.1"
     In Julia 1.0, the default `--project=@.` option did not search up from the root
diff --git a/src/codegen.cpp b/src/codegen.cpp
@@ -6698,14 +6698,17 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
                 !jl_is_submodule(mod, jl_core_module));
     };
     bool mod_is_user_mod = in_user_mod(ctx.module);
+    bool mod_is_project_mod = ctx.module->isprojmod;
     struct DebugLineTable {
         DebugLoc loc;
         StringRef file;
         ssize_t line;
         bool is_user_code;
+        bool is_project_code;
         unsigned inlined_at;
         bool operator ==(const DebugLineTable &other) const {
-            return other.loc == loc && other.file == file && other.line == line && other.is_user_code == is_user_code && other.inlined_at == inlined_at;
+            return other.loc == loc && other.file == file && other.line == line && other.is_user_code == is_user_code &&
+                        other.is_project_code == is_project_code && other.inlined_at == inlined_at;
         }
     };
     std::vector<DebugLineTable> linetable;
@@ -6718,6 +6721,7 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
         topinfo.file = ctx.file;
         topinfo.line = toplineno;
         topinfo.is_user_code = mod_is_user_mod;
+        topinfo.is_project_code = mod_is_project_mod;
         topinfo.inlined_at = 0;
         topinfo.loc = topdebugloc;
         for (size_t i = 0; i < nlocs; i++) {
@@ -6731,10 +6735,13 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
             info.line = jl_unbox_long(jl_fieldref(locinfo, 3));
             info.inlined_at = jl_unbox_long(jl_fieldref(locinfo, 4));
             assert(info.inlined_at <= i);
-            if (module == ctx.module)
+            if (module == ctx.module) {
                 info.is_user_code = mod_is_user_mod;
-            else
+                info.is_project_code = mod_is_project_mod;
+            } else {
                 info.is_user_code = in_user_mod(module);
+                info.is_project_code = module->isprojmod;
+            }
             info.file = jl_symbol_name(filesym);
             if (info.file.empty())
                 info.file = "<missing>";
@@ -6851,13 +6858,15 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
         cursor = -1;
     };
 
-    auto do_coverage = [&] (bool in_user_code) {
+    auto do_coverage = [&] (bool in_user_code, bool in_project_code) {
         return (coverage_mode == JL_LOG_ALL ||
-                (coverage_mode == JL_LOG_USER && in_user_code));
+                (coverage_mode == JL_LOG_USER && in_user_code) ||
+                (coverage_mode == JL_LOG_PROJECT && in_project_code));
     };
-    auto do_malloc_log = [&] (bool in_user_code) {
+    auto do_malloc_log = [&] (bool in_user_code, bool in_project_code) {
         return (malloc_log_mode == JL_LOG_ALL ||
-                (malloc_log_mode == JL_LOG_USER && in_user_code));
+                (malloc_log_mode == JL_LOG_USER && in_user_code) ||
+                (malloc_log_mode == JL_LOG_PROJECT && in_project_code));
     };
     std::vector<unsigned> current_lineinfo, new_lineinfo;
     auto coverageVisitStmt = [&] (size_t dbg) {
@@ -6876,15 +6885,15 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
             if (newdbg != current_lineinfo[dbg]) {
                 current_lineinfo[dbg] = newdbg;
                 const auto &info = linetable.at(newdbg);
-                if (do_coverage(info.is_user_code))
+                if (do_coverage(info.is_user_code, info.is_project_code))
                     coverageVisitLine(ctx, info.file, info.line);
             }
         }
         new_lineinfo.clear();
     };
     auto mallocVisitStmt = [&] (unsigned dbg, Value *sync) {
-        if (!do_malloc_log(mod_is_user_mod) || dbg == 0) {
-            if (do_malloc_log(true) && sync)
+        if (!do_malloc_log(mod_is_user_mod, mod_is_project_mod) || dbg == 0) {
+            if (do_malloc_log(true, true) && sync)
                 ctx.builder.CreateCall(prepare_call(sync_gc_total_bytes_func), {sync});
             return;
         }
@@ -6895,7 +6904,7 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
     if (coverage_mode != JL_LOG_NONE) {
         // record all lines that could be covered
         for (const auto &info : linetable)
-            if (do_coverage(info.is_user_code))
+            if (do_coverage(info.is_user_code, info.is_project_code))
                 jl_coverage_alloc_line(info.file, info.line);
     }
 
@@ -6950,15 +6959,15 @@ static std::pair<std::unique_ptr<Module>, jl_llvm_functions_t>
     }
 
     Value *sync_bytes = nullptr;
-    if (do_malloc_log(true))
+    if (do_malloc_log(true,true))
         sync_bytes = ctx.builder.CreateCall(prepare_call(diff_gc_total_bytes_func), {});
     { // coverage for the function definition line number
         const auto &topinfo = linetable.at(0);
         if (linetable.size() > 1) {
             if (topinfo == linetable.at(1))
                 current_lineinfo.push_back(1);
         }
-        if (do_coverage(topinfo.is_user_code))
+        if (do_coverage(topinfo.is_user_code, topinfo.is_project_code))
             coverageVisitLine(ctx, topinfo.file, topinfo.line);
     }
 
diff --git a/src/dump.c b/src/dump.c
@@ -363,6 +363,7 @@ static void jl_serialize_module(jl_serializer_state *s, jl_module_t *m)
         jl_serialize_value(s, (jl_value_t*)m->usings.items[i]);
     }
     write_uint8(s->s, m->istopmod);
+    write_uint8(s->s, m->isprojmod);
     write_uint64(s->s, m->uuid.hi);
     write_uint64(s->s, m->uuid.lo);
     write_uint64(s->s, m->build_id);
@@ -1675,6 +1676,7 @@ static jl_value_t *jl_deserialize_value_module(jl_serializer_state *s) JL_GC_DIS
         i++;
     }
     m->istopmod = read_uint8(s->s);
+    m->isprojmod = read_uint8(s->s);
     m->uuid.hi = read_uint64(s->s);
     m->uuid.lo = read_uint64(s->s);
     m->build_id = read_uint64(s->s);
diff --git a/src/jl_exported_data.inc b/src/jl_exported_data.inc
@@ -84,6 +84,7 @@
     XX(jl_pinode_type) \
     XX(jl_pointer_type) \
     XX(jl_pointer_typename) \
+    XX(jl_project_module) \
     XX(jl_quotenode_type) \
     XX(jl_readonlymemory_exception) \
     XX(jl_ref_type) \
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
@@ -412,6 +412,7 @@
     XX(jl_set_const) \
     XX(jl_set_errno) \
     XX(jl_set_global) \
+    XX(jl_set_isprojmod) \
     XX(jl_set_istopmod) \
     XX(jl_set_module_compile) \
     XX(jl_set_module_infer) \
diff --git a/src/jloptions.c b/src/jloptions.c
@@ -145,12 +145,12 @@ static const char opts[]  =
     " --math-mode={ieee,fast}   Disallow or enable unsafe floating point optimizations (overrides @fastmath declaration)\n\n"
 
     // instrumentation options
-    " --code-coverage={none|user|all}, --code-coverage\n"
+    " --code-coverage={none|project|user|all}, --code-coverage\n"
     "                           Count executions of source lines (omitting setting is equivalent to \"user\")\n"
     " --code-coverage=tracefile.info\n"
     "                           Append coverage information to the LCOV tracefile (filename supports format tokens).\n"
 // TODO: These TOKENS are defined in `runtime_ccall.cpp`. A more verbose `--help` should include that list here.
-    " --track-allocation={none|user|all}, --track-allocation\n"
+    " --track-allocation={none|project|user|all}, --track-allocation\n"
     "                           Count bytes allocated by each source line (omitting setting is equivalent to \"user\")\n"
     " --bug-report=KIND         Launch a bug report session. It can be used to start a REPL, run a script, or evaluate\n"
     "                           expressions. It first tries to use BugReporting.jl installed in current environment and\n"
@@ -499,7 +499,9 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
         case opt_code_coverage:
             if (optarg != NULL) {
                 size_t endof = strlen(optarg);
-                if (!strcmp(optarg, "user"))
+                if (!strcmp(optarg,"project"))
+                    codecov = JL_LOG_PROJECT;
+                else if (!strcmp(optarg, "user"))
                     codecov = JL_LOG_USER;
                 else if (!strcmp(optarg, "all"))
                     codecov = JL_LOG_ALL;
@@ -520,7 +522,9 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
             break;
         case opt_track_allocation:
             if (optarg != NULL) {
-                if (!strcmp(optarg,"user"))
+                if (!strcmp(optarg,"project"))
+                    malloclog = JL_LOG_PROJECT;
+                else if (!strcmp(optarg,"user"))
                     malloclog = JL_LOG_USER;
                 else if (!strcmp(optarg,"all"))
                     malloclog = JL_LOG_ALL;
diff --git a/src/julia.h b/src/julia.h
diff --git a/src/module.c b/src/module.c
diff --git a/src/staticdata.c b/src/staticdata.c
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
