/**
* \brief Returns a cuda context against the handle in the argument.
*
* If a cuda_context is not present for a handle, it is created
* and associated with this handle and the context is returned
* in the argument. If a cuda_context is already present for
* a handle, it is returned.
*
* \param p_context Pointer to a cuda context instance that should be updated
* with a cuda context.
* \param cuda_profile The cuda profile, supplied as a string.
* \param handle A unique handle which identifies a module. Obtained from
* a call to SCCudaHlGetUniqueHandle().
*
* \retval 0 On success.
* \retval -1 On failure.
*/
int SCCudaHlGetCudaContext(CUcontext *p_context, char *cuda_profile, int handle)
{
SCCudaHlModuleData *data = NULL;
SCCudaDevices *devices = NULL;
if (p_context == NULL) {
SCLogError(SC_ERR_INVALID_ARGUMENTS, "Error invalid arguments. "
"p_context NULL");
return -1;
}
/* check if the particular module that wants a CUDA context
* is already registered or not. If it is not registered
* log a warning and get out of here */
if ( (data = SCCudaHlGetModuleData(handle)) == NULL) {
SCLogDebug("Module not registered. You can't create a CUDA context "
"without registering a module first. To use this "
"registration facility, first register a module using "
"SCCudaHlRegisterModule(), and then register "
"a cuda context with that module hanle using "
"SCCudaHlGetCudaContext(), after which you can call this "
"function ");
return -1;
}
if (data->cuda_context != 0) {
p_context[0] = data->cuda_context;
return 0;
}
int device_id = SC_CUDA_DEFAULT_DEVICE;
if (cuda_profile != NULL) {
/* Get default log level and format. */
MpmCudaConf *profile = SCCudaHlGetProfile(cuda_profile);
if (profile != NULL) {
if (SCCudaIsCudaDeviceIdValid(profile->device_id)) {
device_id = profile->device_id;
} else {
SCLogError(SC_ERR_CUDA_ERROR, "Invalid device id \"%d\" supplied. "
"Using the first device.", profile->device_id);
}
}
}
/* Get the device list for this CUDA platform and create a new cuda context */
devices = SCCudaGetDeviceList();
if (SCCudaCtxCreate(p_context, 0, devices->devices[device_id]->device) == -1)
goto error;
data->cuda_context = p_context[0];
return 0;
error:
return -1;
}
CUcontext CudaHandlerModuleGetContext(const char *name, int device_id)
{
SCMutexLock(&mutex);
CudaHandlerModule *module = cudahl_modules;
while (module != NULL && strcasecmp(module->name, name) != 0)
module = module->next;
if (module != NULL) {
if (module->device_id != device_id) {
SCLogError(SC_ERR_CUDA_HANDLER_ERROR, "Module already "
"registered, but the new device_id is different "
"from the already registered device_id.");
exit(EXIT_FAILURE);
}
SCMutexUnlock(&mutex);
return module->context;
}
CudaHandlerModule *new_module = SCMalloc(sizeof(CudaHandlerModule));
if (new_module == NULL)
exit(EXIT_FAILURE);
memset(new_module, 0, sizeof(CudaHandlerModule));
new_module->device_id = device_id;
new_module->name = SCStrdup(name);
if (new_module->name == NULL)
exit(EXIT_FAILURE);
if (cudahl_modules == NULL) {
cudahl_modules = new_module;
} else {
new_module->next = cudahl_modules;
cudahl_modules = new_module;
}
if (no_of_cuda_contexts <= device_id) {
cuda_contexts = SCRealloc(cuda_contexts, sizeof(CUcontext) * (device_id + 1));
if (cuda_contexts == NULL)
exit(EXIT_FAILURE);
memset(cuda_contexts + no_of_cuda_contexts, 0,
sizeof(CUcontext) * ((device_id + 1) - no_of_cuda_contexts));
no_of_cuda_contexts = device_id + 1;
}
if (cuda_contexts[device_id] == 0) {
SCCudaDevices *devices = SCCudaGetDeviceList();
if (SCCudaCtxCreate(&cuda_contexts[device_id], CU_CTX_SCHED_BLOCKING_SYNC,
devices->devices[device_id]->device) == -1) {
SCLogDebug("ctxcreate failure.");
exit(EXIT_FAILURE);
}
}
new_module->context = cuda_contexts[device_id];
SCMutexUnlock(&mutex);
return cuda_contexts[device_id];
}
