atomic reference counting primatives.

[M. Warner Losh]

In message: <Pine.BSF.4.21.0405201340590.72391-100000 at InterJet.elischer.org>
            Julian Elischer <julian at elischer.org> writes:
: This has been raised before but I've come across uses for it again and
: again so I'm raising it again. 
: JHB once posted some atomic referenc counting primatives. (Do you still
: have them John?) 
: Alfred once said he had soem somewhere too, and other s have commentted
: on this before, but we still don't seem to have any.
: 
: every object is reference counted with its own code and 
: sometimes it's done poorly.
: 
: Some peiople indicated that there are cases where a generic refcounter
: can not be used and usd this as  a reason to not have one at all.
: 
: So, here are some possibilities..
: my first "write it down without too much thinking" effort..
: 
: typedef {mumble} refcnt_t
: 
: refcnt_add(refcnt_t *)
:   Increments the reference count.. no magic except to be atomic.
: 
: 
: int	refcnt_drop(refcnt *, struct mutex *)
:  Decrements the refcount. If it goes to 0 it returns 0 and locks the
: mutex  (if the mutex is supplied)..

What prevents refcnt_add() from happening after ref count drops to 0?
Wouldn't that be a race?  Eg, if we have two threads:


	Thread A			Thread B

	objp = lookup();
[1]					refcnt_drop(&objp->ref, &objp->mtx);
[2]	refcnt_add(&obj->ref);
					BANG!

If [1] happens before [2], then bad things happen at BANG!  If [2]
happens before [1], then the mutex won't be locked at BANG and things
is good.  Thread A believes it has a valid reference to objp after the
refcnt_add and no way of knowing otherwise.

Is there a safe way to use the API into what you are proposing?

Warner