Provided by: nvidia-cuda-dev_7.5.18-0ubuntu1_amd64 bug

NAME

       Event Management -

   Functions
       CUresult cuEventCreate (CUevent *phEvent, unsigned int Flags)
           Creates an event.
       CUresult cuEventDestroy (CUevent hEvent)
           Destroys an event.
       CUresult cuEventElapsedTime (float *pMilliseconds, CUevent hStart, CUevent hEnd)
           Computes the elapsed time between two events.
       CUresult cuEventQuery (CUevent hEvent)
           Queries an event's status.
       CUresult cuEventRecord (CUevent hEvent, CUstream hStream)
           Records an event.
       CUresult cuEventSynchronize (CUevent hEvent)
           Waits for an event to complete.

Detailed Description

       \brief event management functions of the low-level CUDA driver API (cuda.h)

       This section describes the event management functions of the low-level CUDA driver application
       programming interface.

Function Documentation

   CUresult cuEventCreate (CUevent * phEvent, unsigned int Flags)
       Creates an event *phEvent with the flags specified via Flags. Valid flags include:

       • CU_EVENT_DEFAULT: Default event creation flag.

       • CU_EVENT_BLOCKING_SYNC:  Specifies  that  the  created event should use blocking synchronization. A CPU
         thread that uses cuEventSynchronize() to wait on an event created with this flag will block  until  the
         event has actually been recorded.

       • CU_EVENT_DISABLE_TIMING:  Specifies  that the created event does not need to record timing data. Events
         created with this flag specified and the CU_EVENT_BLOCKING_SYNC flag not  specified  will  provide  the
         best performance when used with cuStreamWaitEvent() and cuEventQuery().

       • CU_EVENT_INTERPROCESS:  Specifies  that  the  created  event  may  be  used as an interprocess event by
         cuIpcGetEventHandle(). CU_EVENT_INTERPROCESS must be specified along with CU_EVENT_DISABLE_TIMING.

       Parameters:
           phEvent - Returns newly created event
           Flags - Event creation flags

       Returns:
           CUDA_SUCCESS,   CUDA_ERROR_DEINITIALIZED,   CUDA_ERROR_NOT_INITIALIZED,   CUDA_ERROR_INVALID_CONTEXT,
           CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY

       Note:
           Note that this function may also return error codes from previous, asynchronous launches.

       See also:
           cuEventRecord, cuEventQuery, cuEventSynchronize, cuEventDestroy, cuEventElapsedTime

   CUresult cuEventDestroy (CUevent hEvent)
       Destroys the event specified by hEvent.

       In  case  hEvent  has  been  recorded but has not yet been completed when cuEventDestroy() is called, the
       function will return immediately and the resources associated with hEvent will be released  automatically
       once the device has completed hEvent.

       Parameters:
           hEvent - Event to destroy

       Returns:
           CUDA_SUCCESS,   CUDA_ERROR_DEINITIALIZED,   CUDA_ERROR_NOT_INITIALIZED,   CUDA_ERROR_INVALID_CONTEXT,
           CUDA_ERROR_INVALID_HANDLE

       Note:
           Note that this function may also return error codes from previous, asynchronous launches.

       See also:
           cuEventCreate, cuEventRecord, cuEventQuery, cuEventSynchronize, cuEventElapsedTime

   CUresult cuEventElapsedTime (float * pMilliseconds, CUevent hStart, CUevent hEnd)
       Computes the elapsed  time  between  two  events  (in  milliseconds  with  a  resolution  of  around  0.5
       microseconds).

       If  either  event was last recorded in a non-NULL stream, the resulting time may be greater than expected
       (even if both used the same stream handle). This happens  because  the  cuEventRecord()  operation  takes
       place asynchronously and there is no guarantee that the measured latency is actually just between the two
       events. Any number of other different stream operations could execute in between the two measured events,
       thus altering the timing in a significant way.

       If  cuEventRecord()  has  not  been called on either event then CUDA_ERROR_INVALID_HANDLE is returned. If
       cuEventRecord() has been called on both events but one or both of them has not yet been  completed  (that
       is, cuEventQuery() would return CUDA_ERROR_NOT_READY on at least one of the events), CUDA_ERROR_NOT_READY
       is  returned.  If either event was created with the CU_EVENT_DISABLE_TIMING flag, then this function will
       return CUDA_ERROR_INVALID_HANDLE.

       Parameters:
           pMilliseconds - Time between hStart and hEnd in ms
           hStart - Starting event
           hEnd - Ending event

       Returns:
           CUDA_SUCCESS,   CUDA_ERROR_DEINITIALIZED,   CUDA_ERROR_NOT_INITIALIZED,   CUDA_ERROR_INVALID_CONTEXT,
           CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_NOT_READY

       Note:
           Note that this function may also return error codes from previous, asynchronous launches.

       See also:
           cuEventCreate, cuEventRecord, cuEventQuery, cuEventSynchronize, cuEventDestroy

   CUresult cuEventQuery (CUevent hEvent)
       Query the status of all device work preceding the most recent call to cuEventRecord() (in the appropriate
       compute streams, as specified by the arguments to cuEventRecord()).

       If  this work has successfully been completed by the device, or if cuEventRecord() has not been called on
       hEvent, then CUDA_SUCCESS is returned. If this work has  not  yet  been  completed  by  the  device  then
       CUDA_ERROR_NOT_READY is returned.

       For  the  purposes  of  Unified  Memory,  a  return  value of CUDA_SUCCESS is equivalent to having called
       cuEventSynchronize().

       Parameters:
           hEvent - Event to query

       Returns:
           CUDA_SUCCESS,   CUDA_ERROR_DEINITIALIZED,   CUDA_ERROR_NOT_INITIALIZED,    CUDA_ERROR_INVALID_HANDLE,
           CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_NOT_READY

       Note:
           Note that this function may also return error codes from previous, asynchronous launches.

       See also:
           cuEventCreate, cuEventRecord, cuEventSynchronize, cuEventDestroy, cuEventElapsedTime

   CUresult cuEventRecord (CUevent hEvent, CUstream hStream)
       Records  an  event.  See  note  on NULL stream behavior. Since operation is asynchronous, cuEventQuery or
       cuEventSynchronize() must be used to determine when the event has actually been recorded.

       If cuEventRecord() has previously been called on hEvent, then this call will overwrite any existing state
       in hEvent. Any subsequent calls which examine the status of hEvent will only examine  the  completion  of
       this most recent call to cuEventRecord().

       It is necessary that hEvent and hStream be created on the same context.

       Parameters:
           hEvent - Event to record
           hStream - Stream to record event for

       Returns:
           CUDA_SUCCESS,   CUDA_ERROR_DEINITIALIZED,   CUDA_ERROR_NOT_INITIALIZED,   CUDA_ERROR_INVALID_CONTEXT,
           CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_INVALID_VALUE

       Note:
           This function uses standard  semantics.

           Note that this function may also return error codes from previous, asynchronous launches.

       See also:
           cuEventCreate,     cuEventQuery,     cuEventSynchronize,      cuStreamWaitEvent,      cuEventDestroy,
           cuEventElapsedTime

   CUresult cuEventSynchronize (CUevent hEvent)
       Wait  until  the  completion of all device work preceding the most recent call to cuEventRecord() (in the
       appropriate compute streams, as specified by the arguments to cuEventRecord()).

       If cuEventRecord() has not been called on hEvent, CUDA_SUCCESS is returned immediately.

       Waiting for an event that was created with the CU_EVENT_BLOCKING_SYNC flag will  cause  the  calling  CPU
       thread  to block until the event has been completed by the device. If the CU_EVENT_BLOCKING_SYNC flag has
       not been set, then the CPU thread will busy-wait until the event has been completed by the device.

       Parameters:
           hEvent - Event to wait for

       Returns:
           CUDA_SUCCESS,   CUDA_ERROR_DEINITIALIZED,   CUDA_ERROR_NOT_INITIALIZED,   CUDA_ERROR_INVALID_CONTEXT,
           CUDA_ERROR_INVALID_HANDLE

       Note:
           Note that this function may also return error codes from previous, asynchronous launches.

       See also:
           cuEventCreate, cuEventRecord, cuEventQuery, cuEventDestroy, cuEventElapsedTime

Author

       Generated automatically by Doxygen from the source code.

Version 6.0                                        15 Aug 2015                               Event Management(3)