Skip to contentSkip to conversation

drm/i915: read-read semaphore optimization

RFC PATCH In review Ben Widawsky 5 participants 16 messages Dec 13, 2011 – Jan 17, 2012

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

RFC PATCH 1/1 drm/i915: read-read semaphore optimization

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

Cc Chris Wilson <[email protected]>
Cc Daniel Vetter <[email protected]>
---
 drivers/gpu/drm/i915/i915_drv.h            |    1 +
 drivers/gpu/drm/i915/i915_gem.c            |    1 +
 drivers/gpu/drm/i915/i915_gem_execbuffer.c |   32 ++++++++++++++++++++++-----
 3 files changed, 28 insertions(+), 6 deletions(-)
drivers/gpu/drm/i915/i915_drv.h +1 -0
index 4a9c1b9..d59bf20 100644
@@ -852,6 +852,7 @@ struct drm_i915_gem_object {
 
 	/** Breadcrumb of last rendering to the buffer. */
 	uint32_t last_rendering_seqno;
+	uint32_t lrs_ro[I915_NUM_RINGS];
 	struct intel_ring_buffer *ring;
 
 	/** Breadcrumb of last fenced GPU access to the buffer. */
drivers/gpu/drm/i915/i915_gem.c +1 -0
index ed0b68f..64cc804 100644
@@ -1561,6 +1561,7 @@ i915_gem_object_move_off_active(struct drm_i915_gem_object *obj)
 {
 	list_del_init(&obj->ring_list);
 	obj->last_rendering_seqno = 0;
+	memset(obj->lrs_ro, 0, sizeof(obj->lrs_ro));
 }
 
 static void
drivers/gpu/drm/i915/i915_gem_execbuffer.c +26 -6
index 42a6529..78090a3 100644
@@ -752,21 +752,20 @@ i915_gem_execbuffer_sync_rings(struct drm_i915_gem_object *obj,
 {
 	struct intel_ring_buffer *from = obj->ring;
 	u32 seqno;
-	int ret, idx;
+	int ret, idx, i;
 
 	if (from == NULL || to == from)
 		return 0;
 
-	/* If the object isn't being written to, and the object isn't moving
-	 * into a GPU write domain, it doesn't need to sync.
-	 */
 	if (obj->pending_gpu_write == 0 &&
-	    obj->base.pending_write_domain == 0)
+	    obj->base.pending_write_domain == 0) {
+		obj->lrs_ro[ffs(to->id) - 1] = obj->last_rendering_seqno;
 		return 0;
+	}
 
 	/* XXX gpu semaphores are implicated in various hard hangs on SNB */
 	if (INTEL_INFO(obj->base.dev)->gen < 6 || !i915_semaphores)
-		return i915_gem_object_wait_rendering(obj);
+		ret = i915_gem_object_wait_rendering(obj);
 
 	idx = intel_ring_sync_index(from, to);
 
@@ -792,6 +791,27 @@ i915_gem_execbuffer_sync_rings(struct drm_i915_gem_object *obj,
 
 	from->sync_seqno[idx] = seqno;
 
+	/* We must be doing a write to an object which may be in queue to be
+	 * read by some other command. If we skipped synchronizing because of a read
+	 * only request, we must check and add a sync point now. The reason we
+	 * must sync on the write is because we have more than 2 rings. If two
+	 * rings have outstanding reads (without sync), we can't let the write
+	 * occur until both other have completed.
+	 */
+	for (i = 0; i < I915_NUM_RINGS; i++) {
+		uint32_t ro_seqno = obj->lrs_ro[i];
+		if (ro_seqno != 0) {
+			obj->lrs_ro[i] = 0;
+
+			if (i915_seqno_passed(from->get_seqno(from), ro_seqno))
+				continue;
+
+			ret = to->sync_to(to, from, ro_seqno - 1);
+			if (ret)
+				return ret;
+		}
+	}
+
 	return to->sync_to(to, from, seqno - 1);
 }
 
Signature · 1 line
1.7.8
#1 lore raw
Quoted 12 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Quoted 8 lines
Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

Yes, that race is quite valid and the reason why I thought I hadn't made that optimisation. Darn. :(

To go a step further, we can split the obj->ring_list into (obj->ring_read_list[NUM_RINGS], obj->num_readers, obj->last_read_seqno) and (obj->ring_write_list, obj->last_write_seqno). At which point Daniel complains about bloating every i915_gem_object, and we probably should kmem_cache_alloc a i915_gem_object_seqno on demand. This allows us to track objects in multiple rings and implement read-write locking, albeit at significantly more complexity in managing the active lists. -Chris

Signature · 1 line
Chris Wilson, Intel Open Source Technology Centre
#2 lore raw
Quoted 25 lines · Chris Wilson
Quoted 12 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Quoted 8 lines
Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

Yes, that race is quite valid and the reason why I thought I hadn't made that optimisation. Darn. :(

Quoted 7 lines

To go a step further, we can split the obj->ring_list into (obj->ring_read_list[NUM_RINGS], obj->num_readers, obj->last_read_seqno) and (obj->ring_write_list, obj->last_write_seqno). At which point Daniel complains about bloating every i915_gem_object, and we probably should kmem_cache_alloc a i915_gem_object_seqno on demand. This allows us to track objects in multiple rings and implement read-write locking, albeit at significantly more complexity in managing the active lists.

I think the i915_gem_object bloat can be fought by stealing a few bits from the various seqnos and storing the ring id in there. The thing that makes me more uneasy is that I don't trust our gpu domain tracking (especially since it's not per-ring). So either
- extend it to be per-ring
- or remove it all and invalidate/flush unconditionally.
In the light of all the complexity and the fact that due to our various w/as I prefer the latter.

Afaik the only use-case for parallel reads is video decode with post-processing on the render ring. The decode ring needs read-only access to reference frames to decode the next frame and the render ring read-only access to past frames for post-processing (e.g. deinterlacing). But given the general state of perf optimizations in libva I think we have lower hanging fruit to chase if we actually miss a performance target for this use-case.

Cheers, Daniel

Signature · 3 lines
Daniel Vetter
Mail: [email protected]
Mobile: +41 (0)79 365 57 48
#3 lore raw
Quoted 1 line · Daniel Vetter

- or remove it all and invalidate/flush unconditionally.

Eric and I were chatting yesterday about trying this -- it seems like we'd be able to dramatically simplify the kernel module by doing this, and given how much flushing already occurs, I doubt we'd see any significant performance difference, and we'd save a pile of CPU time, which might actually improve performance.

Signature · 1 line
[email protected]

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#4 lore raw
Quoted 9 lines · Keith Packard
Quoted 1 line · Daniel Vetter

- or remove it all and invalidate/flush unconditionally.

Eric and I were chatting yesterday about trying this -- it seems like we'd be able to dramatically simplify the kernel module by doing this, and given how much flushing already occurs, I doubt we'd see any significant performance difference, and we'd save a pile of CPU time, which might actually improve performance.

Would we want to keep domain tracking if the HW worked correctly and we didn't have to always flush. It seems like a shame to just gut the code if it actually could offer a benefit on future generations.

I know Daniel has the same idea about gutting it...

Ben

#5 lore raw
Quoted 3 lines · Ben Widawsky

Would we want to keep domain tracking if the HW worked correctly and we didn't have to always flush. It seems like a shame to just gut the code if it actually could offer a benefit on future generations.

That sounds like premature optimization to me. If we want something similar on future hardware, we can resurrect the old code and see what pieces are useful. For now, we're fighting correctness and stability issues, and given the limited (zero? negative?) performance benefits, we just need to get to code which works reliably and provides good performance.

The current code has gotten to the 'piles of kludges on kludges' stage, which makes it very fragile -- see the regression caused by changing flushing orders in the VT-d work-around.

Signature · 1 line
[email protected]

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#6 lore raw
In reply to Ben Widawsky
Quoted 12 lines · Ben Widawsky
Quoted 9 lines · Keith Packard
Quoted 1 line · Daniel Vetter

- or remove it all and invalidate/flush unconditionally.

Eric and I were chatting yesterday about trying this -- it seems like we'd be able to dramatically simplify the kernel module by doing this, and given how much flushing already occurs, I doubt we'd see any significant performance difference, and we'd save a pile of CPU time, which might actually improve performance.

Quoted 3 lines

Would we want to keep domain tracking if the HW worked correctly and we didn't have to always flush. It seems like a shame to just gut the code if it actually could offer a benefit on future generations.

It's not a matter of hardware behavior. It's a matter of always needing to flush the caches anyway because you're emitting new commands at the GPU and you're wanting results completed on the screen at the end. So we go to all this fragile, expensive CPU work to get no benefit.

We introduced this complexity with no evidence that it would help, just because we thought, like you, that "avoiding cache flushes should be good, right?". Experiments so far say we were wrong.

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#7 lore raw
Quoted 3 lines · Eric Anholt

We introduced this complexity with no evidence that it would help, just because we thought, like you, that "avoiding cache flushes should be good, right?". Experiments so far say we were wrong.

Right, you'd think we'd have learned to not optimize in advance of data. Someday maybe we'll know better...

And, of course, future hardware may require different code for optimal performance. Who would have guessed that?

Signature · 1 line
[email protected]

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#8 lore raw
In reply to Daniel Vetter
Quoted 7 lines · Daniel Vetter

Afaik the only use-case for parallel reads is video decode with post-processing on the render ring. The decode ring needs read-only access to reference frames to decode the next frame and the render ring read-only access to past frames for post-processing (e.g. deinterlacing). But given the general state of perf optimizations in libva I think we have lower hanging fruit to chase if we actually miss a performance target for this use-case.

One in the near future will be: render to backbuffer (RCS), pageflip to scanout (BCS), read from front (RCS).

And in its current form UXA will do the back-to-front blit on the BCS. But that is async and so not a large race window, whereas the pageflip may takes ~16ms to process. I don't think it is entirely unfeasible that we see some form of this whilst running compositors or games. Or at least would if we enabled semaphores for pageflips. Except in the pageflip scenario we know we are protected by the fb ref, so consider the hypothetical scenario where we have a working vsync'ed blit...

The real question is in any event do we have enough instrumentation to diagnose GPU stalls upon buffer migration? Then we can replace the read optimisation with a tracepoint and wait for a test case. -Chris

Signature · 1 line
Chris Wilson, Intel Open Source Technology Centre
#9 lore raw
In reply to Ben Widawsky
Quoted 12 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Quoted 8 lines
Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

You say it's an optimization -- do you have performance numbers?

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#10 lore raw
Quoted 19 lines · Eric Anholt
Quoted 18 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

Quoted 4 lines
Quoted 2 lines

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

You say it's an optimization -- do you have performance numbers?

33% improvement on a hacked version of gem_ring_sync_loop with.

It's not really a valid test as it's not coherent, but this is approximately the best case improvement.

Oddly semaphores doesn't make much difference in this test, which was surprising.

#11 lore raw
Quoted 25 lines · Ben Widawsky
Quoted 19 lines · Eric Anholt
Quoted 18 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

Quoted 4 lines
Quoted 2 lines

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

You say it's an optimization -- do you have performance numbers?

Quoted 7 lines

33% improvement on a hacked version of gem_ring_sync_loop with.

It's not really a valid test as it's not coherent, but this is approximately the best case improvement.

Oddly semaphores doesn't make much difference in this test, which was surprising.

Our domain tracking is already complicated in unfunny ways. And (at least without a use-case showing gains with hard numbers in either perf or power usage) I think this patch is the kind of "this looks cool" stuff that added a lot to the current problem.

So before adding more complexity on top I'd like to remove some of the superflous stuff we already have. I.e. all the flushing_list stuff and maybe other things ...

Cheers, Daniel

Signature · 3 lines
Daniel Vetter
Mail: [email protected]
Mobile: +41 (0)79 365 57 48
#12 lore raw
Quoted 34 lines · Daniel Vetter
Quoted 25 lines · Ben Widawsky
Quoted 19 lines · Eric Anholt
Quoted 18 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

Quoted 4 lines
Quoted 2 lines

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

You say it's an optimization -- do you have performance numbers?

Quoted 7 lines

33% improvement on a hacked version of gem_ring_sync_loop with.

It's not really a valid test as it's not coherent, but this is approximately the best case improvement.

Oddly semaphores doesn't make much difference in this test, which was surprising.

Quoted 8 lines

Our domain tracking is already complicated in unfunny ways. And (at least without a use-case showing gains with hard numbers in either perf or power usage) I think this patch is the kind of "this looks cool" stuff that added a lot to the current problem.

So before adding more complexity on top I'd like to remove some of the superflous stuff we already have. I.e. all the flushing_list stuff and maybe other things ...

Can you be more clear on what exactly you want done before taking a patch like this? Maybe I can work on it during some down time.

Quoted 2 lines

Cheers, Daniel

~Ben

#13 lore raw
Quoted 40 lines · Ben Widawsky
Quoted 39 lines · Daniel Vetter
Quoted 25 lines · Ben Widawsky
Quoted 19 lines · Eric Anholt
Quoted 18 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

Quoted 4 lines
Quoted 2 lines

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

You say it's an optimization -- do you have performance numbers?

Quoted 7 lines

33% improvement on a hacked version of gem_ring_sync_loop with.

It's not really a valid test as it's not coherent, but this is approximately the best case improvement.

Oddly semaphores doesn't make much difference in this test, which was surprising.

Our domain tracking is already complicated in unfunny ways. And (at least without a use-case showing gains with hard numbers in either perf or power usage) I think this patch is the kind of "this looks cool" stuff that added a lot to the current problem.

Quoted 6 lines
Quoted 3 lines

So before adding more complexity on top I'd like to remove some of the superflous stuff we already have. I.e. all the flushing_list stuff and maybe other things ...

Can you be more clear on what exactly you want done before taking a patch like this? Maybe I can work on it during some down time.

If it claims to be an optimization, at a minimum the patch should include performance numbers.

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx

#14 lore raw
In reply to Ben Widawsky
Quoted 40 lines · Ben Widawsky
Quoted 39 lines · Daniel Vetter
Quoted 25 lines · Ben Widawsky
Quoted 19 lines · Eric Anholt
Quoted 18 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

Quoted 4 lines
Quoted 2 lines

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

You say it's an optimization -- do you have performance numbers?

Quoted 7 lines

33% improvement on a hacked version of gem_ring_sync_loop with.

It's not really a valid test as it's not coherent, but this is approximately the best case improvement.

Oddly semaphores doesn't make much difference in this test, which was surprising.

Our domain tracking is already complicated in unfunny ways. And (at least without a use-case showing gains with hard numbers in either perf or power usage) I think this patch is the kind of "this looks cool" stuff that added a lot to the current problem.

Quoted 6 lines
Quoted 3 lines

So before adding more complexity on top I'd like to remove some of the superflous stuff we already have. I.e. all the flushing_list stuff and maybe other things ...

Can you be more clear on what exactly you want done before taking a patch like this? Maybe I can work on it during some down time.

I was thinking about Eric's no-more-domains stuff specifically, which has tons of natural split-points - and we want to exploit these for merging. Imo step 1 would be to just rework the batch dispatch in intel_ringbuffer.c so that we unconditionally invalidate before and flush afterwards. The ring->flush would become a no-op. No changes to the core flushing_list tracking for step 1.

If we can get this in for 3.4 we could (in the -next merge cycle) walk all the callchains from their ends and rip out everything which is a no-op, starting from ring->flush. I think that's the safest way to attack this. Eric?

Cheers, Daniel

Signature · 3 lines
Daniel Vetter
Mail: [email protected]
Mobile: +41 (0)79 365 57 48
#15 lore raw
Quoted 55 lines · Daniel Vetter
Quoted 40 lines · Ben Widawsky
Quoted 39 lines · Daniel Vetter
Quoted 25 lines · Ben Widawsky
Quoted 19 lines · Eric Anholt
Quoted 18 lines · Ben Widawsky

Since we don't differentiate on the different GPU read domains, it should be safe to allow back to back reads to occur without issuing a wait (or flush in the non-semaphore case).

This has the unfortunate side effect that we need to keep track of all the outstanding buffer reads so that we can synchronize on a write, to another ring (since we don't know which read finishes first). In other words, the code is quite simple for two rings, but gets more tricky for

Quoted 1 line

2 rings.

Here is a picture of the solution to the above problem

Ring 0            Ring 1             Ring 2
batch 0           batch 1            batch 2

read buffer A read buffer A wait batch 0
wait batch 1 write buffer A

Quoted 4 lines
Quoted 2 lines

This code is really untested. I'm hoping for some feedback if this is worth cleaning up, and testing more thoroughly.

You say it's an optimization -- do you have performance numbers?

Quoted 7 lines

33% improvement on a hacked version of gem_ring_sync_loop with.

It's not really a valid test as it's not coherent, but this is approximately the best case improvement.

Oddly semaphores doesn't make much difference in this test, which was surprising.

Our domain tracking is already complicated in unfunny ways. And (at least without a use-case showing gains with hard numbers in either perf or power usage) I think this patch is the kind of "this looks cool" stuff that added a lot to the current problem.

Quoted 6 lines
Quoted 3 lines

So before adding more complexity on top I'd like to remove some of the superflous stuff we already have. I.e. all the flushing_list stuff and maybe other things ...

Can you be more clear on what exactly you want done before taking a patch like this? Maybe I can work on it during some down time.

I was thinking about Eric's no-more-domains stuff specifically, which has tons of natural split-points - and we want to exploit these for merging. Imo step 1 would be to just rework the batch dispatch in intel_ringbuffer.c so that we unconditionally invalidate before and flush afterwards. The ring->flush would become a no-op. No changes to the core flushing_list tracking for step 1.

Quoted 4 lines

If we can get this in for 3.4 we could (in the -next merge cycle) walk all the callchains from their ends and rip out everything which is a no-op, starting from ring->flush. I think that's the safest way to attack this. Eric?

I was stuck with a mysterious regression in my previous attempt at the patch series. I've recently realized that I can do the major code deletion with fewer + lines in the diff, which I hope will avoid that. I'm working it that again now.

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx