Nonblocking maps
Subsystems (2)
v2 cover Nonblocking maps
After going back and forth many times, I think Daniel and I have agreed on the solution for non-blocking maps.
This new interface adds a new call to map buffers non-blocking if possible. In actuality it may block, but it will track if the buffer needs flushing or not and does the right thing for the use. This relies on a new IOCTL to determine the cache type of the object.
With the posted benchmark, there are significant improvements on Gen5 with a very synthetic test meant to test unnecessary blocking on architectures. The test is posted in the series for reference, but isn't actually useful in it's current form other than to prove there is a potential performance improvement. The test shows no performance regression on Gen6.
v2:
Some cleanups to libdrm, and mesa patch was messed up. Lot of reworks on mesa (cleanup + usage of nonblocking) Removed the gpu-tools test case since it was just reference
Ben
PATCH v2 1/1 drm/i915: IOCTL to query the cache level of a BO.
Querying a BO's cache level can help clients wishing to map the buffer. For example, an Ironlake machine could query the buffer to determine it should use GTT mappings, while a Sandybridge machine running the same code would prefer to use regular CPU mapped buffers since the cache is coherent.
--- drivers/gpu/drm/i915/i915_dma.c | 1 + drivers/gpu/drm/i915/i915_drv.h | 2 ++ drivers/gpu/drm/i915/i915_gem.c | 22 ++++++++++++++++++++++ include/drm/i915_drm.h | 7 +++++++ 4 files changed, 32 insertions(+), 0 deletions(-)
drivers/gpu/drm/i915/i915_dma.c +1 -0
@@ -2292,6 +2292,7 @@ struct drm_ioctl_desc i915_ioctls[] = {DRM_IOCTL_DEF_DRV (I915_GEM_MADVISE , i915_gem_madvise_ioctl,DRM_UNLOCKED ),DRM_IOCTL_DEF_DRV (I915_OVERLAY_PUT_IMAGE , intel_overlay_put_image,DRM_MASTER |DRM_CONTROL_ALLOW |DRM_UNLOCKED ),DRM_IOCTL_DEF_DRV (I915_OVERLAY_ATTRS , intel_overlay_attrs,DRM_MASTER |DRM_CONTROL_ALLOW |DRM_UNLOCKED ), + DRM_IOCTL_DEF_DRV(I915_GEM_GET_CACHE_TYPE, i915_gem_get_cache_type_ioctl, DRM_UNLOCKED), };int i915_max_ioctl =DRM_ARRAY_SIZE (i915_ioctls);
drivers/gpu/drm/i915/i915_drv.h +2 -0
@@ -1118,6 +1118,8 @@ int i915_gem_get_tiling(struct drm_device *dev, void *data, struct drm_file *file_priv);int i915_gem_get_aperture_ioctl (struct drm_device *dev,void *data,struct drm_file *file_priv); +int i915_gem_get_cache_type_ioctl (struct drm_device *dev,void *data, +struct drm_file *file_priv);void i915_gem_load (struct drm_device *dev);int i915_gem_init_object (struct drm_gem_object *obj); int __must_check i915_gem_flush_ring(struct intel_ring_buffer *ring,
drivers/gpu/drm/i915/i915_gem.c +22 -0
@@ -3777,6 +3777,28 @@ void i915_gem_free_object(struct drm_gem_object *gem_obj) }int +i915_gem_get_cache_type_ioctl (struct drm_device *dev,void *data, +struct drm_file *file_priv) +{ + +struct drm_i915_gem_get_cache_type *args = data; +struct drm_i915_gem_object *obj; +int ret =0 ; + + obj =to_intel_bo (drm_gem_object_lookup (dev, file_priv, args->handle)); +if (&obj->base ==NULL ) { + ret = -ENOENT ; + goto out; + } + + args->cache_level = obj->cache_level; +drm_gem_object_unreference_unlocked (&obj->base); + +out: +return ret; +} + +int i915_gem_idle (struct drm_device *dev) {drm_i915_private_t *dev_priv = dev->dev_private;
include/drm/i915_drm.h +7 -0
@@ -198,6 +198,7 @@ typedef struct _drm_i915_sarea {#define DRM_I915_OVERLAY_PUT_IMAGE 0x27#define DRM_I915_OVERLAY_ATTRS 0x28#define DRM_I915_GEM_EXECBUFFER2 0x29 +#define DRM_I915_GEM_GET_CACHE_TYPE 0x2a#define DRM_IOCTL_I915_INIT DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t)#define DRM_IOCTL_I915_FLUSH DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH)
@@ -239,6 +240,7 @@ typedef struct _drm_i915_sarea {#define DRM_IOCTL_I915_GEM_MADVISE DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MADVISE, struct drm_i915_gem_madvise)#define DRM_IOCTL_I915_OVERLAY_PUT_IMAGE DRM_IOW(DRM_COMMAND_BASE + DRM_I915_OVERLAY_PUT_IMAGE, struct drm_intel_overlay_put_image)#define DRM_IOCTL_I915_OVERLAY_ATTRS DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_OVERLAY_ATTRS, struct drm_intel_overlay_attrs) +#define DRM_IOCTL_I915_GEM_GET_CACHE_TYPE DRM_IOR (DRM_COMMAND_BASE + DRM_I915_GEM_GET_CACHE_TYPE, struct drm_i915_gem_get_cache_type)/* Allow drivers to submit batchbuffers directly to hardware, relying * on the security mechanisms provided by hardware.
@@ -844,4 +846,9 @@ struct drm_intel_overlay_attrs { __u32 gamma5; }; +struct drm_i915_gem_get_cache_type { +__u32 handle; +__u32 cache_level; +}; +#endif /* _I915_DRM_H_ */
Signature · 1 line
1.7.6.3
PATCH v2 1/1 intel: non-blocking mmaps on the cheap
In reply to Ben WidawskyFrom: Daniel Vetter <[email protected]>
This adds a new mode to map gem objects in a non-blocking way.
The new kernel interface required to get the caching level/coherency is not yet wired up. All the code to transparently choose between gtt mappings or (if coherent) cpu mappings is already in place, though.
To make this useable for mesa, we need to allow other buffer acces in between non-blocking modes. It's not a big problem if this accidentaly blocks once when switching back to non-blocking maps, but domains need to be correctly tracked.
I've gone through historical kernel versions and luckily the only place we move a bo from the gtt domain to the cpu domain is in the set_ioctl. pwrite/pread don't move objects into the cpu domain as long as they're untiled or llc cached.
So track whether an object is in the gtt domain and invalidate this only on access to cpu mappings.
[patch reworked by Ben]
--- include/drm/i915_drm.h | 7 ++ intel/intel_bufmgr.h | 3 + intel/intel_bufmgr_gem.c | 175 +++++++++++++++++++++++++++++++++++++++++----- 3 files changed, 168 insertions(+), 17 deletions(-)
include/drm/i915_drm.h +7 -0
@@ -189,6 +189,7 @@ typedef struct _drm_i915_sarea {#define DRM_I915_OVERLAY_PUT_IMAGE 0x27#define DRM_I915_OVERLAY_ATTRS 0x28#define DRM_I915_GEM_EXECBUFFER2 0x29 +#define DRM_I915_GEM_GET_CACHE_TYPE 0x2a#define DRM_IOCTL_I915_INIT DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t)#define DRM_IOCTL_I915_FLUSH DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH)
@@ -230,6 +231,7 @@ typedef struct _drm_i915_sarea {#define DRM_IOCTL_I915_GEM_MADVISE DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MADVISE, struct drm_i915_gem_madvise)#define DRM_IOCTL_I915_OVERLAY_PUT_IMAGE DRM_IOW(DRM_COMMAND_BASE + DRM_IOCTL_I915_OVERLAY_ATTRS, struct drm_intel_overlay_put_image)#define DRM_IOCTL_I915_OVERLAY_ATTRS DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_OVERLAY_ATTRS, struct drm_intel_overlay_attrs) +#define DRM_IOCTL_I915_GEM_GET_CACHE_TYPE DRM_IOR (DRM_COMMAND_BASE + DRM_I915_GEM_GET_CACHE_TYPE, struct drm_i915_gem_get_cache_type)/* Allow drivers to submit batchbuffers directly to hardware, relying * on the security mechanisms provided by hardware.
@@ -835,4 +837,9 @@ struct drm_intel_overlay_attrs { __u32 gamma5; }; +struct drm_i915_gem_get_cache_type { +__u32 handle; +__u32 cache_level; +}; +#endif /* _I915_DRM_H_ */
intel/intel_bufmgr.h +3 -0
@@ -149,6 +149,9 @@ int drm_intel_gem_bo_map_gtt(drm_intel_bo *bo);int drm_intel_gem_bo_unmap_gtt (drm_intel_bo *bo);void drm_intel_gem_bo_start_gtt_access (drm_intel_bo *bo,int write_enable); +int drm_intel_gem_bo_map_nonblocking (drm_intel_bo *bo); +int drm_intel_gem_bo_unmap_nonblocking (drm_intel_bo *bo); +int drm_intel_get_pipe_from_crtc_id (drm_intel_bufmgr *bufmgr,int crtc_id);int drm_intel_get_aperture_sizes (int fd,size_t *mappable,size_t *total);
intel/intel_bufmgr_gem.c +158 -17
252 lines not on this page · raw message
Signature · 1 line
1.7.6.3
PATCH v2 1/2 i965: Cleanup MapRangeBuffer
In reply to Ben WidawskyClean the code up, and always use a BO when creating a new buffer. I've not seen any regressions but haven't yet tried this on < Gen6.
--- src/mesa/drivers/dri/intel/intel_buffer_objects.c | 86 +++++++++------------ src/mesa/drivers/dri/intel/intel_buffer_objects.h | 4 +- 2 files changed, 37 insertions(+), 53 deletions(-)
src/mesa/drivers/dri/intel/intel_buffer_objects.c +36 -50
@@ -291,6 +291,12 @@ intel_bufferobj_map_range(struct gl_context * ctx,assert (intel_obj); +if (access &GL_MAP_FLUSH_EXPLICIT_BIT ) + goto error_out; + +if (access &GL_MAP_INVALIDATE_RANGE_BIT ) + goto error_out; +/* _mesa_MapBufferRange (GL entrypoint) sets these, but the vbo module also * internally uses our functions directly. */
@@ -322,10 +328,8 @@ intel_bufferobj_map_range(struct gl_context * ctx, drm_intel_bo_references(intel->batch.bo, intel_obj->buffer))intel_flush (ctx); -if (intel_obj->buffer ==NULL ) { - obj->Pointer =NULL ; -return NULL ; - } +if (intel_obj->buffer ==NULL ) + goto error_out;/* If the user doesn't care about existing buffer contents and mapping * would cause us to block, then throw out the old buffer.
@@ -344,24 +348,15 @@ intel_bufferobj_map_range(struct gl_context * ctx,*/ if ((access &GL_MAP_INVALIDATE_RANGE_BIT ) &&drm_intel_bo_busy (intel_obj->buffer)) { -if (access &GL_MAP_FLUSH_EXPLICIT_BIT ) { - intel_obj->range_map_buffer =malloc (length); - obj->Pointer = intel_obj->range_map_buffer; - }else { - intel_obj->range_map_bo =drm_intel_bo_alloc (intel->bufmgr, -"range map" , - length,64 ); -if (!(access &GL_MAP_READ_BIT )) { -drm_intel_gem_bo_map_gtt (intel_obj->range_map_bo); - intel_obj->mapped_gtt =GL_TRUE ; - }else { -drm_intel_bo_map (intel_obj->range_map_bo, - (access &GL_MAP_WRITE_BIT ) !=0 ); - intel_obj->mapped_gtt =GL_FALSE ; - } - obj->Pointer = intel_obj->range_map_bo->virtual; - } -return obj->Pointer; + + intel_obj->range_map_bo =drm_intel_bo_alloc (intel->bufmgr, +"range map" , + length,64 ); + +drm_intel_gem_bo_map_gtt (intel_obj->range_map_bo); + intel_obj->mapped_gtt =GL_TRUE ; + obj->Pointer = intel_obj->range_map_bo->virtual; + goto out; }if (!(access &GL_MAP_READ_BIT )) {
@@ -373,7 +368,15 @@ intel_bufferobj_map_range(struct gl_context * ctx, } obj->Pointer = intel_obj->buffer->virtual + offset; + +out: +if (!(access &GL_MAP_FLUSH_EXPLICIT_BIT )) + intel_obj->needs_flush_at_unmap;return obj->Pointer; + +error_out: + obj->Pointer =NULL ; +return NULL ; }/* Ideally we'd use a BO to avoid taking up cache space for the temporary
@@ -388,27 +391,16 @@ intel_bufferobj_flush_mapped_range(struct gl_context *ctx, {struct intel_context *intel =intel_context (ctx);struct intel_buffer_object *intel_obj =intel_buffer_object (obj); -drm_intel_bo *temp_bo; - -/* Unless we're in the range map using a temporary system buffer, -* there's no work to do. -*/ -if (intel_obj->range_map_buffer ==NULL ) -return ;if (length ==0 )return ; - temp_bo =drm_intel_bo_alloc (intel->bufmgr,"range map flush" , length,64 ); - -drm_intel_bo_subdata (temp_bo,0 , length, intel_obj->range_map_buffer); -intel_emit_linear_blit (intel, intel_obj->buffer, obj->Offset + offset, - temp_bo,0 , + intel_obj->range_map_bo,0 , length); -drm_intel_bo_unreference (temp_bo); +drm_intel_bo_unreference (intel_obj->range_map_bo); }
@@ -425,15 +417,6 @@ intel_bufferobj_unmap(struct gl_context * ctx, struct gl_buffer_object *obj)assert (obj->Pointer);if (intel_obj->sys_buffer !=NULL ) {/* always keep the mapping around. */ - }else if (intel_obj->range_map_buffer !=NULL ) { -/* Since we've emitted some blits to buffers that will (likely) be used -* in rendering operations in other cache domains in this batch, emit a -* flush. Once again, we wish for a domain tracker in libdrm to cover -* usage inside of a batchbuffer. -*/ -intel_batchbuffer_emit_mi_flush (intel); -free (intel_obj->range_map_buffer); - intel_obj->range_map_buffer =NULL ; }else if (intel_obj->range_map_bo !=NULL ) {if (intel_obj->mapped_gtt) {drm_intel_gem_bo_unmap_gtt (intel_obj->range_map_bo);
@@ -441,10 +424,14 @@ intel_bufferobj_unmap(struct gl_context * ctx, struct gl_buffer_object *obj)drm_intel_bo_unmap (intel_obj->range_map_bo); } -intel_emit_linear_blit (intel, - intel_obj->buffer, obj->Offset, - intel_obj->range_map_bo,0 , - obj->Length); +if (intel_obj->needs_flush_at_unmap) { +intel_emit_linear_blit (intel, + intel_obj->buffer, obj->Offset, + intel_obj->range_map_bo,0 , + obj->Length); +drm_intel_bo_unreference (intel_obj->range_map_bo); + intel_obj->needs_flush_at_unmap = false; + }/* Since we've emitted some blits to buffers that will (likely) be used * in rendering operations in other cache domains in this batch, emit a
@@ -452,8 +439,6 @@ intel_bufferobj_unmap(struct gl_context * ctx, struct gl_buffer_object *obj)* usage inside of a batchbuffer. */ intel_batchbuffer_emit_mi_flush (intel); - -drm_intel_bo_unreference (intel_obj->range_map_bo); intel_obj->range_map_bo =NULL ; }else if (intel_obj->buffer !=NULL ) {if (intel_obj->mapped_gtt) {
@@ -462,6 +447,7 @@ intel_bufferobj_unmap(struct gl_context * ctx, struct gl_buffer_object *obj)drm_intel_bo_unmap (intel_obj->buffer); } } + obj->Pointer =NULL ; obj->Offset =0 ; obj->Length =0 ;
src/mesa/drivers/dri/intel/intel_buffer_objects.h +1 -3
@@ -47,9 +47,7 @@ struct intel_buffer_objectvoid *sys_buffer;drm_intel_bo *range_map_bo; -void *range_map_buffer; -unsigned int range_map_offset; -GLsizei range_map_size; +bool needs_flush_at_unmap;GLboolean mapped_gtt;GLboolean source;
Signature · 1 line
1.7.6.3
Re: [Mesa-dev] [PATCH v2 1/2] i965: Cleanup MapRangeBuffer
Quoted 8 lines · On Fri, 23 Sep 2011 17:36:16 -0700 Ben Widawsky <[email protected]> wrote:
Clean the code up, and always use a BO when creating a new buffer. I've not seen any regressions but haven't yet tried this on < Gen6.
Cc Chad Versace <[email protected]>Cc Eric Anholt <[email protected]>Cc Mesa Devs <[email protected]>Signed-off-by Ben Widawsky <[email protected]>---
I screwed up my rebasing up this one... please ignore fixing it up now
Ben
PATCH v2 2/2 i965: Add calls to nonblocking maps
In reply to Ben WidawskyWhen mapping a range of a buffer that has the UNSYNCHRONIZED_BIT, and is only writable, we can take some shortcuts and let people shoot their feet.
--- src/mesa/drivers/dri/intel/intel_buffer_objects.c | 35 ++++++++++++++------ src/mesa/drivers/dri/intel/intel_buffer_objects.h | 8 ++++- 2 files changed, 31 insertions(+), 12 deletions(-)
src/mesa/drivers/dri/intel/intel_buffer_objects.c +24 -11
@@ -354,24 +354,29 @@ intel_bufferobj_map_range(struct gl_context * ctx, length, 64);drm_intel_gem_bo_map_gtt (intel_obj->range_map_bo); - intel_obj->mapped_gtt =GL_TRUE ; + intel_obj->mapped_type =BO_MAP_TYPE_GTT ; obj->Pointer = intel_obj->range_map_bo->virtual; goto out; }if (!(access &GL_MAP_READ_BIT )) { -drm_intel_gem_bo_map_gtt (intel_obj->buffer); - intel_obj->mapped_gtt =GL_TRUE ; +if (access &GL_MAP_UNSYNCHRONIZED_BIT ) { +drm_intel_gem_bo_map_nonblocking (intel_obj->buffer); + intel_obj->mapped_type =BO_MAP_TYPE_NONBLOCKING ; + }else { +drm_intel_gem_bo_map_gtt (intel_obj->buffer); + intel_obj->mapped_type =BO_MAP_TYPE_GTT ; + } }else {drm_intel_bo_map (intel_obj->buffer, (access &GL_MAP_WRITE_BIT ) !=0 ); - intel_obj->mapped_gtt =GL_FALSE ; + intel_obj->mapped_type =BO_MAP_TYPE_CPU ; } obj->Pointer = intel_obj->buffer->virtual + offset; out:if (!(access &GL_MAP_FLUSH_EXPLICIT_BIT )) - intel_obj->needs_flush_at_unmap; + intel_obj->needs_flush_at_unmap = true;return obj->Pointer; error_out:
@@ -418,10 +423,12 @@ intel_bufferobj_unmap(struct gl_context * ctx, struct gl_buffer_object *obj)if (intel_obj->sys_buffer !=NULL ) {/* always keep the mapping around. */ }else if (intel_obj->range_map_bo !=NULL ) { -if (intel_obj->mapped_gtt) { +switch (intel_obj->mapped_type) { +case BO_MAP_TYPE_GTT :drm_intel_gem_bo_unmap_gtt (intel_obj->range_map_bo); - }else { -drm_intel_bo_unmap (intel_obj->range_map_bo); +break ; +default : +return GL_FALSE ; }if (intel_obj->needs_flush_at_unmap) {
@@ -430,7 +437,6 @@ intel_bufferobj_unmap(struct gl_context * ctx, struct gl_buffer_object *obj) intel_obj->range_map_bo,0 , obj->Length);drm_intel_bo_unreference (intel_obj->range_map_bo); - intel_obj->needs_flush_at_unmap = false; }/* Since we've emitted some blits to buffers that will (likely) be used
@@ -441,13 +447,20 @@ intel_bufferobj_unmap(struct gl_context * ctx, struct gl_buffer_object *obj)intel_batchbuffer_emit_mi_flush (intel); intel_obj->range_map_bo =NULL ; }else if (intel_obj->buffer !=NULL ) { -if (intel_obj->mapped_gtt) { +switch (intel_obj->mapped_type) { +case BO_MAP_TYPE_GTT :drm_intel_gem_bo_unmap_gtt (intel_obj->buffer); - }else { +break ; +case BO_MAP_TYPE_CPU :drm_intel_bo_unmap (intel_obj->buffer); +break ; +case BO_MAP_TYPE_NONBLOCKING : +drm_intel_gem_bo_unmap_nonblocking (intel_obj->buffer); +break ; } } + intel_obj->needs_flush_at_unmap = false; obj->Pointer =NULL ; obj->Offset =0 ; obj->Length =0 ;
src/mesa/drivers/dri/intel/intel_buffer_objects.h +7 -1
@@ -33,6 +33,12 @@struct intel_context ;struct gl_buffer_object ; +enum { +BO_MAP_TYPE_NONE =0 , +BO_MAP_TYPE_GTT , +BO_MAP_TYPE_CPU , +BO_MAP_TYPE_NONBLOCKING +};/** * Intel vertex/pixel buffer object, derived from Mesa's gl_buffer_object.
@@ -48,8 +54,8 @@ struct intel_buffer_objectdrm_intel_bo *range_map_bo;bool needs_flush_at_unmap; +int mapped_type; -GLboolean mapped_gtt;GLboolean source; };
Signature · 1 line
1.7.6.3
Quoted 6 lines · Ben Widawsky
With the posted benchmark, there are significant improvements on Gen5 with a very synthetic test meant to test unnecessary blocking on architectures. The test is posted in the series for reference, but isn't actually useful in it's current form other than to prove there is a potential performance improvement. The test shows no performance regression on Gen6.
This concerns me a wee bit. With proper tuning for your synthetic test, it should be possible to see almost unbounded speedups. Can you look some more into this?
-Daniel
Signature · 3 lines
Daniel Vetter Mail: [email protected] Mobile: +41 (0)79 365 57 48