#include "mesa/main/git_sha1.h"
#include "util/strtod.h"
+#include "gen7_pack.h"
+
struct anv_dispatch_table dtable;
static void
goto fail;
}
- if (device->info->gen == 7 &&
- !device->info->is_haswell && !device->info->is_baytrail) {
- fprintf(stderr, "WARNING: Ivy Bridge Vulkan support is incomplete");
+ if (device->info->is_haswell) {
+ fprintf(stderr, "WARNING: Haswell Vulkan support is incomplete\n");
+ } else if (device->info->gen == 7 && !device->info->is_baytrail) {
+ fprintf(stderr, "WARNING: Ivy Bridge Vulkan support is incomplete\n");
+ } else if (device->info->gen == 9) {
+ fprintf(stderr, "WARNING: Skylake Vulkan support is incomplete\n");
} else if (device->info->gen == 8 && !device->info->is_cherryview) {
- /* Briadwell is as fully supported as anything */
+ /* Broadwell is as fully supported as anything */
} else {
- result = vk_errorf(VK_UNSUPPORTED,
+ result = vk_errorf(VK_ERROR_INCOMPATIBLE_DRIVER,
"Vulkan not yet supported on %s", device->name);
goto fail;
}
"non-llc gpu");
goto fail;
}
-
+
close(fd);
brw_process_intel_debug_variable();
device->compiler->shader_debug_log = compiler_debug_log;
device->compiler->shader_perf_log = compiler_perf_log;
+ isl_device_init(&device->isl_dev, device->info);
+
return VK_SUCCESS;
-
+
fail:
close(fd);
return result;
ralloc_free(device->compiler);
}
-static void *default_alloc(
- void* pUserData,
- size_t size,
- size_t alignment,
- VkSystemAllocType allocType)
-{
- return malloc(size);
-}
-
-static void default_free(
- void* pUserData,
- void* pMem)
-{
- free(pMem);
-}
-
-static const VkAllocCallbacks default_alloc_callbacks = {
- .pUserData = NULL,
- .pfnAlloc = default_alloc,
- .pfnFree = default_free
-};
-
static const VkExtensionProperties global_extensions[] = {
{
- .extName = VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME,
- .specVersion = 17,
+ .extensionName = VK_KHR_SURFACE_EXTENSION_NAME,
+ .specVersion = 24,
+ },
+ {
+ .extensionName = VK_KHR_XCB_SURFACE_EXTENSION_NAME,
+ .specVersion = 5,
+ },
+#ifdef HAVE_WAYLAND_PLATFORM
+ {
+ .extensionName = VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME,
+ .specVersion = 4,
},
+#endif
};
static const VkExtensionProperties device_extensions[] = {
{
- .extName = VK_EXT_KHR_DEVICE_SWAPCHAIN_EXTENSION_NAME,
- .specVersion = 53,
+ .extensionName = VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+ .specVersion = 67,
},
};
+static void *
+default_alloc_func(void *pUserData, size_t size, size_t align,
+ VkSystemAllocationScope allocationScope)
+{
+ return malloc(size);
+}
+
+static void *
+default_realloc_func(void *pUserData, void *pOriginal, size_t size,
+ size_t align, VkSystemAllocationScope allocationScope)
+{
+ return realloc(pOriginal, size);
+}
+
+static void
+default_free_func(void *pUserData, void *pMemory)
+{
+ free(pMemory);
+}
+
+static const VkAllocationCallbacks default_alloc = {
+ .pUserData = NULL,
+ .pfnAllocation = default_alloc_func,
+ .pfnReallocation = default_realloc_func,
+ .pfnFree = default_free_func,
+};
+
VkResult anv_CreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance)
{
struct anv_instance *instance;
- const VkAllocCallbacks *alloc_callbacks = &default_alloc_callbacks;
- void *user_data = NULL;
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO);
- if (pCreateInfo->pAppInfo->apiVersion != VK_MAKE_VERSION(0, 170, 2))
+ if (pCreateInfo->pApplicationInfo->apiVersion != VK_MAKE_VERSION(0, 210, 1))
return vk_error(VK_ERROR_INCOMPATIBLE_DRIVER);
- for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
+ for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
bool found = false;
for (uint32_t j = 0; j < ARRAY_SIZE(global_extensions); j++) {
if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
- global_extensions[j].extName) == 0) {
+ global_extensions[j].extensionName) == 0) {
found = true;
break;
}
return vk_error(VK_ERROR_EXTENSION_NOT_PRESENT);
}
- if (pCreateInfo->pAllocCb) {
- alloc_callbacks = pCreateInfo->pAllocCb;
- user_data = pCreateInfo->pAllocCb->pUserData;
- }
- instance = alloc_callbacks->pfnAlloc(user_data, sizeof(*instance), 8,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ instance = anv_alloc2(&default_alloc, pAllocator, sizeof(*instance), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!instance)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
instance->_loader_data.loaderMagic = ICD_LOADER_MAGIC;
- instance->pAllocUserData = alloc_callbacks->pUserData;
- instance->pfnAlloc = alloc_callbacks->pfnAlloc;
- instance->pfnFree = alloc_callbacks->pfnFree;
- instance->apiVersion = pCreateInfo->pAppInfo->apiVersion;
+
+ if (pAllocator)
+ instance->alloc = *pAllocator;
+ else
+ instance->alloc = default_alloc;
+
+ instance->apiVersion = pCreateInfo->pApplicationInfo->apiVersion;
instance->physicalDeviceCount = -1;
_mesa_locale_init();
}
void anv_DestroyInstance(
- VkInstance _instance)
+ VkInstance _instance,
+ const VkAllocationCallbacks* pAllocator)
{
ANV_FROM_HANDLE(anv_instance, instance, _instance);
_mesa_locale_fini();
- instance->pfnFree(instance->pAllocUserData, instance);
-}
-
-void *
-anv_instance_alloc(struct anv_instance *instance, size_t size,
- size_t alignment, VkSystemAllocType allocType)
-{
- void *mem = instance->pfnAlloc(instance->pAllocUserData,
- size, alignment, allocType);
- if (mem) {
- VG(VALGRIND_MEMPOOL_ALLOC(instance, mem, size));
- VG(VALGRIND_MAKE_MEM_UNDEFINED(mem, size));
- }
- return mem;
-}
-
-void
-anv_instance_free(struct anv_instance *instance, void *mem)
-{
- if (mem == NULL)
- return;
-
- VG(VALGRIND_MEMPOOL_FREE(instance, mem));
-
- instance->pfnFree(instance->pAllocUserData, mem);
+ anv_free(&instance->alloc, instance);
}
VkResult anv_EnumeratePhysicalDevices(
if (instance->physicalDeviceCount < 0) {
result = anv_physical_device_init(&instance->physicalDevice,
instance, "/dev/dri/renderD128");
- if (result == VK_UNSUPPORTED) {
+ if (result == VK_ERROR_INCOMPATIBLE_DRIVER) {
instance->physicalDeviceCount = 0;
} else if (result == VK_SUCCESS) {
instance->physicalDeviceCount = 1;
return VK_SUCCESS;
}
-VkResult anv_GetPhysicalDeviceFeatures(
+void anv_GetPhysicalDeviceFeatures(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceFeatures* pFeatures)
{
.geometryShader = true,
.tessellationShader = false,
.sampleRateShading = false,
- .dualSourceBlend = true,
+ .dualSrcBlend = true,
.logicOp = true,
.multiDrawIndirect = true,
- .depthClip = false,
+ .depthClamp = false,
.depthBiasClamp = false,
.fillModeNonSolid = true,
.depthBounds = false,
.wideLines = true,
.largePoints = true,
+ .alphaToOne = true,
+ .multiViewport = true,
+ .samplerAnisotropy = false, /* FINISHME */
.textureCompressionETC2 = true,
.textureCompressionASTC_LDR = true,
.textureCompressionBC = true,
- .occlusionQueryNonConservative = false, /* FINISHME */
+ .occlusionQueryPrecise = false, /* FINISHME */
.pipelineStatisticsQuery = true,
- .vertexSideEffects = false,
- .tessellationSideEffects = false,
- .geometrySideEffects = false,
- .fragmentSideEffects = false,
- .shaderTessellationPointSize = false,
- .shaderGeometryPointSize = true,
+ .vertexPipelineStoresAndAtomics = false,
+ .fragmentStoresAndAtomics = true,
+ .shaderTessellationAndGeometryPointSize = true,
.shaderImageGatherExtended = true,
.shaderStorageImageExtendedFormats = false,
.shaderStorageImageMultisample = false,
.shaderSampledImageArrayDynamicIndexing = false,
.shaderStorageBufferArrayDynamicIndexing = false,
.shaderStorageImageArrayDynamicIndexing = false,
+ .shaderStorageImageReadWithoutFormat = false,
+ .shaderStorageImageWriteWithoutFormat = true,
.shaderClipDistance = false,
.shaderCullDistance = false,
.shaderFloat64 = false,
.shaderInt64 = false,
.shaderInt16 = false,
.alphaToOne = true,
+ .variableMultisampleRate = false,
};
-
- return VK_SUCCESS;
}
-VkResult anv_GetPhysicalDeviceProperties(
+void anv_GetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties)
{
anv_finishme("Get correct values for VkPhysicalDeviceLimits");
+ VkSampleCountFlags sample_counts =
+ VK_SAMPLE_COUNT_1_BIT |
+ VK_SAMPLE_COUNT_2_BIT |
+ VK_SAMPLE_COUNT_4_BIT |
+ VK_SAMPLE_COUNT_8_BIT;
+
VkPhysicalDeviceLimits limits = {
.maxImageDimension1D = (1 << 14),
.maxImageDimension2D = (1 << 14),
.maxImageDimension3D = (1 << 10),
.maxImageDimensionCube = (1 << 14),
.maxImageArrayLayers = (1 << 10),
-
- /* Broadwell supports 1, 2, 4, and 8 samples. */
- .sampleCounts = 4,
-
- .maxTexelBufferSize = (1 << 14),
- .maxUniformBufferSize = UINT32_MAX,
- .maxStorageBufferSize = UINT32_MAX,
+ .maxTexelBufferElements = (1 << 14),
+ .maxUniformBufferRange = UINT32_MAX,
+ .maxStorageBufferRange = UINT32_MAX,
.maxPushConstantsSize = MAX_PUSH_CONSTANTS_SIZE,
.maxMemoryAllocationCount = UINT32_MAX,
+ .maxSamplerAllocationCount = UINT32_MAX,
.bufferImageGranularity = 64, /* A cache line */
.sparseAddressSpaceSize = 0,
.maxBoundDescriptorSets = MAX_SETS,
- .maxDescriptorSets = UINT32_MAX,
.maxPerStageDescriptorSamplers = 64,
.maxPerStageDescriptorUniformBuffers = 64,
.maxPerStageDescriptorStorageBuffers = 64,
.maxPerStageDescriptorSampledImages = 64,
.maxPerStageDescriptorStorageImages = 64,
+ .maxPerStageDescriptorInputAttachments = 64,
+ .maxPerStageResources = 128,
.maxDescriptorSetSamplers = 256,
.maxDescriptorSetUniformBuffers = 256,
.maxDescriptorSetUniformBuffersDynamic = 256,
.maxDescriptorSetStorageBuffersDynamic = 256,
.maxDescriptorSetSampledImages = 256,
.maxDescriptorSetStorageImages = 256,
+ .maxDescriptorSetInputAttachments = 256,
.maxVertexInputAttributes = 32,
.maxVertexInputBindings = 32,
.maxVertexInputAttributeOffset = 256,
.maxVertexInputBindingStride = 256,
.maxVertexOutputComponents = 32,
- .maxTessGenLevel = 0,
- .maxTessPatchSize = 0,
- .maxTessControlPerVertexInputComponents = 0,
- .maxTessControlPerVertexOutputComponents = 0,
- .maxTessControlPerPatchOutputComponents = 0,
- .maxTessControlTotalOutputComponents = 0,
- .maxTessEvaluationInputComponents = 0,
- .maxTessEvaluationOutputComponents = 0,
+ .maxTessellationGenerationLevel = 0,
+ .maxTessellationPatchSize = 0,
+ .maxTessellationControlPerVertexInputComponents = 0,
+ .maxTessellationControlPerVertexOutputComponents = 0,
+ .maxTessellationControlPerPatchOutputComponents = 0,
+ .maxTessellationControlTotalOutputComponents = 0,
+ .maxTessellationEvaluationInputComponents = 0,
+ .maxTessellationEvaluationOutputComponents = 0,
.maxGeometryShaderInvocations = 6,
.maxGeometryInputComponents = 16,
.maxGeometryOutputComponents = 16,
.maxGeometryOutputVertices = 16,
.maxGeometryTotalOutputComponents = 16,
.maxFragmentInputComponents = 16,
- .maxFragmentOutputBuffers = 8,
- .maxFragmentDualSourceBuffers = 2,
+ .maxFragmentOutputAttachments = 8,
+ .maxFragmentDualSrcAttachments = 2,
.maxFragmentCombinedOutputResources = 8,
.maxComputeSharedMemorySize = 1024,
.maxComputeWorkGroupCount = {
.subTexelPrecisionBits = 4 /* FIXME */,
.mipmapPrecisionBits = 4 /* FIXME */,
.maxDrawIndexedIndexValue = UINT32_MAX,
- .maxDrawIndirectInstanceCount = UINT32_MAX,
- .primitiveRestartForPatches = UINT32_MAX,
+ .maxDrawIndirectCount = UINT32_MAX,
.maxSamplerLodBias = 16,
.maxSamplerAnisotropy = 16,
.maxViewports = MAX_VIEWPORTS,
.maxFramebufferWidth = (1 << 14),
.maxFramebufferHeight = (1 << 14),
.maxFramebufferLayers = (1 << 10),
- .maxFramebufferColorSamples = 8,
- .maxFramebufferDepthSamples = 8,
- .maxFramebufferStencilSamples = 8,
+ .framebufferColorSampleCounts = sample_counts,
+ .framebufferDepthSampleCounts = sample_counts,
+ .framebufferStencilSampleCounts = sample_counts,
+ .framebufferNoAttachmentsSampleCounts = sample_counts,
.maxColorAttachments = MAX_RTS,
- .maxSampledImageColorSamples = 8,
- .maxSampledImageDepthSamples = 8,
- .maxSampledImageIntegerSamples = 1,
- .maxStorageImageSamples = 1,
+ .sampledImageColorSampleCounts = sample_counts,
+ .sampledImageIntegerSampleCounts = VK_SAMPLE_COUNT_1_BIT,
+ .sampledImageDepthSampleCounts = sample_counts,
+ .sampledImageStencilSampleCounts = sample_counts,
+ .storageImageSampleCounts = VK_SAMPLE_COUNT_1_BIT,
.maxSampleMaskWords = 1,
- .timestampFrequency = 1000 * 1000 * 1000 / 80,
+ .timestampPeriod = 80.0 / (1000 * 1000 * 1000),
.maxClipDistances = 0 /* FIXME */,
.maxCullDistances = 0 /* FIXME */,
.maxCombinedClipAndCullDistances = 0 /* FIXME */,
+ .discreteQueuePriorities = 1,
.pointSizeRange = { 0.125, 255.875 },
.lineWidthRange = { 0.0, 7.9921875 },
.pointSizeGranularity = (1.0 / 8.0),
.lineWidthGranularity = (1.0 / 128.0),
+ .strictLines = false, /* FINISHME */
+ .standardSampleLocations = true, /* FINISHME */
+ .optimalBufferCopyOffsetAlignment = 128,
+ .optimalBufferCopyRowPitchAlignment = 128,
+ .nonCoherentAtomSize = 64,
};
*pProperties = (VkPhysicalDeviceProperties) {
- .apiVersion = VK_MAKE_VERSION(0, 170, 2),
+ .apiVersion = VK_MAKE_VERSION(0, 210, 1),
.driverVersion = 1,
- .vendorId = 0x8086,
- .deviceId = pdevice->chipset_id,
+ .vendorID = 0x8086,
+ .deviceID = pdevice->chipset_id,
.deviceType = VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU,
.limits = limits,
.sparseProperties = {0}, /* Broadwell doesn't do sparse. */
};
strcpy(pProperties->deviceName, pdevice->name);
- snprintf((char *)pProperties->pipelineCacheUUID, VK_UUID_LENGTH,
+ snprintf((char *)pProperties->pipelineCacheUUID, VK_UUID_SIZE,
"anv-%s", MESA_GIT_SHA1 + 4);
-
- return VK_SUCCESS;
}
-VkResult anv_GetPhysicalDeviceQueueFamilyProperties(
+void anv_GetPhysicalDeviceQueueFamilyProperties(
VkPhysicalDevice physicalDevice,
uint32_t* pCount,
VkQueueFamilyProperties* pQueueFamilyProperties)
{
if (pQueueFamilyProperties == NULL) {
*pCount = 1;
- return VK_SUCCESS;
+ return;
}
assert(*pCount >= 1);
*pQueueFamilyProperties = (VkQueueFamilyProperties) {
.queueFlags = VK_QUEUE_GRAPHICS_BIT |
VK_QUEUE_COMPUTE_BIT |
- VK_QUEUE_DMA_BIT,
+ VK_QUEUE_TRANSFER_BIT,
.queueCount = 1,
- .supportsTimestamps = true,
+ .timestampValidBits = 0, /* XXX: Real value here */
+ .minImageTransferGranularity = (VkExtent3D) { 1, 1, 1 },
};
-
- return VK_SUCCESS;
}
-VkResult anv_GetPhysicalDeviceMemoryProperties(
+void anv_GetPhysicalDeviceMemoryProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceMemoryProperties* pMemoryProperties)
{
/* The property flags below are valid only for llc platforms. */
pMemoryProperties->memoryTypeCount = 1;
pMemoryProperties->memoryTypes[0] = (VkMemoryType) {
- .propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
+ .propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
+ VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+ VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+ VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
.heapIndex = 1,
};
pMemoryProperties->memoryHeapCount = 1;
pMemoryProperties->memoryHeaps[0] = (VkMemoryHeap) {
.size = heap_size,
- .flags = VK_MEMORY_HEAP_HOST_LOCAL_BIT,
+ .flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT,
};
-
- return VK_SUCCESS;
}
PFN_vkVoidFunction anv_GetInstanceProcAddr(
{
}
+static struct anv_state
+anv_state_pool_emit_data(struct anv_state_pool *pool, size_t size, size_t align, const void *p)
+{
+ struct anv_state state;
+
+ state = anv_state_pool_alloc(pool, size, align);
+ memcpy(state.map, p, size);
+
+ if (!pool->block_pool->device->info.has_llc)
+ anv_state_clflush(state);
+
+ return state;
+}
+
static void
anv_device_init_border_colors(struct anv_device *device)
{
[VK_BORDER_COLOR_INT_OPAQUE_WHITE] = { .uint32 = { 1, 1, 1, 1 } },
};
- device->border_colors =
- anv_state_pool_alloc(&device->dynamic_state_pool,
- sizeof(border_colors), 32);
- memcpy(device->border_colors.map, border_colors, sizeof(border_colors));
+ device->border_colors = anv_state_pool_emit_data(&device->dynamic_state_pool,
+ sizeof(border_colors), 32, border_colors);
}
VkResult anv_CreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice)
{
ANV_FROM_HANDLE(anv_physical_device, physical_device, physicalDevice);
- struct anv_instance *instance = physical_device->instance;
struct anv_device *device;
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO);
- for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) {
+ for (uint32_t i = 0; i < pCreateInfo->enabledExtensionNameCount; i++) {
bool found = false;
for (uint32_t j = 0; j < ARRAY_SIZE(device_extensions); j++) {
if (strcmp(pCreateInfo->ppEnabledExtensionNames[i],
- device_extensions[j].extName) == 0) {
+ device_extensions[j].extensionName) == 0) {
found = true;
break;
}
return vk_error(VK_ERROR_EXTENSION_NOT_PRESENT);
}
- anv_set_dispatch_gen(physical_device->info->gen);
+ anv_set_dispatch_devinfo(physical_device->info);
- device = anv_instance_alloc(instance, sizeof(*device), 8,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ device = anv_alloc2(&physical_device->instance->alloc, pAllocator,
+ sizeof(*device), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!device)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
device->_loader_data.loaderMagic = ICD_LOADER_MAGIC;
device->instance = physical_device->instance;
+ if (pAllocator)
+ device->alloc = *pAllocator;
+ else
+ device->alloc = physical_device->instance->alloc;
+
/* XXX(chadv): Can we dup() physicalDevice->fd here? */
device->fd = open(physical_device->path, O_RDWR | O_CLOEXEC);
if (device->fd == -1)
goto fail_device;
-
+
device->context_id = anv_gem_create_context(device);
if (device->context_id == -1)
goto fail_fd;
anv_state_pool_init(&device->dynamic_state_pool,
&device->dynamic_state_block_pool);
- anv_block_pool_init(&device->instruction_block_pool, device, 2048);
+ anv_block_pool_init(&device->instruction_block_pool, device, 4096);
anv_block_pool_init(&device->surface_state_block_pool, device, 4096);
anv_state_pool_init(&device->surface_state_pool,
&device->surface_state_block_pool);
+ anv_bo_init_new(&device->workaround_bo, device, 1024);
+
anv_block_pool_init(&device->scratch_block_pool, device, 0x10000);
device->info = *physical_device->info;
+ device->isl_dev = physical_device->isl_dev;
anv_queue_init(device, &device->queue);
fail_fd:
close(device->fd);
fail_device:
- anv_device_free(device, device);
+ anv_free(&device->alloc, device);
return vk_error(VK_ERROR_INITIALIZATION_FAILED);
}
void anv_DestroyDevice(
- VkDevice _device)
+ VkDevice _device,
+ const VkAllocationCallbacks* pAllocator)
{
ANV_FROM_HANDLE(anv_device, device, _device);
anv_state_pool_free(&device->dynamic_state_pool, device->border_colors);
#endif
+ anv_gem_munmap(device->workaround_bo.map, device->workaround_bo.size);
+ anv_gem_close(device, device->workaround_bo.gem_handle);
+
anv_bo_pool_finish(&device->batch_bo_pool);
anv_state_pool_finish(&device->dynamic_state_pool);
anv_block_pool_finish(&device->dynamic_state_block_pool);
close(device->fd);
- anv_instance_free(device->instance, device);
+ anv_free(&device->alloc, device);
}
VkResult anv_EnumerateInstanceExtensionProperties(
const char* pLayerName,
- uint32_t* pCount,
+ uint32_t* pPropertyCount,
VkExtensionProperties* pProperties)
{
if (pProperties == NULL) {
- *pCount = ARRAY_SIZE(global_extensions);
+ *pPropertyCount = ARRAY_SIZE(global_extensions);
return VK_SUCCESS;
}
- assert(*pCount >= ARRAY_SIZE(global_extensions));
+ assert(*pPropertyCount >= ARRAY_SIZE(global_extensions));
- *pCount = ARRAY_SIZE(global_extensions);
+ *pPropertyCount = ARRAY_SIZE(global_extensions);
memcpy(pProperties, global_extensions, sizeof(global_extensions));
return VK_SUCCESS;
VkResult anv_EnumerateDeviceExtensionProperties(
VkPhysicalDevice physicalDevice,
const char* pLayerName,
- uint32_t* pCount,
+ uint32_t* pPropertyCount,
VkExtensionProperties* pProperties)
{
if (pProperties == NULL) {
- *pCount = ARRAY_SIZE(device_extensions);
+ *pPropertyCount = ARRAY_SIZE(device_extensions);
return VK_SUCCESS;
}
- assert(*pCount >= ARRAY_SIZE(device_extensions));
+ assert(*pPropertyCount >= ARRAY_SIZE(device_extensions));
- *pCount = ARRAY_SIZE(device_extensions);
+ *pPropertyCount = ARRAY_SIZE(device_extensions);
memcpy(pProperties, device_extensions, sizeof(device_extensions));
return VK_SUCCESS;
}
VkResult anv_EnumerateInstanceLayerProperties(
- uint32_t* pCount,
+ uint32_t* pPropertyCount,
VkLayerProperties* pProperties)
{
if (pProperties == NULL) {
- *pCount = 0;
+ *pPropertyCount = 0;
return VK_SUCCESS;
}
VkResult anv_EnumerateDeviceLayerProperties(
VkPhysicalDevice physicalDevice,
- uint32_t* pCount,
+ uint32_t* pPropertyCount,
VkLayerProperties* pProperties)
{
if (pProperties == NULL) {
- *pCount = 0;
+ *pPropertyCount = 0;
return VK_SUCCESS;
}
return vk_error(VK_ERROR_LAYER_NOT_PRESENT);
}
-VkResult anv_GetDeviceQueue(
+void anv_GetDeviceQueue(
VkDevice _device,
uint32_t queueNodeIndex,
uint32_t queueIndex,
assert(queueIndex == 0);
*pQueue = anv_queue_to_handle(&device->queue);
-
- return VK_SUCCESS;
}
VkResult anv_QueueSubmit(
VkQueue _queue,
- uint32_t cmdBufferCount,
- const VkCmdBuffer* pCmdBuffers,
+ uint32_t submitCount,
+ const VkSubmitInfo* pSubmits,
VkFence _fence)
{
ANV_FROM_HANDLE(anv_queue, queue, _queue);
struct anv_device *device = queue->device;
int ret;
- for (uint32_t i = 0; i < cmdBufferCount; i++) {
- ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer, pCmdBuffers[i]);
-
- assert(cmd_buffer->level == VK_CMD_BUFFER_LEVEL_PRIMARY);
+ for (uint32_t i = 0; i < submitCount; i++) {
+ for (uint32_t j = 0; j < pSubmits[i].commandBufferCount; j++) {
+ ANV_FROM_HANDLE(anv_cmd_buffer, cmd_buffer,
+ pSubmits[i].pCommandBuffers[j]);
+ assert(cmd_buffer->level == VK_COMMAND_BUFFER_LEVEL_PRIMARY);
- ret = anv_gem_execbuffer(device, &cmd_buffer->execbuf2.execbuf);
- if (ret != 0) {
- /* We don't know the real error. */
- return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY,
- "execbuf2 failed: %m");
- }
-
- if (fence) {
- ret = anv_gem_execbuffer(device, &fence->execbuf);
+ ret = anv_gem_execbuffer(device, &cmd_buffer->execbuf2.execbuf);
if (ret != 0) {
/* We don't know the real error. */
return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY,
"execbuf2 failed: %m");
}
- }
- for (uint32_t i = 0; i < cmd_buffer->execbuf2.bo_count; i++)
- cmd_buffer->execbuf2.bos[i]->offset = cmd_buffer->execbuf2.objects[i].offset;
+ if (fence) {
+ ret = anv_gem_execbuffer(device, &fence->execbuf);
+ if (ret != 0) {
+ /* We don't know the real error. */
+ return vk_errorf(VK_ERROR_OUT_OF_DEVICE_MEMORY,
+ "execbuf2 failed: %m");
+ }
+ }
+
+ for (uint32_t k = 0; k < cmd_buffer->execbuf2.bo_count; k++)
+ cmd_buffer->execbuf2.bos[k]->offset = cmd_buffer->execbuf2.objects[k].offset;
+ }
}
return VK_SUCCESS;
anv_batch_emit(&batch, GEN7_MI_BATCH_BUFFER_END);
anv_batch_emit(&batch, GEN7_MI_NOOP);
+ if (!device->info.has_llc)
+ anv_state_clflush(state);
+
exec2_objects[0].handle = bo->gem_handle;
exec2_objects[0].relocation_count = 0;
exec2_objects[0].relocs_ptr = 0;
return result;
}
-void *
-anv_device_alloc(struct anv_device * device,
- size_t size,
- size_t alignment,
- VkSystemAllocType allocType)
-{
- return anv_instance_alloc(device->instance, size, alignment, allocType);
-}
-
-void
-anv_device_free(struct anv_device * device,
- void * mem)
-{
- anv_instance_free(device->instance, mem);
-}
-
VkResult
anv_bo_init_new(struct anv_bo *bo, struct anv_device *device, uint64_t size)
{
return VK_SUCCESS;
}
-VkResult anv_AllocMemory(
+VkResult anv_AllocateMemory(
VkDevice _device,
- const VkMemoryAllocInfo* pAllocInfo,
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
VkDeviceMemory* pMem)
{
ANV_FROM_HANDLE(anv_device, device, _device);
struct anv_device_memory *mem;
VkResult result;
- assert(pAllocInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO);
+ assert(pAllocateInfo->sType == VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO);
/* We support exactly one memory heap. */
- assert(pAllocInfo->memoryTypeIndex == 0);
+ assert(pAllocateInfo->memoryTypeIndex == 0);
/* FINISHME: Fail if allocation request exceeds heap size. */
- mem = anv_device_alloc(device, sizeof(*mem), 8,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ mem = anv_alloc2(&device->alloc, pAllocator, sizeof(*mem), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (mem == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
- result = anv_bo_init_new(&mem->bo, device, pAllocInfo->allocationSize);
+ result = anv_bo_init_new(&mem->bo, device, pAllocateInfo->allocationSize);
if (result != VK_SUCCESS)
goto fail;
return VK_SUCCESS;
fail:
- anv_device_free(device, mem);
+ anv_free2(&device->alloc, pAllocator, mem);
return result;
}
void anv_FreeMemory(
VkDevice _device,
- VkDeviceMemory _mem)
+ VkDeviceMemory _mem,
+ const VkAllocationCallbacks* pAllocator)
{
ANV_FROM_HANDLE(anv_device, device, _device);
ANV_FROM_HANDLE(anv_device_memory, mem, _mem);
if (mem->bo.gem_handle != 0)
anv_gem_close(device, mem->bo.gem_handle);
- anv_device_free(device, mem);
+ anv_free2(&device->alloc, pAllocator, mem);
}
VkResult anv_MapMemory(
VkDevice _device,
- VkDeviceMemory _mem,
+ VkDeviceMemory _memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
void** ppData)
{
ANV_FROM_HANDLE(anv_device, device, _device);
- ANV_FROM_HANDLE(anv_device_memory, mem, _mem);
+ ANV_FROM_HANDLE(anv_device_memory, mem, _memory);
/* FIXME: Is this supposed to be thread safe? Since vkUnmapMemory() only
* takes a VkDeviceMemory pointer, it seems like only one map of the memory
mem->map_size = size;
*ppData = mem->map;
-
+
return VK_SUCCESS;
}
void anv_UnmapMemory(
VkDevice _device,
- VkDeviceMemory _mem)
+ VkDeviceMemory _memory)
{
- ANV_FROM_HANDLE(anv_device_memory, mem, _mem);
+ ANV_FROM_HANDLE(anv_device_memory, mem, _memory);
anv_gem_munmap(mem->map, mem->map_size);
}
+static void
+clflush_mapped_ranges(struct anv_device *device,
+ uint32_t count,
+ const VkMappedMemoryRange *ranges)
+{
+ for (uint32_t i = 0; i < count; i++) {
+ ANV_FROM_HANDLE(anv_device_memory, mem, ranges[i].memory);
+ void *p = mem->map + (ranges[i].offset & ~CACHELINE_MASK);
+ void *end = mem->map + ranges[i].offset + ranges[i].size;
+
+ while (p < end) {
+ __builtin_ia32_clflush(p);
+ p += CACHELINE_SIZE;
+ }
+ }
+}
+
VkResult anv_FlushMappedMemoryRanges(
- VkDevice device,
- uint32_t memRangeCount,
- const VkMappedMemoryRange* pMemRanges)
+ VkDevice _device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
{
- /* clflush here for !llc platforms */
+ ANV_FROM_HANDLE(anv_device, device, _device);
+
+ if (device->info.has_llc)
+ return VK_SUCCESS;
+
+ /* Make sure the writes we're flushing have landed. */
+ __builtin_ia32_sfence();
+
+ clflush_mapped_ranges(device, memoryRangeCount, pMemoryRanges);
return VK_SUCCESS;
}
VkResult anv_InvalidateMappedMemoryRanges(
- VkDevice device,
- uint32_t memRangeCount,
- const VkMappedMemoryRange* pMemRanges)
+ VkDevice _device,
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges)
{
- return anv_FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
+ ANV_FROM_HANDLE(anv_device, device, _device);
+
+ if (device->info.has_llc)
+ return VK_SUCCESS;
+
+ clflush_mapped_ranges(device, memoryRangeCount, pMemoryRanges);
+
+ /* Make sure no reads get moved up above the invalidate. */
+ __builtin_ia32_lfence();
+
+ return VK_SUCCESS;
}
-VkResult anv_GetBufferMemoryRequirements(
+void anv_GetBufferMemoryRequirements(
VkDevice device,
VkBuffer _buffer,
VkMemoryRequirements* pMemoryRequirements)
pMemoryRequirements->size = buffer->size;
pMemoryRequirements->alignment = 16;
-
- return VK_SUCCESS;
}
-VkResult anv_GetImageMemoryRequirements(
+void anv_GetImageMemoryRequirements(
VkDevice device,
VkImage _image,
VkMemoryRequirements* pMemoryRequirements)
pMemoryRequirements->size = image->size;
pMemoryRequirements->alignment = image->alignment;
-
- return VK_SUCCESS;
}
-VkResult anv_GetImageSparseMemoryRequirements(
+void anv_GetImageSparseMemoryRequirements(
VkDevice device,
VkImage image,
- uint32_t* pNumRequirements,
+ uint32_t* pSparseMemoryRequirementCount,
VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
{
- return vk_error(VK_UNSUPPORTED);
+ stub();
}
-VkResult anv_GetDeviceMemoryCommitment(
+void anv_GetDeviceMemoryCommitment(
VkDevice device,
VkDeviceMemory memory,
VkDeviceSize* pCommittedMemoryInBytes)
{
*pCommittedMemoryInBytes = 0;
- stub_return(VK_SUCCESS);
}
VkResult anv_BindBufferMemory(
VkDevice device,
VkBuffer _buffer,
- VkDeviceMemory _mem,
- VkDeviceSize memOffset)
+ VkDeviceMemory _memory,
+ VkDeviceSize memoryOffset)
{
- ANV_FROM_HANDLE(anv_device_memory, mem, _mem);
+ ANV_FROM_HANDLE(anv_device_memory, mem, _memory);
ANV_FROM_HANDLE(anv_buffer, buffer, _buffer);
buffer->bo = &mem->bo;
- buffer->offset = memOffset;
+ buffer->offset = memoryOffset;
return VK_SUCCESS;
}
VkResult anv_BindImageMemory(
VkDevice device,
VkImage _image,
- VkDeviceMemory _mem,
- VkDeviceSize memOffset)
+ VkDeviceMemory _memory,
+ VkDeviceSize memoryOffset)
{
- ANV_FROM_HANDLE(anv_device_memory, mem, _mem);
+ ANV_FROM_HANDLE(anv_device_memory, mem, _memory);
ANV_FROM_HANDLE(anv_image, image, _image);
image->bo = &mem->bo;
- image->offset = memOffset;
+ image->offset = memoryOffset;
return VK_SUCCESS;
}
-VkResult anv_QueueBindSparseBufferMemory(
- VkQueue queue,
- VkBuffer buffer,
- uint32_t numBindings,
- const VkSparseMemoryBindInfo* pBindInfo)
-{
- stub_return(VK_UNSUPPORTED);
-}
-
-VkResult anv_QueueBindSparseImageOpaqueMemory(
- VkQueue queue,
- VkImage image,
- uint32_t numBindings,
- const VkSparseMemoryBindInfo* pBindInfo)
-{
- stub_return(VK_UNSUPPORTED);
-}
-
-VkResult anv_QueueBindSparseImageMemory(
+VkResult anv_QueueBindSparse(
VkQueue queue,
- VkImage image,
- uint32_t numBindings,
- const VkSparseImageMemoryBindInfo* pBindInfo)
+ uint32_t bindInfoCount,
+ const VkBindSparseInfo* pBindInfo,
+ VkFence fence)
{
- stub_return(VK_UNSUPPORTED);
+ stub_return(VK_ERROR_INCOMPATIBLE_DRIVER);
}
VkResult anv_CreateFence(
VkDevice _device,
const VkFenceCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
VkFence* pFence)
{
ANV_FROM_HANDLE(anv_device, device, _device);
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO);
- fence = anv_device_alloc(device, sizeof(*fence), 8,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ fence = anv_alloc2(&device->alloc, pAllocator, sizeof(*fence), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (fence == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
anv_batch_emit(&batch, GEN7_MI_BATCH_BUFFER_END);
anv_batch_emit(&batch, GEN7_MI_NOOP);
+ if (!device->info.has_llc) {
+ assert(((uintptr_t) fence->bo.map & CACHELINE_MASK) == 0);
+ assert(batch.next - fence->bo.map <= CACHELINE_SIZE);
+ __builtin_ia32_sfence();
+ __builtin_ia32_clflush(fence->bo.map);
+ }
+
fence->exec2_objects[0].handle = fence->bo.gem_handle;
fence->exec2_objects[0].relocation_count = 0;
fence->exec2_objects[0].relocs_ptr = 0;
return VK_SUCCESS;
fail:
- anv_device_free(device, fence);
+ anv_free2(&device->alloc, pAllocator, fence);
return result;
}
void anv_DestroyFence(
VkDevice _device,
- VkFence _fence)
+ VkFence _fence,
+ const VkAllocationCallbacks* pAllocator)
{
ANV_FROM_HANDLE(anv_device, device, _device);
ANV_FROM_HANDLE(anv_fence, fence, _fence);
anv_gem_munmap(fence->bo.map, fence->bo.size);
anv_gem_close(device, fence->bo.gem_handle);
- anv_device_free(device, fence);
+ anv_free2(&device->alloc, pAllocator, fence);
}
VkResult anv_ResetFences(
uint64_t timeout)
{
ANV_FROM_HANDLE(anv_device, device, _device);
+
+ /* DRM_IOCTL_I915_GEM_WAIT uses a signed 64 bit timeout and is supposed
+ * to block indefinitely timeouts <= 0. Unfortunately, this was broken
+ * for a couple of kernel releases. Since there's no way to know
+ * whether or not the kernel we're using is one of the broken ones, the
+ * best we can do is to clamp the timeout to INT64_MAX. This limits the
+ * maximum timeout from 584 years to 292 years - likely not a big deal.
+ */
+ if (timeout > INT64_MAX)
+ timeout = INT64_MAX;
+
int64_t t = timeout;
- int ret;
/* FIXME: handle !waitAll */
for (uint32_t i = 0; i < fenceCount; i++) {
ANV_FROM_HANDLE(anv_fence, fence, pFences[i]);
- ret = anv_gem_wait(device, fence->bo.gem_handle, &t);
+ int ret = anv_gem_wait(device, fence->bo.gem_handle, &t);
if (ret == -1 && errno == ETIME) {
return VK_TIMEOUT;
} else if (ret == -1) {
VkResult anv_CreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore)
{
- pSemaphore->handle = 1;
+ *pSemaphore = (VkSemaphore)1;
stub_return(VK_SUCCESS);
}
void anv_DestroySemaphore(
VkDevice device,
- VkSemaphore semaphore)
+ VkSemaphore semaphore,
+ const VkAllocationCallbacks* pAllocator)
{
stub();
}
-VkResult anv_QueueSignalSemaphore(
- VkQueue queue,
- VkSemaphore semaphore)
-{
- stub_return(VK_UNSUPPORTED);
-}
-
-VkResult anv_QueueWaitSemaphore(
- VkQueue queue,
- VkSemaphore semaphore)
-{
- stub_return(VK_UNSUPPORTED);
-}
-
// Event functions
VkResult anv_CreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent)
{
- stub_return(VK_UNSUPPORTED);
+ stub_return(VK_ERROR_INCOMPATIBLE_DRIVER);
}
void anv_DestroyEvent(
VkDevice device,
- VkEvent event)
+ VkEvent event,
+ const VkAllocationCallbacks* pAllocator)
{
stub();
}
VkDevice device,
VkEvent event)
{
- stub_return(VK_UNSUPPORTED);
+ stub_return(VK_ERROR_INCOMPATIBLE_DRIVER);
}
VkResult anv_SetEvent(
VkDevice device,
VkEvent event)
{
- stub_return(VK_UNSUPPORTED);
+ stub_return(VK_ERROR_INCOMPATIBLE_DRIVER);
}
VkResult anv_ResetEvent(
VkDevice device,
VkEvent event)
{
- stub_return(VK_UNSUPPORTED);
+ stub_return(VK_ERROR_INCOMPATIBLE_DRIVER);
}
// Buffer functions
VkResult anv_CreateBuffer(
VkDevice _device,
const VkBufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer)
{
ANV_FROM_HANDLE(anv_device, device, _device);
assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO);
- buffer = anv_device_alloc(device, sizeof(*buffer), 8,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ buffer = anv_alloc2(&device->alloc, pAllocator, sizeof(*buffer), 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (buffer == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
void anv_DestroyBuffer(
VkDevice _device,
- VkBuffer _buffer)
+ VkBuffer _buffer,
+ const VkAllocationCallbacks* pAllocator)
{
ANV_FROM_HANDLE(anv_device, device, _device);
ANV_FROM_HANDLE(anv_buffer, buffer, _buffer);
- anv_device_free(device, buffer);
+ anv_free2(&device->alloc, pAllocator, buffer);
}
void
anv_fill_buffer_surface_state(struct anv_device *device, void *state,
const struct anv_format *format,
- uint32_t offset, uint32_t range)
+ uint32_t offset, uint32_t range, uint32_t stride)
{
switch (device->info.gen) {
case 7:
- gen7_fill_buffer_surface_state(state, format, offset, range);
+ if (device->info.is_haswell)
+ gen75_fill_buffer_surface_state(state, format, offset, range, stride);
+ else
+ gen7_fill_buffer_surface_state(state, format, offset, range, stride);
break;
case 8:
- gen8_fill_buffer_surface_state(state, format, offset, range);
+ gen8_fill_buffer_surface_state(state, format, offset, range, stride);
+ break;
+ case 9:
+ gen9_fill_buffer_surface_state(state, format, offset, range, stride);
break;
default:
unreachable("unsupported gen\n");
}
}
-VkResult
-anv_buffer_view_create(
- struct anv_device * device,
- const VkBufferViewCreateInfo* pCreateInfo,
- struct anv_buffer_view ** bview_out)
+VkResult anv_CreateBufferView(
+ VkDevice _device,
+ const VkBufferViewCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkBufferView* pView)
{
- ANV_FROM_HANDLE(anv_buffer, buffer, pCreateInfo->buffer);
- struct anv_buffer_view *bview;
-
- assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO);
-
- bview = anv_device_alloc(device, sizeof(*bview), 8,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
- if (bview == NULL)
- return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
-
- *bview = (struct anv_buffer_view) {
- .bo = buffer->bo,
- .offset = buffer->offset + pCreateInfo->offset,
- .surface_state = anv_state_pool_alloc(&device->surface_state_pool, 64, 64),
- .format = anv_format_for_vk_format(pCreateInfo->format),
- .range = pCreateInfo->range,
- };
-
- *bview_out = bview;
-
- return VK_SUCCESS;
+ stub_return(VK_ERROR_INCOMPATIBLE_DRIVER);
}
void anv_DestroyBufferView(
VkDevice _device,
- VkBufferView _bview)
+ VkBufferView _bview,
+ const VkAllocationCallbacks* pAllocator)
{
- ANV_FROM_HANDLE(anv_device, device, _device);
- ANV_FROM_HANDLE(anv_buffer_view, bview, _bview);
-
- anv_state_pool_free(&device->surface_state_pool, bview->surface_state);
- anv_device_free(device, bview);
+ stub();
}
void anv_DestroySampler(
VkDevice _device,
- VkSampler _sampler)
+ VkSampler _sampler,
+ const VkAllocationCallbacks* pAllocator)
{
ANV_FROM_HANDLE(anv_device, device, _device);
ANV_FROM_HANDLE(anv_sampler, sampler, _sampler);
- anv_device_free(device, sampler);
-}
-
-// Descriptor set functions
-
-VkResult anv_CreateDescriptorSetLayout(
- VkDevice _device,
- const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- VkDescriptorSetLayout* pSetLayout)
-{
- ANV_FROM_HANDLE(anv_device, device, _device);
- struct anv_descriptor_set_layout *set_layout;
- uint32_t s;
-
- assert(pCreateInfo->sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO);
-
- uint32_t immutable_sampler_count = 0;
- for (uint32_t b = 0; b < pCreateInfo->count; b++) {
- if (pCreateInfo->pBinding[b].pImmutableSamplers)
- immutable_sampler_count += pCreateInfo->pBinding[b].arraySize;
- }
-
- size_t size = sizeof(struct anv_descriptor_set_layout) +
- pCreateInfo->count * sizeof(set_layout->binding[0]) +
- immutable_sampler_count * sizeof(struct anv_sampler *);
-
- set_layout = anv_device_alloc(device, size, 8,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
- if (!set_layout)
- return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
-
- /* We just allocate all the samplers at the end of the struct */
- struct anv_sampler **samplers =
- (struct anv_sampler **)&set_layout->binding[pCreateInfo->count];
-
- set_layout->binding_count = pCreateInfo->count;
- set_layout->shader_stages = 0;
- set_layout->size = 0;
-
- /* Initialize all binding_layout entries to -1 */
- memset(set_layout->binding, -1,
- pCreateInfo->count * sizeof(set_layout->binding[0]));
-
- /* Initialize all samplers to 0 */
- memset(samplers, 0, immutable_sampler_count * sizeof(*samplers));
-
- uint32_t sampler_count[VK_SHADER_STAGE_NUM] = { 0, };
- uint32_t surface_count[VK_SHADER_STAGE_NUM] = { 0, };
- uint32_t dynamic_offset_count = 0;
-
- for (uint32_t b = 0; b < pCreateInfo->count; b++) {
- uint32_t array_size = MAX2(1, pCreateInfo->pBinding[b].arraySize);
- set_layout->binding[b].array_size = array_size;
- set_layout->binding[b].descriptor_index = set_layout->size;
- set_layout->size += array_size;
-
- switch (pCreateInfo->pBinding[b].descriptorType) {
- case VK_DESCRIPTOR_TYPE_SAMPLER:
- case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
- for_each_bit(s, pCreateInfo->pBinding[b].stageFlags) {
- set_layout->binding[b].stage[s].sampler_index = sampler_count[s];
- sampler_count[s] += array_size;
- }
- break;
- default:
- break;
- }
-
- switch (pCreateInfo->pBinding[b].descriptorType) {
- case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
- case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
- case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
- case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
- case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
- case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
- for_each_bit(s, pCreateInfo->pBinding[b].stageFlags) {
- set_layout->binding[b].stage[s].surface_index = surface_count[s];
- surface_count[s] += array_size;
- }
- break;
- default:
- break;
- }
-
- switch (pCreateInfo->pBinding[b].descriptorType) {
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
- set_layout->binding[b].dynamic_offset_index = dynamic_offset_count;
- dynamic_offset_count += array_size;
- break;
- default:
- break;
- }
-
- if (pCreateInfo->pBinding[b].pImmutableSamplers) {
- set_layout->binding[b].immutable_samplers = samplers;
- samplers += array_size;
-
- for (uint32_t i = 0; i < array_size; i++)
- set_layout->binding[b].immutable_samplers[i] =
- anv_sampler_from_handle(pCreateInfo->pBinding[b].pImmutableSamplers[i]);
- } else {
- set_layout->binding[b].immutable_samplers = NULL;
- }
-
- set_layout->shader_stages |= pCreateInfo->pBinding[b].stageFlags;
- }
-
- set_layout->dynamic_offset_count = dynamic_offset_count;
-
- *pSetLayout = anv_descriptor_set_layout_to_handle(set_layout);
-
- return VK_SUCCESS;
-}
-
-void anv_DestroyDescriptorSetLayout(
- VkDevice _device,
- VkDescriptorSetLayout _set_layout)
-{
- ANV_FROM_HANDLE(anv_device, device, _device);
- ANV_FROM_HANDLE(anv_descriptor_set_layout, set_layout, _set_layout);
-
- anv_device_free(device, set_layout);
-}
-
-VkResult anv_CreateDescriptorPool(
- VkDevice device,
- const VkDescriptorPoolCreateInfo* pCreateInfo,
- VkDescriptorPool* pDescriptorPool)
-{
- anv_finishme("VkDescriptorPool is a stub");
- pDescriptorPool->handle = 1;
- return VK_SUCCESS;
-}
-
-void anv_DestroyDescriptorPool(
- VkDevice _device,
- VkDescriptorPool _pool)
-{
- anv_finishme("VkDescriptorPool is a stub: free the pool's descriptor sets");
-}
-
-VkResult anv_ResetDescriptorPool(
- VkDevice device,
- VkDescriptorPool descriptorPool)
-{
- anv_finishme("VkDescriptorPool is a stub: free the pool's descriptor sets");
- return VK_SUCCESS;
-}
-
-VkResult
-anv_descriptor_set_create(struct anv_device *device,
- const struct anv_descriptor_set_layout *layout,
- struct anv_descriptor_set **out_set)
-{
- struct anv_descriptor_set *set;
- size_t size = sizeof(*set) + layout->size * sizeof(set->descriptors[0]);
-
- set = anv_device_alloc(device, size, 8, VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
- if (!set)
- return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
-
- /* A descriptor set may not be 100% filled. Clear the set so we can can
- * later detect holes in it.
- */
- memset(set, 0, size);
-
- set->layout = layout;
-
- /* Go through and fill out immutable samplers if we have any */
- struct anv_descriptor *desc = set->descriptors;
- for (uint32_t b = 0; b < layout->binding_count; b++) {
- if (layout->binding[b].immutable_samplers) {
- for (uint32_t i = 0; i < layout->binding[b].array_size; i++)
- desc[i].sampler = layout->binding[b].immutable_samplers[i];
- }
- desc += layout->binding[b].array_size;
- }
-
- *out_set = set;
-
- return VK_SUCCESS;
-}
-
-void
-anv_descriptor_set_destroy(struct anv_device *device,
- struct anv_descriptor_set *set)
-{
- anv_device_free(device, set);
-}
-
-VkResult anv_AllocDescriptorSets(
- VkDevice _device,
- VkDescriptorPool descriptorPool,
- VkDescriptorSetUsage setUsage,
- uint32_t count,
- const VkDescriptorSetLayout* pSetLayouts,
- VkDescriptorSet* pDescriptorSets)
-{
- ANV_FROM_HANDLE(anv_device, device, _device);
-
- VkResult result = VK_SUCCESS;
- struct anv_descriptor_set *set;
- uint32_t i;
-
- for (i = 0; i < count; i++) {
- ANV_FROM_HANDLE(anv_descriptor_set_layout, layout, pSetLayouts[i]);
-
- result = anv_descriptor_set_create(device, layout, &set);
- if (result != VK_SUCCESS)
- break;
-
- pDescriptorSets[i] = anv_descriptor_set_to_handle(set);
- }
-
- if (result != VK_SUCCESS)
- anv_FreeDescriptorSets(_device, descriptorPool, i, pDescriptorSets);
-
- return result;
-}
-
-VkResult anv_FreeDescriptorSets(
- VkDevice _device,
- VkDescriptorPool descriptorPool,
- uint32_t count,
- const VkDescriptorSet* pDescriptorSets)
-{
- ANV_FROM_HANDLE(anv_device, device, _device);
-
- for (uint32_t i = 0; i < count; i++) {
- ANV_FROM_HANDLE(anv_descriptor_set, set, pDescriptorSets[i]);
-
- anv_descriptor_set_destroy(device, set);
- }
-
- return VK_SUCCESS;
-}
-
-void anv_UpdateDescriptorSets(
- VkDevice device,
- uint32_t writeCount,
- const VkWriteDescriptorSet* pDescriptorWrites,
- uint32_t copyCount,
- const VkCopyDescriptorSet* pDescriptorCopies)
-{
- for (uint32_t i = 0; i < writeCount; i++) {
- const VkWriteDescriptorSet *write = &pDescriptorWrites[i];
- ANV_FROM_HANDLE(anv_descriptor_set, set, write->destSet);
-
- switch (write->descriptorType) {
- case VK_DESCRIPTOR_TYPE_SAMPLER:
- for (uint32_t j = 0; j < write->count; j++) {
- ANV_FROM_HANDLE(anv_sampler, sampler,
- write->pDescriptors[j].sampler);
-
- set->descriptors[write->destBinding + j] = (struct anv_descriptor) {
- .type = ANV_DESCRIPTOR_TYPE_SAMPLER,
- .sampler = sampler,
- };
- }
- break;
-
- case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
- for (uint32_t j = 0; j < write->count; j++) {
- struct anv_descriptor *desc =
- &set->descriptors[write->destBinding + j];
- ANV_FROM_HANDLE(anv_image_view, iview,
- write->pDescriptors[j].imageView);
- ANV_FROM_HANDLE(anv_sampler, sampler,
- write->pDescriptors[j].sampler);
-
- desc->type = ANV_DESCRIPTOR_TYPE_IMAGE_VIEW_AND_SAMPLER;
- desc->image_view = iview;
-
- /* If this descriptor has an immutable sampler, we don't want
- * to stomp on it.
- */
- if (sampler)
- desc->sampler = sampler;
- }
- break;
-
- case VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE:
- case VK_DESCRIPTOR_TYPE_STORAGE_IMAGE:
- for (uint32_t j = 0; j < write->count; j++) {
- ANV_FROM_HANDLE(anv_image_view, iview,
- write->pDescriptors[j].imageView);
-
- set->descriptors[write->destBinding + j] = (struct anv_descriptor) {
- .type = ANV_DESCRIPTOR_TYPE_IMAGE_VIEW,
- .image_view = iview,
- };
- }
- break;
-
- case VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER:
- case VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER:
- anv_finishme("texel buffers not implemented");
- break;
-
- case VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT:
- anv_finishme("input attachments not implemented");
- break;
-
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
- case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC:
- case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC:
- for (uint32_t j = 0; j < write->count; j++) {
- if (write->pDescriptors[j].bufferView.handle) {
- ANV_FROM_HANDLE(anv_buffer_view, bview,
- write->pDescriptors[j].bufferView);
-
- set->descriptors[write->destBinding + j] =
- (struct anv_descriptor) {
- .type = ANV_DESCRIPTOR_TYPE_BUFFER_VIEW,
- .buffer_view = bview,
- };
- } else {
- ANV_FROM_HANDLE(anv_buffer, buffer,
- write->pDescriptors[j].bufferInfo.buffer);
- assert(buffer);
-
- set->descriptors[write->destBinding + j] =
- (struct anv_descriptor) {
- .type = ANV_DESCRIPTOR_TYPE_BUFFER_AND_OFFSET,
- .buffer = buffer,
- .offset = write->pDescriptors[j].bufferInfo.offset,
- .range = write->pDescriptors[j].bufferInfo.range,
- };
- }
- }
-
- default:
- break;
- }
- }
-
- for (uint32_t i = 0; i < copyCount; i++) {
- const VkCopyDescriptorSet *copy = &pDescriptorCopies[i];
- ANV_FROM_HANDLE(anv_descriptor_set, src, copy->destSet);
- ANV_FROM_HANDLE(anv_descriptor_set, dest, copy->destSet);
- for (uint32_t j = 0; j < copy->count; j++) {
- dest->descriptors[copy->destBinding + j] =
- src->descriptors[copy->srcBinding + j];
- }
- }
+ anv_free2(&device->alloc, pAllocator, sampler);
}
VkResult anv_CreateFramebuffer(
VkDevice _device,
const VkFramebufferCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer)
{
ANV_FROM_HANDLE(anv_device, device, _device);
size_t size = sizeof(*framebuffer) +
sizeof(struct anv_image_view *) * pCreateInfo->attachmentCount;
- framebuffer = anv_device_alloc(device, size, 8,
- VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
+ framebuffer = anv_alloc2(&device->alloc, pAllocator, size, 8,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (framebuffer == NULL)
return vk_error(VK_ERROR_OUT_OF_HOST_MEMORY);
void anv_DestroyFramebuffer(
VkDevice _device,
- VkFramebuffer _fb)
+ VkFramebuffer _fb,
+ const VkAllocationCallbacks* pAllocator)
{
ANV_FROM_HANDLE(anv_device, device, _device);
ANV_FROM_HANDLE(anv_framebuffer, fb, _fb);
- anv_device_free(device, fb);
+ anv_free2(&device->alloc, pAllocator, fb);
}
void vkCmdDbgMarkerBegin(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const char* pMarker)
__attribute__ ((visibility ("default")));
void vkCmdDbgMarkerEnd(
- VkCmdBuffer cmdBuffer)
+ VkCommandBuffer commandBuffer)
__attribute__ ((visibility ("default")));
void vkCmdDbgMarkerBegin(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const char* pMarker)
{
}
void vkCmdDbgMarkerEnd(
- VkCmdBuffer cmdBuffer)
+ VkCommandBuffer commandBuffer)
{
}
projects / mesa.git / blobdiff