bool SharedMemoryManagerVoxelMaps::getDevicePointer(void*& dev_pointer, const uint32_t index) { std::string index_str = boost::lexical_cast<std::string>(index); std::string handler_var_name = shm_variable_name_voxelmap_handler_dev_pointer + index_str; std::pair<cudaIpcMemHandle_t*, std::size_t> res = shmm->getMemSegment().find<cudaIpcMemHandle_t>( handler_var_name.c_str()); if (res.second == 0) { return false; } cudaIpcMemHandle_t handler = *res.first; cudaError_t cuda_error = cudaIpcOpenMemHandle((void**) &dev_pointer, (cudaIpcMemHandle_t) handler, cudaIpcMemLazyEnablePeerAccess); // the handle is closed by Visualizer.cu return cuda_error == cudaSuccess; }
static PyObject * THPStorage_(newSharedCuda)(PyObject *_unused, PyObject *args) { HANDLE_TH_ERRORS THPUtils_assert(PyTuple_GET_SIZE(args) == 5, "tuple of 5 items expected"); PyObject *_device = PyTuple_GET_ITEM(args, 0); PyObject *_handle = PyTuple_GET_ITEM(args, 1); PyObject *_size = PyTuple_GET_ITEM(args, 2); PyObject *_offset = PyTuple_GET_ITEM(args, 3); PyObject *_view_size = PyTuple_GET_ITEM(args, 4); if (!(THPUtils_checkLong(_device) && THPUtils_checkLong(_size) && (_handle == Py_None || PyBytes_Check(_handle)) && THPUtils_checkLong(_offset) && THPUtils_checkLong(_view_size))) { THPUtils_invalidArguments(args, NULL, "_new_shared in CUDA mode", 1, "(int device, bytes handle, int storage_size, int offset, int view_size"); return NULL; } size_t storage_size = (size_t)THPUtils_unpackLong(_size); ptrdiff_t offset = (ptrdiff_t)THPUtils_unpackLong(_offset); size_t view_size = (size_t)THPUtils_unpackLong(_view_size); int64_t device = THPUtils_unpackLong(_device); AutoGPU __autogpu(device); char *buffer; Py_ssize_t handle_size; if (PyBytes_AsStringAndSize(_handle, &buffer, &handle_size) == -1) { return NULL; } THPUtils_assert(handle_size == CUDA_IPC_HANDLE_SIZE, "incorrect handle size"); cudaIpcMemHandle_t handle = *(cudaIpcMemHandle_t*)buffer; void *devPtr = NULL; THCudaCheck(cudaIpcOpenMemHandle(&devPtr, handle, cudaIpcMemLazyEnablePeerAccess)); THStoragePtr base(THStorage_(newWithDataAndAllocator)( LIBRARY_STATE (real*)devPtr, storage_size, &THCIpcAllocator, (void*)device)); base->flag = TH_STORAGE_REFCOUNTED | TH_STORAGE_FREEMEM; if (offset != 0 || view_size != storage_size) { return THPStorage_(newTHView)(base.get(), offset, view_size); } return THPStorage_(New)(base.release()); END_HANDLE_TH_ERRORS }
bool SharedMemoryManagerVoxelLists::getVisualizationData(Cube*& cubes, uint32_t& size, const uint32_t index) { std::string handler_name = shm_variable_name_voxellist_handler_dev_pointer + boost::lexical_cast<std::string>(index); std::string number_cubes_name = shm_variable_name_voxellist_num_voxels + boost::lexical_cast<std::string>(index); // Find shared memory handles for: Cubes device pointer, number of cubes std::pair<cudaIpcMemHandle_t*, std::size_t> shm_cubes_handle = shmm->getMemSegment().find<cudaIpcMemHandle_t>(handler_name.c_str()); std::pair<uint32_t*, std::size_t> shm_size = shmm->getMemSegment().find<uint32_t>(number_cubes_name.c_str()); if (shm_cubes_handle.second == 0 || shm_size.second == 0) { // Shared memory handles not found return false; } size_t new_size = *shm_size.first; if (new_size > 0) { Cube* new_cubes; cudaError_t cuda_error = cudaIpcOpenMemHandle((void**) &new_cubes, *shm_cubes_handle.first, cudaIpcMemLazyEnablePeerAccess); if (cuda_error == cudaSuccess) { cubes = new_cubes; size = new_size; } else { // IPC handle to device pointer could not be opened cudaIpcCloseMemHandle(new_cubes); return false; } } else { cubes = NULL; // No memory is allocated when voxellist is empty size = new_size; } return true; }
bool SharedMemoryManagerOctrees::getOctreeVisualizationData(Cube*& cubes, uint32_t& size, uint32_t index) { bool error = false; std::string handler_name = shm_variable_name_octree_handler_dev_pointer + boost::lexical_cast<std::string>(index); std::string number_cubes_name = shm_variable_name_number_cubes + boost::lexical_cast<std::string>(index); //Find the handler object std::pair<cudaIpcMemHandle_t*, std::size_t> res_h = shmm->getMemSegment().find<cudaIpcMemHandle_t>( handler_name.c_str()); error = res_h.second == 0; Cube* dev_data_pointer; if (!error) { cudaIpcMemHandle_t handler = *res_h.first; // get to device data pointer from the handler cudaError_t cuda_error = cudaIpcOpenMemHandle((void**) &dev_data_pointer, (cudaIpcMemHandle_t) handler, cudaIpcMemLazyEnablePeerAccess); // the handle is closed by Visualizer.cu if (cuda_error == cudaSuccess) { //Find the number of cubes std::pair<uint32_t*, std::size_t> res_d = shmm->getMemSegment().find<uint32_t>(number_cubes_name.c_str()); error = res_d.second == 0; if (!error) { cubes = dev_data_pointer; size = *res_d.first; return true; } } } /*If an error occurred */ cudaIpcCloseMemHandle(dev_data_pointer); return false; }