diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index a9ef5f4..b77b742 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -28,6 +28,7 @@
 #include <string.h>
 #include <assert.h>
 #include <list>
+#include <map>
 #include <unordered_map>
 #include <vector>
 using namespace std;
@@ -42,12 +43,22 @@
 #include "loader_platform.h"
 #include "layers_msg.h"
 
-static VkLayerDispatchTable nextTable;
-static VkLayerInstanceDispatchTable nextInstanceTable;
-static VkBaseLayerObject *pCurObj;
+static std::unordered_map<void *, VkLayerDispatchTable *> tableMap;
+static std::unordered_map<void *, VkLayerInstanceDispatchTable *> tableInstanceMap;
+
 static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_initOnce);
-static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_tabDeviceOnce);
-static LOADER_PLATFORM_THREAD_ONCE_DECLARATION(g_tabInstanceOnce);
+
+static inline VkLayerDispatchTable *device_dispatch_table(VkObject object) {
+    VkLayerDispatchTable *pDisp  = *(VkLayerDispatchTable **) object;
+    VkLayerDispatchTable *pTable = tableMap[pDisp];
+    return pTable;
+}
+
+static inline VkLayerInstanceDispatchTable *instance_dispatch_table(VkObject object) {
+    VkLayerInstanceDispatchTable **ppDisp    = (VkLayerInstanceDispatchTable **) object;
+    VkLayerInstanceDispatchTable *pInstanceTable = tableInstanceMap[*ppDisp];
+    return pInstanceTable;
+}
 
 // TODO : This can be much smarter, using separate locks for separate global data
 static int globalLockInitialized = 0;
@@ -145,6 +156,7 @@
 {
     // Create fence object
     uint64_t       fenceId    = g_currentFenceId++;
+    // If no fence, create an internal fence to track the submissions
     if (fence != NULL) {
         fenceMap[fence].fenceId = fenceId;
         fenceMap[fence].queue = queue;
@@ -767,21 +779,48 @@
     }
 }
 
-// TODO handle multiple GPUs/instances for both instance and device dispatch tables
-static void initDeviceTable(void)
-{
-    PFN_vkGetDeviceProcAddr fpNextGPA;
-    fpNextGPA = (PFN_vkGetDeviceProcAddr) pCurObj->pGPA;
-    assert(fpNextGPA);
-    layer_initialize_dispatch_table(&nextTable, fpNextGPA, (VkDevice) pCurObj->nextObject);
+static VkLayerDispatchTable * initDeviceTable(const VkBaseLayerObject *devw)
+ {
+    VkLayerDispatchTable *pTable;
+
+    assert(devw);
+    VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) (devw->baseObject);
+
+    std::unordered_map<void *, VkLayerDispatchTable *>::const_iterator it = tableMap.find((void *) *ppDisp);
+    if (it == tableMap.end())
+    {
+        pTable =  new VkLayerDispatchTable;
+        tableMap[(void *) *ppDisp] = pTable;
+    } else
+    {
+        return it->second;
+    }
+
+    layer_initialize_dispatch_table(pTable, (PFN_vkGetDeviceProcAddr) devw->pGPA, (VkDevice) devw->nextObject);
+
+    return pTable;
 }
 
-static void initInstanceTable(void)
+
+static VkLayerInstanceDispatchTable * initInstanceTable(const VkBaseLayerObject *instw)
 {
-    PFN_vkGetInstanceProcAddr fpNextGPA;
-    fpNextGPA = (PFN_vkGetInstanceProcAddr) pCurObj->pGPA;
-    assert(fpNextGPA);
-    layer_init_instance_dispatch_table(&nextInstanceTable, fpNextGPA, (VkInstance) pCurObj->nextObject);
+    VkLayerInstanceDispatchTable *pTable;
+    assert(instw);
+    VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) instw->baseObject;
+
+    std::unordered_map<void *, VkLayerInstanceDispatchTable *>::const_iterator it = tableInstanceMap.find((void *) *ppDisp);
+    if (it == tableInstanceMap.end())
+    {
+        pTable =  new VkLayerInstanceDispatchTable;
+        tableInstanceMap[(void *) *ppDisp] = pTable;
+    } else
+    {
+        return it->second;
+    }
+
+    layer_init_instance_dispatch_table(pTable, (PFN_vkGetInstanceProcAddr) instw->pGPA, (VkInstance) instw->nextObject);
+
+    return pTable;
 }
 
 static void initMemTracker(
@@ -815,24 +854,21 @@
     }
 }
 
-//VkResult VKAPI vkCreateInstance(
-//    const VkInstanceCreateInfo*                 pCreateInfo,
-//    VkInstance*                                 pInstance)
-//{
-//    loader_platform_thread_once(&g_initOnce, initMemTracker);
-//    VkResult result = nextTable.CreateInstance(pCreateInfo, pInstance);
-//    if (result == VK_SUCCESS) {
-//        enable_debug_report(pCreateInfo->extensionCount, pCreateInfo->ppEnabledExtensionNames);
-//    }
-//    return result;
-//}
+// hook DestroyInstance to remove tableInstanceMap entry
+VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
+{
+    VkLayerInstanceDispatchTable *pDisp = *(VkLayerInstanceDispatchTable **) instance;
+    VkResult res = instance_dispatch_table(instance)->DestroyInstance(instance);
+    tableInstanceMap.erase(pDisp);
+    return res;
+}
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
     VkDevice                 *pDevice)
 {
-    VkResult result = nextInstanceTable.CreateDevice(gpu, pCreateInfo, pDevice);
+    VkResult result = instance_dispatch_table(gpu)->CreateDevice(gpu, pCreateInfo, pDevice);
     if (result == VK_SUCCESS) {
         // Save off device in case we need it to create Fences
         globalDevice = *pDevice;
@@ -874,7 +910,11 @@
     delete_queue_info_list();
 
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = nextTable.DestroyDevice(device);
+
+    VkLayerDispatchTable *pDisp  =  *(VkLayerDispatchTable **) device;
+    VkLayerDispatchTable *pTable = tableMap[pDisp];
+    VkResult              result = pTable->DestroyDevice(device);
+    tableMap.erase(pDisp);
     return result;
 }
 
@@ -937,7 +977,7 @@
     uint32_t  queueIndex,
     VkQueue   *pQueue)
 {
-    VkResult result = nextTable.GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
+    VkResult result = device_dispatch_table(device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_queue_info(*pQueue);
@@ -967,7 +1007,8 @@
     }
 
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = nextTable.QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
+    VkResult result = device_dispatch_table(queue)->QueueSubmit(
+        queue, cmdBufferCount, pCmdBuffers, fence);
     return result;
 }
 
@@ -976,7 +1017,7 @@
     const VkMemoryAllocInfo *pAllocInfo,
     VkDeviceMemory          *pMem)
 {
-    VkResult result = nextTable.AllocMemory(device, pAllocInfo, pMem);
+    VkResult result = device_dispatch_table(device)->AllocMemory(device, pAllocInfo, pMem);
     // TODO : Track allocations and overall size here
     loader_platform_thread_lock_mutex(&globalLock);
     add_mem_obj_info(*pMem, pAllocInfo);
@@ -1005,7 +1046,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_DESTROY_OBJECT_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = nextTable.FreeMemory(device, mem);
+    VkResult result = device_dispatch_table(device)->FreeMemory(device, mem);
     return result;
 }
 
@@ -1016,7 +1057,7 @@
 {
     // TODO : Update tracking for this alloc
     //  Make sure memory is not pinned, which can't have priority set
-    VkResult result = nextTable.SetMemoryPriority(device, mem, priority);
+    VkResult result = device_dispatch_table(device)->SetMemoryPriority(device, mem, priority);
     return result;
 }
 
@@ -1037,7 +1078,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_DEVICE_MEMORY, mem, 0, MEMTRACK_INVALID_STATE, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = nextTable.MapMemory(device, mem, offset, size, flags, ppData);
+    VkResult result = device_dispatch_table(device)->MapMemory(device, mem, offset, size, flags, ppData);
     return result;
 }
 
@@ -1047,7 +1088,7 @@
 {
     // TODO : Track as memory gets unmapped, do we want to check what changed following map?
     //   Make sure that memory was ever mapped to begin with
-    VkResult result = nextTable.UnmapMemory(device, mem);
+    VkResult result = device_dispatch_table(device)->UnmapMemory(device, mem);
     return result;
 }
 
@@ -1059,7 +1100,7 @@
 {
     // TODO : Track this
     //  Verify that memory is actually pinnable
-    VkResult result = nextTable.PinSystemMemory(device, pSysMem, memSize, pMem);
+    VkResult result = device_dispatch_table(device)->PinSystemMemory(device, pSysMem, memSize, pMem);
     return result;
 }
 
@@ -1069,7 +1110,7 @@
     VkDeviceMemory         *pMem)
 {
     // TODO : Track this
-    VkResult result = nextTable.OpenSharedMemory(device, pOpenInfo, pMem);
+    VkResult result = device_dispatch_table(device)->OpenSharedMemory(device, pOpenInfo, pMem);
     return result;
 }
 
@@ -1079,7 +1120,7 @@
     VkDeviceMemory             *pMem)
 {
     // TODO : Track this
-    VkResult result = nextTable.OpenPeerMemory(device, pOpenInfo, pMem);
+    VkResult result = device_dispatch_table(device)->OpenPeerMemory(device, pOpenInfo, pMem);
     return result;
 }
 
@@ -1090,7 +1131,7 @@
     VkDeviceMemory            *pMem)
 {
     // TODO : Track this
-    VkResult result = nextTable.OpenPeerImage(device, pOpenInfo, pImage, pMem);
+    VkResult result = device_dispatch_table(device)->OpenPeerImage(device, pOpenInfo, pImage, pMem);
     return result;
 }
 
@@ -1132,7 +1173,7 @@
     }
 
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = nextTable.DestroyObject(device, objType, object);
+    VkResult result = device_dispatch_table(device)->DestroyObject(device, objType, object);
     return result;
 }
 
@@ -1148,7 +1189,7 @@
     //   Could potentially save returned mem requirements and validate values passed into BindObjectMemory for this object
     // From spec : The only objects that are guaranteed to have no external memory requirements are devices, queues,
     //             command buffers, shaders and memory objects.
-    VkResult result = nextTable.GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
+    VkResult result = device_dispatch_table(device)->GetObjectInfo(device, objType, object, infoType, pDataSize, pData);
     return result;
 }
 
@@ -1159,7 +1200,7 @@
     VkDeviceMemory mem,
     VkDeviceSize   offset)
 {
-    VkResult result = nextTable.BindObjectMemory(device, objType, object, mem, offset);
+    VkResult result = device_dispatch_table(device)->BindObjectMemory(device, objType, object, mem, offset);
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
     set_object_binding(object, mem);
@@ -1177,7 +1218,8 @@
     VkDeviceMemory mem,
     VkDeviceSize   memOffset)
 {
-    VkResult result = nextTable.QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset);
+    VkResult result = device_dispatch_table(queue)->QueueBindSparseBufferMemory(
+        queue, buffer, rangeOffset, rangeSize, mem, memOffset);
     loader_platform_thread_lock_mutex(&globalLock);
     // Track objects tied to memory
     if (VK_FALSE == set_sparse_buffer_binding(buffer, mem)) {
@@ -1196,7 +1238,7 @@
     const VkFenceCreateInfo *pCreateInfo,
     VkFence                 *pFence)
 {
-    VkResult result = nextTable.CreateFence(device, pCreateInfo, pFence);
+    VkResult result = device_dispatch_table(device)->CreateFence(device, pCreateInfo, pFence);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pFence, pCreateInfo->sType, pCreateInfo, sizeof(VkFenceCreateInfo), "fence");
@@ -1210,7 +1252,7 @@
     uint32_t  fenceCount,
     VkFence  *pFences)
 {
-    VkResult result = nextTable.ResetFences(device, fenceCount, pFences);
+    VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         // Reset fence state in fenceCreateInfo structure
@@ -1239,7 +1281,7 @@
     VkDevice device,
     VkFence  fence)
 {
-    VkResult result = nextTable.GetFenceStatus(device, fence);
+    VkResult result = device_dispatch_table(device)->GetFenceStatus(device, fence);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         update_fence_tracking(fence);
@@ -1267,7 +1309,7 @@
         }
     }
 
-    VkResult result = nextTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout);
+    VkResult result = device_dispatch_table(device)->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
     loader_platform_thread_lock_mutex(&globalLock);
 
     if (VK_SUCCESS == result) {
@@ -1284,7 +1326,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkQueueWaitIdle(
     VkQueue queue)
 {
-    VkResult result = nextTable.QueueWaitIdle(queue);
+    VkResult result = device_dispatch_table(queue)->QueueWaitIdle(queue);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         retire_queue_fences(queue);
@@ -1296,7 +1338,7 @@
 VK_LAYER_EXPORT VkResult VKAPI vkDeviceWaitIdle(
     VkDevice device)
 {
-    VkResult result = nextTable.DeviceWaitIdle(device);
+    VkResult result = device_dispatch_table(device)->DeviceWaitIdle(device);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         retire_device_fences(device);
@@ -1310,7 +1352,7 @@
     const VkEventCreateInfo *pCreateInfo,
     VkEvent                 *pEvent)
 {
-    VkResult result = nextTable.CreateEvent(device, pCreateInfo, pEvent);
+    VkResult result = device_dispatch_table(device)->CreateEvent(device, pCreateInfo, pEvent);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pEvent, pCreateInfo->sType, pCreateInfo, sizeof(VkEventCreateInfo), "event");
@@ -1324,7 +1366,7 @@
     const VkQueryPoolCreateInfo *pCreateInfo,
     VkQueryPool                 *pQueryPool)
 {
-    VkResult result = nextTable.CreateQueryPool(device, pCreateInfo, pQueryPool);
+    VkResult result = device_dispatch_table(device)->CreateQueryPool(device, pCreateInfo, pQueryPool);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pQueryPool, pCreateInfo->sType, pCreateInfo, sizeof(VkQueryPoolCreateInfo), "query_pool");
@@ -1338,7 +1380,7 @@
     const VkBufferCreateInfo *pCreateInfo,
     VkBuffer                 *pBuffer)
 {
-    VkResult result = nextTable.CreateBuffer(device, pCreateInfo, pBuffer);
+    VkResult result = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pBuffer);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pBuffer, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferCreateInfo), "buffer");
@@ -1352,7 +1394,7 @@
     const VkBufferViewCreateInfo *pCreateInfo,
     VkBufferView                 *pView)
 {
-    VkResult result = nextTable.CreateBufferView(device, pCreateInfo, pView);
+    VkResult result = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkBufferViewCreateInfo), "buffer_view");
@@ -1366,7 +1408,7 @@
     const VkImageCreateInfo *pCreateInfo,
     VkImage                 *pImage)
 {
-    VkResult result = nextTable.CreateImage(device, pCreateInfo, pImage);
+    VkResult result = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pImage);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pImage, pCreateInfo->sType, pCreateInfo, sizeof(VkImageCreateInfo), "image");
@@ -1380,7 +1422,7 @@
     const VkImageViewCreateInfo *pCreateInfo,
     VkImageView                 *pView)
 {
-    VkResult result = nextTable.CreateImageView(device, pCreateInfo, pView);
+    VkResult result = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkImageViewCreateInfo), "image_view");
@@ -1394,7 +1436,7 @@
     const VkColorAttachmentViewCreateInfo *pCreateInfo,
     VkColorAttachmentView                 *pView)
 {
-    VkResult result = nextTable.CreateColorAttachmentView(device, pCreateInfo, pView);
+    VkResult result = device_dispatch_table(device)->CreateColorAttachmentView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkColorAttachmentViewCreateInfo), "color_attachment_view");
@@ -1408,7 +1450,7 @@
     const VkDepthStencilViewCreateInfo *pCreateInfo,
     VkDepthStencilView                 *pView)
 {
-    VkResult result = nextTable.CreateDepthStencilView(device, pCreateInfo, pView);
+    VkResult result = device_dispatch_table(device)->CreateDepthStencilView(device, pCreateInfo, pView);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pView, pCreateInfo->sType, pCreateInfo, sizeof(VkDepthStencilViewCreateInfo), "ds_view");
@@ -1422,7 +1464,7 @@
     const VkShaderCreateInfo *pCreateInfo,
     VkShader                 *pShader)
 {
-    VkResult result = nextTable.CreateShader(device, pCreateInfo, pShader);
+    VkResult result = device_dispatch_table(device)->CreateShader(device, pCreateInfo, pShader);
     return result;
 }
 
@@ -1431,7 +1473,7 @@
     const VkGraphicsPipelineCreateInfo *pCreateInfo,
     VkPipeline                         *pPipeline)
 {
-    VkResult result = nextTable.CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
+    VkResult result = device_dispatch_table(device)->CreateGraphicsPipeline(device, pCreateInfo, pPipeline);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline");
@@ -1446,7 +1488,8 @@
     VkPipeline                          basePipeline,
     VkPipeline                         *pPipeline)
 {
-    VkResult result = nextTable.CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline);
+    VkResult result = device_dispatch_table(device)->CreateGraphicsPipelineDerivative(
+        device, pCreateInfo, basePipeline, pPipeline);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkGraphicsPipelineCreateInfo), "graphics_pipeline");
@@ -1460,7 +1503,7 @@
     const VkComputePipelineCreateInfo *pCreateInfo,
     VkPipeline                        *pPipeline)
 {
-    VkResult result = nextTable.CreateComputePipeline(device, pCreateInfo, pPipeline);
+    VkResult result = device_dispatch_table(device)->CreateComputePipeline(device, pCreateInfo, pPipeline);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pPipeline, pCreateInfo->sType, pCreateInfo, sizeof(VkComputePipelineCreateInfo), "compute_pipeline");
@@ -1474,7 +1517,7 @@
     const VkSamplerCreateInfo *pCreateInfo,
     VkSampler                 *pSampler)
 {
-    VkResult result = nextTable.CreateSampler(device, pCreateInfo, pSampler);
+    VkResult result = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pSampler);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pSampler, pCreateInfo->sType, pCreateInfo, sizeof(VkSamplerCreateInfo), "sampler");
@@ -1488,7 +1531,7 @@
     const VkDynamicVpStateCreateInfo *pCreateInfo,
     VkDynamicVpState                 *pState)
 {
-    VkResult result = nextTable.CreateDynamicViewportState(device, pCreateInfo, pState);
+    VkResult result = device_dispatch_table(device)->CreateDynamicViewportState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicVpStateCreateInfo), "viewport_state");
@@ -1502,7 +1545,7 @@
     const VkDynamicRsStateCreateInfo *pCreateInfo,
     VkDynamicRsState                 *pState)
 {
-    VkResult result = nextTable.CreateDynamicRasterState(device, pCreateInfo, pState);
+    VkResult result = device_dispatch_table(device)->CreateDynamicRasterState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicRsStateCreateInfo), "raster_state");
@@ -1516,7 +1559,7 @@
     const VkDynamicCbStateCreateInfo *pCreateInfo,
     VkDynamicCbState                 *pState)
 {
-    VkResult result = nextTable.CreateDynamicColorBlendState(device, pCreateInfo, pState);
+    VkResult result = device_dispatch_table(device)->CreateDynamicColorBlendState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicCbStateCreateInfo), "cb_state");
@@ -1530,7 +1573,7 @@
     const VkDynamicDsStateCreateInfo *pCreateInfo,
     VkDynamicDsState                 *pState)
 {
-    VkResult result = nextTable.CreateDynamicDepthStencilState(device, pCreateInfo, pState);
+    VkResult result = device_dispatch_table(device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState);
     if (result == VK_SUCCESS) {
         loader_platform_thread_lock_mutex(&globalLock);
         add_object_info(*pState, pCreateInfo->sType, pCreateInfo, sizeof(VkDynamicDsStateCreateInfo), "ds_state");
@@ -1544,7 +1587,7 @@
     const VkCmdBufferCreateInfo *pCreateInfo,
     VkCmdBuffer                 *pCmdBuffer)
 {
-    VkResult result = nextTable.CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
+    VkResult result = device_dispatch_table(device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
     // At time of cmd buffer creation, create global cmd buffer info for the returned cmd buffer
     loader_platform_thread_lock_mutex(&globalLock);
     if (*pCmdBuffer)
@@ -1567,7 +1610,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_RESET_CB_WHILE_IN_FLIGHT, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = nextTable.BeginCommandBuffer(cmdBuffer, pBeginInfo);
+    VkResult result = device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo);
     loader_platform_thread_lock_mutex(&globalLock);
     clear_cmd_buf_and_mem_references(cmdBuffer);
     loader_platform_thread_unlock_mutex(&globalLock);
@@ -1578,7 +1621,7 @@
     VkCmdBuffer cmdBuffer)
 {
     // TODO : Anything to do here?
-    VkResult result = nextTable.EndCommandBuffer(cmdBuffer);
+    VkResult result = device_dispatch_table(cmdBuffer)->EndCommandBuffer(cmdBuffer);
     return result;
 }
 
@@ -1596,7 +1639,7 @@
     // Clear memory references as this point.
     clear_cmd_buf_and_mem_references(cmdBuffer);
     loader_platform_thread_unlock_mutex(&globalLock);
-    VkResult result = nextTable.ResetCommandBuffer(cmdBuffer);
+    VkResult result = device_dispatch_table(cmdBuffer)->ResetCommandBuffer(cmdBuffer);
     return result;
 }
 // TODO : For any vkCmdBind* calls that include an object which has mem bound to it,
@@ -1624,7 +1667,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_PIPELINE, pipeline, 0, MEMTRACK_INVALID_OBJECT, (char *) "DS", (char *) str);
     }
 #endif
-    nextTable.CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+    device_dispatch_table(cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindDynamicStateObject(
@@ -1649,7 +1692,7 @@
     }
     pCmdBuf->pDynamicState[stateBindPoint] = pObjInfo;
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
+    device_dispatch_table(cmdBuffer)->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindDescriptorSets(
@@ -1662,7 +1705,8 @@
     const uint32_t        *pDynamicOffsets)
 {
     // TODO : Somewhere need to verify that all textures referenced by shaders in DS are in some type of *SHADER_READ* state
-    nextTable.CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+    device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(
+        cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindVertexBuffers(
@@ -1672,7 +1716,7 @@
     const VkBuffer     *pBuffers,
     const VkDeviceSize *pOffsets)
 {
-    nextTable.CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+    device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBindIndexBuffer(
@@ -1681,7 +1725,7 @@
     VkDeviceSize offset,
     VkIndexType  indexType)
 {
-    nextTable.CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+    device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndirect(
@@ -1699,7 +1743,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
+    device_dispatch_table(cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(
@@ -1717,7 +1761,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
+    device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdDispatchIndirect(
@@ -1733,7 +1777,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdDispatchIndirect(cmdBuffer, buffer, offset);
+    device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyBuffer(
@@ -1757,7 +1801,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+    device_dispatch_table(cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyImage(
@@ -1770,7 +1814,8 @@
     const VkImageCopy *pRegions)
 {
     // TODO : Each image will have mem mapping so track them
-    nextTable.CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+    device_dispatch_table(cmdBuffer)->CmdCopyImage(
+        cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBlitImage(
@@ -1784,7 +1829,8 @@
     VkTexFilter        filter)
 {
     // TODO : Each image will have mem mapping so track them
-    nextTable.CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+    device_dispatch_table(cmdBuffer)->CmdBlitImage(
+        cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
@@ -1811,7 +1857,8 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+    device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(
+        cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdCopyImageToBuffer(
@@ -1837,7 +1884,8 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+    device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(
+        cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdUpdateBuffer(
@@ -1855,7 +1903,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+    device_dispatch_table(cmdBuffer)->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdFillBuffer(
@@ -1873,7 +1921,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
+    device_dispatch_table(cmdBuffer)->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearColorImage(
@@ -1893,7 +1941,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+    device_dispatch_table(cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdClearDepthStencil(
@@ -1914,7 +1962,8 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
+    device_dispatch_table(cmdBuffer)->CmdClearDepthStencil(
+        cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResolveImage(
@@ -1940,7 +1989,8 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+    device_dispatch_table(cmdBuffer)->CmdResolveImage(
+        cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdBeginQuery(
@@ -1957,7 +2007,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+    device_dispatch_table(cmdBuffer)->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdEndQuery(
@@ -1973,7 +2023,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdEndQuery(cmdBuffer, queryPool, slot);
+    device_dispatch_table(cmdBuffer)->CmdEndQuery(cmdBuffer, queryPool, slot);
 }
 
 VK_LAYER_EXPORT void VKAPI vkCmdResetQueryPool(
@@ -1990,7 +2040,7 @@
         layerCbMsg(VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER, cmdBuffer, 0, MEMTRACK_MEMORY_BINDING_ERROR, "MEM", str);
     }
     loader_platform_thread_unlock_mutex(&globalLock);
-    nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+    device_dispatch_table(cmdBuffer)->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkDbgCreateMsgCallback(
@@ -2000,14 +2050,14 @@
         void* pUserData,
         VkDbgMsgCallback* pMsgCallback)
 {
-    return layer_create_msg_callback(instance, &nextInstanceTable, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+    return layer_create_msg_callback(instance, instance_dispatch_table(instance), msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkDbgDestroyMsgCallback(
         VkInstance instance,
         VkDbgMsgCallback msgCallback)
 {
-    return layer_destroy_msg_callback(instance, &nextInstanceTable, msgCallback);
+    return layer_destroy_msg_callback(instance, instance_dispatch_table(instance), msgCallback);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(
@@ -2015,7 +2065,7 @@
     const VkSwapChainCreateInfoWSI *pCreateInfo,
     VkSwapChainWSI                 *pSwapChain)
 {
-    VkResult result = nextTable.CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
+    VkResult result = device_dispatch_table(device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain);
 
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
@@ -2050,7 +2100,7 @@
 
     loader_platform_thread_unlock_mutex(&globalLock);
 
-    return nextTable.DestroySwapChainWSI(swapChain);
+    return device_dispatch_table(swapChain)->DestroySwapChainWSI(swapChain);
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(
@@ -2059,7 +2109,7 @@
     size_t                 *pDataSize,
     void                   *pData)
 {
-    VkResult result = nextTable.GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
+    VkResult result = device_dispatch_table(swapChain)->GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData);
 
     if (infoType == VK_SWAP_CHAIN_INFO_TYPE_PERSISTENT_IMAGES_WSI && result == VK_SUCCESS) {
         const size_t count = *pDataSize / sizeof(VkSwapChainImageInfoWSI);
@@ -2106,9 +2156,9 @@
     if (dev == NULL) {
         return NULL;
     }
-    pCurObj = devw;
+
     loader_platform_thread_once(&g_initOnce, initMemTracker);
-    loader_platform_thread_once(&g_tabDeviceOnce, initDeviceTable);
+    initDeviceTable((const VkBaseLayerObject *) dev);
 
     if (!strcmp(funcName, "vkGetDeviceProcAddr"))
         return (void *) vkGetDeviceProcAddr;
@@ -2264,12 +2314,13 @@
         return NULL;
     }
 
-    pCurObj = instw;
     loader_platform_thread_once(&g_initOnce, initMemTracker);
-    loader_platform_thread_once(&g_tabInstanceOnce, initInstanceTable);
+    initInstanceTable((const VkBaseLayerObject *) instance);
 
     if (!strcmp(funcName, "vkGetInstanceProcAddr"))
         return (void *) vkGetInstanceProcAddr;
+    if (!strcmp(funcName, "vkDestroyInstance"))
+        return (void *) vkDestroyInstance;
     if (!strcmp(funcName, "vkCreateDevice"))
         return (void*) vkCreateDevice;
     else {