/usr/local/lib64/python3.6/site-packages/torch/profiler/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/profiler/__pycache__/profiler.cpython-36.pyc (16181B)
3
EgWF @ s d dl Z d dlZd dlZd dlZd dlmZ d dlmZmZm Z m
Z
d dl m Z d dl
Z
d dljjZd dlmZmZ G dd deZd d deeeeeed d
d Zeed d
dZdee
e edddZdd Z G dd de Z dS ) N)Enum)AnyCallableIterableOptional)warn)kineto_availableProfilerActivityc @ s e Zd ZdZdZdZdZdZdS )ProfilerActionzG
Profiler actions that can be taken at the specified intervals
r N)__name__
__module__ __qualname____doc__NONEWARMUPRECORDRECORD_AND_SAVE r r C/usr/local/lib64/python3.6/site-packages/torch/profiler/profiler.pyr
s
r
)repeat
skip_first)waitwarmupactiver r returnc s` t td fdd }dkrDdkrD dkrDdkrDdksLtddkr\td |S )a
Returns a callable that can be used as profiler ``schedule`` argument. The profiler will skip
the first ``skip_first`` steps, then wait for ``wait`` steps, then do the warmup for the next ``warmup`` steps,
then do the active recording for the next ``active`` steps and then repeat the cycle starting with ``wait`` steps.
The optional number of cycles is specified with the ``repeat`` parameter, the zero value means that
the cycles will continue until the profiling is finished.
)stepr c s | dks t | k rtjS | 8 } }dkrH| | krHtjS | | }|k r^tjS | k rptjS ||d k rtjS tjS d S )Nr r )AssertionErrorr
r r r r )r Z num_stepsZmod_step)r r r r r r r schedule_fn s z schedule.
.schedule_fnr z#Invalid profiler schedule argumentsz>Profiler won't be using warmup, this can skew profiler results)intr
r r )r r r r r r r )r r r r r r schedule s r" )_r c C s t jS )zy
Default profiler behavior - immediately starts recording the events,
keeps doing it on every profiler step.
)r
r )r# r r r _default_schedule_fn8 s r$ F)dir_name worker_nameuse_gzipc s8 ddl ddlddldd fdd }|S )a
Outputs tracing files to directory of ``dir_name``, then that directory can be
directly delivered to tensorboard as logdir.
``worker_name`` should be unique for each worker in distributed scenario,
it will be set to '[hostname]_[pid]' by default.
r N)r c
s j j s@yj dd W n tk
r> td Y nX s\djj tj djt j
d }r|d }| j j j | d S )NT)exist_okzCan't create directory: z{}_{}z{}.{}.pt.trace.jsoni z.gz)
pathisdirmakedirs Exception RuntimeErrorformat gethostnamestrgetpidr! timeexport_chrome_tracejoin)prof file_name)r% ossocketr2 r' r& r r
handler_fnJ s z-tensorboard_trace_handler..handler_fn)r7 r8 r2 )r% r& r' r9 r )r% r7 r8 r2 r' r& r tensorboard_trace_handler? s
r: c C s
t jj S )a
Returns a set of supported profiler tracing activities.
Note: profiler uses CUPTI library to trace on-device CUDA kernels.
In case when CUDA is enabled but CUPTI is not available, passing
``ProfilerActivity.CUDA`` to profiler results in using the legacy CUDA
profiling code (same as in the legacy ``torch.autograd.profiler``).
This, in turn, results in including CUDA time in the profiler table output,
but not in the JSON trace.
)torchautogradZ_supported_activitiesr r r r supported_activitiesY s r= c @ s e Zd ZdZdddddddddd eee eeege f eede
f e e e e e ee d ddZ dd Z
d
d Zd d
Zdd Zdd ZedddZd0eedddZd1e eddd Zd d Zeed d d!Zeed d"d#Zd$d% Zd&d' Zd(d) Zd*d+ Z d,d- Z d.d/ Z dS )2profilea Profiler context manager.
Args:
activities (iterable): list of activity groups (CPU, CUDA) to use in profiling, supported values:
``torch.profiler.ProfilerActivity.CPU``, ``torch.profiler.ProfilerActivity.CUDA``.
Default value: ProfilerActivity.CPU and (when available) ProfilerActivity.CUDA.
schedule (callable): callable that takes step (int) as a single parameter and returns
``ProfilerAction`` value that specifies the profiler action to perform at each step.
on_trace_ready (callable): callable that is called at each step when ``schedule``
returns ``ProfilerAction.RECORD_AND_SAVE`` during the profiling.
record_shapes (bool): save information about operator's input shapes.
profile_memory (bool): track tensor memory allocation/deallocation.
with_stack (bool): record source information (file and line number) for the ops.
with_flops (bool): use formula to estimate the FLOPs (floating point operations) of specific operators
(matrix multiplication and 2D convolution).
with_modules (bool): record module hierarchy (including function names)
corresponding to the callstack of the op. e.g. If module A's forward call's
module B's forward which contains an aten::add op,
then aten::add's module hierarchy is A.B
Note that this support exist, at the moment, only for TorchScript models
and not eager mode models.
use_cuda (bool):
.. deprecated:: 1.8.1
use ``activities`` instead.
.. note::
Use :func:`~torch.profiler.schedule` to generate the callable schedule.
Non-default schedules are useful when profiling long training jobs
and allow the user to obtain multiple traces at the different iterations
of the training process.
The default schedule simply records all the events continuously for the
duration of the context manager.
.. note::
Use :func:`~torch.profiler.tensorboard_trace_handler` to generate result files for TensorBoard:
``on_trace_ready=torch.profiler.tensorboard_trace_handler(dir_name)``
After profiling, result files can be found in the specified directory. Use the command:
``tensorboard --logdir dir_name``
to see the results in TensorBoard.
For more information, see
`PyTorch Profiler TensorBoard Plugin `__
.. note::
Enabling shape and stack tracing results in additional overhead.
When record_shapes=True is specified, profiler will temporarily hold references to the tensors;
that may further prevent certain optimizations that depend on the reference count and introduce
extra tensor copies.
Examples:
.. code-block:: python
with torch.profiler.profile(
activities=[
torch.profiler.ProfilerActivity.CPU,
torch.profiler.ProfilerActivity.CUDA,
]
) as p:
code_to_profile()
print(p.key_averages().table(
sort_by="self_cuda_time_total", row_limit=-1))
Using the profiler's ``schedule``, ``on_trace_ready`` and ``step`` functions:
.. code-block:: python
# Non-default profiler schedule allows user to turn profiler on and off
# on different iterations of the training loop;
# trace_handler is called every time a new trace becomes available
def trace_handler(prof):
print(prof.key_averages().table(
sort_by="self_cuda_time_total", row_limit=-1))
# prof.export_chrome_trace("/tmp/test_trace_" + str(prof.step_num) + ".json")
with torch.profiler.profile(
activities=[
torch.profiler.ProfilerActivity.CPU,
torch.profiler.ProfilerActivity.CUDA,
],
# In this example with wait=1, warmup=1, active=2,
# profiler will skip the first step/iteration,
# start warming up on the second, record
# the third and the forth iterations,
# after which the trace will become available
# and on_trace_ready (when set) is called;
# the cycle repeats starting with the next step
schedule=torch.profiler.schedule(
wait=1,
warmup=1,
active=2),
on_trace_ready=trace_handler
# on_trace_ready=torch.profiler.tensorboard_trace_handler('./log')
# used when outputting for tensorboard
) as p:
for iter in range(N):
code_iteration_to_profile(iter)
# send a signal to the profiler that the next iteration has started
p.step()
NF)
activitiesr" on_trace_ready
record_shapesprofile_memory
with_stack
with_flops with_modulesuse_cuda.c
C s |rt || _nt | _| d k rVtd | r<| jjtj ntj| jkrV| jjtj t| jdkslt d|r~|| _
d| _ n t | _
d| _ || _
|| _|| _|| _|| _|| _d| _| j
| j| _d | _d | _d S )Nz7use_cuda is deprecated, use activities argument insteadr z"No valid profiler activities foundTF)setr? r= r addr CUDAremovelenr r" record_stepsr$ r@ rA rD rB rC rE step_numcurrent_actionprofiler step_rec_fn)
selfr? r" r@ rA rB rC rD rE rF r r r __init__ s2
zprofile.__init__c C s | j | S )N)start)rQ r r r __enter__ s zprofile.__enter__c C s | j d S )N)stop)rQ exc_typeexc_valexc_tbr r r __exit__ s zprofile.__exit__c C s2 | j | jr.tjdt| j | _| jj d S )Nz
ProfilerStep#)_enter_actionsrL r5 record_functionr0 rM rP rT )rQ r r r rS s z
profile.startc C s( | j r | jr | jjd d d | j d S )N)rL rP rY
_exit_actions)rQ r r r rU s z profile.stopc C s | j r | jr | jjddd | j}| jd7 _| j| j| _| jtjkr|tjkrVnf|tjkrzt d | j
| j nB|tj krt d | j n&|tj
kst| j | jr| j| n| jtjkr@|tjkr| j n\|tjkrnP|tj kr t d | j n2|tj
ks t| j | jr6| j| | j n| jtj tj
gkr|tjkrr| j | j
n^|tjkr| j
nH|tj krn:|tj
kst| j | jr| j| | j | j
| j rtjdt| j | _| jj dS )zP
Signals the profiler that the next profiling step has started.
Nr z+Incorrect schedule: WARMUP followed by NONEz+Incorrect schedule: RECORD followed by NONEz-Incorrect schedule: RECORD followed by WARMUPz
ProfilerStep#)rL rP rY rN rM r" r
r r r _start_trace _stop_tracer r r r@
_start_warmupr5 r[ r0 rT )rQ Z prev_actionr r r r sd
z profile.step)r) c C s | j s
t|jdrtjdddd}|j | j j|j}t|j(}t j|d}|j
| W dQ R X W dQ R X t j |j |S | j j|S dS )zD
Exports the collected trace in Chrome JSON format.
z.gzzw+tz.jsonF)suffixdeletewtN)
rO r endswithtempfileNamedTemporaryFilecloser3 nameopengzip
writelinesr7 rJ )rQ r) fpZretvalueZfinZfoutr r r r3 L s
zprofile.export_chrome_traceself_cpu_time_total)r) metricc C s | j s
t| j j||S )a Save stack traces in a file in a format suitable for visualization.
Args:
path (str): save stacks file to this location;
metric (str): metric to use: "self_cpu_time_total" or "self_cuda_time_total"
.. note::
Example of using FlameGraph tool:
- git clone https://github.com/brendangregg/FlameGraph
- cd FlameGraph
- ./flamegraph.pl --title "CPU time" --countname "us." profiler.stacks > perf_viz.svg
)rO r
export_stacks)rQ r) rm r r r rn ] s
zprofile.export_stacksr )group_by_input_shapegroup_by_stack_nc C s | j s
t| j j||S )a Averages events, grouping them by operator name and (optionally) input shapes and
stack.
.. note::
To use shape/stack functionality make sure to set record_shapes/with_stack
when creating profiler context manager.
)rO r key_averages)rQ ro rp r r r rq n s
zprofile.key_averagesc C s | j s
t| j jS )z
Returns the list of unaggregated profiler events,
to be used in the trace callback or after the profiling is finished
)rO r Zfunction_events)rQ r r r eventsy s
zprofile.events)keyvaluec C s& d|j dd d }tjj|| dS )zo
Adds a user defined metadata with a string key and a string value
into the trace file
"z\"N)replacer; r< _add_metadata_json)rQ rs rt Z
wrapped_valuer r r add_metadata s zprofile.add_metadatac C s t jj|| dS )zs
Adds a user defined metadata with a string key and a valid json value
into the trace file
N)r; r< rw )rQ rs rt r r r add_metadata_json s zprofile.add_metadata_jsonc C s: dd l j}|j s |j r"d S |j |j |j dS )Nr )backendZrankZ
world_size)Ztorch.distributedZ distributedZ is_availableZis_initialized get_backendZget_rankZget_world_size)rQ distr r r _get_distributed_info s
z profile._get_distributed_infoc C s< | j tjkr| j n"| j tjtjgkr8| j | j d S )N)rN r
r r_ r r r] )rQ r r r rZ s
zprofile._enter_actionsc C sL | j tjkr | j | j n*| j tjtjgkrH| j | jrH| j| d S )N)rN r
r r] r^ r r r@ )rQ r r r r\ s
zprofile._exit_actionsc
C sD t jtj| jktj| jk| j| j| j| j | j
dd| _ | j j d S )NT)rF Zuse_cpurA rD rB rC rE Z
use_kineto)
r5 r> r rI r? ZCPUrA rD rB rC rE rO Z_prepare_trace)rQ r r r r_ s
zprofile._start_warmupc C s@ | j d k st| j j t r<| j }|r<| jdtj| d S )NZdistributedInfo)rO r r] r r} ry jsondumps)rQ Z dist_infor r r r] s
zprofile._start_tracec C s" | j d k st| j jd d d d S )N)rO r rY )rQ r r r r^ s zprofile._stop_trace)rl )Fr ) r r r r r r r r r! r
r boolrR rT rY rS rU r r0 r3 rn rq rr rx ry r} rZ r\ r_ r] r^ r r r r r> g s6 iJ!<
r> )NF) ri r~ r7 rd enumr typingr r r r warningsr r; Ztorch.autograd.profilerr< rO r5 Ztorch.autogradr r r
r! r" r$ r0 r r: r= objectr> r r r r s