command buffer allocation

[vktest3] / src / vk.c

diff --git a/src/vk.c b/src/vk.c
index 82b1ccf..5480fc1 100644 (file)
--- a/src/vk.c
+++ b/src/vk.c
@@ -62,6 +62,14 @@ static int have_ext(VkExtensionProperties *ext, int next, const char *name);
 static Display *dpy;
 static Window win;
 static int initflags;
+#define MAX_INIT_QUEUE 32
+static struct {
+       unsigned int flags;
+       int count;
+       int qfam;
+       VkCommandPool cmdpool;
+} initq[MAX_INIT_QUEUE];
+static int num_initq;
 
 static VkInstance vk;
 static VkPhysicalDevice vkpdev;
@@ -93,8 +101,32 @@ void vk_init_xwin(Display *d, Window w)
        win = w;
 }
 
+void vk_init_queue(unsigned int qflags, int count)
+{
+       int i;
+
+       for(i=0; i<num_initq; i++) {
+               if(initq[i].flags == qflags) {
+                       initq[i].count += count;
+                       return;
+               }
+       }
+
+       if(num_initq >= MAX_INIT_QUEUE) {
+               fprintf(stderr, "vk_init_queue: too many queues\n");
+               return;
+       }
+       initq[num_initq].flags = qflags;
+       initq[num_initq].count = count;
+       num_initq++;
+}
+
 int vk_init(unsigned int flags, unsigned int *usedflags)
 {
+       if(!num_initq) {
+               vk_init_queue(VKQ_GFX | VKQ_PRESENT, 1);
+       }
+
        initflags = flags;
        if(create_instance() == -1)     return -1;
        if(create_surface() == -1) return -1;
@@ -217,9 +249,69 @@ VkQueue vk_getq_fam(int fam, int n)
        return q;
 }
 
-VkQueue vk_getq(unsigned int flags)
+VkQueue vk_getq(unsigned int flags, int n)
+{
+       return vk_getq_fam(vk_find_qfamily(flags), n);
+}
+
+static VkCommandPool find_cmdpool(int qfam)
+{
+       int i;
+       VkCommandPoolCreateInfo pinf;
+
+       for(i=0; i<num_initq; i++) {
+               if(initq[i].qfam == qfam) {
+                       if(!initq[i].cmdpool) {
+                               /* allocate command pool for this queue family */
+                               memset(&pinf, 0, sizeof pinf);
+                               pinf.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
+                               pinf.flags = VK_COMMAND_POOL_CREATE_TRANSIENT_BIT | VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
+                               pinf.queueFamilyIndex = qfam;
+
+                               if(vkCreateCommandPool(vkdev, &pinf, 0, &initq[i].cmdpool) != 0) {
+                                       fprintf(stderr, "ck_create_cmdbuf: failed to create command buffer pool\n");
+                                       return 0;
+                               }
+                       }
+                       return initq[i].cmdpool;
+               }
+       }
+
+       fprintf(stderr, "vk_create_cmdbuf: failed to find command pool for queue family: %d\n", qfam);
+       return 0;
+}
+
+VkCommandBuffer vk_create_cmdbuf_fam(int qfam, int level)
 {
-       return vk_getq_fam(vk_find_qfamily(flags), 0);
+       VkCommandBufferAllocateInfo inf = {0};
+       VkCommandBuffer cmdbuf;
+       VkCommandPool cmdpool;
+
+       if(!(cmdpool = find_cmdpool(qfam))) {
+               return 0;
+       }
+
+       inf.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
+       inf.commandPool = cmdpool;
+       inf.level = level;
+       inf.commandBufferCount = 1;
+
+       if(vkAllocateCommandBuffers(vkdev, &inf, &cmdbuf) != 0) {
+               fprintf(stderr, "vk_create_cmdbuf: failed to allocate command buffer\n");
+               return 0;
+       }
+       return cmdbuf;
+}
+
+VkCommandBuffer vk_create_cmdbuf(unsigned int qflags, int level)
+{
+       int qfam;
+
+       if((qfam = vk_find_qfamily(qflags)) == -1) {
+               fprintf(stderr, "vk_create_cmdbuf: failed to find matching queue family\n");
+               return 0;
+       }
+       return vk_create_cmdbuf_fam(qfam, level);
 }
 
 int vk_create_rpass(void)
@@ -648,12 +740,12 @@ int choose_phys_dev(void)
 
 static int create_device(void)
 {
-       float prio = 1.0f;
-       VkDeviceQueueCreateInfo qinf = {0};
+       float *prio;
+       VkDeviceQueueCreateInfo qinf[MAX_INIT_QUEUE] = {0};
        VkPhysicalDeviceFeatures feat = {0};
        VkDeviceCreateInfo devinf = {0};
        const char *ext[ARRSZ(known_devext_list) + 16];
-       int i, num_ext;
+       int i, j, num_ext, qfam, totalq;
 
        vkEnumerateDeviceExtensionProperties(vkpdev, 0, &dev_ext_count, 0);
        dev_ext = malloc_nf(dev_ext_count * sizeof *dev_ext);
@@ -680,14 +772,37 @@ static int create_device(void)
                }
        }
 
-       qinf.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
-       qinf.queueFamilyIndex = vk_find_qfamily(VKQ_GFX | VKQ_PRESENT);
-       qinf.queueCount = 1;
-       qinf.pQueuePriorities = &prio;
+       totalq = 0;
+       for(i=0; i<num_initq; i++) {
+               totalq += initq[i].count;
+       }
+       if(totalq > 1024) {
+               fprintf(stderr, "create_device: arbitrary limit of total queues exceeded (%d)\n", totalq);
+               return -1;
+       }
+       prio = alloca(totalq * sizeof *prio);
+
+       for(i=0; i<num_initq; i++) {
+               if((qfam = vk_find_qfamily(initq[i].flags)) == -1) {
+                       fprintf(stderr, "create_device: failed to find queue family (flags: 0x%2x)\n",
+                                       initq[i].flags);
+                       return -1;
+               }
+               initq[i].qfam = qfam;
+               initq[i].cmdpool = 0;
+
+               qinf[i].sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
+               qinf[i].queueFamilyIndex = qfam;
+               qinf[i].queueCount = initq[i].count;
+               qinf[i].pQueuePriorities = prio;
+               for(j=0; j<initq[i].count; i++) {
+                       *prio++ = 1.0f; /* all queue priorities 1 */
+               }
+       }
 
        devinf.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
-       devinf.pQueueCreateInfos = &qinf;
-       devinf.queueCreateInfoCount = 1;
+       devinf.pQueueCreateInfos = qinf;
+       devinf.queueCreateInfoCount = num_initq;
        devinf.pEnabledFeatures = &feat;
        devinf.enabledExtensionCount = num_ext;
        devinf.ppEnabledExtensionNames = ext;