2 * Copyright © 2014-2015 Broadcom
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
29 #include <xf86drmMode.h>
31 #include "util/u_memory.h"
32 #include "util/ralloc.h"
34 #include "vc4_context.h"
35 #include "vc4_screen.h"
37 static bool dump_stats = false;
40 vc4_bo_cache_free_all(struct vc4_bo_cache *cache);
43 vc4_bo_dump_stats(struct vc4_screen *screen)
45 struct vc4_bo_cache *cache = &screen->bo_cache;
47 fprintf(stderr, " BOs allocated: %d\n", screen->bo_count);
48 fprintf(stderr, " BOs size: %dkb\n", screen->bo_size / 1024);
49 fprintf(stderr, " BOs cached: %d\n", cache->bo_count);
50 fprintf(stderr, " BOs cached size: %dkb\n", cache->bo_size / 1024);
52 if (!list_empty(&cache->time_list)) {
53 struct vc4_bo *first = LIST_ENTRY(struct vc4_bo,
54 cache->time_list.next,
56 struct vc4_bo *last = LIST_ENTRY(struct vc4_bo,
57 cache->time_list.prev,
60 fprintf(stderr, " oldest cache time: %ld\n",
61 (long)first->free_time);
62 fprintf(stderr, " newest cache time: %ld\n",
63 (long)last->free_time);
66 clock_gettime(CLOCK_MONOTONIC, &time);
67 fprintf(stderr, " now: %ld\n",
73 vc4_bo_remove_from_cache(struct vc4_bo_cache *cache, struct vc4_bo *bo)
75 list_del(&bo->time_list);
76 list_del(&bo->size_list);
78 cache->bo_size -= bo->size;
81 static struct vc4_bo *
82 vc4_bo_from_cache(struct vc4_screen *screen, uint32_t size, const char *name)
84 struct vc4_bo_cache *cache = &screen->bo_cache;
85 uint32_t page_index = size / 4096 - 1;
87 if (cache->size_list_size <= page_index)
90 struct vc4_bo *bo = NULL;
91 pipe_mutex_lock(cache->lock);
92 if (!list_empty(&cache->size_list[page_index])) {
93 bo = LIST_ENTRY(struct vc4_bo, cache->size_list[page_index].next,
96 /* Check that the BO has gone idle. If not, then we want to
97 * allocate something new instead, since we assume that the
98 * user will proceed to CPU map it and fill it with stuff.
100 if (!vc4_bo_wait(bo, 0, NULL)) {
101 pipe_mutex_unlock(cache->lock);
105 pipe_reference_init(&bo->reference, 1);
106 vc4_bo_remove_from_cache(cache, bo);
110 pipe_mutex_unlock(cache->lock);
115 vc4_bo_alloc(struct vc4_screen *screen, uint32_t size, const char *name)
120 size = align(size, 4096);
122 bo = vc4_bo_from_cache(screen, size, name);
125 fprintf(stderr, "Allocated %s %dkb from cache:\n",
127 vc4_bo_dump_stats(screen);
132 bo = CALLOC_STRUCT(vc4_bo);
136 pipe_reference_init(&bo->reference, 1);
142 bool cleared_and_retried = false;
144 if (!using_vc4_simulator) {
145 struct drm_vc4_create_bo create;
146 memset(&create, 0, sizeof(create));
150 ret = drmIoctl(screen->fd, DRM_IOCTL_VC4_CREATE_BO, &create);
151 bo->handle = create.handle;
153 struct drm_mode_create_dumb create;
154 memset(&create, 0, sizeof(create));
158 create.height = (size + 127) / 128;
160 ret = drmIoctl(screen->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create);
161 bo->handle = create.handle;
162 assert(create.size >= size);
165 if (!list_empty(&screen->bo_cache.time_list) &&
166 !cleared_and_retried) {
167 cleared_and_retried = true;
168 vc4_bo_cache_free_all(&screen->bo_cache);
177 screen->bo_size += bo->size;
179 fprintf(stderr, "Allocated %s %dkb:\n", name, size / 1024);
180 vc4_bo_dump_stats(screen);
187 vc4_bo_last_unreference(struct vc4_bo *bo)
189 struct vc4_screen *screen = bo->screen;
191 struct timespec time;
192 clock_gettime(CLOCK_MONOTONIC, &time);
193 pipe_mutex_lock(screen->bo_cache.lock);
194 vc4_bo_last_unreference_locked_timed(bo, time.tv_sec);
195 pipe_mutex_unlock(screen->bo_cache.lock);
199 vc4_bo_free(struct vc4_bo *bo)
201 struct vc4_screen *screen = bo->screen;
204 #ifdef USE_VC4_SIMULATOR
205 if (bo->simulator_winsys_map) {
207 bo->map = bo->simulator_winsys_map;
210 munmap(bo->map, bo->size);
213 struct drm_gem_close c;
214 memset(&c, 0, sizeof(c));
215 c.handle = bo->handle;
216 int ret = drmIoctl(screen->fd, DRM_IOCTL_GEM_CLOSE, &c);
218 fprintf(stderr, "close object %d: %s\n", bo->handle, strerror(errno));
221 screen->bo_size -= bo->size;
224 fprintf(stderr, "Freed %s%s%dkb:\n",
225 bo->name ? bo->name : "",
228 vc4_bo_dump_stats(screen);
235 free_stale_bos(struct vc4_screen *screen, time_t time)
237 struct vc4_bo_cache *cache = &screen->bo_cache;
238 bool freed_any = false;
240 list_for_each_entry_safe(struct vc4_bo, bo, &cache->time_list,
242 if (dump_stats && !freed_any) {
243 fprintf(stderr, "Freeing stale BOs:\n");
244 vc4_bo_dump_stats(screen);
248 /* If it's more than a second old, free it. */
249 if (time - bo->free_time > 2) {
250 vc4_bo_remove_from_cache(cache, bo);
257 if (dump_stats && freed_any) {
258 fprintf(stderr, "Freed stale BOs:\n");
259 vc4_bo_dump_stats(screen);
264 vc4_bo_cache_free_all(struct vc4_bo_cache *cache)
266 pipe_mutex_lock(cache->lock);
267 list_for_each_entry_safe(struct vc4_bo, bo, &cache->time_list,
269 vc4_bo_remove_from_cache(cache, bo);
272 pipe_mutex_unlock(cache->lock);
276 vc4_bo_last_unreference_locked_timed(struct vc4_bo *bo, time_t time)
278 struct vc4_screen *screen = bo->screen;
279 struct vc4_bo_cache *cache = &screen->bo_cache;
280 uint32_t page_index = bo->size / 4096 - 1;
287 if (cache->size_list_size <= page_index) {
288 struct list_head *new_list =
289 ralloc_array(screen, struct list_head, page_index + 1);
291 /* Move old list contents over (since the array has moved, and
292 * therefore the pointers to the list heads have to change).
294 for (int i = 0; i < cache->size_list_size; i++) {
295 struct list_head *old_head = &cache->size_list[i];
296 if (list_empty(old_head))
297 list_inithead(&new_list[i]);
299 new_list[i].next = old_head->next;
300 new_list[i].prev = old_head->prev;
301 new_list[i].next->prev = &new_list[i];
302 new_list[i].prev->next = &new_list[i];
305 for (int i = cache->size_list_size; i < page_index + 1; i++)
306 list_inithead(&new_list[i]);
308 cache->size_list = new_list;
309 cache->size_list_size = page_index + 1;
312 bo->free_time = time;
313 list_addtail(&bo->size_list, &cache->size_list[page_index]);
314 list_addtail(&bo->time_list, &cache->time_list);
316 cache->bo_size += bo->size;
318 fprintf(stderr, "Freed %s %dkb to cache:\n",
319 bo->name, bo->size / 1024);
320 vc4_bo_dump_stats(screen);
324 free_stale_bos(screen, time);
327 static struct vc4_bo *
328 vc4_bo_open_handle(struct vc4_screen *screen,
329 uint32_t winsys_stride,
330 uint32_t handle, uint32_t size)
332 struct vc4_bo *bo = CALLOC_STRUCT(vc4_bo);
336 pipe_reference_init(&bo->reference, 1);
343 #ifdef USE_VC4_SIMULATOR
345 bo->simulator_winsys_map = bo->map;
346 bo->simulator_winsys_stride = winsys_stride;
347 bo->map = malloc(bo->size);
354 vc4_bo_open_name(struct vc4_screen *screen, uint32_t name,
355 uint32_t winsys_stride)
357 struct drm_gem_open o = {
360 int ret = drmIoctl(screen->fd, DRM_IOCTL_GEM_OPEN, &o);
362 fprintf(stderr, "Failed to open bo %d: %s\n",
363 name, strerror(errno));
367 return vc4_bo_open_handle(screen, winsys_stride, o.handle, o.size);
371 vc4_bo_open_dmabuf(struct vc4_screen *screen, int fd, uint32_t winsys_stride)
374 int ret = drmPrimeFDToHandle(screen->fd, fd, &handle);
377 fprintf(stderr, "Failed to get vc4 handle for dmabuf %d\n", fd);
381 /* Determine the size of the bo we were handed. */
382 size = lseek(fd, 0, SEEK_END);
384 fprintf(stderr, "Couldn't get size of dmabuf fd %d.\n", fd);
388 return vc4_bo_open_handle(screen, winsys_stride, handle, size);
392 vc4_bo_get_dmabuf(struct vc4_bo *bo)
395 int ret = drmPrimeHandleToFD(bo->screen->fd, bo->handle,
398 fprintf(stderr, "Failed to export gem bo %d to dmabuf\n",
408 vc4_bo_alloc_shader(struct vc4_screen *screen, const void *data, uint32_t size)
413 bo = CALLOC_STRUCT(vc4_bo);
417 pipe_reference_init(&bo->reference, 1);
419 bo->size = align(size, 4096);
421 bo->private = false; /* Make sure it doesn't go back to the cache. */
423 if (!using_vc4_simulator) {
424 struct drm_vc4_create_shader_bo create = {
426 .data = (uintptr_t)data,
429 ret = drmIoctl(screen->fd, DRM_IOCTL_VC4_CREATE_SHADER_BO,
431 bo->handle = create.handle;
433 struct drm_mode_create_dumb create;
434 memset(&create, 0, sizeof(create));
438 create.height = (size + 127) / 128;
440 ret = drmIoctl(screen->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create);
441 bo->handle = create.handle;
442 assert(create.size >= size);
445 memcpy(bo->map, data, size);
448 fprintf(stderr, "create shader ioctl failure\n");
453 screen->bo_size += bo->size;
455 fprintf(stderr, "Allocated shader %dkb:\n", bo->size / 1024);
456 vc4_bo_dump_stats(screen);
463 vc4_bo_flink(struct vc4_bo *bo, uint32_t *name)
465 struct drm_gem_flink flink = {
466 .handle = bo->handle,
468 int ret = drmIoctl(bo->screen->fd, DRM_IOCTL_GEM_FLINK, &flink);
470 fprintf(stderr, "Failed to flink bo %d: %s\n",
471 bo->handle, strerror(errno));
482 static int vc4_wait_seqno_ioctl(int fd, uint64_t seqno, uint64_t timeout_ns)
484 if (using_vc4_simulator)
487 struct drm_vc4_wait_seqno wait = {
489 .timeout_ns = timeout_ns,
491 int ret = drmIoctl(fd, DRM_IOCTL_VC4_WAIT_SEQNO, &wait);
500 vc4_wait_seqno(struct vc4_screen *screen, uint64_t seqno, uint64_t timeout_ns,
503 if (screen->finished_seqno >= seqno)
506 if (unlikely(vc4_debug & VC4_DEBUG_PERF) && timeout_ns && reason) {
507 if (vc4_wait_seqno_ioctl(screen->fd, seqno, 0) == -ETIME) {
508 fprintf(stderr, "Blocking on seqno %lld for %s\n",
509 (long long)seqno, reason);
513 int ret = vc4_wait_seqno_ioctl(screen->fd, seqno, timeout_ns);
516 fprintf(stderr, "wait failed: %d\n", ret);
523 screen->finished_seqno = seqno;
527 static int vc4_wait_bo_ioctl(int fd, uint32_t handle, uint64_t timeout_ns)
529 if (using_vc4_simulator)
532 struct drm_vc4_wait_bo wait = {
534 .timeout_ns = timeout_ns,
536 int ret = drmIoctl(fd, DRM_IOCTL_VC4_WAIT_BO, &wait);
545 vc4_bo_wait(struct vc4_bo *bo, uint64_t timeout_ns, const char *reason)
547 struct vc4_screen *screen = bo->screen;
549 if (unlikely(vc4_debug & VC4_DEBUG_PERF) && timeout_ns && reason) {
550 if (vc4_wait_bo_ioctl(screen->fd, bo->handle, 0) == -ETIME) {
551 fprintf(stderr, "Blocking on %s BO for %s\n",
556 int ret = vc4_wait_bo_ioctl(screen->fd, bo->handle, timeout_ns);
559 fprintf(stderr, "wait failed: %d\n", ret);
570 vc4_bo_map_unsynchronized(struct vc4_bo *bo)
578 if (!using_vc4_simulator) {
579 struct drm_vc4_mmap_bo map;
580 memset(&map, 0, sizeof(map));
581 map.handle = bo->handle;
582 ret = drmIoctl(bo->screen->fd, DRM_IOCTL_VC4_MMAP_BO, &map);
585 struct drm_mode_map_dumb map;
586 memset(&map, 0, sizeof(map));
587 map.handle = bo->handle;
588 ret = drmIoctl(bo->screen->fd, DRM_IOCTL_MODE_MAP_DUMB, &map);
592 fprintf(stderr, "map ioctl failure\n");
596 bo->map = mmap(NULL, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED,
597 bo->screen->fd, offset);
598 if (bo->map == MAP_FAILED) {
599 fprintf(stderr, "mmap of bo %d (offset 0x%016llx, size %d) failed\n",
600 bo->handle, (long long)offset, bo->size);
608 vc4_bo_map(struct vc4_bo *bo)
610 void *map = vc4_bo_map_unsynchronized(bo);
612 bool ok = vc4_bo_wait(bo, PIPE_TIMEOUT_INFINITE, "bo map");
614 fprintf(stderr, "BO wait for map failed\n");
622 vc4_bufmgr_destroy(struct pipe_screen *pscreen)
624 struct vc4_screen *screen = vc4_screen(pscreen);
625 struct vc4_bo_cache *cache = &screen->bo_cache;
627 vc4_bo_cache_free_all(cache);
630 fprintf(stderr, "BO stats after screen destroy:\n");
631 vc4_bo_dump_stats(screen);