#include <sys/sysinfo.h>
#include <unistd.h>
#include <fcntl.h>
-#include <xf86drm.h>
#include "drm-uapi/drm_fourcc.h"
+#include "drm-uapi/drm.h"
+#include <xf86drm.h>
#include "anv_private.h"
#include "util/debug.h"
#include "util/os_file.h"
#include "util/u_atomic.h"
#include "util/u_string.h"
-#include "util/xmlpool.h"
+#include "util/driconf.h"
#include "git_sha1.h"
#include "vk_util.h"
#include "common/gen_aux_map.h"
*/
#define MAX_DEBUG_MESSAGE_LENGTH 4096
+/* Render engine timestamp register */
+#define TIMESTAMP 0x2358
+
static void
compiler_debug_log(void *data, const char *fmt, ...)
{
anv_perf_warn(NULL, NULL,
"Failed to get I915_CONTEXT_PARAM_GTT_SIZE: %m");
- if (anv_gem_get_aperture(fd, &device->gtt_size) == -1) {
+ if (gen_get_aperture_size(fd, &device->gtt_size) == -1) {
return vk_errorfi(device->instance, NULL,
VK_ERROR_INITIALIZATION_FAILED,
"failed to get aperture size: %m");
device->has_syncobj = anv_gem_get_param(fd, I915_PARAM_HAS_EXEC_FENCE_ARRAY);
device->has_syncobj_wait = device->has_syncobj &&
anv_gem_supports_syncobj_wait(fd);
+ device->has_syncobj_wait_available =
+ anv_gem_get_drm_cap(fd, DRM_CAP_SYNCOBJ_TIMELINE) != 0;
+
device->has_context_priority = anv_gem_has_context_priority(fd);
result = anv_physical_device_init_heaps(device, fd);
device->has_context_isolation =
anv_gem_get_param(fd, I915_PARAM_HAS_CONTEXT_ISOLATION);
+ device->has_exec_timeline =
+ anv_gem_get_param(fd, I915_PARAM_HAS_EXEC_TIMELINE_FENCES);
+ if (env_var_as_boolean("ANV_QUEUE_THREAD_DISABLE", false))
+ device->has_exec_timeline = false;
+
device->always_use_bindless =
env_var_as_boolean("ANV_ALWAYS_BINDLESS", false);
+ device->use_call_secondary =
+ device->use_softpin &&
+ !env_var_as_boolean("ANV_DISABLE_SECONDARY_CMD_BUFFER_CALLS", false);
+
/* We first got the A64 messages on broadwell and we can only use them if
* we can pass addresses directly into the shader which requires softpin.
*/
device->has_implicit_ccs = device->info.has_aux_map;
+ /* Check if we can read the GPU timestamp register from the CPU */
+ uint64_t u64_ignore;
+ device->has_reg_timestamp = anv_gem_reg_read(fd, TIMESTAMP | I915_REG_READ_8B_WA,
+ &u64_ignore) == 0;
+
device->has_mem_available = get_available_system_memory() != 0;
device->always_flush_cache =
driParseOptionInfo(&instance->available_dri_options, anv_dri_options_xml);
driParseConfigFiles(&instance->dri_options, &instance->available_dri_options,
0, "anv", NULL,
+ instance->app_info.app_name,
+ instance->app_info.app_version,
instance->app_info.engine_name,
instance->app_info.engine_version);
vk_foreach_struct(ext, pFeatures->pNext) {
switch (ext->sType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: {
+ VkPhysicalDevice4444FormatsFeaturesEXT *features =
+ (VkPhysicalDevice4444FormatsFeaturesEXT *)ext;
+ features->formatA4R4G4B4 = true;
+ features->formatA4B4G4R4 = false;
+ break;
+ }
+
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: {
VkPhysicalDevice8BitStorageFeaturesKHR *features =
(VkPhysicalDevice8BitStorageFeaturesKHR *)ext;
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: {
+ VkPhysicalDeviceCustomBorderColorFeaturesEXT *features =
+ (VkPhysicalDeviceCustomBorderColorFeaturesEXT *)ext;
+ features->customBorderColors = pdevice->info.gen >= 8;
+ features->customBorderColorWithoutFormat = pdevice->info.gen >= 8;
+ break;
+ }
+
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: {
VkPhysicalDeviceDepthClipEnableFeaturesEXT *features =
(VkPhysicalDeviceDepthClipEnableFeaturesEXT *)ext;
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: {
+ VkPhysicalDeviceImageRobustnessFeaturesEXT *features =
+ (VkPhysicalDeviceImageRobustnessFeaturesEXT *)ext;
+ features->robustImageAccess = true;
+ break;
+ }
+
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: {
VkPhysicalDeviceIndexTypeUint8FeaturesEXT *features =
(VkPhysicalDeviceIndexTypeUint8FeaturesEXT *)ext;
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: {
+ VkPhysicalDevicePerformanceQueryFeaturesKHR *feature =
+ (VkPhysicalDevicePerformanceQueryFeaturesKHR *)ext;
+ feature->performanceCounterQueryPools = true;
+ /* HW only supports a single configuration at a time. */
+ feature->performanceCounterMultipleQueryPools = false;
+ break;
+ }
+
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: {
+ VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *features =
+ (VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT *)ext;
+ features->pipelineCreationCacheControl = true;
+ break;
+ }
+
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: {
VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *features =
(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR *)ext;
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: {
+ VkPhysicalDeviceShaderAtomicFloatFeaturesEXT *features = (void *)ext;
+ features->shaderBufferFloat32Atomics = true;
+ features->shaderBufferFloat32AtomicAdd = false;
+ features->shaderBufferFloat64Atomics = false;
+ features->shaderBufferFloat64AtomicAdd = false;
+ features->shaderSharedFloat32Atomics = true;
+ features->shaderSharedFloat32AtomicAdd = false;
+ features->shaderSharedFloat64Atomics = false;
+ features->shaderSharedFloat64AtomicAdd = false;
+ features->shaderImageFloat32Atomics = true;
+ features->shaderImageFloat32AtomicAdd = false;
+ features->sparseImageFloat32Atomics = false;
+ features->sparseImageFloat32AtomicAdd = false;
+ break;
+ }
+
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: {
VkPhysicalDeviceShaderAtomicInt64FeaturesKHR *features = (void *)ext;
CORE_FEATURE(1, 2, shaderBufferInt64Atomics);
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: {
+ VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *features =
+ (VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL *)ext;
+ features->shaderIntegerFunctions2 = true;
+ break;
+ }
+
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: {
VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR *features =
(VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR *)ext;
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: {
+ VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *features =
+ (VkPhysicalDeviceExtendedDynamicStateFeaturesEXT *)ext;
+ features->extendedDynamicState = true;
+ break;
+ }
+
default:
anv_debug_ignored_stype(ext->sType);
break;
#define MAX_PER_STAGE_DESCRIPTOR_INPUT_ATTACHMENTS 64
#define MAX_DESCRIPTOR_SET_INPUT_ATTACHMENTS 256
+#define MAX_CUSTOM_BORDER_COLORS 4096
+
void anv_GetPhysicalDeviceProperties(
VkPhysicalDevice physicalDevice,
VkPhysicalDeviceProperties* pProperties)
vk_foreach_struct(ext, pProperties->pNext) {
switch (ext->sType) {
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: {
+ VkPhysicalDeviceCustomBorderColorPropertiesEXT *properties =
+ (VkPhysicalDeviceCustomBorderColorPropertiesEXT *)ext;
+ properties->maxCustomBorderColorSamplers = MAX_CUSTOM_BORDER_COLORS;
+ break;
+ }
+
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: {
VkPhysicalDeviceDepthStencilResolvePropertiesKHR *properties =
(VkPhysicalDeviceDepthStencilResolvePropertiesKHR *)ext;
break;
}
+ case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: {
+ VkPhysicalDevicePerformanceQueryPropertiesKHR *properties =
+ (VkPhysicalDevicePerformanceQueryPropertiesKHR *)ext;
+ /* We could support this by spawning a shader to do the equation
+ * normalization.
+ */
+ properties->allowCommandBufferQueryCopies = false;
+ break;
+ }
+
case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: {
VkPhysicalDevicePointClippingProperties *properties =
(VkPhysicalDevicePointClippingProperties *) ext;
return state;
}
-/* Haswell border color is a bit of a disaster. Float and unorm formats use a
- * straightforward 32-bit float color in the first 64 bytes. Instead of using
- * a nice float/integer union like Gen8+, Haswell specifies the integer border
- * color as a separate entry /after/ the float color. The layout of this entry
- * also depends on the format's bpp (with extra hacks for RG32), and overlaps.
- *
- * Since we don't know the format/bpp, we can't make any of the border colors
- * containing '1' work for all formats, as it would be in the wrong place for
- * some of them. We opt to make 32-bit integers work as this seems like the
- * most common option. Fortunately, transparent black works regardless, as
- * all zeroes is the same in every bit-size.
- */
-struct hsw_border_color {
- float float32[4];
- uint32_t _pad0[12];
- uint32_t uint32[4];
- uint32_t _pad1[108];
-};
-
-struct gen8_border_color {
- union {
- float float32[4];
- uint32_t uint32[4];
- };
- /* Pad out to 64 bytes */
- uint32_t _pad[12];
-};
-
static void
anv_device_init_border_colors(struct anv_device *device)
{
return vk_outarray_status(&out);
}
-static void
-anv_device_init_dispatch(struct anv_device *device)
-{
- const struct anv_instance *instance = device->physical->instance;
-
- const struct anv_device_dispatch_table *genX_table;
- switch (device->info.gen) {
- case 12:
- genX_table = &gen12_device_dispatch_table;
- break;
- case 11:
- genX_table = &gen11_device_dispatch_table;
- break;
- case 10:
- genX_table = &gen10_device_dispatch_table;
- break;
- case 9:
- genX_table = &gen9_device_dispatch_table;
- break;
- case 8:
- genX_table = &gen8_device_dispatch_table;
- break;
- case 7:
- if (device->info.is_haswell)
- genX_table = &gen75_device_dispatch_table;
- else
- genX_table = &gen7_device_dispatch_table;
- break;
- default:
- unreachable("unsupported gen\n");
- }
-
- for (unsigned i = 0; i < ARRAY_SIZE(device->dispatch.entrypoints); i++) {
- /* Vulkan requires that entrypoints for extensions which have not been
- * enabled must not be advertised.
- */
- if (!anv_device_entrypoint_is_enabled(i, instance->app_info.api_version,
- &instance->enabled_extensions,
- &device->enabled_extensions)) {
- device->dispatch.entrypoints[i] = NULL;
- } else if (genX_table->entrypoints[i]) {
- device->dispatch.entrypoints[i] = genX_table->entrypoints[i];
- } else {
- device->dispatch.entrypoints[i] =
- anv_device_dispatch_table.entrypoints[i];
- }
- }
-}
-
static int
vk_priority_to_gen(int priority)
{
device->robust_buffer_access = robust_buffer_access;
device->enabled_extensions = enabled_extensions;
- anv_device_init_dispatch(device);
+ const struct anv_instance *instance = physical_device->instance;
+ for (unsigned i = 0; i < ARRAY_SIZE(device->dispatch.entrypoints); i++) {
+ /* Vulkan requires that entrypoints for extensions which have not been
+ * enabled must not be advertised.
+ */
+ if (!anv_device_entrypoint_is_enabled(i, instance->app_info.api_version,
+ &instance->enabled_extensions,
+ &device->enabled_extensions)) {
+ device->dispatch.entrypoints[i] = NULL;
+ } else {
+ device->dispatch.entrypoints[i] =
+ anv_resolve_device_entrypoint(&device->info, i);
+ }
+ }
if (pthread_mutex_init(&device->mutex, NULL) != 0) {
result = vk_error(VK_ERROR_INITIALIZATION_FAILED);
if (result != VK_SUCCESS)
goto fail_batch_bo_pool;
+ if (device->info.gen >= 8) {
+ /* The border color pointer is limited to 24 bits, so we need to make
+ * sure that any such color used at any point in the program doesn't
+ * exceed that limit.
+ * We achieve that by reserving all the custom border colors we support
+ * right off the bat, so they are close to the base address.
+ */
+ anv_state_reserved_pool_init(&device->custom_border_colors,
+ &device->dynamic_state_pool,
+ MAX_CUSTOM_BORDER_COLORS,
+ sizeof(struct gen8_border_color), 64);
+ }
+
result = anv_state_pool_init(&device->instruction_state_pool, device,
INSTRUCTION_STATE_POOL_MIN_ADDRESS, 0, 16384);
if (result != VK_SUCCESS)
goto fail_surface_state_pool;
}
- if (device->info.gen >= 12) {
+ if (device->info.has_aux_map) {
device->aux_map_ctx = gen_aux_map_init(device, &aux_map_allocator,
&physical_device->info);
if (!device->aux_map_ctx)
goto fail_binding_table_pool;
}
- result = anv_device_alloc_bo(device, 4096, 0 /* flags */,
+ result = anv_device_alloc_bo(device, 4096,
+ ANV_BO_ALLOC_CAPTURE | ANV_BO_ALLOC_MAPPED /* flags */,
0 /* explicit_address */,
&device->workaround_bo);
if (result != VK_SUCCESS)
goto fail_surface_aux_map_pool;
+ device->workaround_address = (struct anv_address) {
+ .bo = device->workaround_bo,
+ .offset = align_u32(
+ intel_debug_write_identifiers(device->workaround_bo->map,
+ device->workaround_bo->size,
+ "Anv") + 8, 8),
+ };
+
+ device->debug_frame_desc =
+ intel_debug_get_identifier_block(device->workaround_bo->map,
+ device->workaround_bo->size,
+ GEN_DEBUG_BLOCK_TYPE_FRAME);
+
result = anv_device_init_trivial_batch(device);
if (result != VK_SUCCESS)
goto fail_workaround_bo;
unreachable("unhandled gen");
}
if (result != VK_SUCCESS)
- goto fail_workaround_bo;
+ goto fail_clear_value_bo;
- anv_pipeline_cache_init(&device->default_pipeline_cache, device, true);
+ anv_pipeline_cache_init(&device->default_pipeline_cache, device,
+ true /* cache_enabled */, false /* external_sync */);
anv_device_init_blorp(device);
return VK_SUCCESS;
- fail_workaround_bo:
- anv_scratch_pool_finish(device, &device->scratch_pool);
+ fail_clear_value_bo:
if (device->info.gen >= 10)
anv_device_release_bo(device, device->hiz_clear_bo);
- anv_device_release_bo(device, device->workaround_bo);
+ anv_scratch_pool_finish(device, &device->scratch_pool);
fail_trivial_batch_bo:
anv_device_release_bo(device, device->trivial_batch_bo);
+ fail_workaround_bo:
+ anv_device_release_bo(device, device->workaround_bo);
fail_surface_aux_map_pool:
- if (device->info.gen >= 12) {
+ if (device->info.has_aux_map) {
gen_aux_map_finish(device->aux_map_ctx);
device->aux_map_ctx = NULL;
}
fail_instruction_state_pool:
anv_state_pool_finish(&device->instruction_state_pool);
fail_dynamic_state_pool:
+ if (device->info.gen >= 8)
+ anv_state_reserved_pool_finish(&device->custom_border_colors);
anv_state_pool_finish(&device->dynamic_state_pool);
fail_batch_bo_pool:
anv_bo_pool_finish(&device->batch_bo_pool);
/* We only need to free these to prevent valgrind errors. The backing
* BO will go away in a couple of lines so we don't actually leak.
*/
+ if (device->info.gen >= 8)
+ anv_state_reserved_pool_finish(&device->custom_border_colors);
anv_state_pool_free(&device->dynamic_state_pool, device->border_colors);
anv_state_pool_free(&device->dynamic_state_pool, device->slice_hash);
#endif
if (device->info.gen >= 10)
anv_device_release_bo(device, device->hiz_clear_bo);
- if (device->info.gen >= 12) {
+ if (device->info.has_aux_map) {
gen_aux_map_finish(device->aux_map_ctx);
device->aux_map_ctx = NULL;
}
sampler->bindless_state);
}
+ if (sampler->custom_border_color.map) {
+ anv_state_reserved_pool_free(&device->custom_border_colors,
+ sampler->custom_border_color);
+ }
+
vk_object_base_finish(&sampler->base);
vk_free2(&device->vk.alloc, pAllocator, sampler);
}
return (uint64_t) current.tv_sec * 1000000000ULL + current.tv_nsec;
}
-#define TIMESTAMP 0x2358
-
VkResult anv_GetCalibratedTimestampsEXT(
VkDevice _device,
uint32_t timestampCount,
for (d = 0; d < timestampCount; d++) {
switch (pTimestampInfos[d].timeDomain) {
case VK_TIME_DOMAIN_DEVICE_EXT:
- ret = anv_gem_reg_read(device, TIMESTAMP | 1,
+ ret = anv_gem_reg_read(device->fd, TIMESTAMP | I915_REG_READ_8B_WA,
&pTimestamps[d]);
if (ret != 0) {