NAME

       Interactions with the CUDA Driver API - \brief interactions between CUDA Driver API and
       CUDA Runtime API (cuda_runtime_api.h)

       This section describes the interactions between the CUDA Driver API and the CUDA Runtime
       API

Primary Contexts

       There exists a one to one relationship between CUDA devices in the CUDA Runtime API and
       CUcontext s in the CUDA Driver API within a process. The specific context which the CUDA
       Runtime API uses for a device is called the device's primary context. From the perspective
       of the CUDA Runtime API, a device and its primary context are synonymous.

Initialization and Tear-Down

       CUDA Runtime API calls operate on the CUDA Driver API CUcontext which is current to to the
       calling host thread.

       The function cudaSetDevice() makes the primary context for the specified device current to
       the calling thread by calling cuCtxSetCurrent().

       The CUDA Runtime API will automatically initialize the primary context for a device at the
       first CUDA Runtime API call which requires an active context. If no CUcontext is current
       to the calling thread when a CUDA Runtime API call which requires an active context is
       made, then the primary context for a device will be selected, made current to the calling
       thread, and initialized.

       The context which the CUDA Runtime API initializes will be initialized using the
       parameters specified by the CUDA Runtime API functions cudaSetDeviceFlags(),
       cudaD3D9SetDirect3DDevice(), cudaD3D10SetDirect3DDevice(), cudaD3D11SetDirect3DDevice(),
       cudaGLSetGLDevice(), and cudaVDPAUSetVDPAUDevice(). Note that these functions will fail
       with cudaErrorSetOnActiveProcess if they are called when the primary context for the
       specified device has already been initialized. (or if the current device has already been
       initialized, in the case of cudaSetDeviceFlags()).

       Primary contexts will remain active until they are explicitly deinitialized using
       cudaDeviceReset(). The function cudaDeviceReset() will deinitialize the primary context
       for the calling thread's current device immediately. The context will remain current to
       all of the threads that it was current to. The next CUDA Runtime API call on any thread
       which requires an active context will trigger the reinitialization of that device's
       primary context.

       Note that there is no reference counting of the primary context's lifetime. It is
       recommended that the primary context not be deinitialized except just before exit or to
       recover from an unspecified launch failure.

Context Interoperability

       Note that the use of multiple CUcontext s per device within a single process will
       substantially degrade performance and is strongly discouraged. Instead, it is highly
       recommended that the implicit one-to-one device-to-context mapping for the process
       provided by the CUDA Runtime API be used.

       If a non-primary CUcontext created by the CUDA Driver API is current to a thread then the
       CUDA Runtime API calls to that thread will operate on that CUcontext, with some exceptions
       listed below. Interoperability between data types is discussed in the following sections.

       The function cudaPointerGetAttributes() will return the error
       cudaErrorIncompatibleDriverContext if the pointer being queried was allocated by a non-
       primary context. The function cudaDeviceEnablePeerAccess() and the rest of the peer access
       API may not be called when a non-primary CUcontext is current. To use the pointer query
       and peer access APIs with a context created using the CUDA Driver API, it is necessary
       that the CUDA Driver API be used to access these features.

       All CUDA Runtime API state (e.g, global variables' addresses and values) travels with its
       underlying CUcontext. In particular, if a CUcontext is moved from one thread to another
       then all CUDA Runtime API state will move to that thread as well.

       Please note that attaching to legacy contexts (those with a version of 3010 as returned by
       cuCtxGetApiVersion()) is not possible. The CUDA Runtime will return
       cudaErrorIncompatibleDriverContext in such cases.

Interactions between CUstream and cudaStream_t

       The types CUstream and cudaStream_t are identical and may be used interchangeably.

Interactions between CUevent and cudaEvent_t

       The types CUevent and cudaEvent_t are identical and may be used interchangeably.

Interactions between CUarray and cudaArray_t

       The types CUarray and struct cudaArray * represent the same data type and may be used
       interchangeably by casting the two types between each other.

       In order to use a CUarray in a CUDA Runtime API function which takes a struct cudaArray *,
       it is necessary to explicitly cast the CUarray to a struct cudaArray *.

       In order to use a struct cudaArray * in a CUDA Driver API function which takes a CUarray,
       it is necessary to explicitly cast the struct cudaArray * to a CUarray .

Interactions between CUgraphicsResource and cudaGraphicsResource_t

       The types CUgraphicsResource and cudaGraphicsResource_t represent the same data type and
       may be used interchangeably by casting the two types between each other.

       In order to use a CUgraphicsResource in a CUDA Runtime API function which takes a
       cudaGraphicsResource_t, it is necessary to explicitly cast the CUgraphicsResource to a
       cudaGraphicsResource_t.

       In order to use a cudaGraphicsResource_t in a CUDA Driver API function which takes a
       CUgraphicsResource, it is necessary to explicitly cast the cudaGraphicsResource_t to a
       CUgraphicsResource.

Author

       Generated automatically by Doxygen from the source code.