AppGpu AppGpuInit(uint id, PhysicalDevice obj) { // TODO : Limits AppGpu gpu = new AppGpu { Id = id, Obj = obj, Props = obj.GetProperties(), QueueProps = obj.GetQueueFamilyProperties(), MemoryProps = obj.GetMemoryProperties(), Features = obj.GetFeatures(), Limits = null, }; gpu.QueueReqs = new DeviceQueueCreateInfo[gpu.QueueProps.Length]; for (uint i = 0; i < gpu.QueueProps.Length; i++) { uint queueCount = gpu.QueueProps[i].QueueCount; DeviceQueueCreateInfo queueReq = new DeviceQueueCreateInfo { QueueFamilyIndex = i, QueueCount = queueCount, QueuePriorities = new float[queueCount], }; gpu.QueueReqs[i] = queueReq; } gpu.Device = AppDevInit(gpu); AppDevInitFormats(gpu.Device); return(gpu); }
public static bool TrySelectQueue(PhysicalDevice physicalDevice, QueueFlags flags, bool present, out uint selectedIndex) { if (QueueFamilyPropertiesCachePhysicalDevice != physicalDevice) { QueueFamilyPropertiesCachePhysicalDevice = physicalDevice; QueueFamilyPropertiesCache = physicalDevice.GetQueueFamilyProperties(); } selectedIndex = 0; int score = 0; uint i = 0; foreach (QueueFamilyProperties test in QueueFamilyPropertiesCache) { /*foreach(SurfaceFormatKhr format in physicalDevice.GetSurfaceFormatsKHR()) * { * * } * physicalDevice.GetSurfaceSupportKHR(i);*/ int checkScore = ScoreQueue(test, flags); if (checkScore > score) { selectedIndex = i; score = checkScore; } i++; } return(score > 0); }
private (uint, uint) FindQueueFamilies() { var queueFamilyProperties = PhysicalDevice.GetQueueFamilyProperties(); var graphicsFamily = queueFamilyProperties .Select((properties, index) => new { properties, index }) .SkipWhile(pair => !pair.properties.QueueFlags.HasFlag(QueueFlags.Graphics)) .FirstOrDefault(); if (graphicsFamily == null) { throw new Exception("Unable to find graphics queue"); } uint?presentFamily = default; for (uint i = 0; i < queueFamilyProperties.Length; ++i) { if (PhysicalDevice.GetSurfaceSupport(i, Surface)) { presentFamily = i; } } if (!presentFamily.HasValue) { throw new Exception("Unable to find present queue"); } return((uint)graphicsFamily.index, presentFamily.Value); }
private static void PrintDeviceInformation(PhysicalDevice physicalDevice) { var properties = physicalDevice.GetProperties(); Console.WriteLine($"Driver Version: {properties.DriverVersion}"); Console.WriteLine($"Device Name: {properties.DeviceName}"); Console.WriteLine($"Device Type: {properties.DeviceType}"); Console.WriteLine($"Api Version: {Version.ToString(properties.ApiVersion)}"); foreach (var queueFamilyProperties in physicalDevice.GetQueueFamilyProperties()) { Console.WriteLine($"Count of Queues: {queueFamilyProperties.QueueCount}"); Console.WriteLine("Supported operations on this queue: "); if (queueFamilyProperties.QueueFlags.HasFlag(QueueFlags.Graphics)) { Console.WriteLine("\t\tGraphics"); } if (queueFamilyProperties.QueueFlags.HasFlag(QueueFlags.Compute)) { Console.WriteLine("\t\tCompute"); } if (queueFamilyProperties.QueueFlags.HasFlag(QueueFlags.Transfer)) { Console.WriteLine("\t\tTransfer"); } if (queueFamilyProperties.QueueFlags.HasFlag(QueueFlags.SparseBinding)) { Console.WriteLine("\t\tSparse Binding"); } } }
public QueueFamilyIndices(PhysicalDevice device, SurfaceKhr surface) { int graphicsIndex = -1; int presentIndex = -1; int i = 0; var queues = device.GetQueueFamilyProperties(); foreach (var f in queues) { if (graphicsIndex < 0 && f.QueueCount > 0 && (f.QueueFlags & QueueFlags.Graphics) != 0) { graphicsIndex = i; } if (presentIndex < 0 && f.QueueCount > 0 && device.GetSurfaceSupportKHR((uint)i, surface)) { presentIndex = i; } ++i; } GraphicsFamily = graphicsIndex; PresentFamily = presentIndex; }
static void CreateDevice() { var queueCreateInfo = new DeviceQueueCreateInfo { QueueFamilyIndex = 0, QueueCount = 1, QueuePriorities = 0, }; var deviceEnabledExtensions = new[] { "VK_KHR_swapchain", }; var deviceCreateInfo = new DeviceCreateInfo { QueueCreateInfoCount = 1, QueueCreateInfos = queueCreateInfo, EnabledExtensionNames = deviceEnabledExtensions, }; device = physicalDevice.CreateDevice(deviceCreateInfo, null); Console.WriteLine("[ OK ] Device"); var queueNodeIndex = physicalDevice.GetQueueFamilyProperties() .Where((properties, index) => (properties.QueueFlags & QueueFlags.Graphics) != 0) //&& physicalDevice.GetSurfaceSupport((uint)index, surface) .Select((properties, index) => index) .First(); queue = device.GetQueue(0, (uint)queueNodeIndex); Console.WriteLine("[ OK ] Queue"); }
private QueueFamilyIndices FindQueueFamilies(PhysicalDevice device) { QueueFamilyIndices indices = new QueueFamilyIndices(); var queueFamilies = device.GetQueueFamilyProperties(); for (uint index = 0; index < queueFamilies.Length && !indices.IsComplete; index++) { if (queueFamilies[index].QueueFlags.HasFlag(QueueFlags.Graphics)) { indices.GraphicsFamily = index; } if (device.GetSurfaceSupport(index, this.surface)) { indices.PresentFamily = index; } if (queueFamilies[index].QueueFlags.HasFlag(QueueFlags.Transfer) && !queueFamilies[index].QueueFlags.HasFlag(QueueFlags.Graphics)) { indices.TransferFamily = index; } } if (!indices.TransferFamily.HasValue) { indices.TransferFamily = indices.GraphicsFamily; } return(indices); }
public void Write(PhysicalDevice physicalDevice) { WriteLine("PhysicalDeviceProperties:"); WriteLine("========================="); var properties = physicalDevice.GetProperties(); _tabs++; PhysicalDeviceProperties(properties); WriteLine("PhysicalDeviceLimits:"); WriteLine("---------------------"); var limits = properties.Limits; _tabs++; PhysicalDeviceLimits(limits); _tabs--; WriteLine("PhysicalDeviceSparseProperties:"); WriteLine("-------------------------------"); var sparse = properties.SparseProperties; _tabs++; PhysicalDeviceSparseProperties(sparse); _tabs = 0; WriteLine(""); var queueFamilyProperties = physicalDevice.GetQueueFamilyProperties(); for (int x = 0; x < queueFamilyProperties.Length; x++) { WriteLine($"QueueFamilyProperties[{x}]:"); WriteLine("=========================="); _tabs++; QueueFamilyProperties(queueFamilyProperties[x]); _tabs--; WriteLine(""); } _tabs = 0; WriteLine("PhysicalDeviceMemoryProperties"); WriteLine("=============================="); var physicalDeviceMemoryProperties = physicalDevice.GetMemoryProperties(); _tabs++; PhysicalDeviceMemoryProperties(physicalDeviceMemoryProperties); WriteLine(""); _tabs = 0; WriteLine("PhysicalDeviceFeatures:"); WriteLine("======================="); var features = physicalDevice.GetFeatures(); _tabs++; PhysicalDeviceFeatures(features); Console.WriteLine(_sb.ToString()); }
Queue GetQueue(PhysicalDevice physicalDevice, uint queueFamily) { var queueNodeIndex = physicalDevice.GetQueueFamilyProperties() .Where((properties, index) => (properties.QueueFlags & QueueFlags.Graphics) != 0) .Select((properties, index) => index) .First(); return(device.GetQueue(queueFamily, (uint)queueNodeIndex)); }
private void CreateDevice() { QueueFamilyProperties[] queueProps = PhysicalDevice.GetQueueFamilyProperties(); int computeFamilyIndex = -1; int graphicsFamilyIndex = -1; int sparseBindingFamilyIndex = -1; int transferFamilyIndex = -1; for (var i = 0; i < queueProps.Length; i++) { QueueFamilyProperties props = queueProps[i]; if (computeFamilyIndex == -1 && props.QueueFlags.HasFlag(Queues.Compute)) { computeFamilyIndex = i; } if (graphicsFamilyIndex == -1 && props.QueueFlags.HasFlag(Queues.Graphics)) { graphicsFamilyIndex = i; } if (sparseBindingFamilyIndex == -1 && props.QueueFlags.HasFlag(Queues.SparseBinding)) { sparseBindingFamilyIndex = i; } if (transferFamilyIndex == -1 && props.QueueFlags.HasFlag(Queues.Transfer)) { transferFamilyIndex = i; } } var queueInfos = new[] { computeFamilyIndex, graphicsFamilyIndex, sparseBindingFamilyIndex, transferFamilyIndex }.Distinct().Select(i => new DeviceQueueCreateInfo(i, 1, 1.0f)).ToArray(); string[] selectExtensions = new[] { Constant.DeviceExtension.ExtDebugMarker } .Where(AvailableDeviceExtensions.Contains) .ToArray(); var createInfo = new DeviceCreateInfo(queueInfos, selectExtensions, PhysicalDeviceFeatures); Device = PhysicalDevice.CreateDevice(createInfo); ComputeQueue = Device.GetQueue(computeFamilyIndex); GraphicsQueue = Device.GetQueue(graphicsFamilyIndex); SparseBindingQueue = Device.GetQueue(sparseBindingFamilyIndex); TransferQueue = Device.GetQueue(transferFamilyIndex); }
public PhysicalDeviceInfo(PhysicalDevice physicalDevice) { PhysicalDevice = physicalDevice; Properties = PhysicalDevice.GetProperties(); QueueFamilyProperties = PhysicalDevice.GetQueueFamilyProperties(); MemoryProperties = PhysicalDevice.GetMemoryProperties(); Features = PhysicalDevice.GetFeatures(); GraphicsQFamilies = Array.AsReadOnly(QueueFamiliesWithFlag(QueueFlags.Graphics)); ComputeQFamilies = Array.AsReadOnly(QueueFamiliesWithFlag(QueueFlags.Compute)); TransferQFamilies = Array.AsReadOnly(QueueFamiliesWithFlag(QueueFlags.Transfer)); SparseBindingQFamilies = Array.AsReadOnly(QueueFamiliesWithFlag(QueueFlags.SparseBinding)); }
public void CreateDevice() { // Required in order to keep the validation layer happy :) PhysicalDevice.GetQueueFamilyProperties(); var createInfo = new DeviceCreateInfo(new[] { new DeviceQueueCreateInfo(0, 1, 1.0f) }); using (PhysicalDevice.CreateDevice(createInfo)) { } using (PhysicalDevice.CreateDevice(createInfo, CustomAllocator)) { } }
private void InitializeVulkan(PhysicalDevice physDev, SurfaceKhr surface) { var queueFamilyProperties = physDev.GetQueueFamilyProperties(); uint queueFamilyUsedIndex; for (queueFamilyUsedIndex = 0; queueFamilyUsedIndex < queueFamilyProperties.Length; ++queueFamilyUsedIndex) { if (!physDev.GetSurfaceSupportKHR(queueFamilyUsedIndex, surface)) { continue; } if (queueFamilyProperties[queueFamilyUsedIndex].QueueFlags.HasFlag(QueueFlags.Graphics)) { break; } } var queueInfo = new DeviceQueueCreateInfo { QueuePriorities = new[] { 1.0f }, QueueFamilyIndex = queueFamilyUsedIndex }; var deviceInfo = new DeviceCreateInfo { EnabledExtensionNames = new[] { "VK_KHR_swapchain", }, QueueCreateInfos = new[] { queueInfo } }; _device = physDev.CreateDevice(deviceInfo); _queue = _device.GetQueue(0, 0); _surfaceCapabilities = physDev.GetSurfaceCapabilitiesKHR(surface); var surfaceFormat = SelectSurfaceFormat(physDev, surface); _swapchainKhr = CreateSwapchainKhr(surface, surfaceFormat); _images = _device.GetSwapchainImagesKHR(_swapchainKhr); _renderPass = CreateRenderPass(surfaceFormat); _framebuffers = CreateFramebuffers(_images, surfaceFormat); var fenceInfo = new FenceCreateInfo(); _fence = _device.CreateFence(fenceInfo); var semaphoreInfo = new SemaphoreCreateInfo(); _semaphore = _device.CreateSemaphore(semaphoreInfo); _commandBuffers = CreateCommandBuffers(_images, _framebuffers, _renderPass, _surfaceCapabilities); }
public static uint GetIndexOfFirstAvailablePresentQueueFamily(this PhysicalDevice @this, SurfaceKhr surface) { var queueFamilies = @this.GetQueueFamilyProperties(); for (uint i = 0; i < queueFamilies.Length; i++) { if (@this.GetSurfaceSupportKHR(i, surface)) { return(i); } } throw new VulkanException($"Could not find a queue family on device {@this.GetName()} that can present to given surface"); }
public static uint GetIndexOfFirstAvailableGraphicsQueueFamily(this PhysicalDevice @this) { var queueFamilies = @this.GetQueueFamilyProperties(); for (uint i = 0; i < queueFamilies.Length; i++) { if (queueFamilies[i].QueueFlags.HasFlag(QueueFlags.Graphics)) { return(i); } } throw new VulkanException("Could not find a graphics queue family for device " + @this.GetName()); }
static public uint FindBestComputeQueue(PhysicalDevice physicalDevice) { uint i = 0; foreach (var queueFamily in physicalDevice.GetQueueFamilyProperties()) { var maskedFlages = (QueueFlags.Transfer | QueueFlags.Compute) & queueFamily.QueueFlags; if (maskedFlages == QueueFlags.Compute) { return(i); } i++; } return(~0U); }
public virtual void Initialize(PhysicalDevice physicalDevice, SurfaceKhr surface) { var queueFamilyProperties = physicalDevice.GetQueueFamilyProperties(); uint queueFamilyUsedIndex; for (queueFamilyUsedIndex = 0; queueFamilyUsedIndex < queueFamilyProperties.Length; ++queueFamilyUsedIndex) { if (!physicalDevice.GetSurfaceSupportKHR(queueFamilyUsedIndex, surface)) { continue; } if (queueFamilyProperties [queueFamilyUsedIndex].QueueFlags.HasFlag(QueueFlags.Graphics)) { break; } } var queueInfo = new DeviceQueueCreateInfo { QueuePriorities = new float [] { 1.0f }, QueueFamilyIndex = queueFamilyUsedIndex }; var deviceInfo = new DeviceCreateInfo { EnabledExtensionNames = new string [] { "VK_KHR_swapchain" }, QueueCreateInfos = new DeviceQueueCreateInfo [] { queueInfo } }; device = physicalDevice.CreateDevice(deviceInfo); queue = device.GetQueue(0, 0); surfaceCapabilities = physicalDevice.GetSurfaceCapabilitiesKHR(surface); var surfaceFormat = SelectFormat(physicalDevice, surface); swapchain = CreateSwapchain(surface, surfaceFormat); images = device.GetSwapchainImagesKHR(swapchain); renderPass = CreateRenderPass(surfaceFormat); framebuffers = CreateFramebuffers(images, surfaceFormat); var fenceInfo = new FenceCreateInfo(); fence = device.CreateFence(fenceInfo); var semaphoreInfo = new SemaphoreCreateInfo(); semaphore = device.CreateSemaphore(semaphoreInfo); initialized = true; }
public static void PrintQueueFamilies(this PhysicalDevice @this) { var queueFamilyProperties = @this.GetQueueFamilyProperties(); _logger.LogInfo($"Queue families from device {@this.GetName()}:"); for (int i = 0; i < queueFamilyProperties.Length; i++) { var family = queueFamilyProperties[i]; _logger.LogInfo("\tFamily " + i + ":"); _logger.LogInfo("\t\tCount: " + family.QueueCount); _logger.LogInfo("\t\tFlags: " + family.QueueFlags); _logger.LogInfo("\t\tTimestampValidBits: " + family.TimestampValidBits); _logger.LogInfo("\t\tMinImageTransferGranularity:"); _logger.LogInfo($"\t\t\tWidth: {family.MinImageTransferGranularity.Width}"); _logger.LogInfo($"\t\t\tHeight: {family.MinImageTransferGranularity.Height}"); _logger.LogInfo($"\t\t\tDepth: {family.MinImageTransferGranularity.Depth}"); } }
public void PropertiesSet() { QueueFamilyProperties[] props = PhysicalDevice.GetQueueFamilyProperties(); int queueFamilyIndex = props.Length - 1; int queueCount = props[props.Length - 1].QueueCount; int queueIndex = queueCount - 1; var deviceCreateInfo = new DeviceCreateInfo(new[] { new DeviceQueueCreateInfo(queueFamilyIndex, queueCount, Enumerable.Range(0, queueCount).Select(_ => 1.0f).ToArray()) }); using (Device device = PhysicalDevice.CreateDevice(deviceCreateInfo)) { Queue queue = device.GetQueue(queueFamilyIndex, queueIndex); Assert.Equal(device, queue.Parent); Assert.Equal(queueFamilyIndex, queue.FamilyIndex); Assert.Equal(queueIndex, queue.Index); } }
private QueueFamilyIndices FindQueueFamilies(PhysicalDevice device) { var queueFamilyProperties = device.GetQueueFamilyProperties(); var queueFamilyIndices = new QueueFamilyIndices(); for (int queueFamilyUsedIndex = 0; queueFamilyUsedIndex < queueFamilyProperties.Length; queueFamilyUsedIndex++) { //Check Present Support if (device.GetSurfaceSupportKHR((uint)queueFamilyUsedIndex, data.surface)) { queueFamilyIndices.PresentFamily = queueFamilyUsedIndex; } //Check Graphics Support if (queueFamilyProperties[queueFamilyUsedIndex].QueueFlags.HasFlag(QueueFlags.Graphics)) { queueFamilyIndices.GraphicsFamily = queueFamilyUsedIndex; } } return(queueFamilyIndices); }
internal HostDevice( PhysicalDevice vulkanPhysicaldevice, SurfaceType surfaceType, Logger logger = null) { if (vulkanPhysicaldevice == null) { throw new ArgumentNullException(nameof(vulkanPhysicaldevice)); } this.physicalDevice = vulkanPhysicaldevice; this.surfaceType = surfaceType; this.logger = logger; this.properties = vulkanPhysicaldevice.GetProperties(); this.deviceMemoryProperties = vulkanPhysicaldevice.GetMemoryProperties(); this.supportedFeatures = vulkanPhysicaldevice.GetFeatures(); this.availableExtensions = vulkanPhysicaldevice.EnumerateExtensionProperties(); this.queueFamilies = vulkanPhysicaldevice.GetQueueFamilyProperties(); logger?.Log(nameof(HostDevice), $"Found device: {Name}"); logger?.LogList(nameof(HostDevice), $"{Name} available extensions:", availableExtensions); }
public static QueueFamilyIndices _FindQueueFamilies(PhysicalDevice device, Surface surface) { QueueFamilyIndices indices = new QueueFamilyIndices(); var queueFamilies = device.GetQueueFamilyProperties(); for (uint index = 0; index < queueFamilies.Length && !indices.IsComplete; index++) { if (queueFamilies[index].QueueFlags.HasFlag(QueueFlags.Graphics)) { indices.GraphicsFamily = index; } if (device.GetSurfaceSupport(index, surface)) { indices.PresentFamily = index; } } return(indices); }
public static QueueFamilyPropertiesExt[] GetQueueFamilyPropertiesExt(this PhysicalDevice self) { var queueProperties = self.GetQueueFamilyProperties(); return(queueProperties.Select((q, i) => new QueueFamilyPropertiesExt(q, (uint)i, self)).ToArray()); }
public void GetQueueFamilyProperties() { QueueFamilyProperties[] properties = PhysicalDevice.GetQueueFamilyProperties(); Assert.True(properties.Length > 0); }
/// <summary> /// Get whether a physical device meets requirement features and capabilities /// </summary> /// <param name="device"></param> /// <returns></returns> private static bool GetDeviceMeetsRequirements(PhysicalDevice device, SurfaceKhr surface) { // Argument checks if (device is null) { throw new ArgumentNullException(nameof(device)); } if (surface is null) { throw new ArgumentNullException(nameof(surface)); } // Check device features { var features = device.GetFeatures(); if (!features.SamplerAnisotropy) { return(false); } var limits = device.GetProperties().Limits; if (limits.MaxVertexInputAttributes < 16) { return(false); } if (limits.MaxUniformBufferRange < sizeof(float) * 4 * 254) { return(false); } if (limits.MaxVertexInputBindings < 2) { return(false); } if (limits.MaxPointSize <= 1) { return(false); } } // Check queue families { var families = device.GetQueueFamilyProperties(); // Graphics, compute, transfer { if (families.Count(family => QueueFamily.Supports(family, Queues.Graphics)) == 0 || families.Count(family => QueueFamily.Supports(family, Queues.Compute)) == 0 || families.Count(family => QueueFamily.Supports(family, Queues.Transfer)) == 0) { return(false); } } // Present { var foundPresent = false; for (var i = 0; i < families.Length; i++) { if (QueueFamily.SupportsPresenting(i, device, surface)) { foundPresent = true; break; } } if (!foundPresent) { return(false); } } } return(true); }