Re: [Valgrind-users] Marking blocks as write-once/grow-only

[Julian S. <js...@ac...>]

On 05/08/2014 10:26 AM, Alex Bennée wrote:
> 
> Julian Seward <js...@ac...> writes:
> 
>>> Is it possible for the DRD/Helgrind tools to detect this sort of
>>> double-write access behaviour?
>>
>> Both of them should be able to detect a write-vs-write race, if
>> that's what you mean.
> 
> But is that only if two threads race to write the same location at the
> same time?

Well, yes.  But isn't that what you care about?  Or are you concerned
about a race at a higher level of granularity?


> What I think has happened is:
> 
> (1) thread a writes from code_buf_start a series of operations
> (2) thread b writes from code_buf_start over the top of thread a
> (3) thread b finalises the code buffer at code_buf_end<b>
> (4) thread a finalises the code buffer at code_buf_end<a>

I'm still confused.  What does this sequence look like if you
add in the lock acquire/release points?  This sounds like it
ought to be straightforward, but you need to say what locks
exist, what they protect, and when they are supposed to be
acquired/released.

In the absence of further info I'd assume that there is just
one lock, which protects the entire code buffer and any
"finalisation info".  And that is supposed to be acquired and
held for the entire period in which a thread writes to and
finalises the code buffer.

In which case the above sequence can't happen, since (2) will
block as soon as it tries to acquire the lock.

J