Lines Matching refs:device
92 struct anv_device *device = (struct anv_device *)data;
93 struct anv_instance *instance = device->physical->instance;
170 get_device_extensions(const struct anv_physical_device *device,
174 .KHR_8bit_storage = device->info.ver >= 8,
175 .KHR_16bit_storage = device->info.ver >= 8,
177 .KHR_buffer_device_address = device->has_a64_buffer_access,
187 .KHR_external_fence = device->has_syncobj_wait,
188 .KHR_external_fence_fd = device->has_syncobj_wait,
194 .KHR_fragment_shading_rate = device->info.ver >= 11,
207 device->use_softpin && device->perf &&
208 (device->perf->i915_perf_version >= 3 ||
210 device->use_call_secondary,
217 .KHR_shader_atomic_int64 = device->info.ver >= 9 &&
218 device->use_softpin,
221 .KHR_shader_float16_int8 = device->info.ver >= 8,
222 .KHR_shader_float_controls = device->info.ver >= 8,
225 .KHR_shader_subgroup_extended_types = device->info.ver >= 8,
242 .EXT_buffer_device_address = device->has_a64_buffer_access,
243 .EXT_calibrated_timestamps = device->has_reg_timestamp,
245 .EXT_conditional_rendering = device->info.verx10 >= 75,
246 .EXT_conservative_rasterization = device->info.ver >= 9,
247 .EXT_custom_border_color = device->info.ver >= 8,
249 .EXT_descriptor_indexing = device->has_a64_buffer_access &&
250 device->has_bindless_images,
258 .EXT_fragment_shader_interlock = device->info.ver >= 9,
259 .EXT_global_priority = device->has_context_priority,
266 .EXT_memory_budget = device->sys.available,
271 .EXT_post_depth_coverage = device->info.ver >= 9,
278 .EXT_sampler_filter_minmax = device->info.ver >= 9,
282 .EXT_shader_atomic_float2 = device->info.ver >= 9,
284 .EXT_shader_stencil_export = device->info.ver >= 9,
300 .INTEL_performance_query = device->perf &&
301 device->perf->i915_perf_version >= 3,
302 .INTEL_shader_integer_functions2 = device->info.ver >= 8,
309 anv_compute_sys_heap_size(struct anv_physical_device *device,
324 available_ram = MIN2(available_ram, device->gtt_size * 3 / 4);
326 if (available_ram > (2ull << 30) && !device->supports_48bit_addresses) {
342 anv_gather_meminfo(struct anv_physical_device *device, int fd, bool update)
350 if (device->info.has_local_mem) {
351 return vk_errorf(device, VK_ERROR_INCOMPATIBLE_DRIVER,
357 return vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
383 region = &device->sys;
386 region = &device->vram;
395 size = anv_compute_sys_heap_size(device, size);
417 anv_init_meminfo(struct anv_physical_device *device, int fd)
419 return anv_gather_meminfo(device, fd, false);
423 anv_update_meminfo(struct anv_physical_device *device, int fd)
425 ASSERTED VkResult result = anv_gather_meminfo(device, fd, true);
431 anv_physical_device_init_heaps(struct anv_physical_device *device, int fd)
434 &device->gtt_size) == -1) {
438 anv_perf_warn(VK_LOG_NO_OBJS(&device->instance->vk),
441 if (intel_get_aperture_size(fd, &device->gtt_size) == -1) {
442 return vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
450 device->supports_48bit_addresses = (device->info.ver >= 8) &&
451 device->gtt_size > (4ULL << 30 /* GiB */);
453 VkResult result = anv_init_meminfo(device, fd);
457 assert(device->sys.size != 0);
459 if (device->vram.size > 0) {
463 device->memory.heap_count = 2;
464 device->memory.heaps[0] = (struct anv_memory_heap) {
465 .size = device->vram.size,
469 device->memory.heaps[1] = (struct anv_memory_heap) {
470 .size = device->sys.size,
475 device->memory.type_count = 3;
476 device->memory.types[0] = (struct anv_memory_type) {
480 device->memory.types[1] = (struct anv_memory_type) {
486 device->memory.types[2] = (struct anv_memory_type) {
492 } else if (device->info.has_llc) {
493 device->memory.heap_count = 1;
494 device->memory.heaps[0] = (struct anv_memory_heap) {
495 .size = device->sys.size,
503 device->memory.type_count = 1;
504 device->memory.types[0] = (struct anv_memory_type) {
512 device->memory.heap_count = 1;
513 device->memory.heaps[0] = (struct anv_memory_heap) {
514 .size = device->sys.size,
524 device->memory.type_count = 2;
525 device->memory.types[0] = (struct anv_memory_type) {
531 device->memory.types[1] = (struct anv_memory_type) {
539 device->memory.need_clflush = false;
540 for (unsigned i = 0; i < device->memory.type_count; i++) {
541 VkMemoryPropertyFlags props = device->memory.types[i].propertyFlags;
544 device->memory.need_clflush = true;
551 anv_physical_device_init_uuids(struct anv_physical_device *device)
556 return vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
562 return vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
566 memcpy(device->driver_build_sha1, build_id_data(note), 20);
573 * invalid. It needs both a driver build and the PCI ID of the device.
577 _mesa_sha1_update(&sha1_ctx, &device->info.chipset_id,
578 sizeof(device->info.chipset_id));
579 _mesa_sha1_update(&sha1_ctx, &device->always_use_bindless,
580 sizeof(device->always_use_bindless));
581 _mesa_sha1_update(&sha1_ctx, &device->has_a64_buffer_access,
582 sizeof(device->has_a64_buffer_access));
583 _mesa_sha1_update(&sha1_ctx, &device->has_bindless_images,
584 sizeof(device->has_bindless_images));
585 _mesa_sha1_update(&sha1_ctx, &device->has_bindless_samplers,
586 sizeof(device->has_bindless_samplers));
588 memcpy(device->pipeline_cache_uuid, sha1, VK_UUID_SIZE);
590 intel_uuid_compute_driver_id(device->driver_uuid, &device->info, VK_UUID_SIZE);
591 intel_uuid_compute_device_id(device->device_uuid, &device->isl_dev, VK_UUID_SIZE);
597 anv_physical_device_init_disk_cache(struct anv_physical_device *device)
602 device->info.chipset_id);
606 _mesa_sha1_format(timestamp, device->driver_build_sha1);
609 brw_get_compiler_config_value(device->compiler);
610 device->disk_cache = disk_cache_create(renderer, timestamp, driver_flags);
612 device->disk_cache = NULL;
617 anv_physical_device_free_disk_cache(struct anv_physical_device *device)
620 if (device->disk_cache)
621 disk_cache_destroy(device->disk_cache);
623 assert(device->disk_cache == NULL);
759 "Unable to open device %s: out of memory", path);
762 "Unable to open device %s: %m", path);
787 struct anv_physical_device *device =
788 vk_zalloc(&instance->vk.alloc, sizeof(*device), 8,
790 if (device == NULL) {
801 result = vk_physical_device_init(&device->vk, &instance->vk,
808 device->instance = instance;
810 assert(strlen(path) < ARRAY_SIZE(device->path));
811 snprintf(device->path, ARRAY_SIZE(device->path), "%s", path);
813 device->info = devinfo;
814 device->is_alpha = is_alpha;
816 device->pci_info.domain = drm_device->businfo.pci->domain;
817 device->pci_info.bus = drm_device->businfo.pci->bus;
818 device->pci_info.device = drm_device->businfo.pci->dev;
819 device->pci_info.function = drm_device->businfo.pci->func;
821 device->cmd_parser_version = -1;
822 if (device->info.ver == 7) {
823 device->cmd_parser_version =
825 if (device->cmd_parser_version == -1) {
826 result = vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
833 result = vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
839 result = vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
844 if (!device->info.has_llc &&
846 result = vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
851 if (device->info.ver >= 8 && !device->info.is_cherryview &&
853 result = vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
859 result = vk_errorf(device, VK_ERROR_INITIALIZATION_FAILED,
864 device->has_exec_async = anv_gem_get_param(fd, I915_PARAM_HAS_EXEC_ASYNC);
865 device->has_exec_capture = anv_gem_get_param(fd, I915_PARAM_HAS_EXEC_CAPTURE);
866 device->has_exec_fence = anv_gem_get_param(fd, I915_PARAM_HAS_EXEC_FENCE);
867 device->has_syncobj_wait = anv_gem_supports_syncobj_wait(fd);
868 device->has_syncobj_wait_available =
871 device->has_context_priority = anv_gem_has_context_priority(fd);
874 memset(&device->vram, 0, sizeof(device->vram));
875 memset(&device->sys, 0, sizeof(device->sys));
877 result = anv_physical_device_init_heaps(device, fd);
881 device->use_softpin = device->info.ver >= 8 &&
882 !device->info.is_cherryview;
883 assert(device->use_softpin == device->supports_48bit_addresses);
885 device->has_context_isolation =
888 device->has_exec_timeline =
891 device->has_exec_timeline = false;
893 device->has_thread_submit =
894 device->has_syncobj_wait_available && device->has_exec_timeline;
896 device->always_use_bindless =
899 device->use_call_secondary =
900 device->use_softpin &&
906 device->has_a64_buffer_access = device->info.ver >= 8 &&
907 device->use_softpin;
911 device->has_bindless_images = device->info.ver >= 9;
918 device->has_bindless_samplers = device->info.ver >= 8;
920 device->has_implicit_ccs = device->info.has_aux_map;
924 device->has_reg_timestamp = anv_gem_reg_read(fd, TIMESTAMP | I915_REG_READ_8B_WA,
927 device->always_flush_cache = INTEL_DEBUG(DEBUG_SYNC) ||
930 device->has_mmap_offset =
933 device->has_userptr_probe =
936 device->compiler = brw_compiler_create(NULL, &device->info);
937 if (device->compiler == NULL) {
941 device->compiler->shader_debug_log = compiler_debug_log;
942 device->compiler->shader_perf_log = compiler_perf_log;
943 device->compiler->supports_pull_constants = false;
944 device->compiler->constant_buffer_0_is_relative =
945 device->info.ver < 8 || !device->has_context_isolation;
946 device->compiler->supports_shader_constants = true;
947 device->compiler->compact_params = false;
948 device->compiler->indirect_ubos_use_sampler = device->info.ver < 12;
962 device->info.ver < 8 && anv_gem_get_bit6_swizzle(fd, I915_TILING_X);
964 isl_device_init(&device->isl_dev, &device->info, swizzled);
966 result = anv_physical_device_init_uuids(device);
970 anv_physical_device_init_disk_cache(device);
975 /* prod the device with a GETPARAM call which will fail if
976 * we don't have permission to even render on this device
984 device->master_fd = master_fd;
986 device->engine_info = anv_gem_get_engine_info(fd);
987 anv_physical_device_init_queue_families(device);
989 result = anv_init_wsi(device);
993 anv_physical_device_init_perf(device, fd);
995 anv_measure_device_init(device);
997 get_device_extensions(device, &device->vk.supported_extensions);
999 device->local_fd = fd;
1001 anv_genX(&device->info, init_physical_device_state)(device);
1003 *device_out = device;
1008 device->has_master = true;
1009 device->master_major = major(st.st_rdev);
1010 device->master_minor = minor(st.st_rdev);
1012 device->has_master = false;
1013 device->master_major = 0;
1014 device->master_minor = 0;
1018 device->has_local = true;
1019 device->local_major = major(st.st_rdev);
1020 device->local_minor = minor(st.st_rdev);
1022 device->has_local = false;
1023 device->local_major = 0;
1024 device->local_minor = 0;
1030 free(device->engine_info);
1031 anv_physical_device_free_disk_cache(device);
1033 ralloc_free(device->compiler);
1035 vk_physical_device_finish(&device->vk);
1037 vk_free(&instance->vk.alloc, device);
1046 anv_physical_device_destroy(struct anv_physical_device *device)
1048 anv_finish_wsi(device);
1049 anv_measure_device_destroy(device);
1050 free(device->engine_info);
1051 anv_physical_device_free_disk_cache(device);
1052 ralloc_free(device->compiler);
1053 ralloc_free(device->perf);
1054 close(device->local_fd);
1055 if (device->master_fd >= 0)
1056 close(device->master_fd);
1057 vk_physical_device_finish(&device->vk);
1058 vk_free(&device->instance->vk.alloc, device);
1179 /* Incompatible DRM device, skip. */
1185 /* Error creating the physical device, report the error. */
2286 * "Note that the device divides a pixel into a 16x16 array of
2311 properties->pciDevice = pdevice->pci_info.device;
2570 ANV_FROM_HANDLE(anv_physical_device, device, physicalDevice);
2572 anv_update_meminfo(device, device->local_fd);
2575 for (size_t i = 0; i < device->memory.heap_count; i++) {
2576 if (device->memory.heaps[i].is_local_mem) {
2577 total_vram_heaps_size += device->memory.heaps[i].size;
2579 total_sys_heaps_size += device->memory.heaps[i].size;
2583 for (size_t i = 0; i < device->memory.heap_count; i++) {
2584 VkDeviceSize heap_size = device->memory.heaps[i].size;
2585 VkDeviceSize heap_used = device->memory.heaps[i].used;
2589 if (device->memory.heaps[i].is_local_mem) {
2591 mem_available = device->vram.available;
2594 mem_available = device->sys.available;
2626 for (uint32_t i = device->memory.heap_count; i < VK_MAX_MEMORY_HEAPS; i++) {
2653 VkDevice device,
2720 anv_device_init_border_colors(struct anv_device *device)
2722 if (device->info.is_haswell) {
2732 device->border_colors =
2733 anv_state_pool_emit_data(&device->dynamic_state_pool,
2745 device->border_colors =
2746 anv_state_pool_emit_data(&device->dynamic_state_pool,
2752 anv_device_init_trivial_batch(struct anv_device *device)
2754 VkResult result = anv_device_alloc_bo(device, "trivial-batch", 4096,
2757 &device->trivial_batch_bo);
2762 .start = device->trivial_batch_bo->map,
2763 .next = device->trivial_batch_bo->map,
2764 .end = device->trivial_batch_bo->map + 4096,
2770 if (!device->info.has_llc)
2816 struct anv_device *device = v_batch;
2821 if (get_bo_from_pool(&ret_bo, &device->dynamic_state_pool.block_pool, address))
2823 if (get_bo_from_pool(&ret_bo, &device->instruction_state_pool.block_pool, address))
2825 if (get_bo_from_pool(&ret_bo, &device->binding_table_pool.block_pool, address))
2827 if (get_bo_from_pool(&ret_bo, &device->surface_state_pool.block_pool, address))
2830 if (!device->cmd_buffer_being_decoded)
2835 u_vector_foreach(bo, &device->cmd_buffer_being_decoded->seen_bbos) {
2863 struct anv_device *device = (struct anv_device*)driver_ctx;
2864 assert(device->physical->supports_48bit_addresses &&
2865 device->physical->use_softpin);
2867 struct anv_state_pool *pool = &device->dynamic_state_pool;
2881 struct anv_device *device = (struct anv_device*)driver_ctx;
2882 struct anv_state_pool *pool = &device->dynamic_state_pool;
2900 struct anv_device *device;
2944 device = vk_zalloc2(&physical_device->instance->vk.alloc, pAllocator,
2945 sizeof(*device), 8,
2947 if (!device)
2958 result = vk_device_init(&device->vk, &physical_device->vk,
2970 intel_batch_decode_ctx_init(&device->decoder_ctx,
2973 decode_get_bo, NULL, device);
2976 device->physical = physical_device;
2977 device->_lost = false;
2980 device->fd = open(physical_device->path, O_RDWR | O_CLOEXEC);
2981 if (device->fd == -1) {
2982 result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
2990 if (device->physical->engine_info) {
3007 device->context_id =
3008 anv_gem_create_context_engines(device,
3013 device->context_id = anv_gem_create_context(device);
3015 if (device->context_id == -1) {
3016 result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
3026 anv_gem_set_context_param(device->fd, device->context_id,
3029 device->has_thread_submit = physical_device->has_thread_submit;
3031 device->queues =
3032 vk_zalloc(&device->vk.alloc, num_queues * sizeof(*device->queues), 8,
3034 if (device->queues == NULL) {
3035 result = vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
3039 device->queue_count = 0;
3049 uint32_t exec_flags = device->physical->engine_info ?
3050 device->queue_count : I915_EXEC_RENDER;
3052 result = anv_queue_init(device, &device->queues[device->queue_count],
3057 device->queue_count++;
3062 if (pthread_mutex_init(&device->vma_mutex, NULL) != 0) {
3063 result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
3068 util_vma_heap_init(&device->vma_lo,
3071 util_vma_heap_init(&device->vma_cva, CLIENT_VISIBLE_HEAP_MIN_ADDRESS,
3078 util_vma_heap_init(&device->vma_hi, HIGH_HEAP_MIN_ADDRESS,
3083 list_inithead(&device->memory_objects);
3091 int err = anv_gem_set_context_param(device->fd, device->context_id,
3095 result = vk_error(device, VK_ERROR_NOT_PERMITTED_EXT);
3100 device->info = physical_device->info;
3101 device->isl_dev = physical_device->isl_dev;
3108 device->can_chain_batches = device->info.ver >= 8;
3110 device->robust_buffer_access = robust_buffer_access;
3112 if (pthread_mutex_init(&device->mutex, NULL) != 0) {
3113 result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
3119 result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
3124 result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
3127 if (pthread_cond_init(&device->queue_submit, &condattr) != 0) {
3129 result = vk_error(device, VK_ERROR_INITIALIZATION_FAILED);
3134 result = anv_bo_cache_init(&device->bo_cache, device);
3138 anv_bo_pool_init(&device->batch_bo_pool, device, "batch");
3144 result = anv_state_pool_init(&device->general_state_pool, device,
3150 result = anv_state_pool_init(&device->dynamic_state_pool, device,
3156 if (device->info.ver >= 8) {
3163 anv_state_reserved_pool_init(&device->custom_border_colors,
3164 &device->dynamic_state_pool,
3169 result = anv_state_pool_init(&device->instruction_state_pool, device,
3175 result = anv_state_pool_init(&device->surface_state_pool, device,
3185 result = anv_state_pool_init(&device->binding_table_pool, device,
3193 if (device->info.has_aux_map) {
3194 device->aux_map_ctx = intel_aux_map_init(device, &aux_map_allocator,
3196 if (!device->aux_map_ctx)
3200 result = anv_device_alloc_bo(device, "workaround", 4096,
3205 &device->workaround_bo);
3209 device->workaround_address = (struct anv_address) {
3210 .bo = device->workaround_bo,
3212 intel_debug_write_identifiers(device->workaround_bo->map,
3213 device->workaround_bo->size,
3217 device->debug_frame_desc =
3218 intel_debug_get_identifier_block(device->workaround_bo->map,
3219 device->workaround_bo->size,
3222 result = anv_device_init_trivial_batch(device);
3230 device->null_surface_state =
3231 anv_state_pool_alloc(&device->surface_state_pool,
3232 device->isl_dev.ss.size,
3233 device->isl_dev.ss.align);
3234 isl_null_fill_state(&device->isl_dev, device->null_surface_state.map,
3236 assert(device->null_surface_state.offset == 0);
3238 anv_scratch_pool_init(device, &device->scratch_pool);
3241 memset(device->rt_scratch_bos, 0, sizeof(device->rt_scratch_bos));
3243 result = anv_genX(&device->info, init_device_state)(device);
3247 anv_pipeline_cache_init(&device->default_pipeline_cache, device,
3250 result = anv_device_init_rt_shaders(device);
3254 anv_device_init_blorp(device);
3256 anv_device_init_border_colors(device);
3258 anv_device_perf_init(device);
3260 *pDevice = anv_device_to_handle(device);
3265 anv_pipeline_cache_finish(&device->default_pipeline_cache);
3267 anv_scratch_pool_finish(device, &device->scratch_pool);
3268 anv_device_release_bo(device, device->trivial_batch_bo);
3270 anv_device_release_bo(device, device->workaround_bo);
3272 if (device->info.has_aux_map) {
3273 intel_aux_map_finish(device->aux_map_ctx);
3274 device->aux_map_ctx = NULL;
3278 anv_state_pool_finish(&device->binding_table_pool);
3280 anv_state_pool_finish(&device->surface_state_pool);
3282 anv_state_pool_finish(&device->instruction_state_pool);
3284 if (device->info.ver >= 8)
3285 anv_state_reserved_pool_finish(&device->custom_border_colors);
3286 anv_state_pool_finish(&device->dynamic_state_pool);
3288 anv_state_pool_finish(&device->general_state_pool);
3290 anv_bo_pool_finish(&device->batch_bo_pool);
3291 anv_bo_cache_finish(&device->bo_cache);
3293 pthread_cond_destroy(&device->queue_submit);
3295 pthread_mutex_destroy(&device->mutex);
3298 util_vma_heap_finish(&device->vma_hi);
3299 util_vma_heap_finish(&device->vma_cva);
3300 util_vma_heap_finish(&device->vma_lo);
3303 for (uint32_t i = 0; i < device->queue_count; i++)
3304 anv_queue_finish(&device->queues[i]);
3305 vk_free(&device->vk.alloc, device->queues);
3307 anv_gem_destroy_context(device, device->context_id);
3309 close(device->fd);
3311 vk_device_finish(&device->vk);
3313 vk_free(&device->vk.alloc, device);
3322 ANV_FROM_HANDLE(anv_device, device, _device);
3324 if (!device)
3327 anv_device_finish_blorp(device);
3329 anv_device_finish_rt_shaders(device);
3331 anv_pipeline_cache_finish(&device->default_pipeline_cache);
3337 if (device->info.ver >= 8)
3338 anv_state_reserved_pool_finish(&device->custom_border_colors);
3339 anv_state_pool_free(&device->dynamic_state_pool, device->border_colors);
3340 anv_state_pool_free(&device->dynamic_state_pool, device->slice_hash);
3343 for (unsigned i = 0; i < ARRAY_SIZE(device->rt_scratch_bos); i++) {
3344 if (device->rt_scratch_bos[i] != NULL)
3345 anv_device_release_bo(device, device->rt_scratch_bos[i]);
3348 anv_scratch_pool_finish(device, &device->scratch_pool);
3350 anv_device_release_bo(device, device->workaround_bo);
3351 anv_device_release_bo(device, device->trivial_batch_bo);
3353 if (device->info.has_aux_map) {
3354 intel_aux_map_finish(device->aux_map_ctx);
3355 device->aux_map_ctx = NULL;
3358 if (device->physical->use_softpin)
3359 anv_state_pool_finish(&device->binding_table_pool);
3360 anv_state_pool_finish(&device->surface_state_pool);
3361 anv_state_pool_finish(&device->instruction_state_pool);
3362 anv_state_pool_finish(&device->dynamic_state_pool);
3363 anv_state_pool_finish(&device->general_state_pool);
3365 anv_bo_pool_finish(&device->batch_bo_pool);
3367 anv_bo_cache_finish(&device->bo_cache);
3369 if (device->physical->use_softpin) {
3370 util_vma_heap_finish(&device->vma_hi);
3371 util_vma_heap_finish(&device->vma_cva);
3372 util_vma_heap_finish(&device->vma_lo);
3375 pthread_cond_destroy(&device->queue_submit);
3376 pthread_mutex_destroy(&device->mutex);
3378 for (uint32_t i = 0; i < device->queue_count; i++)
3379 anv_queue_finish(&device->queues[i]);
3380 vk_free(&device->vk.alloc, device->queues);
3382 anv_gem_destroy_context(device, device->context_id);
3385 intel_batch_decode_ctx_finish(&device->decoder_ctx);
3387 close(device->fd);
3389 vk_device_finish(&device->vk);
3390 vk_free(&device->vk.alloc, device);
3407 _anv_device_report_lost(struct anv_device *device)
3409 assert(p_atomic_read(&device->_lost) > 0);
3411 device->lost_reported = true;
3413 for (uint32_t i = 0; i < device->queue_count; i++) {
3414 struct anv_queue *queue = &device->queues[i];
3424 _anv_device_set_lost(struct anv_device *device,
3431 if (p_atomic_read(&device->_lost) > 0)
3434 p_atomic_inc(&device->_lost);
3435 device->lost_reported = true;
3438 err = __vk_errorv(device, VK_ERROR_DEVICE_LOST, file, line, msg, ap);
3466 p_atomic_inc(&queue->device->_lost);
3475 anv_device_query_status(struct anv_device *device)
3481 if (anv_device_is_lost(device))
3485 int ret = anv_gem_context_get_reset_stats(device->fd, device->context_id,
3489 return anv_device_set_lost(device, "get_reset_stats failed: %m");
3493 return anv_device_set_lost(device, "GPU hung on one of our command buffers");
3495 return anv_device_set_lost(device, "GPU hung with commands in-flight");
3502 anv_device_bo_busy(struct anv_device *device, struct anv_bo *bo)
3508 int ret = anv_gem_busy(device, bo->gem_handle);
3513 return anv_device_set_lost(device, "gem wait failed: %m");
3516 /* Query for device status after the busy call. If the BO we're checking
3522 return anv_device_query_status(device);
3526 anv_device_wait(struct anv_device *device, struct anv_bo *bo,
3529 int ret = anv_gem_wait(device, bo->gem_handle, &timeout);
3534 return anv_device_set_lost(device, "gem wait failed: %m");
3537 /* Query for device status after the wait. If the BO we're waiting on got
3542 return anv_device_query_status(device);
3546 anv_vma_alloc(struct anv_device *device,
3551 pthread_mutex_lock(&device->vma_mutex);
3557 if (util_vma_heap_alloc_addr(&device->vma_cva,
3562 addr = util_vma_heap_alloc(&device->vma_cva, size, align);
3571 addr = util_vma_heap_alloc(&device->vma_hi, size, align);
3574 addr = util_vma_heap_alloc(&device->vma_lo, size, align);
3577 pthread_mutex_unlock(&device->vma_mutex);
3584 anv_vma_free(struct anv_device *device,
3589 pthread_mutex_lock(&device->vma_mutex);
3593 util_vma_heap_free(&device->vma_lo, addr_48b, size);
3596 util_vma_heap_free(&device->vma_cva, addr_48b, size);
3599 util_vma_heap_free(&device->vma_hi, addr_48b, size);
3602 pthread_mutex_unlock(&device->vma_mutex);
3611 ANV_FROM_HANDLE(anv_device, device, _device);
3612 struct anv_physical_device *pdevice = device->physical;
3625 return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
3636 return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
3638 mem = vk_object_alloc(&device->vk, pAllocator, sizeof(*mem),
3641 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
3701 if (device->physical->has_implicit_ccs)
3717 if (device->info.has_aux_map)
3753 result = anv_device_import_bo(device, fd_info->fd, alloc_flags,
3767 result = vk_errorf(device, VK_ERROR_INVALID_EXTERNAL_HANDLE,
3772 anv_device_release_bo(device, mem->bo);
3792 result = vk_error(device, VK_ERROR_INVALID_EXTERNAL_HANDLE);
3799 result = anv_device_import_bo_from_host_ptr(device,
3812 /* Set ALLOC_LOCAL_MEM flag if heap has device local bit set and requested
3820 result = anv_device_alloc_bo(device, "user", pAllocateInfo->allocationSize,
3834 int ret = anv_gem_set_tiling(device, mem->bo->gem_handle,
3838 anv_device_release_bo(device, mem->bo);
3839 result = vk_errorf(device, VK_ERROR_OUT_OF_DEVICE_MEMORY,
3850 anv_device_release_bo(device, mem->bo);
3851 result = vk_errorf(device, VK_ERROR_OUT_OF_DEVICE_MEMORY,
3856 pthread_mutex_lock(&device->mutex);
3857 list_addtail(&mem->link, &device->memory_objects);
3858 pthread_mutex_unlock(&device->mutex);
3865 vk_object_free(&device->vk, pAllocator, mem);
3892 ANV_FROM_HANDLE(anv_device, device, _device);
3898 (1 << device->physical->memory.type_count) - 1;
3909 return vk_error(device, VK_ERROR_INVALID_EXTERNAL_HANDLE);
3919 ANV_FROM_HANDLE(anv_device, device, _device);
3928 (1ull << device->physical->memory.type_count) - 1;
3942 ANV_FROM_HANDLE(anv_device, device, _device);
3948 pthread_mutex_lock(&device->mutex);
3950 pthread_mutex_unlock(&device->mutex);
3955 p_atomic_add(&device->physical->memory.heaps[mem->type->heapIndex].used,
3958 anv_device_release_bo(device, mem->bo);
3965 vk_object_free(&device->vk, pAllocator, mem);
3976 ANV_FROM_HANDLE(anv_device, device, _device);
4010 if (!device->info.has_llc &&
4016 if (!device->physical->has_mmap_offset)
4026 void *map = anv_gem_mmap(device, mem->bo->gem_handle,
4029 return vk_error(device, VK_ERROR_MEMORY_MAP_FAILED);
4044 ANV_FROM_HANDLE(anv_device, device, _device);
4050 anv_gem_munmap(device, mem->map, mem->map_size);
4058 clflush_mapped_ranges(struct anv_device *device,
4081 ANV_FROM_HANDLE(anv_device, device, _device);
4083 if (!device->physical->memory.need_clflush)
4089 clflush_mapped_ranges(device, memoryRangeCount, pMemoryRanges);
4099 ANV_FROM_HANDLE(anv_device, device, _device);
4101 if (!device->physical->memory.need_clflush)
4104 clflush_mapped_ranges(device, memoryRangeCount, pMemoryRanges);
4113 VkDevice device,
4141 VkDevice device,
4158 if (anv_device_is_lost(queue->device))
4172 ANV_FROM_HANDLE(anv_device, device, _device);
4177 event = vk_object_alloc(&device->vk, pAllocator, sizeof(*event),
4180 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
4182 event->state = anv_state_pool_alloc(&device->dynamic_state_pool,
4196 ANV_FROM_HANDLE(anv_device, device, _device);
4202 anv_state_pool_free(&device->dynamic_state_pool, event->state);
4204 vk_object_free(&device->vk, pAllocator, event);
4211 ANV_FROM_HANDLE(anv_device, device, _device);
4214 if (anv_device_is_lost(device))
4245 anv_get_buffer_memory_requirements(struct anv_device *device,
4255 * structure for the physical device is supported.
4257 uint32_t memory_types = (1ull << device->physical->memory.type_count) - 1;
4273 if (device->robust_buffer_access &&
4301 ANV_FROM_HANDLE(anv_device, device, _device);
4304 anv_get_buffer_memory_requirements(device,
4315 ANV_FROM_HANDLE(anv_device, device, _device);
4317 anv_get_buffer_memory_requirements(device,
4329 ANV_FROM_HANDLE(anv_device, device, _device);
4337 if (pCreateInfo->size > device->physical->gtt_size)
4338 return vk_error(device, VK_ERROR_OUT_OF_DEVICE_MEMORY);
4342 buffer = vk_object_alloc(&device->vk, pAllocator, sizeof(*buffer),
4345 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
4362 ANV_FROM_HANDLE(anv_device, device, _device);
4368 vk_object_free(&device->vk, pAllocator, buffer);
4372 VkDevice device,
4384 VkDevice device,
4391 VkDevice device,
4403 anv_fill_buffer_surface_state(struct anv_device *device, struct anv_state state,
4409 isl_buffer_fill_state(&device->isl_dev, state.map,
4411 .mocs = isl_mocs(&device->isl_dev, usage,
4424 ANV_FROM_HANDLE(anv_device, device, _device);
4431 anv_state_pool_free(&device->dynamic_state_pool,
4436 anv_state_reserved_pool_free(&device->custom_border_colors,
4440 vk_object_free(&device->vk, pAllocator, sampler);
4449 ANV_FROM_HANDLE(anv_device, device, _device);
4464 framebuffer = vk_object_alloc(&device->vk, pAllocator, size,
4467 return vk_error(device, VK_ERROR_OUT_OF_HOST_MEMORY);
4491 ANV_FROM_HANDLE(anv_device, device, _device);
4497 vk_object_free(&device->vk, pAllocator, fb);
4549 ANV_FROM_HANDLE(anv_device, device, _device);
4550 uint64_t timestamp_frequency = device->info.timestamp_frequency;
4565 ret = anv_gem_reg_read(device->fd, TIMESTAMP | I915_REG_READ_8B_WA,
4569 return anv_device_set_lost(device, "Failed to read the TIMESTAMP "