Name	Size	Mode	Actions
comm.cpython-36.pyc	372	0644	editdlrm
error.cpython-36.pyc	143	0644	editdlrm
graphs.cpython-36.pyc	15811	0644	editdlrm
memory.cpython-36.pyc	21717	0644	editdlrm
nccl.cpython-36.pyc	3444	0644	editdlrm
nvtx.cpython-36.pyc	1966	0644	editdlrm
profiler.cpython-36.pyc	1632	0644	editdlrm
random.cpython-36.pyc	5520	0644	editdlrm
sparse.cpython-36.pyc	144	0644	editdlrm
streams.cpython-36.pyc	9485	0644	editdlrm
_utils.cpython-36.pyc	1892	0644	editdlrm
__init__.cpython-36.pyc	23210	0644	editdlrm

3 Eg��@s�dd
lZdd
l
Z
ddlmZ
ee
jd�sHed�
e
jjd<ed�
e
jjd<Gdd�de
jj�ZGdd �d e�Z Gd d�de
jj �Zd
S)�N�
)
�_dummy_type�_CudaStreamBase�_CudaEventBasecs|eZ
dZd
Zd�f
dd� Zdd�Zdd �Zdd d�
Z�f
dd �Z�f
dd�Z e dd��
Z�f
dd�Zdd�Z dd�Z�ZS)�Streama�Wrapper around a CUDA stream. A CUDA stream is a linear sequence of execution that belongs to a specific device, independent from other streams. See :ref:`cuda-semantics` for details. Args: device(torch.device or int, optional): a device on which to allocate the stream. If :attr:`device` is ``None`` (default) or a negative integer, this will use the current device. priority(int, optional): priority of the stream. Can be either -1 (high priority) or 0 (low priority). By default, streams have priority 0. .. note:: Although CUDA versions >= 11 support more than two levels of priorities, in PyTorch, we only support two levels of priorities. Nr
cs4tj
j|
�
�
tt|�j|f
d
|i
|��
SQRXdS)N�priority)�torch�cuda�device�superr�__new__)�clsr r�kwargs)
� __class__��>/usr/local/lib64/python3.6/site-packages/torch/cuda/streams.pyrs

zStream.__new__cCs|
j|�

d
S)aMakes all future work submitted to the stream wait for an event. Args: event (torch.cuda.Event): an event to wait for. .. note:: This is a wrapper around ``cudaStreamWaitEvent()``: see `CUDA Stream documentation`_ for more info. This function returns without waiting for :attr:`event`: only future operations are affected. .. _CUDA Stream documentation: https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__STREAM.html N)
�wait)�self�eventrrr� wait_event#szStream.wait_eventcCs|j|
j
��

d
S)a�
Synchronizes with another stream. All future work submitted to this stream will wait until all kernels submitted to a given stream at the time of call complete. Args: stream (Stream): a stream to synchronize. .. note:: This function returns without waiting for currently enqueued kernels in :attr:`stream`: only future operations are affected. N)r�record_event)r�streamrrr�wait_stream4szStream.wait_streamcCs|
d
krt�}
|
j
|�

|
S)z�Records an event. Args: event (torch.cuda.Event, optional): event to record. If not given, a new one will be allocated. Returns: Recorded event. N)�Event�record)rrrrrrBs 


zStream.record_eventc

stt
|�j�S)
z�Checks if all the work submitted has been completed. Returns: A boolean indicating if all kernels in this stream are completed.)rr�query)
r)
rrrrQszStream.queryc

stt
|�j�
d
S)z�Wait for all the kernels in this stream to complete. .. note:: This is a wrapper around ``cudaStreamSynchronize()``: see `CUDA Stream documentation`_ for more info. N)rr�synchronize)
r)
rrrrXszStream.synchronizec

Cstj
|j�
S)
N)�ctypes�c_void_p�cuda_stream)
rrrr�_as_parameter_`szStream._as_parameter_cst|
t
�rtt
|�j|
�
Sd
S)NF)� isinstancerr�__eq__)r�
o)
rrrr"ds


z Stream.__eq__c

Cst|j
|jf�
S)
N)�hashrr )
rrrr�__hash__is
zStream.__hash__c

Csd
j|j
|j�S)Nz1)�formatr r)
rrrr�__repr__ls

zStream.__repr__)Nr
)
N)�__name__� __module__�__qualname__�__doc__rrrrrr�propertyr r"r%r'� __classcell__rr)
rrrs rcs"eZ
dZd
Zd�f
dd� Z�ZS)�ExternalStreama�Wrapper around an externally allocated CUDA stream. This class is used to wrap streams allocated in other libraries in order to facilitate data exchange and multi-library interactions. .. note:: This class doesn't manage the stream life-cycle, it is the user responsibility to keep the referenced stream alive while this class is being used. Args: stream_ptr(int): Integer representation of the `cudaStream_t` value. allocated externally. device(torch.device or int, optional): the device where the stream was originally allocated. if device is specified incorrectly, subsequent launches using this stream may fail. Ncs4tj
j|�
�
tt|�j|f
d
|
i
|��
SQRXdS)N� stream_ptr)rr r rrr)r r/r r)
rrrr�s

zExternalStream.__new__)
N)r(r)r*r+rr-rr)
rrr.qsr.cs�eZ
dZd
Zd�f
dd� Ze�f
dd��
Zd�f
dd � Zd�f
d d� Z�f
dd �Z �f
dd�Z �f
dd�Z�f
dd�Ze dd��
Zdd�Z�ZS)ra�Wrapper around a CUDA event. CUDA events are synchronization markers that can be used to monitor the device's progress, to accurately measure timing, and to synchronize CUDA streams. The underlying CUDA events are lazily initialized when the event is first recorded or exported to another process. After creation, only streams on the same device may record the event. However, streams on any device can wait on the event. Args: enable_timing (bool, optional): indicates if the event should measure time (default: ``False``) blocking (bool, optional): if ``True``, :meth:`wait` will be blocking (default: ``False``) interprocess (bool): if ``True``, the event can be shared between processes (default: ``False``) .. _CUDA Event Documentation: https://docs.nvidia.com/cuda/cuda-runtime-api/group__CUDART__EVENT.html Fcstt
|�j||
||d
�S)N)� enable_timing�blocking�interprocess)rrr)r r0r1r2)
rrrr�s


z Event.__new__cstt
|�j|
|�S)
zz )r8r&r �value)
rrrrr'�s

zEvent.__repr__)FFF)
N)
N)r(r)r*r+r�classmethodr3rrrr6rr7r,r r'r-rr)
rrr�s   r)rr�_utilsr�hasattr�_C�__dict__rrr.rrrrrr�
s

e