AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

venus: move vn_renderer_bo_ops to vn_renderer

Browse Source 
Signed-off-by: Chia-I Wu <olvaffe@gmail.com>
Reviewed-by: Yiwei Zhang <zzyiwei@chromium.org>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/10437>
This commit is contained in:
Chia-I Wu
2021-04-22 15:30:38 -07:00
parent 0d703b9d64
commit 2db720330b
3 changed files with 130 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/virtio/vulkan/vn_renderer.h
+51 -48
View File
@@ -15,42 +15,9 @@ struct vn_renderer_shmem {
void *mmap_ptr;
};
struct vn_renderer_bo_ops {
void (*destroy)(struct vn_renderer_bo *bo);
/* import a VkDeviceMemory as the storage */
VkResult (*init_gpu)(struct vn_renderer_bo *bo,
VkDeviceSize size,
vn_object_id mem_id,
VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles);
/* import a dmabuf as the storage */
VkResult (*init_dmabuf)(struct vn_renderer_bo *bo,
VkDeviceSize size,
int fd,
VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles);
int (*export_dmabuf)(struct vn_renderer_bo *bo);
/* map is not thread-safe */
void *(*map)(struct vn_renderer_bo *bo);
void (*flush)(struct vn_renderer_bo *bo,
VkDeviceSize offset,
VkDeviceSize size);
void (*invalidate)(struct vn_renderer_bo *bo,
VkDeviceSize offset,
VkDeviceSize size);
};
struct vn_renderer_bo {
atomic_int refcount;
uint32_t res_id;
struct vn_renderer_bo_ops ops;
};
enum vn_renderer_sync_flags {
@@ -191,8 +158,6 @@ struct vn_renderer_ops {
VkResult (*wait)(struct vn_renderer *renderer,
const struct vn_renderer_wait *wait);
struct vn_renderer_bo *(*bo_create)(struct vn_renderer *renderer);
struct vn_renderer_sync *(*sync_create)(struct vn_renderer *renderer);
};
@@ -203,9 +168,47 @@ struct vn_renderer_shmem_ops {
struct vn_renderer_shmem *shmem);
};
struct vn_renderer_bo_ops {
struct vn_renderer_bo *(*create)(struct vn_renderer *renderer);
/* import a VkDeviceMemory as the storage */
VkResult (*init_gpu)(struct vn_renderer *renderer,
struct vn_renderer_bo *bo,
VkDeviceSize size,
vn_object_id mem_id,
VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles);
/* import a dmabuf as the storage */
VkResult (*init_dmabuf)(struct vn_renderer *renderer,
struct vn_renderer_bo *bo,
VkDeviceSize size,
int fd,
VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles);
void (*destroy)(struct vn_renderer *renderer, struct vn_renderer_bo *bo);
int (*export_dmabuf)(struct vn_renderer *renderer,
struct vn_renderer_bo *bo);
/* map is not thread-safe */
void *(*map)(struct vn_renderer *renderer, struct vn_renderer_bo *bo);
void (*flush)(struct vn_renderer *renderer,
struct vn_renderer_bo *bo,
VkDeviceSize offset,
VkDeviceSize size);
void (*invalidate)(struct vn_renderer *renderer,
struct vn_renderer_bo *bo,
VkDeviceSize offset,
VkDeviceSize size);
};
struct vn_renderer {
struct vn_renderer_ops ops;
struct vn_renderer_shmem_ops shmem_ops;
struct vn_renderer_bo_ops bo_ops;
};
VkResult
@@ -324,14 +327,14 @@ vn_renderer_bo_create_gpu(struct vn_renderer *renderer,
VkExternalMemoryHandleTypeFlags external_handles,
struct vn_renderer_bo **_bo)
{
struct vn_renderer_bo *bo = renderer->ops.bo_create(renderer);
struct vn_renderer_bo *bo = renderer->bo_ops.create(renderer);
if (!bo)
return VK_ERROR_OUT_OF_HOST_MEMORY;
VkResult result =
bo->ops.init_gpu(bo, size, mem_id, flags, external_handles);
VkResult result = renderer->bo_ops.init_gpu(renderer, bo, size, mem_id,
flags, external_handles);
if (result != VK_SUCCESS) {
bo->ops.destroy(bo);
renderer->bo_ops.destroy(renderer, bo);
return result;
}
@@ -349,14 +352,14 @@ vn_renderer_bo_create_dmabuf(struct vn_renderer *renderer,
VkExternalMemoryHandleTypeFlags external_handles,
struct vn_renderer_bo **_bo)
{
struct vn_renderer_bo *bo = renderer->ops.bo_create(renderer);
struct vn_renderer_bo *bo = renderer->bo_ops.create(renderer);
if (!bo)
return VK_ERROR_OUT_OF_HOST_MEMORY;
VkResult result =
bo->ops.init_dmabuf(bo, size, fd, flags, external_handles);
VkResult result = renderer->bo_ops.init_dmabuf(renderer, bo, size, fd,
flags, external_handles);
if (result != VK_SUCCESS) {
bo->ops.destroy(bo);
renderer->bo_ops.destroy(renderer, bo);
return result;
}
@@ -385,7 +388,7 @@ vn_renderer_bo_unref(struct vn_renderer *renderer, struct vn_renderer_bo *bo)
if (old == 1) {
atomic_thread_fence(memory_order_acquire);
bo->ops.destroy(bo);
renderer->bo_ops.destroy(renderer, bo);
return true;
}
@@ -396,13 +399,13 @@ static inline int
vn_renderer_bo_export_dmabuf(struct vn_renderer *renderer,
struct vn_renderer_bo *bo)
{
return bo->ops.export_dmabuf(bo);
return renderer->bo_ops.export_dmabuf(renderer, bo);
}
static inline void *
vn_renderer_bo_map(struct vn_renderer *renderer, struct vn_renderer_bo *bo)
{
return bo->ops.map(bo);
return renderer->bo_ops.map(renderer, bo);
}
static inline void
@@ -411,7 +414,7 @@ vn_renderer_bo_flush(struct vn_renderer *renderer,
VkDeviceSize offset,
VkDeviceSize end)
{
bo->ops.flush(bo, offset, end);
renderer->bo_ops.flush(renderer, bo, offset, end);
}
static inline void
@@ -420,7 +423,7 @@ vn_renderer_bo_invalidate(struct vn_renderer *renderer,
VkDeviceSize offset,
VkDeviceSize size)
{
bo->ops.invalidate(bo, offset, size);
renderer->bo_ops.invalidate(renderer, bo, offset, size);
}
static inline VkResult
src/virtio/vulkan/vn_renderer_virtgpu.c
+39 -39
View File
@@ -59,7 +59,6 @@ struct virtgpu_shmem {
struct virtgpu_bo {
struct vn_renderer_bo base;
struct virtgpu *gpu;
uint32_t blob_flags;
VkDeviceSize size;
@@ -1054,7 +1053,8 @@ virtgpu_sync_create(struct vn_renderer *renderer)
}
static void
virtgpu_bo_invalidate(struct vn_renderer_bo *bo,
virtgpu_bo_invalidate(struct vn_renderer *renderer,
struct vn_renderer_bo *bo,
VkDeviceSize offset,
VkDeviceSize size)
{
@@ -1062,7 +1062,8 @@ virtgpu_bo_invalidate(struct vn_renderer_bo *bo,
}
static void
virtgpu_bo_flush(struct vn_renderer_bo *bo,
virtgpu_bo_flush(struct vn_renderer *renderer,
struct vn_renderer_bo *bo,
VkDeviceSize offset,
VkDeviceSize size)
{
@@ -1070,10 +1071,10 @@ virtgpu_bo_flush(struct vn_renderer_bo *bo,
}
static void *
virtgpu_bo_map(struct vn_renderer_bo *_bo)
virtgpu_bo_map(struct vn_renderer *renderer, struct vn_renderer_bo *_bo)
{
struct virtgpu *gpu = (struct virtgpu *)renderer;
struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo;
struct virtgpu *gpu = bo->gpu;
const bool mappable = bo->blob_flags & VIRTGPU_BLOB_FLAG_USE_MAPPABLE;
/* not thread-safe but is fine */
@@ -1084,10 +1085,11 @@ virtgpu_bo_map(struct vn_renderer_bo *_bo)
}
static int
virtgpu_bo_export_dmabuf(struct vn_renderer_bo *_bo)
virtgpu_bo_export_dmabuf(struct vn_renderer *renderer,
struct vn_renderer_bo *_bo)
{
struct virtgpu *gpu = (struct virtgpu *)renderer;
struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo;
struct virtgpu *gpu = bo->gpu;
const bool mappable = bo->blob_flags & VIRTGPU_BLOB_FLAG_USE_MAPPABLE;
const bool shareable = bo->blob_flags & VIRTGPU_BLOB_FLAG_USE_SHAREABLE;
@@ -1096,6 +1098,21 @@ virtgpu_bo_export_dmabuf(struct vn_renderer_bo *_bo)
: -1;
}
static void
virtgpu_bo_destroy(struct vn_renderer *renderer, struct vn_renderer_bo *_bo)
{
struct virtgpu *gpu = (struct virtgpu *)renderer;
struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo;
if (bo->gem_handle) {
if (bo->gem_ptr)
munmap(bo->gem_ptr, bo->size);
virtgpu_ioctl_gem_close(gpu, bo->gem_handle);
}
free(bo);
}
static uint32_t
virtgpu_bo_blob_flags(VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles)
@@ -1112,14 +1129,15 @@ virtgpu_bo_blob_flags(VkMemoryPropertyFlags flags,
}
static VkResult
virtgpu_bo_init_dmabuf(struct vn_renderer_bo *_bo,
virtgpu_bo_init_dmabuf(struct vn_renderer *renderer,
struct vn_renderer_bo *_bo,
VkDeviceSize size,
int fd,
VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles)
{
struct virtgpu *gpu = (struct virtgpu *)renderer;
struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo;
struct virtgpu *gpu = bo->gpu;
struct drm_virtgpu_resource_info info;
uint32_t gem_handle = 0;
@@ -1161,14 +1179,15 @@ fail:
}
static VkResult
virtgpu_bo_init_gpu(struct vn_renderer_bo *_bo,
virtgpu_bo_init_gpu(struct vn_renderer *renderer,
struct vn_renderer_bo *_bo,
VkDeviceSize size,
vn_object_id mem_id,
VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles)
{
struct virtgpu *gpu = (struct virtgpu *)renderer;
struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo;
struct virtgpu *gpu = bo->gpu;
bo->blob_flags = virtgpu_bo_blob_flags(flags, external_handles);
bo->size = size;
@@ -1181,40 +1200,13 @@ virtgpu_bo_init_gpu(struct vn_renderer_bo *_bo,
return bo->gem_handle ? VK_SUCCESS : VK_ERROR_OUT_OF_DEVICE_MEMORY;
}
static void
virtgpu_bo_destroy(struct vn_renderer_bo *_bo)
{
struct virtgpu_bo *bo = (struct virtgpu_bo *)_bo;
struct virtgpu *gpu = bo->gpu;
if (bo->gem_handle) {
if (bo->gem_ptr)
munmap(bo->gem_ptr, bo->size);
virtgpu_ioctl_gem_close(gpu, bo->gem_handle);
}
free(bo);
}
static struct vn_renderer_bo *
virtgpu_bo_create(struct vn_renderer *renderer)
{
struct virtgpu *gpu = (struct virtgpu *)renderer;
struct virtgpu_bo *bo = calloc(1, sizeof(*bo));
if (!bo)
return NULL;
bo->gpu = gpu;
bo->base.ops.destroy = virtgpu_bo_destroy;
bo->base.ops.init_gpu = virtgpu_bo_init_gpu;
bo->base.ops.init_dmabuf = virtgpu_bo_init_dmabuf;
bo->base.ops.export_dmabuf = virtgpu_bo_export_dmabuf;
bo->base.ops.map = virtgpu_bo_map;
bo->base.ops.flush = virtgpu_bo_flush;
bo->base.ops.invalidate = virtgpu_bo_invalidate;
return &bo->base;
}
@@ -1505,12 +1497,20 @@ virtgpu_init(struct virtgpu *gpu)
gpu->base.ops.get_info = virtgpu_get_info;
gpu->base.ops.submit = virtgpu_submit;
gpu->base.ops.wait = virtgpu_wait;
gpu->base.ops.bo_create = virtgpu_bo_create;
gpu->base.ops.sync_create = virtgpu_sync_create;
gpu->base.shmem_ops.create = virtgpu_shmem_create;
gpu->base.shmem_ops.destroy = virtgpu_shmem_destroy;
gpu->base.bo_ops.create = virtgpu_bo_create;
gpu->base.bo_ops.init_gpu = virtgpu_bo_init_gpu;
gpu->base.bo_ops.init_dmabuf = virtgpu_bo_init_dmabuf;
gpu->base.bo_ops.destroy = virtgpu_bo_destroy;
gpu->base.bo_ops.export_dmabuf = virtgpu_bo_export_dmabuf;
gpu->base.bo_ops.map = virtgpu_bo_map;
gpu->base.bo_ops.flush = virtgpu_bo_flush;
gpu->base.bo_ops.invalidate = virtgpu_bo_invalidate;
return VK_SUCCESS;
}
src/virtio/vulkan/vn_renderer_vtest.c
+40 -40
View File
@@ -35,7 +35,6 @@ struct vtest_shmem {
struct vtest_bo {
struct vn_renderer_bo base;
struct vtest *vtest;
uint32_t blob_flags;
VkDeviceSize size;
@@ -673,7 +672,8 @@ vtest_sync_create(struct vn_renderer *renderer)
}
static void
vtest_bo_invalidate(struct vn_renderer_bo *bo,
vtest_bo_invalidate(struct vn_renderer *renderer,
struct vn_renderer_bo *bo,
VkDeviceSize offset,
VkDeviceSize size)
{
@@ -681,7 +681,8 @@ vtest_bo_invalidate(struct vn_renderer_bo *bo,
}
static void
vtest_bo_flush(struct vn_renderer_bo *bo,
vtest_bo_flush(struct vn_renderer *renderer,
struct vn_renderer_bo *bo,
VkDeviceSize offset,
VkDeviceSize size)
{
@@ -689,10 +690,10 @@ vtest_bo_flush(struct vn_renderer_bo *bo,
}
static void *
vtest_bo_map(struct vn_renderer_bo *_bo)
vtest_bo_map(struct vn_renderer *renderer, struct vn_renderer_bo *_bo)
{
struct vtest *vtest = (struct vtest *)renderer;
struct vtest_bo *bo = (struct vtest_bo *)_bo;
struct vtest *vtest = bo->vtest;
const bool mappable = bo->blob_flags & VCMD_BLOB_FLAG_MAPPABLE;
const bool shareable = bo->blob_flags & VCMD_BLOB_FLAG_SHAREABLE;
@@ -723,13 +724,34 @@ vtest_bo_map(struct vn_renderer_bo *_bo)
}
static int
vtest_bo_export_dmabuf(struct vn_renderer_bo *_bo)
vtest_bo_export_dmabuf(struct vn_renderer *renderer,
struct vn_renderer_bo *_bo)
{
const struct vtest_bo *bo = (struct vtest_bo *)_bo;
const bool shareable = bo->blob_flags & VCMD_BLOB_FLAG_SHAREABLE;
return shareable ? os_dupfd_cloexec(bo->res_fd) : -1;
}
static void
vtest_bo_destroy(struct vn_renderer *renderer, struct vn_renderer_bo *_bo)
{
struct vtest *vtest = (struct vtest *)renderer;
struct vtest_bo *bo = (struct vtest_bo *)_bo;
if (bo->base.res_id) {
if (bo->res_ptr)
munmap(bo->res_ptr, bo->size);
if (bo->res_fd >= 0)
close(bo->res_fd);
mtx_lock(&vtest->sock_mutex);
vtest_vcmd_resource_unref(vtest, bo->base.res_id);
mtx_unlock(&vtest->sock_mutex);
}
free(bo);
}
static uint32_t
vtest_bo_blob_flags(VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles)
@@ -746,14 +768,15 @@ vtest_bo_blob_flags(VkMemoryPropertyFlags flags,
}
static VkResult
vtest_bo_init_gpu(struct vn_renderer_bo *_bo,
vtest_bo_init_gpu(struct vn_renderer *renderer,
struct vn_renderer_bo *_bo,
VkDeviceSize size,
vn_object_id mem_id,
VkMemoryPropertyFlags flags,
VkExternalMemoryHandleTypeFlags external_handles)
{
struct vtest *vtest = (struct vtest *)renderer;
struct vtest_bo *bo = (struct vtest_bo *)_bo;
struct vtest *vtest = bo->vtest;
bo->blob_flags = vtest_bo_blob_flags(flags, external_handles);
bo->size = size;
@@ -767,46 +790,15 @@ vtest_bo_init_gpu(struct vn_renderer_bo *_bo,
return VK_SUCCESS;
}
static void
vtest_bo_destroy(struct vn_renderer_bo *_bo)
{
struct vtest_bo *bo = (struct vtest_bo *)_bo;
struct vtest *vtest = bo->vtest;
if (bo->base.res_id) {
if (bo->res_ptr)
munmap(bo->res_ptr, bo->size);
if (bo->res_fd >= 0)
close(bo->res_fd);
mtx_lock(&vtest->sock_mutex);
vtest_vcmd_resource_unref(vtest, bo->base.res_id);
mtx_unlock(&vtest->sock_mutex);
}
free(bo);
}
static struct vn_renderer_bo *
vtest_bo_create(struct vn_renderer *renderer)
{
struct vtest *vtest = (struct vtest *)renderer;
struct vtest_bo *bo = calloc(1, sizeof(*bo));
if (!bo)
return NULL;
bo->vtest = vtest;
bo->res_fd = -1;
bo->base.ops.destroy = vtest_bo_destroy;
bo->base.ops.init_gpu = vtest_bo_init_gpu;
bo->base.ops.init_dmabuf = NULL;
bo->base.ops.export_dmabuf = vtest_bo_export_dmabuf;
bo->base.ops.map = vtest_bo_map;
bo->base.ops.flush = vtest_bo_flush;
bo->base.ops.invalidate = vtest_bo_invalidate;
return &bo->base;
}
@@ -1056,12 +1048,20 @@ vtest_init(struct vtest *vtest)
vtest->base.ops.get_info = vtest_get_info;
vtest->base.ops.submit = vtest_submit;
vtest->base.ops.wait = vtest_wait;
vtest->base.ops.bo_create = vtest_bo_create;
vtest->base.ops.sync_create = vtest_sync_create;
vtest->base.shmem_ops.create = vtest_shmem_create;
vtest->base.shmem_ops.destroy = vtest_shmem_destroy;
vtest->base.bo_ops.create = vtest_bo_create;
vtest->base.bo_ops.init_gpu = vtest_bo_init_gpu;
vtest->base.bo_ops.init_dmabuf = NULL;
vtest->base.bo_ops.destroy = vtest_bo_destroy;
vtest->base.bo_ops.export_dmabuf = vtest_bo_export_dmabuf;
vtest->base.bo_ops.map = vtest_bo_map;
vtest->base.bo_ops.flush = vtest_bo_flush;
vtest->base.bo_ops.invalidate = vtest_bo_invalidate;
return VK_SUCCESS;
}