void AppGpuDumpMemoryProps(AppGpu gpu, StreamWriter output)
{
PhysicalDeviceMemoryProperties props = gpu.MemoryProps;
output.WriteLine("VkPhysicalDeviceMemoryProperties:");
output.WriteLine("=================================");
output.WriteLine("\tmemoryTypeCount = {0}", props.MemoryTypeCount);
for (int i = 0; i < props.MemoryTypeCount; i++)
{
MemoryType memoryType = props.MemoryTypes[i];
output.WriteLine("\tmemoryTypes[{0}] : ", i);
output.WriteLine("\t\tpropertyFlags = {0}", memoryType.PropertyFlags);
output.WriteLine("\t\theapIndex = {0}", memoryType.HeapIndex);
}
output.WriteLine("\tmemoryHeapCount = {0}", props.MemoryHeapCount);
for (int i = 0; i < props.MemoryHeapCount; i++)
{
MemoryHeap memoryHeap = props.MemoryHeaps[i];
output.WriteLine("\tmemoryHeaps[{0}] : ", i);
output.WriteLine("\t\tsize = {0}", memoryHeap.Size);
}
}
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 void DumpInfo(StreamWriter output)
{
uint apiVersion = Vulkan.Version.Make(1, 0, 0);
DumpHeader(apiVersion, output);
AppInstance instance = AppCreateInstance(apiVersion);
output.WriteLine("Instance Extensions and layers:");
output.WriteLine("===============================");
AppDumpExtensions("", "Instance", instance.Extensions, output);
output.WriteLine("Instance Layers\tcount = {0}", instance.Layers.Length);
foreach (LayerExtensionList layer in instance.Layers)
{
LayerProperties layerProp = layer.LayerProperties;
uint major, minor, patch;
ExtractVersion(layerProp.SpecVersion, out major, out minor, out patch);
string specVersion = string.Format("{0}.{1}.{2}", major, minor, patch);
string layerVersion = string.Format("{0}", layerProp.ImplementationVersion);
output.WriteLine("\t{0} ({1}) Vulkan version {2}, layer version {3}",
layerProp.LayerName, layerProp.Description,
specVersion, layerVersion);
AppDumpExtensions("\t", layerProp.LayerName, layer.ExtensionProperties, output);
}
PhysicalDevice[] objs = instance.Instance.EnumeratePhysicalDevices();
AppGpu[] gpus = new AppGpu[objs.Length];
for (uint i = 0; i < objs.Length; i++)
{
gpus[i] = AppGpuInit(i, objs[i]);
AppGpuDump(gpus[i], output);
output.WriteLine();
output.WriteLine();
}
for (uint i = 0; i < gpus.Length; i++)
{
AppGpuDestroy(gpus[i]);
}
AppDestroyInstance(instance);
output.Flush();
}
void AppGpuDumpProps(AppGpu gpu, StreamWriter output)
{
PhysicalDeviceProperties props = gpu.Props;
output.WriteLine("VkPhysicalDeviceProperties:");
output.WriteLine("===========================");
output.WriteLine("\tapiVersion = {0}", props.ApiVersion);
output.WriteLine("\tdriverVersion = {0}", props.DriverVersion);
output.WriteLine("\tvendorID = 0x{0:x}", props.VendorID);
output.WriteLine("\tdeviceID = 0x{0:x}", props.DeviceID);
output.WriteLine("\tdeviceType = {0}", GetVkName(props.DeviceType.ToString(), "", ""));
output.WriteLine("\tdeviceName = {0}", props.DeviceName);
AppDumpLimits(props.Limits, output);
AppDumpSparseProps(props.SparseProperties, output);;
}
void AppGpuDumpQueuProps(AppGpu gpu, uint id, StreamWriter output)
{
QueueFamilyProperties props = gpu.QueueProps[id];
output.WriteLine("VkQueueFamilyProperties[{0}]:", id);
output.WriteLine("============================");
output.WriteLine("\tqueueFlags = {0}{1}{2}",
((QueueFlags)props.QueueFlags & QueueFlags.Graphics) == QueueFlags.Graphics ? 'G' : '.',
((QueueFlags)props.QueueFlags & QueueFlags.Compute) == QueueFlags.Compute ? 'C' : '.',
((QueueFlags)props.QueueFlags & QueueFlags.Transfer) == QueueFlags.Transfer ? 'D' : '.');
//((QueueFlags)props.QueueFlags & QueueFlags.SparseBinding) == QueueFlags.SparseBinding ? 'S' : '.'); // Add this option, not pressent in original
output.WriteLine("\tqueueCount = {0}", props.QueueCount);
output.WriteLine("\ttimestampValidBits = {0}", props.TimestampValidBits);
output.WriteLine("\tminImageTransferGranularity = ({0}, {1}, {2})",
props.MinImageTransferGranularity.Width,
props.MinImageTransferGranularity.Height,
props.MinImageTransferGranularity.Depth);
}
void AppGpuDump(AppGpu gpu, StreamWriter output)
{
output.WriteLine("Device Extensions and layers:");
output.WriteLine("=============================");
output.WriteLine("GPU{0}", gpu.Id);
AppGpuDumpProps(gpu, output);
output.WriteLine();
AppDumpExtensions("", "Device", gpu.DeviceExtensions, output);
output.WriteLine();
output.WriteLine("Layers\tcount = {0}", gpu.DeviceLayers.Length);
foreach (LayerExtensionList layerInfo in gpu.DeviceLayers)
{
uint major, minor, patch;
ExtractVersion(layerInfo.LayerProperties.SpecVersion, out major, out minor, out patch);
string specVersion = string.Format("{0}.{1}.{2}", major, minor, patch);
string layerVersion = string.Format("{0}", layerInfo.LayerProperties.ImplementationVersion);
output.WriteLine("\t{0} ({1}) Vulkan version {2}, layer version {3}",
layerInfo.LayerProperties.LayerName,
layerInfo.LayerProperties.Description, specVersion,
layerVersion);
AppDumpExtensions("\t", layerInfo.LayerProperties.LayerName, layerInfo.ExtensionProperties, output);
}
output.WriteLine();
for (uint i = 0; i < gpu.QueueProps.Length; i++)
{
AppGpuDumpQueuProps(gpu, i, output);
output.WriteLine();
}
AppGpuDumpMemoryProps(gpu, output);
output.WriteLine();
AppGpuDumpFeatures(gpu, output);
output.WriteLine();
AppDevDump(gpu.Device, output);
}
AppDev AppDevInit(AppGpu gpu)
{
DeviceCreateInfo info = new DeviceCreateInfo
{
QueueCreateInfoCount = 0, // TODO : this sould not be
QueueCreateInfos = new DeviceQueueCreateInfo[0],
EnabledLayerCount = 0,
EnabledLayerNames = new string[0],
};
// Scan layers
List <LayerExtensionList> layers = new List <LayerExtensionList>();
LayerProperties[] layerProperties = gpu.Obj.EnumerateDeviceLayerProperties();
if (layerProperties != null)
{
foreach (LayerProperties layer in layerProperties)
{
LayerExtensionList layerExtList = new LayerExtensionList
{
LayerProperties = layer,
ExtensionProperties = gpu.Obj.EnumerateDeviceExtensionProperties(layer.LayerName),
};
if (layerExtList.ExtensionProperties == null)
{
layerExtList.ExtensionProperties = new ExtensionProperties[0];
}
layers.Add(layerExtList);
}
}
ExtensionProperties[] extensions = gpu.Obj.EnumerateDeviceExtensionProperties("");
foreach (string knownExtName in KnownDeviceExtensions)
{
bool extensionFound = false;
foreach (ExtensionProperties extention in extensions)
{
if (extention.ExtensionName == knownExtName)
{
extensionFound = true;
break;
}
}
if (!extensionFound)
{
throw new Exception("Cannot find extension: " + knownExtName);
}
}
gpu.DeviceLayers = layers.ToArray();
gpu.DeviceExtensions = extensions;
info.QueueCreateInfoCount = (uint)gpu.QueueReqs.Length;
info.QueueCreateInfos = gpu.QueueReqs;
info.EnabledExtensionNames = KnownDeviceExtensions;
info.EnabledExtensionCount = (uint)KnownDeviceExtensions.Length;
Device device = gpu.Obj.CreateDevice(info, null);
return(new AppDev
{
Gpu = gpu,
Obj = device,
});
}
void AppGpuDumpFeatures(AppGpu gpu, StreamWriter output)
{
PhysicalDeviceFeatures features = gpu.Features;
output.WriteLine("VkPhysicalDeviceFeatures:");
output.WriteLine("=========================");
output.WriteLine("\trobustBufferAccess = {0}", features.RobustBufferAccess);
output.WriteLine("\tfullDrawIndexUint32 = {0}", features.FullDrawIndexUint32);
output.WriteLine("\timageCubeArray = {0}", features.ImageCubeArray);
output.WriteLine("\tindependentBlend = {0}", features.IndependentBlend);
output.WriteLine("\tgeometryShader = {0}", features.GeometryShader);
output.WriteLine("\ttessellationShader = {0}", features.TessellationShader);
output.WriteLine("\tsampleRateShading = {0}", features.SampleRateShading);
output.WriteLine("\tdualSrcBlend = {0}", features.DualSrcBlend);
output.WriteLine("\tlogicOp = {0}", features.LogicOp);
output.WriteLine("\tmultiDrawIndirect = {0}", features.MultiDrawIndirect);
output.WriteLine("\tdrawIndirectFirstInstance = {0}", features.DrawIndirectFirstInstance);
output.WriteLine("\tdepthClamp = {0}", features.DepthClamp);
output.WriteLine("\tdepthBiasClamp = {0}", features.DepthBiasClamp);
output.WriteLine("\tfillModeNonSolid = {0}", features.FillModeNonSolid);
output.WriteLine("\tdepthBounds = {0}", features.DepthBounds);
output.WriteLine("\twideLines = {0}", features.WideLines);
output.WriteLine("\tlargePoints = {0}", features.LargePoints);
output.WriteLine("\ttextureCompressionETC2 = {0}", features.TextureCompressionETC2);
output.WriteLine("\ttextureCompressionASTC_LDR = {0}", features.TextureCompressionASTCLdr);
output.WriteLine("\ttextureCompressionBC = {0}", features.TextureCompressionBC);
output.WriteLine("\tocclusionQueryPrecise = {0}", features.OcclusionQueryPrecise);
output.WriteLine("\tpipelineStatisticsQuery = {0}", features.PipelineStatisticsQuery);
output.WriteLine("\tvertexSideEffects = {0}", features.VertexPipelineStoresAndAtomics);
output.WriteLine("\ttessellationSideEffects = {0}", features.FragmentStoresAndAtomics);
output.WriteLine("\tgeometrySideEffects = {0}", features.ShaderTessellationAndGeometryPointSize);
output.WriteLine("\tshaderImageGatherExtended = {0}", features.ShaderImageGatherExtended);
output.WriteLine("\tshaderStorageImageExtendedFormats = {0}", features.ShaderStorageImageExtendedFormats);
output.WriteLine("\tshaderStorageImageMultisample = {0}", features.ShaderStorageImageMultisample);
output.WriteLine("\tshaderStorageImageReadWithoutFormat = {0}", features.ShaderStorageImageReadWithoutFormat);
output.WriteLine("\tshaderStorageImageWriteWithoutFormat = {0}", features.ShaderStorageImageWriteWithoutFormat);
output.WriteLine("\tshaderUniformBufferArrayDynamicIndexing = {0}", features.ShaderUniformBufferArrayDynamicIndexing);
output.WriteLine("\tshaderSampledImageArrayDynamicIndexing = {0}", features.ShaderSampledImageArrayDynamicIndexing);
output.WriteLine("\tshaderStorageBufferArrayDynamicIndexing = {0}", features.ShaderStorageBufferArrayDynamicIndexing);
output.WriteLine("\tshaderStorageImageArrayDynamicIndexing = {0}", features.ShaderStorageImageArrayDynamicIndexing);
output.WriteLine("\tshaderClipDistance = {0}", features.ShaderClipDistance);
output.WriteLine("\tshaderCullDistance = {0}", features.ShaderCullDistance);
output.WriteLine("\tshaderFloat64 = {0}", features.ShaderFloat64);
output.WriteLine("\tshaderInt64 = {0}", features.ShaderInt64);
output.WriteLine("\tshaderInt16 = {0}", features.ShaderInt16);
output.WriteLine("\tshaderResourceResidency = {0}", features.ShaderResourceResidency);
output.WriteLine("\tshaderResourceMinLod = {0}", features.ShaderResourceMinLod);
output.WriteLine("\talphaToOne = {0}", features.AlphaToOne);
output.WriteLine("\tsparseBinding = {0}", features.SparseBinding);
output.WriteLine("\tsparseResidencyBuffer = {0}", features.SparseResidencyBuffer);
output.WriteLine("\tsparseResidencyImage2D = {0}", features.SparseResidencyImage2D);
output.WriteLine("\tsparseResidencyImage3D = {0}", features.SparseResidencyImage3D);
output.WriteLine("\tsparseResidency2Samples = {0}", features.SparseResidency2Samples);
output.WriteLine("\tsparseResidency4Samples = {0}", features.SparseResidency4Samples);
output.WriteLine("\tsparseResidency8Samples = {0}", features.SparseResidency8Samples);
output.WriteLine("\tsparseResidency16Samples = {0}", features.SparseResidency16Samples);
output.WriteLine("\tsparseResidencyAliased = {0}", features.SparseResidencyAliased);
output.WriteLine("\tvariableMultisampleRate = {0}", features.VariableMultisampleRate);
output.WriteLine("\tiheritedQueries = {0}", features.InheritedQueries);
}
void AppGpuDestroy(AppGpu gpu)
{
AppDevDestroy(gpu.Device);
// TODO : Check if we need to free some structs
}
