Skip to contentSkip to conversation

Nonblocking maps

PATCH Superseded Ben Widawsky 2 participants 7 messages Sep 24, 2011 – Sep 25, 2011

Subsystems (2)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

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

#1 lore raw

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.

Cc Daniel Vetter <[email protected]>
Cc Eric Anholt <[email protected]>
Cc "Kilarski, Bernard R" <[email protected]>
---
 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
index 8a3942c..8178cbb 100644
@@ -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
index 7916bd9..2dfcb3d 100644
@@ -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
index a546a71..a120a74 100644
@@ -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
index 28c0d11..a0dff8a 100644
@@ -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
#2 lore raw

PATCH v2 1/1 intel: non-blocking mmaps on the cheap

In reply to Ben Widawsky

From: 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
index adc2392..4b62222 100644
@@ -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
index 889ef46..47f3416 100644
@@ -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
#3 lore raw

PATCH v2 1/2 i965: Cleanup MapRangeBuffer

In reply to Ben Widawsky

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]>
---
 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
index 4df2d76..d475355 100644
@@ -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
index e74d061..24a1636 100644
@@ -47,9 +47,7 @@ struct intel_buffer_object
    void *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
#4 lore raw

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]>

---

I screwed up my rebasing up this one... please ignore fixing it up now

Ben

#5 lore raw

PATCH v2 2/2 i965: Add calls to nonblocking maps

In reply to Ben Widawsky

When 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.

Cc Eric Anholt <[email protected]>
Cc Mesa Devs <[email protected]>
---
 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
index d475355..3a540fa 100644
@@ -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
index 24a1636..fd43bd5 100644
@@ -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_object
 
    drm_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
#6 lore raw
In reply to Ben Widawsky
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