/**
* \brief Register a new module. To understand what exactly these utilities are
* needed for please look at the file comments.
*
* \param name A unique name to register the module with. No module should have
* registered itself previously with this name.
*
* \retval handle A unique handle that is associated with this module and all
* future use of API would require supplying this handle.
*/
int SCCudaHlRegisterModule(const char *name)
{
SCCudaHlModuleData *data = module_data;
SCCudaHlModuleData *new_data = NULL;
while (data != NULL &&
strcmp(data->name, name) != 0) {
data = data->next;
}
if (data != NULL) {
SCLogInfo("Module \"%s\" already registered. Returning the handle "
"for the already registered module", name);
return data->handle;
}
/* the module is not already registered. Register the module */
new_data = SCMalloc(sizeof(SCCudaHlModuleData));
if (new_data == NULL) {
exit(EXIT_FAILURE);
}
memset(new_data, 0, sizeof(SCCudaHlModuleData));
if ( (new_data->name = SCStrdup(name)) == NULL) {
SCLogError(SC_ERR_MEM_ALLOC, "Error allocating memory");
exit(EXIT_FAILURE);
}
new_data->handle = SCCudaHlGetUniqueHandle();
/* first module to be registered */
if (module_data == NULL) {
module_data = new_data;
return new_data->handle;
}
/* add this new module_data instance to the global module_data list */
data = module_data;
while (data->next != NULL)
data = data->next;
data->next = new_data;
return new_data->handle;
}
/**
* \brief Returns a cuda_module against the handle in the argument.
*
* If a cuda_module is not present for a handle, it is created
* and associated with this handle and the cuda_module is returned
* in the argument.
*
* \param p_module Pointer to a cuda module instance that should be updated
* with a cuda module.
* \param handle A unique handle which identifies a module. Obtained from
* a call to SCCudaHlGetUniqueHandle().
*
* \retval A unique handle within the module that is associated with the
* loaded CUmodule. Needed for future API calls.
* \retval -1 on failure.
*/
int SCCudaHlGetCudaModule(CUmodule *p_module, const char *ptx_image, int handle)
{
SCCudaHlModuleData *data = NULL;
SCCudaHlModuleCUmodule *new_module_cumodule = NULL;
SCCudaHlModuleCUmodule *module_cumodules = NULL;
if (p_module == NULL) {
SCLogError(SC_ERR_INVALID_ARGUMENTS, "Error invalid arguments"
"p_module NULL");
return -1;
}
/* check if the particular module that wants a CUDA module is already
* registered or not. If it is registered, check if a context has
* been associated with the module. If yes, then we can go ahead and
* create a cuda module and associate it with the module referenced by
* the handle in the functions arguments. If no, log warning and get
* out of here */
if ( ((data = SCCudaHlGetModuleData(handle)) == NULL) ||
(data->cuda_context == 0)) {
SCLogDebug("Module not registered or no cuda context associated with "
"this module. You can't create a CUDA module without"
"associating a context with a module first. To use this "
"registration facility, first register a module using "
"context using SCCudaHlRegisterModule(), and then register "
"a cuda context with that module using "
"SCCudaHlGetCudaContext(), after which you can call this "
"function ");
return -1;
}
/* Register new CUmodule in the module */
new_module_cumodule = SCMalloc(sizeof(SCCudaHlModuleCUmodule));
if (new_module_cumodule == NULL) {
exit(EXIT_FAILURE);
}
memset(new_module_cumodule, 0, sizeof(SCCudaHlModuleCUmodule));
/* Create a cuda module, update the module with this cuda module reference
* and then return the module reference back to the calling function using
* the argument */
if (SCCudaModuleLoadData(p_module, (void *)ptx_image) == -1)
goto error;
new_module_cumodule->cuda_module = p_module[0];
new_module_cumodule->cuda_module_handle = SCCudaHlGetUniqueHandle();
/* insert it into the cuda_modules list for the module instance */
if (data->cuda_modules == NULL) {
data->cuda_modules = new_module_cumodule;
return new_module_cumodule->cuda_module_handle;
}
module_cumodules = data->cuda_modules;
while (module_cumodules->next != NULL)
module_cumodules = module_cumodules->next;
module_cumodules->next = new_module_cumodule;
return new_module_cumodule->cuda_module_handle;
error:
return -1;
}
/**
* \brief Returns a cuda_module against the handle in the argument.
*
* If a cuda_module is not present for a handle, it is created
* and associated with this handle and the cuda_module is returned
* in the argument.
*
* \param p_module The loaded CUmodule that is returned.
* \param ptx_image Name of the module source file, w/o the .cu extension
* \param handle A unique handle which identifies a module. Obtained from
* a call to SCCudaHlGetUniqueHandle().
*
* \retval A unique handle within the module that is associated with the
* loaded CUmodule. Needed for future API calls.
* \retval -1 on failure.
*/
int SCCudaHlGetCudaModule(CUmodule *p_module, const char *ptx_image, int handle)
{
SCCudaHlModuleData *data = NULL;
SCCudaHlModuleCUmodule *new_module_cumodule = NULL;
SCCudaHlModuleCUmodule *module_cumodules = NULL;
if (p_module == NULL) {
SCLogError(SC_ERR_INVALID_ARGUMENTS, "Error invalid arguments"
"p_module NULL");
return -1;
}
/* check if the particular module that wants a CUDA module is already
* registered or not. If it is registered, check if a context has
* been associated with the module. If yes, then we can go ahead and
* create a cuda module and associate it with the module referenced by
* the handle in the functions arguments. If no, log warning and get
* out of here */
if ( ((data = SCCudaHlGetModuleData(handle)) == NULL) ||
(data->cuda_context == 0)) {
SCLogDebug("Module not registered or no cuda context associated with "
"this module. You can't create a CUDA module without"
"associating a context with a module first. To use this "
"registration facility, first register a module using "
"context using SCCudaHlRegisterModule(), and then register "
"a cuda context with that module using "
"SCCudaHlGetCudaContext(), after which you can call this "
"function ");
return -1;
}
/* Register new CUmodule in the module */
new_module_cumodule = SCMalloc(sizeof(SCCudaHlModuleCUmodule));
if (unlikely(new_module_cumodule == NULL)) {
exit(EXIT_FAILURE);
}
memset(new_module_cumodule, 0, sizeof(SCCudaHlModuleCUmodule));
/* select the ptx image based on the compute capability supported by all
* devices (i.e. the lowest) */
char* image = SCMalloc(strlen(ptx_image)+15);
if (unlikely(image == NULL)) {
exit(EXIT_FAILURE);
}
memset(image, 0x0, strlen(ptx_image)+15);
int major = INT_MAX;
int minor = INT_MAX;
SCCudaDevices *devices = SCCudaGetDeviceList();
int i=0;
for (; i<devices->count; i++){
if (devices->devices[i]->major_rev < major){
major = devices->devices[i]->major_rev;
minor = devices->devices[i]->minor_rev;
}
if (devices->devices[i]->major_rev == major &&
devices->devices[i]->minor_rev < minor){
minor = devices->devices[i]->minor_rev;
}
}
snprintf(image, strlen(ptx_image) + 15, "%s_sm_%u%u",
ptx_image, major, minor);
/* we don't have a cuda module associated with this module. Create a
* cuda module, update the module with this cuda module reference and
* then return the module refernce back to the calling function using
* the argument */
SCLogDebug("Loading kernel module: %s\n",image);
if (SCCudaModuleLoadData(p_module, (void *)SCCudaPtxDumpGetModule(image)) == -1)
goto error;
SCFree(image);
new_module_cumodule->cuda_module = p_module[0];
new_module_cumodule->cuda_module_handle = SCCudaHlGetUniqueHandle();
/* insert it into the cuda_modules list for the module instance */
if (data->cuda_modules == NULL) {
data->cuda_modules = new_module_cumodule;
return new_module_cumodule->cuda_module_handle;
}
module_cumodules = data->cuda_modules;
while (module_cumodules->next != NULL)
module_cumodules = module_cumodules->next;
module_cumodules->next = new_module_cumodule;
return new_module_cumodule->cuda_module_handle;
error:
SCFree(image);
return -1;
}
