@profile

@profile <expression> runs your expression while taking periodic backtraces. These are appended to an internal buffer of backtraces.

clear()

Clear any existing backtraces from the internal buffer.

print([io::IO = stdout,] [data::Vector = fetch()], [lidict::Union{LineInfoDict, LineInfoFlatDict} = getdict(data)]; kwargs...)

Prints profiling results toio (by default,stdout). If you do not supply adata vector, the internal buffer of accumulated backtraces will be used.

The keyword arguments can be any combination of:

• format – Determines whether backtraces are printed with (default,:tree) or without (:flat) indentation indicating tree structure.

• C – Iftrue, backtraces from C and Fortran code are shown (normally they are excluded).

• combine – Iftrue (default), instruction pointers are merged that correspond to the same line of code.

• maxdepth – Limits the depth higher thanmaxdepth in the:tree format.

• sortedby – Controls the order in:flat format.:filefuncline (default) sorts by the source line,:count sorts in order of number of collected samples, and:overhead sorts by the number of samples incurred by each function by itself.

• groupby – Controls grouping over tasks and threads, or no grouping. Options are:none (default),:thread,:task,[:thread, :task], or[:task, :thread] where the last two provide nested grouping.

• noisefloor – Limits frames that exceed the heuristic noise floor of the sample (only applies to format:tree). A suggested value to try for this is 2.0 (the default is 0). This parameter hides samples for whichn <= noisefloor * √N, wheren is the number of samples on this line, andN is the number of samples for the callee.

• mincount – Limits the printout to only those lines with at leastmincount occurrences.

• recur – Controls the recursion handling in:tree format.:off (default) prints the tree as normal.:flat instead compresses any recursion (by ip), showing the approximate effect of converting any self-recursion into an iterator.:flatc does the same but also includes collapsing of C frames (may do odd things aroundjl_apply).

• threads::Union{Int,AbstractVector{Int}} – Specify which threads to include snapshots from in the report. Note that this does not control which threads samples are collected on (which may also have been collected on another machine).

• tasks::Union{Int,AbstractVector{Int}} – Specify which tasks to include snapshots from in the report. Note that this does not control which tasks samples are collected within.

print([io::IO = stdout,] data::Vector, lidict::LineInfoDict; kwargs...)

Prints profiling results toio. This variant is used to examine results exported by a previous call toretrieve. Supply the vectordata of backtraces and a dictionarylidict of line information.

SeeProfile.print([io], data) for an explanation of the valid keyword arguments.

init(; n::Integer, delay::Real)

Configure thedelay between backtraces (measured in seconds), and the numbern of instruction pointers that may be stored per thread. Each instruction pointer corresponds to a single line of code; backtraces generally consist of a long list of instruction pointers. Note that 6 spaces for instruction pointers per backtrace are used to store metadata and two NULL end markers. Current settings can be obtained by calling this function with no arguments, and each can be set independently using keywords or in the order(n, delay).

fetch(;include_meta = true) -> data

Return a copy of the buffer of profile backtraces. Note that the values indata have meaning only on this machine in the current session, because it depends on the exact memory addresses used in JIT-compiling. This function is primarily for internal use;retrieve may be a better choice for most users. By default metadata such as threadid and taskid is included. Setinclude_meta tofalse to strip metadata.

retrieve(; kwargs...) -> data, lidict

"Exports" profiling results in a portable format, returning the set of all backtraces (data) and a dictionary that maps the (session-specific) instruction pointers indata toLineInfo values that store the file name, function name, and line number. This function allows you to save profiling results for future analysis.

callers(funcname, [data, lidict], [filename=<filename>], [linerange=<start:stop>]) -> Vector{Tuple{count, lineinfo}}

Given a previous profiling run, determine who called a particular function. Supplying the filename (and optionally, range of line numbers over which the function is defined) allows you to disambiguate an overloaded method. The returned value is a vector containing a count of the number of calls and line information about the caller. One can optionally supply backtracedata obtained fromretrieve; otherwise, the current internal profile buffer is used.

clear_malloc_data()

Clears any stored memory allocation data when running julia with--track-allocation. Execute the command(s) you want to test (to force JIT-compilation), then callclear_malloc_data. Then execute your command(s) again, quit Julia, and examine the resulting*.mem files.

get_peek_duration()

Get the duration in seconds of the profile "peek" that is triggered viaSIGINFO orSIGUSR1, depending on platform.

set_peek_duration(t::Float64)

Set the duration in seconds of the profile "peek" that is triggered viaSIGINFO orSIGUSR1, depending on platform.

Profile.Allocs.@profile [sample_rate=0.1] expr

Profile allocations that happen duringexpr, returning both the result and and AllocResults struct.

A sample rate of 1.0 will record everything; 0.0 will record nothing.

julia> Profile.Allocs.@profile sample_rate=0.01 peakflops()1.03733270279065e11julia> results = Profile.Allocs.fetch()julia> last(sort(results.allocs, by=x->x.size))Profile.Allocs.Alloc(Vector{Any}, Base.StackTraces.StackFrame[_new_array_ at array.c:127, ...], 5576)

See the profiling tutorial in the Julia documentation for more information.

Profile.Allocs.clear()

Clear all previously profiled allocation information from memory.

Profile.Allocs.print([io::IO = stdout,] [data::AllocResults = fetch()]; kwargs...)

Prints profiling results toio (by default,stdout). If you do not supply adata vector, the internal buffer of accumulated backtraces will be used.

SeeProfile.print for an explanation of the valid keyword arguments.

Profile.Allocs.fetch()

Retrieve the recorded allocations, and decode them into Julia objects which can be analyzed.

Profile.Allocs.start(sample_rate::Real)

Begin recording allocations with the given sample rate A sample rate of 1.0 will record everything; 0.0 will record nothing.

Profile.Allocs.stop()

Stop recording allocations.

Profile.take_heap_snapshot(filepath::String, all_one::Bool=false, streaming=false)Profile.take_heap_snapshot(all_one::Bool=false; dir::String, streaming=false)

Write a snapshot of the heap, in the JSON format expected by the Chrome Devtools Heap Snapshot viewer (.heapsnapshot extension) to a file ($pid_$timestamp.heapsnapshot) in the current directory by default (or tempdir if the current directory is unwritable), or indir if given, or the given full file path, or IO stream.

Ifall_one is true, then report the size of every object as one so they can be easily counted. Otherwise, report the actual size.

Ifstreaming is true, we will stream the snapshot data out into four files, using filepath as the prefix, to avoid having to hold the entire snapshot in memory. This option should be used for any setting where your memory is constrained. These files can then be reassembled by calling Profile.HeapSnapshot.assemble_snapshot(), which can be done offline.

NOTE: We strongly recommend setting streaming=true for performance reasons. Reconstructing the snapshot from the parts requires holding the entire snapshot in memory, so if the snapshot is large, you can run out of memory while processing it. Streaming allows you to reconstruct the snapshot offline, after your workload is done running. If you do attempt to collect a snapshot with streaming=false (the default, for backwards-compatibility) and your process is killed, note that this will always save the parts in the same directory as your provided filepath, so you can still reconstruct the snapshot after the fact, viaassemble_snapshot().