0xC0000005: Access violation when reading at position 0xDDDDDDDD. C++

0

Header

#include <iostream>

#define GLFW_INCLUDE_VULKAN
#include "GLFW\glfw3.h"

#include "PhysicalDeviceVK.h"

#define CATCH(value) if(value != VK_SUCCESS){ __debugbreak;}

class DeviceVK 
{

private:

    /**
    * @return VkPhysicalDevice Get the best physical device.
    */
    VkPhysicalDevice getPhysicalDevice(VkInstance instance);

    /**
    * @return uint32_t Get the index of the best queue family.
    */
    uint32_t getQueueFamily(std::vector<VkQueueFamilyProperties> queueFamilies);

    /**
    * @return VkDeviceCreateInfo create the device create info.
    */
    VkDeviceCreateInfo createDeviceCreateInfo();

public:

    VkDevice device = nullptr;
    VkQueue queue = nullptr;
    PhysicalDeviceVK physicalDevice;

    uint32_t queueIndex = NULL;

    DeviceVK(VkInstance instance, VkSurfaceKHR surface);
    DeviceVK() {}
};

C++ File

#include "DeviceVK.h"

DeviceVK::DeviceVK(VkInstance instance, VkSurfaceKHR surface)
{
    VkPhysicalDevice bestGPU = getPhysicalDevice(instance);
    this->physicalDevice = PhysicalDeviceVK(bestGPU);

    VkDeviceCreateInfo deviceCreateInfo = createDeviceCreateInfo();
    CATCH(vkCreateDevice(bestGPU, &deviceCreateInfo, nullptr, &this->device));

    vkGetDeviceQueue(this->device, this->queueIndex, 1, &this->queue);
    this->physicalDevice.debug(surface);
}

VkPhysicalDevice DeviceVK::getPhysicalDevice(VkInstance instance) 
{
    uint32_t amountOfGraphicCards = 0;
    vkEnumeratePhysicalDevices(instance, &amountOfGraphicCards, nullptr);
    VkPhysicalDevice* physicalDevices = new VkPhysicalDevice[amountOfGraphicCards];

    CATCH(vkEnumeratePhysicalDevices(instance, &amountOfGraphicCards, physicalDevices));

    int bestGPU = 0, maxHeap = 0;

    for (int i = 0; i < amountOfGraphicCards; i++)
    {
        PhysicalDeviceVK physicalDevice(physicalDevices[i]);

        VkPhysicalDeviceMemoryProperties memoryProperties = physicalDevice.getPhysicalDeviceMemoryProperties();

        auto heapsPointer = memoryProperties.memoryHeaps;
        auto heaps = std::vector<VkMemoryHeap>(heapsPointer, heapsPointer + memoryProperties.memoryHeapCount);

        for (const auto& heap : heaps)
        {
            if (heap.flags & VkMemoryHeapFlagBits::VK_MEMORY_HEAP_DEVICE_LOCAL_BIT)
            {
                if (maxHeap < heap.size)
                {
                    maxHeap = heap.size;
                    bestGPU = i;
                }
            }
        }
    }

    VkPhysicalDevice bestDevice = physicalDevices[bestGPU];
    return bestDevice;
}

uint32_t DeviceVK::getQueueFamily(std::vector<VkQueueFamilyProperties> queueFamilies)
{
    return ((uint32_t)0);
}

VkDeviceCreateInfo DeviceVK::createDeviceCreateInfo()
{

    std::vector<VkQueueFamilyProperties> queueFamilies = this->physicalDevice.getQueueFamilyProperties();
    this->queueIndex = getQueueFamily(queueFamilies);

    VkDeviceQueueCreateInfo deviceQueueCreateInfo;
    deviceQueueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
    deviceQueueCreateInfo.pNext = nullptr;
    deviceQueueCreateInfo.flags = 0;
    deviceQueueCreateInfo.queueFamilyIndex = this->queueIndex;
    deviceQueueCreateInfo.queueCount = queueFamilies.size();
    const float queuePriorityValue = 1.0f;
    deviceQueueCreateInfo.pQueuePriorities = &queuePriorityValue;

    queueFamilies.clear();

    VkPhysicalDeviceFeatures deviceFeatures = {};

    const std::vector<const char*> deviceExtensions =
    {
        VK_KHR_SWAPCHAIN_EXTENSION_NAME
    };

    VkDeviceCreateInfo deviceCreateInfo;
    deviceCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    deviceCreateInfo.pNext = nullptr;
    deviceCreateInfo.flags = 0;
    deviceCreateInfo.queueCreateInfoCount = 1;
    deviceCreateInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
    deviceCreateInfo.enabledLayerCount = 0;
    deviceCreateInfo.ppEnabledLayerNames = nullptr;
    deviceCreateInfo.enabledExtensionCount = deviceExtensions.size();
    deviceCreateInfo.ppEnabledExtensionNames = deviceExtensions.data();
    deviceCreateInfo.pEnabledFeatures = &deviceFeatures;
    return deviceCreateInfo;
}

Here I call the class

void VulkanGraphic::createDevice()
{
    this->deviceVK = DeviceVK(this->instance, this->surface);
}

Every time in run this program, it crashes because of a

0xC0000005: Access violation when reading at position 0xDDDDDDDD.

I also tried deleting the last two lines, where the error appears. But it actually says, that the program crashes at the End of the constructor, where a empty line is.

I'm using Vulkan and GLFW

The error happens

Also when I'm removing the lines...

c++
visual-studio
vulkan
asked on Stack Overflow Apr 17, 2021 by Plugrol Huldo • edited Apr 17, 2021 by Plugrol Huldo

0 Answers

Nobody has answered this question yet.


User contributions licensed under CC BY-SA 3.0