layers: Make unique_objects ID map global
Increasingly, instance objects are referenced by device-level APIs.
Made unique ID map global, shared across all instances and devices.
Change-Id: I5b62e7b95ec25a2a8b390d46024b43c29f2199ce
diff --git a/layers/unique_objects.cpp b/layers/unique_objects.cpp
index 542496c..e45b672 100644
--- a/layers/unique_objects.cpp
+++ b/layers/unique_objects.cpp
@@ -289,19 +289,19 @@
for (uint32_t idx0 = 0; idx0 < createInfoCount; ++idx0) {
local_pCreateInfos[idx0].initialize(&pCreateInfos[idx0]);
if (pCreateInfos[idx0].basePipelineHandle) {
- local_pCreateInfos[idx0].basePipelineHandle = Unwrap(device_data, pCreateInfos[idx0].basePipelineHandle);
+ local_pCreateInfos[idx0].basePipelineHandle = Unwrap(pCreateInfos[idx0].basePipelineHandle);
}
if (pCreateInfos[idx0].layout) {
- local_pCreateInfos[idx0].layout = Unwrap(device_data, pCreateInfos[idx0].layout);
+ local_pCreateInfos[idx0].layout = Unwrap(pCreateInfos[idx0].layout);
}
if (pCreateInfos[idx0].stage.module) {
- local_pCreateInfos[idx0].stage.module = Unwrap(device_data, pCreateInfos[idx0].stage.module);
+ local_pCreateInfos[idx0].stage.module = Unwrap(pCreateInfos[idx0].stage.module);
}
}
}
if (pipelineCache) {
std::lock_guard<std::mutex> lock(global_lock);
- pipelineCache = Unwrap(device_data, pipelineCache);
+ pipelineCache = Unwrap(pipelineCache);
}
VkResult result = device_data->dispatch_table.CreateComputePipelines(device, pipelineCache, createInfoCount,
@@ -311,7 +311,7 @@
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t i = 0; i < createInfoCount; ++i) {
if (pPipelines[i] != VK_NULL_HANDLE) {
- pPipelines[i] = WrapNew(device_data, pPipelines[i]);
+ pPipelines[i] = WrapNew(pPipelines[i]);
}
}
}
@@ -330,8 +330,7 @@
bool uses_color_attachment = false;
bool uses_depthstencil_attachment = false;
{
- const auto subpasses_uses_it =
- device_data->renderpasses_states.find(Unwrap(device_data, pCreateInfos[idx0].renderPass));
+ const auto subpasses_uses_it = device_data->renderpasses_states.find(Unwrap(pCreateInfos[idx0].renderPass));
if (subpasses_uses_it != device_data->renderpasses_states.end()) {
const auto &subpasses_uses = subpasses_uses_it->second;
if (subpasses_uses.subpasses_using_color_attachment.count(pCreateInfos[idx0].subpass))
@@ -344,27 +343,26 @@
local_pCreateInfos[idx0].initialize(&pCreateInfos[idx0], uses_color_attachment, uses_depthstencil_attachment);
if (pCreateInfos[idx0].basePipelineHandle) {
- local_pCreateInfos[idx0].basePipelineHandle = Unwrap(device_data, pCreateInfos[idx0].basePipelineHandle);
+ local_pCreateInfos[idx0].basePipelineHandle = Unwrap(pCreateInfos[idx0].basePipelineHandle);
}
if (pCreateInfos[idx0].layout) {
- local_pCreateInfos[idx0].layout = Unwrap(device_data, pCreateInfos[idx0].layout);
+ local_pCreateInfos[idx0].layout = Unwrap(pCreateInfos[idx0].layout);
}
if (pCreateInfos[idx0].pStages) {
for (uint32_t idx1 = 0; idx1 < pCreateInfos[idx0].stageCount; ++idx1) {
if (pCreateInfos[idx0].pStages[idx1].module) {
- local_pCreateInfos[idx0].pStages[idx1].module =
- Unwrap(device_data, pCreateInfos[idx0].pStages[idx1].module);
+ local_pCreateInfos[idx0].pStages[idx1].module = Unwrap(pCreateInfos[idx0].pStages[idx1].module);
}
}
}
if (pCreateInfos[idx0].renderPass) {
- local_pCreateInfos[idx0].renderPass = Unwrap(device_data, pCreateInfos[idx0].renderPass);
+ local_pCreateInfos[idx0].renderPass = Unwrap(pCreateInfos[idx0].renderPass);
}
}
}
if (pipelineCache) {
std::lock_guard<std::mutex> lock(global_lock);
- pipelineCache = Unwrap(device_data, pipelineCache);
+ pipelineCache = Unwrap(pipelineCache);
}
VkResult result = device_data->dispatch_table.CreateGraphicsPipelines(device, pipelineCache, createInfoCount,
@@ -374,7 +372,7 @@
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t i = 0; i < createInfoCount; ++i) {
if (pPipelines[i] != VK_NULL_HANDLE) {
- pPipelines[i] = WrapNew(device_data, pPipelines[i]);
+ pPipelines[i] = WrapNew(pPipelines[i]);
}
}
}
@@ -408,7 +406,7 @@
PostCallCreateRenderPass(dev_data, pCreateInfo, *pRenderPass);
- *pRenderPass = WrapNew(dev_data, *pRenderPass);
+ *pRenderPass = WrapNew(*pRenderPass);
}
return result;
}
@@ -421,8 +419,8 @@
layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(device), layer_data_map);
std::unique_lock<std::mutex> lock(global_lock);
uint64_t renderPass_id = reinterpret_cast<uint64_t &>(renderPass);
- renderPass = (VkRenderPass)dev_data->unique_id_mapping[renderPass_id];
- dev_data->unique_id_mapping.erase(renderPass_id);
+ renderPass = (VkRenderPass)unique_id_mapping[renderPass_id];
+ unique_id_mapping.erase(renderPass_id);
lock.unlock();
dev_data->dispatch_table.DestroyRenderPass(device, renderPass, pAllocator);
@@ -437,9 +435,9 @@
if (pCreateInfo) {
std::lock_guard<std::mutex> lock(global_lock);
local_pCreateInfo = new safe_VkSwapchainCreateInfoKHR(pCreateInfo);
- local_pCreateInfo->oldSwapchain = Unwrap(my_map_data, pCreateInfo->oldSwapchain);
+ local_pCreateInfo->oldSwapchain = Unwrap(pCreateInfo->oldSwapchain);
// Surface is instance-level object
- local_pCreateInfo->surface = Unwrap(my_map_data->instance_data, pCreateInfo->surface);
+ local_pCreateInfo->surface = Unwrap(pCreateInfo->surface);
}
VkResult result = my_map_data->dispatch_table.CreateSwapchainKHR(device, local_pCreateInfo->ptr(), pAllocator, pSwapchain);
@@ -448,7 +446,7 @@
}
if (VK_SUCCESS == result) {
std::lock_guard<std::mutex> lock(global_lock);
- *pSwapchain = WrapNew(my_map_data, *pSwapchain);
+ *pSwapchain = WrapNew(*pSwapchain);
}
return result;
}
@@ -466,10 +464,10 @@
local_pCreateInfos[i].initialize(&pCreateInfos[i]);
if (pCreateInfos[i].surface) {
// Surface is instance-level object
- local_pCreateInfos[i].surface = Unwrap(dev_data->instance_data, pCreateInfos[i].surface);
+ local_pCreateInfos[i].surface = Unwrap(pCreateInfos[i].surface);
}
if (pCreateInfos[i].oldSwapchain) {
- local_pCreateInfos[i].oldSwapchain = Unwrap(dev_data, pCreateInfos[i].oldSwapchain);
+ local_pCreateInfos[i].oldSwapchain = Unwrap(pCreateInfos[i].oldSwapchain);
}
}
}
@@ -480,7 +478,7 @@
if (VK_SUCCESS == result) {
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t i = 0; i < swapchainCount; i++) {
- pSwapchains[i] = WrapNew(dev_data, pSwapchains[i]);
+ pSwapchains[i] = WrapNew(pSwapchains[i]);
}
}
return result;
@@ -492,7 +490,7 @@
VkSwapchainKHR wrapped_swapchain_handle = swapchain;
if (VK_NULL_HANDLE != swapchain) {
std::lock_guard<std::mutex> lock(global_lock);
- swapchain = Unwrap(my_device_data, swapchain);
+ swapchain = Unwrap(swapchain);
}
VkResult result =
my_device_data->dispatch_table.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages);
@@ -501,7 +499,7 @@
std::lock_guard<std::mutex> lock(global_lock);
auto &wrapped_swapchain_image_handles = my_device_data->swapchain_wrapped_image_handle_map[wrapped_swapchain_handle];
for (uint32_t i = static_cast<uint32_t>(wrapped_swapchain_image_handles.size()); i < *pSwapchainImageCount; i++) {
- wrapped_swapchain_image_handles.emplace_back(WrapNew(my_device_data, pSwapchainImages[i]));
+ wrapped_swapchain_image_handles.emplace_back(WrapNew(pSwapchainImages[i]));
}
for (uint32_t i = 0; i < *pSwapchainImageCount; i++) {
pSwapchainImages[i] = wrapped_swapchain_image_handles[i];
@@ -517,13 +515,13 @@
auto &image_array = dev_data->swapchain_wrapped_image_handle_map[swapchain];
for (auto &image_handle : image_array) {
- dev_data->unique_id_mapping.erase(HandleToUint64(image_handle));
+ unique_id_mapping.erase(HandleToUint64(image_handle));
}
dev_data->swapchain_wrapped_image_handle_map.erase(swapchain);
uint64_t swapchain_id = HandleToUint64(swapchain);
- swapchain = (VkSwapchainKHR)dev_data->unique_id_mapping[swapchain_id];
- dev_data->unique_id_mapping.erase(swapchain_id);
+ swapchain = (VkSwapchainKHR)unique_id_mapping[swapchain_id];
+ unique_id_mapping.erase(swapchain_id);
lock.unlock();
dev_data->dispatch_table.DestroySwapchainKHR(device, swapchain, pAllocator);
}
@@ -537,12 +535,12 @@
local_pPresentInfo = new safe_VkPresentInfoKHR(pPresentInfo);
if (local_pPresentInfo->pWaitSemaphores) {
for (uint32_t index1 = 0; index1 < local_pPresentInfo->waitSemaphoreCount; ++index1) {
- local_pPresentInfo->pWaitSemaphores[index1] = Unwrap(dev_data, pPresentInfo->pWaitSemaphores[index1]);
+ local_pPresentInfo->pWaitSemaphores[index1] = Unwrap(pPresentInfo->pWaitSemaphores[index1]);
}
}
if (local_pPresentInfo->pSwapchains) {
for (uint32_t index1 = 0; index1 < local_pPresentInfo->swapchainCount; ++index1) {
- local_pPresentInfo->pSwapchains[index1] = Unwrap(dev_data, pPresentInfo->pSwapchains[index1]);
+ local_pPresentInfo->pSwapchains[index1] = Unwrap(pPresentInfo->pSwapchains[index1]);
}
}
}
@@ -572,10 +570,10 @@
if (pCreateInfo) {
local_create_info = new safe_VkDescriptorUpdateTemplateCreateInfoKHR(pCreateInfo);
if (pCreateInfo->descriptorSetLayout) {
- local_create_info->descriptorSetLayout = Unwrap(dev_data, pCreateInfo->descriptorSetLayout);
+ local_create_info->descriptorSetLayout = Unwrap(pCreateInfo->descriptorSetLayout);
}
if (pCreateInfo->pipelineLayout) {
- local_create_info->pipelineLayout = Unwrap(dev_data, pCreateInfo->pipelineLayout);
+ local_create_info->pipelineLayout = Unwrap(pCreateInfo->pipelineLayout);
}
}
}
@@ -583,7 +581,7 @@
pDescriptorUpdateTemplate);
if (VK_SUCCESS == result) {
std::lock_guard<std::mutex> lock(global_lock);
- *pDescriptorUpdateTemplate = WrapNew(dev_data, *pDescriptorUpdateTemplate);
+ *pDescriptorUpdateTemplate = WrapNew(*pDescriptorUpdateTemplate);
// Shadow template createInfo for later updates
std::unique_ptr<TEMPLATE_STATE> template_state(new TEMPLATE_STATE(*pDescriptorUpdateTemplate, local_create_info));
@@ -599,8 +597,8 @@
std::unique_lock<std::mutex> lock(global_lock);
uint64_t descriptor_update_template_id = reinterpret_cast<uint64_t &>(descriptorUpdateTemplate);
dev_data->desc_template_map.erase(descriptor_update_template_id);
- descriptorUpdateTemplate = (VkDescriptorUpdateTemplateKHR)dev_data->unique_id_mapping[descriptor_update_template_id];
- dev_data->unique_id_mapping.erase(descriptor_update_template_id);
+ descriptorUpdateTemplate = (VkDescriptorUpdateTemplateKHR)unique_id_mapping[descriptor_update_template_id];
+ unique_id_mapping.erase(descriptor_update_template_id);
lock.unlock();
dev_data->dispatch_table.DestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator);
}
@@ -629,8 +627,8 @@
allocation_size = std::max(allocation_size, offset + sizeof(VkDescriptorImageInfo));
VkDescriptorImageInfo *wrapped_entry = new VkDescriptorImageInfo(*image_entry);
- wrapped_entry->sampler = Unwrap(dev_data, image_entry->sampler);
- wrapped_entry->imageView = Unwrap(dev_data, image_entry->imageView);
+ wrapped_entry->sampler = Unwrap(image_entry->sampler);
+ wrapped_entry->imageView = Unwrap(image_entry->imageView);
template_entries.emplace_back(offset, kVulkanObjectTypeImage, reinterpret_cast<void *>(wrapped_entry));
} break;
@@ -642,7 +640,7 @@
allocation_size = std::max(allocation_size, offset + sizeof(VkDescriptorBufferInfo));
VkDescriptorBufferInfo *wrapped_entry = new VkDescriptorBufferInfo(*buffer_entry);
- wrapped_entry->buffer = Unwrap(dev_data, buffer_entry->buffer);
+ wrapped_entry->buffer = Unwrap(buffer_entry->buffer);
template_entries.emplace_back(offset, kVulkanObjectTypeBuffer, reinterpret_cast<void *>(wrapped_entry));
} break;
@@ -651,7 +649,7 @@
auto buffer_view_handle = reinterpret_cast<VkBufferView *>(update_entry);
allocation_size = std::max(allocation_size, offset + sizeof(VkBufferView));
- VkBufferView wrapped_entry = Unwrap(dev_data, *buffer_view_handle);
+ VkBufferView wrapped_entry = Unwrap(*buffer_view_handle);
template_entries.emplace_back(offset, kVulkanObjectTypeBufferView, reinterpret_cast<void *>(wrapped_entry));
} break;
default:
@@ -695,8 +693,8 @@
void *unwrapped_buffer = nullptr;
{
std::lock_guard<std::mutex> lock(global_lock);
- descriptorSet = Unwrap(dev_data, descriptorSet);
- descriptorUpdateTemplate = (VkDescriptorUpdateTemplateKHR)dev_data->unique_id_mapping[template_handle];
+ descriptorSet = Unwrap(descriptorSet);
+ descriptorUpdateTemplate = (VkDescriptorUpdateTemplateKHR)unique_id_mapping[template_handle];
unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(dev_data, template_handle, pData);
}
dev_data->dispatch_table.UpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, unwrapped_buffer);
@@ -711,8 +709,8 @@
void *unwrapped_buffer = nullptr;
{
std::lock_guard<std::mutex> lock(global_lock);
- descriptorUpdateTemplate = Unwrap(dev_data, descriptorUpdateTemplate);
- layout = Unwrap(dev_data, layout);
+ descriptorUpdateTemplate = Unwrap(descriptorUpdateTemplate);
+ layout = Unwrap(layout);
unwrapped_buffer = BuildUnwrappedUpdateTemplateBuffer(dev_data, template_handle, pData);
}
dev_data->dispatch_table.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set,
@@ -730,7 +728,7 @@
if ((result == VK_SUCCESS || result == VK_INCOMPLETE) && pProperties) {
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
- pProperties[idx0].display = WrapNew(my_map_data, pProperties[idx0].display);
+ pProperties[idx0].display = WrapNew(pProperties[idx0].display);
}
}
return result;
@@ -746,8 +744,8 @@
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t i = 0; i < *pDisplayCount; i++) {
// TODO: this looks like it really wants a /reverse/ mapping. What's going on here?
- auto it = my_map_data->unique_id_mapping.find(reinterpret_cast<const uint64_t &>(pDisplays[i]));
- assert(it != my_map_data->unique_id_mapping.end());
+ auto it = unique_id_mapping.find(reinterpret_cast<const uint64_t &>(pDisplays[i]));
+ assert(it != unique_id_mapping.end());
pDisplays[i] = reinterpret_cast<VkDisplayKHR &>(it->second);
}
}
@@ -760,14 +758,14 @@
instance_layer_data *my_map_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
{
std::lock_guard<std::mutex> lock(global_lock);
- display = Unwrap(my_map_data, display);
+ display = Unwrap(display);
}
VkResult result = my_map_data->dispatch_table.GetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties);
if (result == VK_SUCCESS && pProperties) {
std::lock_guard<std::mutex> lock(global_lock);
for (uint32_t idx0 = 0; idx0 < *pPropertyCount; ++idx0) {
- pProperties[idx0].displayMode = WrapNew(my_map_data, pProperties[idx0].displayMode);
+ pProperties[idx0].displayMode = WrapNew(pProperties[idx0].displayMode);
}
}
return result;
@@ -778,7 +776,7 @@
instance_layer_data *dev_data = GetLayerDataPtr(get_dispatch_key(physicalDevice), instance_layer_data_map);
{
std::lock_guard<std::mutex> lock(global_lock);
- mode = Unwrap(dev_data, mode);
+ mode = Unwrap(mode);
}
VkResult result = dev_data->dispatch_table.GetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities);
return result;
@@ -790,8 +788,8 @@
auto local_tag_info = new safe_VkDebugMarkerObjectTagInfoEXT(pTagInfo);
{
std::lock_guard<std::mutex> lock(global_lock);
- auto it = device_data->unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_tag_info->object));
- if (it != device_data->unique_id_mapping.end()) {
+ auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_tag_info->object));
+ if (it != unique_id_mapping.end()) {
local_tag_info->object = it->second;
}
}
@@ -805,8 +803,8 @@
auto local_name_info = new safe_VkDebugMarkerObjectNameInfoEXT(pNameInfo);
{
std::lock_guard<std::mutex> lock(global_lock);
- auto it = device_data->unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_name_info->object));
- if (it != device_data->unique_id_mapping.end()) {
+ auto it = unique_id_mapping.find(reinterpret_cast<uint64_t &>(local_name_info->object));
+ if (it != unique_id_mapping.end()) {
local_name_info->object = it->second;
}
}
diff --git a/layers/unique_objects.h b/layers/unique_objects.h
index 60523ca..27eb34f 100644
--- a/layers/unique_objects.h
+++ b/layers/unique_objects.h
@@ -35,6 +35,7 @@
// All increments must be guarded by global_lock
static uint64_t global_unique_id = 1;
+static std::unordered_map<uint64_t, uint64_t> unique_id_mapping; // Map uniqueID to actual object handle
struct TEMPLATE_STATE {
VkDescriptorUpdateTemplateKHR desc_update_template;
@@ -51,13 +52,10 @@
std::vector<VkDebugReportCallbackEXT> logging_callback;
VkLayerInstanceDispatchTable dispatch_table = {};
- // The following are for keeping track of the temporary callbacks that can
- // be used in vkCreateInstance and vkDestroyInstance:
+ // The following are for keeping track of the temporary callbacks that can be used in vkCreateInstance and vkDestroyInstance:
uint32_t num_tmp_callbacks;
VkDebugReportCallbackCreateInfoEXT *tmp_dbg_create_infos;
VkDebugReportCallbackEXT *tmp_callbacks;
-
- std::unordered_map<uint64_t, uint64_t> unique_id_mapping; // Map uniqueID to actual object handle
};
struct layer_data {
@@ -69,14 +67,13 @@
std::unordered_map<uint64_t, std::unique_ptr<TEMPLATE_STATE>> desc_template_map;
bool wsi_enabled;
- std::unordered_map<uint64_t, uint64_t> unique_id_mapping; // Map uniqueID to actual object handle
VkPhysicalDevice gpu;
struct SubpassesUsageStates {
std::unordered_set<uint32_t> subpasses_using_color_attachment;
std::unordered_set<uint32_t> subpasses_using_depthstencil_attachment;
};
- // uses unwrapped handles
+ // Uses unwrapped handles
std::unordered_map<VkRenderPass, SubpassesUsageStates> renderpasses_states;
// Map of wrapped swapchain handles to arrays of wrapped swapchain image IDs
@@ -115,18 +112,17 @@
/* Unwrap a handle. */
// must hold lock!
-template <typename HandleType, typename MapType>
-HandleType Unwrap(MapType *layer_data, HandleType wrappedHandle) {
+template <typename HandleType>
+HandleType Unwrap(HandleType wrappedHandle) {
// TODO: don't use operator[] here.
- return (HandleType)layer_data->unique_id_mapping[reinterpret_cast<uint64_t const &>(wrappedHandle)];
+ return (HandleType)unique_id_mapping[reinterpret_cast<uint64_t const &>(wrappedHandle)];
}
-/* Wrap a newly created handle with a new unique ID, and return the new ID. */
-// must hold lock!
-template <typename HandleType, typename MapType>
-HandleType WrapNew(MapType *layer_data, HandleType newlyCreatedHandle) {
+// Wrap a newly created handle with a new unique ID, and return the new ID -- must hold lock!
+template <typename HandleType>
+HandleType WrapNew(HandleType newlyCreatedHandle) {
auto unique_id = global_unique_id++;
- layer_data->unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
+ unique_id_mapping[unique_id] = reinterpret_cast<uint64_t const &>(newlyCreatedHandle);
return (HandleType)unique_id;
}
diff --git a/scripts/unique_objects_generator.py b/scripts/unique_objects_generator.py
index fe7cc9c..67905da 100644
--- a/scripts/unique_objects_generator.py
+++ b/scripts/unique_objects_generator.py
@@ -472,7 +472,7 @@
def build_extension_processing_func(self):
# Construct helper functions to build and free pNext extension chains
pnext_proc = ''
- pnext_proc += 'void *CreateUnwrappedExtensionStructs(layer_data *dev_data, const void *pNext) {\n'
+ pnext_proc += 'void *CreateUnwrappedExtensionStructs(const void *pNext) {\n'
pnext_proc += ' void *cur_pnext = const_cast<void *>(pNext);\n'
pnext_proc += ' void *head_pnext = NULL;\n'
pnext_proc += ' void *prev_ext_struct = NULL;\n'
@@ -542,7 +542,7 @@
create_ndo_code += '%sfor (uint32_t index0 = 0; index0 < %s; index0++) {\n' % (indent, cmd_info[-1].len)
indent = self.incIndent(indent)
ndo_dest = '%s[index0]' % cmd_info[-1].name
- create_ndo_code += '%s%s = WrapNew(dev_data, %s);\n' % (indent, ndo_dest, ndo_dest)
+ create_ndo_code += '%s%s = WrapNew(%s);\n' % (indent, ndo_dest, ndo_dest)
if ndo_array == True:
indent = self.decIndent(indent)
create_ndo_code += '%s}\n' % indent
@@ -571,7 +571,7 @@
indent = self.incIndent(indent)
destroy_ndo_code += '%s%s handle = %s[index0];\n' % (indent, cmd_info[param].type, cmd_info[param].name)
destroy_ndo_code += '%suint64_t unique_id = reinterpret_cast<uint64_t &>(handle);\n' % (indent)
- destroy_ndo_code += '%sdev_data->unique_id_mapping.erase(unique_id);\n' % (indent)
+ destroy_ndo_code += '%sunique_id_mapping.erase(unique_id);\n' % (indent)
indent = self.decIndent(indent);
destroy_ndo_code += '%s}\n' % indent
indent = self.decIndent(indent);
@@ -580,8 +580,8 @@
# Remove a single handle from the map
destroy_ndo_code += '%sstd::unique_lock<std::mutex> lock(global_lock);\n' % (indent)
destroy_ndo_code += '%suint64_t %s_id = reinterpret_cast<uint64_t &>(%s);\n' % (indent, cmd_info[param].name, cmd_info[param].name)
- destroy_ndo_code += '%s%s = (%s)dev_data->unique_id_mapping[%s_id];\n' % (indent, cmd_info[param].name, cmd_info[param].type, cmd_info[param].name)
- destroy_ndo_code += '%sdev_data->unique_id_mapping.erase(%s_id);\n' % (indent, cmd_info[param].name)
+ destroy_ndo_code += '%s%s = (%s)unique_id_mapping[%s_id];\n' % (indent, cmd_info[param].name, cmd_info[param].type, cmd_info[param].name)
+ destroy_ndo_code += '%sunique_id_mapping.erase(%s_id);\n' % (indent, cmd_info[param].name)
destroy_ndo_code += '%slock.unlock();\n' % (indent)
return ndo_array, destroy_ndo_code
@@ -616,11 +616,11 @@
pre_call_code += '%s local_%s%s = new %s[%s];\n' % (indent, prefix, ndo_name, ndo_type, ndo_count)
pre_call_code += '%s for (uint32_t %s = 0; %s < %s; ++%s) {\n' % (indent, index, index, ndo_count, index)
indent = self.incIndent(indent)
- pre_call_code += '%s local_%s%s[%s] = Unwrap(dev_data, %s[%s]);\n' % (indent, prefix, ndo_name, index, ndo_name, index)
+ pre_call_code += '%s local_%s%s[%s] = Unwrap(%s[%s]);\n' % (indent, prefix, ndo_name, index, ndo_name, index)
else:
pre_call_code += '%s for (uint32_t %s = 0; %s < %s; ++%s) {\n' % (indent, index, index, ndo_count, index)
indent = self.incIndent(indent)
- pre_call_code += '%s %s%s[%s] = Unwrap(dev_data, %s%s[%s]);\n' % (indent, prefix, ndo_name, index, prefix, ndo_name, index)
+ pre_call_code += '%s %s%s[%s] = Unwrap(%s%s[%s]);\n' % (indent, prefix, ndo_name, index, prefix, ndo_name, index)
indent = self.decIndent(indent)
pre_call_code += '%s }\n' % indent
indent = self.decIndent(indent)
@@ -632,14 +632,14 @@
else:
if top_level == True:
if (destroy_func == False) or (destroy_array == True):
- pre_call_code += '%s %s = Unwrap(dev_data, %s);\n' % (indent, ndo_name, ndo_name)
+ pre_call_code += '%s %s = Unwrap(%s);\n' % (indent, ndo_name, ndo_name)
else:
# Make temp copy of this var with the 'local' removed. It may be better to not pass in 'local_'
# as part of the string and explicitly print it
fix = str(prefix).strip('local_');
pre_call_code += '%s if (%s%s) {\n' % (indent, fix, ndo_name)
indent = self.incIndent(indent)
- pre_call_code += '%s %s%s = Unwrap(dev_data, %s%s);\n' % (indent, prefix, ndo_name, fix, ndo_name)
+ pre_call_code += '%s %s%s = Unwrap(%s%s);\n' % (indent, prefix, ndo_name, fix, ndo_name)
indent = self.decIndent(indent)
pre_call_code += '%s }\n' % indent
return decl_code, pre_call_code, post_call_code
@@ -692,7 +692,7 @@
if first_level_param == True:
pre_code += '%s %s[%s].initialize(&%s[%s]);\n' % (indent, new_prefix, index, member.name, index)
if process_pnext:
- pre_code += '%s %s[%s].pNext = CreateUnwrappedExtensionStructs(dev_data, %s[%s].pNext);\n' % (indent, new_prefix, index, new_prefix, index)
+ pre_code += '%s %s[%s].pNext = CreateUnwrappedExtensionStructs(%s[%s].pNext);\n' % (indent, new_prefix, index, new_prefix, index)
local_prefix = '%s[%s].' % (new_prefix, index)
# Process sub-structs in this struct
(tmp_decl, tmp_pre, tmp_post) = self.uniquify_members(struct_info, indent, local_prefix, array_index, create_func, destroy_func, destroy_array, False)
@@ -724,7 +724,7 @@
pre_code += tmp_pre
post_code += tmp_post
if process_pnext:
- pre_code += '%s local_%s%s->pNext = CreateUnwrappedExtensionStructs(dev_data, local_%s%s->pNext);\n' % (indent, prefix, member.name, prefix, member.name)
+ pre_code += '%s local_%s%s->pNext = CreateUnwrappedExtensionStructs(local_%s%s->pNext);\n' % (indent, prefix, member.name, prefix, member.name)
indent = self.decIndent(indent)
pre_code += '%s }\n' % indent
if first_level_param == True: