misc: Change vkEnumerateGpus to vkEnumeratePhysicalDevices
Conflicts:
loader/loader.h
diff --git a/include/vkLayer.h b/include/vkLayer.h
index 53460c7..e9e8b03 100644
--- a/include/vkLayer.h
+++ b/include/vkLayer.h
@@ -30,7 +30,7 @@
PFN_vkGetProcAddr GetProcAddr;
PFN_vkCreateInstance CreateInstance;
PFN_vkDestroyInstance DestroyInstance;
- PFN_vkEnumerateGpus EnumerateGpus;
+ PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
PFN_vkGetGpuInfo GetGpuInfo;
PFN_vkCreateDevice CreateDevice;
PFN_vkDestroyDevice DestroyDevice;
diff --git a/include/vulkan.h b/include/vulkan.h
index d80c15a..4e91b43 100644
--- a/include/vulkan.h
+++ b/include/vulkan.h
@@ -87,7 +87,6 @@
VK_DEFINE_SUBCLASS_HANDLE(VkFramebuffer, VkObject)
VK_DEFINE_SUBCLASS_HANDLE(VkRenderPass, VkObject)
-#define VK_MAX_PHYSICAL_GPUS 16
#define VK_MAX_PHYSICAL_GPU_NAME 256
#define VK_MAX_EXTENSION_NAME 256
@@ -2200,7 +2199,7 @@
// API functions
typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance);
typedef VkResult (VKAPI *PFN_vkDestroyInstance)(VkInstance instance);
-typedef VkResult (VKAPI *PFN_vkEnumerateGpus)(VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, VkPhysicalGpu* pGpus);
+typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalGpu* pPhysicalDevices);
typedef VkResult (VKAPI *PFN_vkGetGpuInfo)(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData);
typedef void * (VKAPI *PFN_vkGetProcAddr)(VkPhysicalGpu gpu, const char * pName);
typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalGpu gpu, const VkDeviceCreateInfo* pCreateInfo, VkDevice* pDevice);
@@ -2326,11 +2325,10 @@
VkResult VKAPI vkDestroyInstance(
VkInstance instance);
-VkResult VKAPI vkEnumerateGpus(
+VkResult VKAPI vkEnumeratePhysicalDevices(
VkInstance instance,
- uint32_t maxGpus,
- uint32_t* pGpuCount,
- VkPhysicalGpu* pGpus);
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalGpu* pPhysicalDevices);
VkResult VKAPI vkGetGpuInfo(
VkPhysicalGpu gpu,
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index fae24d1..5408ee7 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -139,13 +139,6 @@
return result;
}
-VK_LAYER_EXPORT VkResult VKAPI vkEnumerateGpus(VkInstance instance, uint32_t maxGpus, uint32_t* pGpuCount, VkPhysicalGpu* pGpus)
-{
-
- VkResult result = nextTable.EnumerateGpus(instance, maxGpus, pGpuCount, pGpus);
- return result;
-}
-
VK_LAYER_EXPORT VkResult VKAPI vkGetGpuInfo(VkPhysicalGpu gpu, VkPhysicalGpuInfoType infoType, size_t* pDataSize, void* pData)
{
pCurObj = (VkBaseLayerObject *) gpu;
diff --git a/loader/loader.c b/loader/loader.c
index 20646a7..b71a39a 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -69,9 +69,9 @@
const struct loader_scanned_icds *scanned_icds;
VkLayerDispatchTable *loader_dispatch;
- uint32_t layer_count[VK_MAX_PHYSICAL_GPUS];
- struct loader_layers layer_libs[VK_MAX_PHYSICAL_GPUS][MAX_LAYER_LIBRARIES];
- VkBaseLayerObject *wrappedGpus[VK_MAX_PHYSICAL_GPUS];
+ uint32_t layer_count[MAX_GPUS_FOR_LAYER];
+ struct loader_layers layer_libs[MAX_GPUS_FOR_LAYER][MAX_LAYER_LIBRARIES];
+ VkBaseLayerObject *wrappedGpus[MAX_GPUS_FOR_LAYER];
uint32_t gpu_count;
VkBaseLayerObject *gpus;
@@ -85,7 +85,7 @@
PFN_vkGetProcAddr GetProcAddr;
PFN_vkCreateInstance CreateInstance;
PFN_vkDestroyInstance DestroyInstance;
- PFN_vkEnumerateGpus EnumerateGpus;
+ PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
PFN_vkGetGlobalExtensionInfo GetGlobalExtensionInfo;
VkInstance instance;
struct loader_scanned_icds *next;
@@ -443,7 +443,7 @@
LOOKUP(fp_gpa, GetProcAddr);
LOOKUP(fp_create_inst, CreateInstance);
LOOKUP(fp_destroy_inst, DestroyInstance);
- LOOKUP(fp_enumerate, EnumerateGpus);
+ LOOKUP(fp_enumerate, EnumeratePhysicalDevices);
LOOKUP(fp_get_global_ext_info, GetGlobalExtensionInfo);
#undef LOOKUP
@@ -457,7 +457,7 @@
new_node->GetProcAddr = fp_gpa;
new_node->CreateInstance = fp_create_inst;
new_node->DestroyInstance = fp_destroy_inst;
- new_node->EnumerateGpus = fp_enumerate;
+ new_node->EnumeratePhysicalDevices = fp_enumerate;
new_node->GetGlobalExtensionInfo = fp_get_global_ext_info;
new_node->extension_count = 0;
new_node->extensions = NULL;
@@ -1017,7 +1017,7 @@
struct layer_name_pair *pLayerNames;
if (!icd)
return 0;
- assert(gpu_index < VK_MAX_PHYSICAL_GPUS);
+ assert(gpu_index < MAX_GPUS_FOR_LAYER);
gpu = icd->gpus + gpu_index;
/* activate any layer libraries */
@@ -1194,73 +1194,90 @@
return VK_SUCCESS;
}
-LOADER_EXPORT VkResult VKAPI vkEnumerateGpus(
+LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
VkInstance instance,
- uint32_t maxGpus,
- uint32_t* pGpuCount,
- VkPhysicalGpu* pGpus)
+ uint32_t* pPhysicalDeviceCount,
+ VkPhysicalGpu* pPhysicalDevices)
{
struct loader_instance *ptr_instance = (struct loader_instance *) instance;
struct loader_icd *icd;
- uint32_t count = 0;
+ uint32_t n, count = 0;
VkResult res;
//in spirit of VK don't error check on the instance parameter
icd = ptr_instance->icds;
- while (icd) {
- VkPhysicalGpu gpus[VK_MAX_PHYSICAL_GPUS];
- VkBaseLayerObject * wrapped_gpus;
- PFN_vkGetProcAddr get_proc_addr = icd->scanned_icds->GetProcAddr;
- uint32_t n, max = maxGpus - count;
-
- if (max > VK_MAX_PHYSICAL_GPUS) {
- max = VK_MAX_PHYSICAL_GPUS;
+ if (pPhysicalDevices == NULL) {
+ while (icd) {
+ res = icd->scanned_icds->EnumeratePhysicalDevices(
+ icd->scanned_icds->instance,
+ &n, NULL);
+ if (res != VK_SUCCESS)
+ return res;
+ icd->gpu_count = n;
+ count += n;
+ icd = icd->next;
}
- res = icd->scanned_icds->EnumerateGpus(icd->scanned_icds->instance,
- max, &n,
- gpus);
- if (res == VK_SUCCESS && n) {
- wrapped_gpus = (VkBaseLayerObject*) malloc(n *
- sizeof(VkBaseLayerObject));
- icd->gpus = wrapped_gpus;
- icd->gpu_count = n;
- icd->loader_dispatch = (VkLayerDispatchTable *) malloc(n *
- sizeof(VkLayerDispatchTable));
- for (unsigned int i = 0; i < n; i++) {
- (wrapped_gpus + i)->baseObject = gpus[i];
- (wrapped_gpus + i)->pGPA = get_proc_addr;
- (wrapped_gpus + i)->nextObject = gpus[i];
- memcpy(pGpus + count, gpus, sizeof(*pGpus));
- loader_init_dispatch_table(icd->loader_dispatch + i,
- get_proc_addr, gpus[i]);
+ ptr_instance->total_gpu_count = count;
- /* Verify ICD compatibility */
- if (!valid_loader_magic_value(gpus[i])) {
- loader_log(VK_DBG_MSG_WARNING, 0,
+ } else
+ {
+ VkPhysicalGpu* gpus;
+ if (*pPhysicalDeviceCount < ptr_instance->total_gpu_count)
+ return VK_ERROR_INVALID_VALUE;
+ gpus = malloc( sizeof(VkPhysicalGpu) * *pPhysicalDeviceCount);
+ if (!gpus)
+ return VK_ERROR_OUT_OF_MEMORY;
+ while (icd) {
+ VkBaseLayerObject * wrapped_gpus;
+ PFN_vkGetProcAddr get_proc_addr = icd->scanned_icds->GetProcAddr;
+
+ res = icd->scanned_icds->EnumeratePhysicalDevices(
+ icd->scanned_icds->instance,
+ &n,
+ gpus);
+ if (res == VK_SUCCESS && n) {
+ wrapped_gpus = (VkBaseLayerObject*) malloc(n *
+ sizeof(VkBaseLayerObject));
+ icd->gpus = wrapped_gpus;
+ icd->gpu_count = n;
+ icd->loader_dispatch = (VkLayerDispatchTable *) malloc(n *
+ sizeof(VkLayerDispatchTable));
+ for (unsigned int i = 0; i < n; i++) {
+ (wrapped_gpus + i)->baseObject = gpus[i];
+ (wrapped_gpus + i)->pGPA = get_proc_addr;
+ (wrapped_gpus + i)->nextObject = gpus[i];
+ memcpy(pPhysicalDevices + count, gpus, sizeof(*pPhysicalDevices));
+ loader_init_dispatch_table(icd->loader_dispatch + i,
+ get_proc_addr, gpus[i]);
+
+ /* Verify ICD compatibility */
+ if (!valid_loader_magic_value(gpus[i])) {
+ loader_log(VK_DBG_MSG_WARNING, 0,
"Loader: Incompatible ICD, first dword must be initialized to ICD_LOADER_MAGIC. See loader/README.md for details.\n");
- assert(0);
+ assert(0);
+ }
+
+ const VkLayerDispatchTable **disp;
+ disp = (const VkLayerDispatchTable **) gpus[i];
+ *disp = icd->loader_dispatch + i;
+ loader_activate_layers(icd, i, ptr_instance->extension_count,
+ (const char *const*) ptr_instance->extension_names);
}
- const VkLayerDispatchTable **disp;
- disp = (const VkLayerDispatchTable **) gpus[i];
- *disp = icd->loader_dispatch + i;
- loader_activate_layers(icd, i, ptr_instance->extension_count,
- (const char *const*) ptr_instance->extension_names);
+ count += n;
+
+ if (count >= *pPhysicalDeviceCount) {
+ break;
+ }
}
- count += n;
-
- if (count >= maxGpus) {
- break;
- }
+ icd = icd->next;
}
-
- icd = icd->next;
}
- *pGpuCount = count;
+ *pPhysicalDeviceCount = count;
return (count > 0) ? VK_SUCCESS : res;
}
diff --git a/loader/loader.h b/loader/loader.h
index b615989..79d77c8 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -68,6 +68,7 @@
}
struct loader_instance {
+ uint32_t total_gpu_count;
struct loader_icd *icds;
struct loader_instance *next;
uint32_t extension_count;
@@ -77,5 +78,6 @@
extern uint32_t loader_activate_layers(struct loader_icd *icd, uint32_t gpu_index, uint32_t ext_count, const char *const* ext_names);
extern struct loader_icd * loader_get_icd(const VkBaseLayerObject *gpu, uint32_t *gpu_index);
#define MAX_LAYER_LIBRARIES 64
+#define MAX_GPUS_FOR_LAYER 16
#endif /* LOADER_H */
diff --git a/tests/image_tests.cpp b/tests/image_tests.cpp
index d2b2e69..326a8c8 100644
--- a/tests/image_tests.cpp
+++ b/tests/image_tests.cpp
@@ -63,6 +63,8 @@
#include "vktestbinding.h"
#include "test_common.h"
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
class VkImageTest : public ::testing::Test {
public:
void CreateImage(uint32_t w, uint32_t h);
@@ -76,7 +78,7 @@
protected:
vk_testing::Device *m_device;
VkApplicationInfo app_info;
- VkPhysicalGpu objs[VK_MAX_PHYSICAL_GPUS];
+ VkPhysicalGpu objs[16];
uint32_t gpu_count;
VkInstance inst;
VkImage m_image;
@@ -102,8 +104,10 @@
inst_info.ppEnabledExtensionNames = NULL;
err = vkCreateInstance(&inst_info, &this->inst);
ASSERT_VK_SUCCESS(err);
- err = vkEnumerateGpus(this->inst, VK_MAX_PHYSICAL_GPUS,
- &this->gpu_count, objs);
+ err = vkEnumeratePhysicalDevices(this->inst, &this->gpu_count, NULL);
+ ASSERT_VK_SUCCESS(err);
+ ASSERT_LE(this->gpu_count, ARRAY_SIZE(objs)) << "Too many GPUs";
+ err = vkEnumeratePhysicalDevices(this->inst, &this->gpu_count, objs);
ASSERT_VK_SUCCESS(err);
ASSERT_GE(this->gpu_count, 1) << "No GPU available";
diff --git a/tests/init.cpp b/tests/init.cpp
index 554b9c8..de02b34 100644
--- a/tests/init.cpp
+++ b/tests/init.cpp
@@ -65,6 +65,8 @@
#include "test_common.h"
#include "icd-spv.h"
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
class XglTest : public ::testing::Test {
public:
void CreateImageTest();
@@ -78,7 +80,7 @@
protected:
VkApplicationInfo app_info;
VkInstance inst;
- VkPhysicalGpu objs[VK_MAX_PHYSICAL_GPUS];
+ VkPhysicalGpu objs[16];
uint32_t gpu_count;
uint32_t m_device_id;
@@ -107,8 +109,10 @@
inst_info.ppEnabledExtensionNames = NULL;
err = vkCreateInstance(&inst_info, &inst);
ASSERT_VK_SUCCESS(err);
- err = vkEnumerateGpus(inst, VK_MAX_PHYSICAL_GPUS, &this->gpu_count,
- objs);
+ err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, NULL);
+ ASSERT_VK_SUCCESS(err);
+ ASSERT_LE(this->gpu_count, ARRAY_SIZE(objs)) << "Too many GPUs";
+ err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, objs);
ASSERT_VK_SUCCESS(err);
ASSERT_GE(this->gpu_count, 1) << "No GPU available";
@@ -136,7 +140,7 @@
TEST(Initialization, vkEnumerateGpus) {
VkApplicationInfo app_info = {};
VkInstance inst;
- VkPhysicalGpu objs[VK_MAX_PHYSICAL_GPUS];
+ VkPhysicalGpu objs[16];
uint32_t gpu_count;
VkResult err;
vk_testing::PhysicalGpu *gpu;
@@ -160,7 +164,10 @@
err = vkCreateInstance(&inst_info, &inst);
ASSERT_VK_SUCCESS(err);
- err = vkEnumerateGpus(inst, VK_MAX_PHYSICAL_GPUS, &gpu_count, objs);
+ err = vkEnumeratePhysicalDevices(inst, &gpu_count, NULL);
+ ASSERT_VK_SUCCESS(err);
+ ASSERT_LE(gpu_count, ARRAY_SIZE(objs)) << "Too many GPUs";
+ err = vkEnumeratePhysicalDevices(inst, &gpu_count, objs);
ASSERT_VK_SUCCESS(err);
ASSERT_GE(gpu_count, 1) << "No GPU available";
diff --git a/tests/test_environment.cpp b/tests/test_environment.cpp
index 6d34cf7..03beb12 100644
--- a/tests/test_environment.cpp
+++ b/tests/test_environment.cpp
@@ -60,7 +60,10 @@
inst_info.ppEnabledExtensionNames = NULL;
err = vkCreateInstance(&inst_info, &inst);
ASSERT_EQ(VK_SUCCESS, err);
- err = vkEnumerateGpus(inst, ARRAY_SIZE(gpus), &count, gpus);
+ err = vkEnumeratePhysicalDevices(inst, &count, NULL);
+ ASSERT_EQ(VK_SUCCESS, err);
+ ASSERT_LE(count, ARRAY_SIZE(gpus));
+ err = vkEnumeratePhysicalDevices(inst, &count, gpus);
ASSERT_EQ(VK_SUCCESS, err);
ASSERT_GT(count, default_dev_);
@@ -92,7 +95,10 @@
err = vkCreateInstance(&instInfo, &inst);
ASSERT_EQ(VK_SUCCESS, err);
- err = vkEnumerateGpus(inst, ARRAY_SIZE(gpus), &count, gpus);
+ err = vkEnumeratePhysicalDevices(inst, &count, NULL);
+ ASSERT_EQ(VK_SUCCESS, err);
+ ASSERT_LE(count, ARRAY_SIZE(gpus));
+ err = vkEnumeratePhysicalDevices(inst, &count, gpus);
ASSERT_EQ(VK_SUCCESS, err);
ASSERT_GT(count, default_dev_);
diff --git a/tests/test_environment.h b/tests/test_environment.h
index b2ab934..2081992 100644
--- a/tests/test_environment.h
+++ b/tests/test_environment.h
@@ -18,7 +18,7 @@
const std::vector<Device *> &devices() { return devs_; }
Device &default_device() { return *(devs_[default_dev_]); }
- VkPhysicalGpu gpus[VK_MAX_PHYSICAL_GPUS];
+ VkPhysicalGpu gpus[16];
private:
VkApplicationInfo app_;
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index 42ed4fe..6c1de3b 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -27,6 +27,8 @@
#include "vkrenderframework.h"
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
+
VkRenderFramework::VkRenderFramework() :
m_cmdBuffer( VK_NULL_HANDLE ),
m_renderPass(VK_NULL_HANDLE),
@@ -68,8 +70,10 @@
instInfo.ppEnabledExtensionNames = NULL;
err = vkCreateInstance(&instInfo, &this->inst);
ASSERT_VK_SUCCESS(err);
- err = vkEnumerateGpus(inst, VK_MAX_PHYSICAL_GPUS, &this->gpu_count,
- objs);
+ err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, NULL);
+ ASSERT_LE(this->gpu_count, ARRAY_SIZE(objs)) << "Too many gpus";
+ ASSERT_VK_SUCCESS(err);
+ err = vkEnumeratePhysicalDevices(inst, &this->gpu_count, objs);
ASSERT_VK_SUCCESS(err);
ASSERT_GE(this->gpu_count, 1) << "No GPU available";
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 0c2777b..55a4769 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -100,7 +100,7 @@
protected:
VkApplicationInfo app_info;
VkInstance inst;
- VkPhysicalGpu objs[VK_MAX_PHYSICAL_GPUS];
+ VkPhysicalGpu objs[16];
uint32_t gpu_count;
VkDeviceObj *m_device;
VkCmdBuffer m_cmdBuffer;
diff --git a/vk-generate.py b/vk-generate.py
index 120d7b4..1147620 100755
--- a/vk-generate.py
+++ b/vk-generate.py
@@ -49,7 +49,7 @@
return out_objs and out_objs[-1] == proto.params[-1]
def _is_loader_special_case(self, proto):
- if proto.name in ["GetProcAddr", "EnumerateGpus", "EnumerateLayers", "DbgRegisterMsgCallback", "DbgUnregisterMsgCallback", "DbgSetGlobalOption", "DestroyInstance"]:
+ if proto.name in ["GetProcAddr", "EnumeratePhysicalDevices", "EnumerateLayers", "DbgRegisterMsgCallback", "DbgUnregisterMsgCallback", "DbgSetGlobalOption", "DestroyInstance"]:
return True
return not self.is_dispatchable_object_first_param(proto)
@@ -348,7 +348,7 @@
# we could get the list from argv if wanted
self.intercepted = [proto.name for proto in self.protos
- if proto.name not in ["EnumerateGpus"]]
+ if proto.name not in ["EnumeratePhysicalDevices"]]
for proto in self.protos:
if proto.name == "GetProcAddr":
diff --git a/vulkan.py b/vulkan.py
index 4c51bd4..3e49704 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -225,11 +225,10 @@
Proto("VkResult", "DestroyInstance",
[Param("VkInstance", "instance")]),
- Proto("VkResult", "EnumerateGpus",
+ Proto("VkResult", "EnumeratePhysicalDevices",
[Param("VkInstance", "instance"),
- Param("uint32_t", "maxGpus"),
- Param("uint32_t*", "pGpuCount"),
- Param("VkPhysicalGpu*", "pGpus")]),
+ Param("uint32_t*", "pPhysicalDeviceCount"),
+ Param("VkPhysicalGpu*", "pPhysicalDevices")]),
Proto("VkResult", "GetGpuInfo",
[Param("VkPhysicalGpu", "gpu"),