Re: [boost] Nonlocking data structures.

From: Lance.Diduck_at_[hidden]
Date: 2008-04-21 13:35:26

> I thought boost::shared_ptr was lock-free and thread safe on the major
platforms supported by boost.  I could  > be wrong though.

The reference counter is lock-free and thread safe. The shared_ptr
itself is not

shared_ptr<A> mutualA(new A);
mutex mutualAlock;
void * thread_func(void*){
    shared_ptr<A> isolatedA;
    {
         //accessing mutualA requires lock
      lock(mutualAlock);
      isolatedA=mutualA;
    }
    //accessing isolatedA is fine
    //this only depends on the ref counter being thread safe
    vector<shared_ptr<A> > vA(100,isolatedA);
}

Also, it should be clear that this is unsafe:

void * thread_func2(void*){
        mutualA->doSomething();
}
Since another thread is likely to do 
void * thread_func3(void*){
        mutualA.reset(new A);//oops just deleted object thread_func2 was
using
}

In the pointer I have, the above code would be 
linear_mutual_ptr<A> mutualA(new A); //for the shared instance
void * thread_func_l(void*){
    linear_ptr<A> isolatedA=mutualA;//for the isolated instance
    //isolatedA now has a copy, access like shared_ptr sans weak_ptr
    vector<linear_ptr<A> > vA(100,linearA);
//and FWIW this works
    vector<linear_mutual_ptr<A> > vAm(100,mutualA);
//but copies of linear_mutual_ptr are not as efficient
//AND of course not every element may actually 
//points to the same object
}
void * thread_func2_l(void*){
//ensure that the object is going to hang around long enough
//to complete the operation
        linear_ptr<A>(mutualA)->doSomething();
}

linear_mutual_ptr also has a 
bool compare_and_swap(linear_ptr<T> const &oldval, linear_ptr<T> const
&newval)volatile 
Operation, so that simple STM systems can be built using it, i.e.

void * thread_func_l2(void*){
    do{
    linear_ptr<A> isolatedA=mutualA;
    linear_ptr<A> isolatedA2(new A(*isolatedA));
    //not shown, but A's operator new has a lock-free allocator attached
    isolatedA2->modify();
    if(mutualA.compare_and_swap(isolatedA,isolatedA2))return 0;
    }while(true);
}

Lance 

-----Original Message-----
From: boost-bounces_at_[hidden]
[mailto:boost-bounces_at_[hidden]] On Behalf Of Patrick Twohig
Sent: Monday, April 21, 2008 12:37 PM
To: boost_at_[hidden]
Subject: Re: [boost] Nonlocking data structures.

I thought boost::shared_ptr was lock-free and thread safe on the major
platforms supported by boost.  I could be wrong though.
_______________________________________________
Unsubscribe & other changes:
http://lists.boost.org/mailman/listinfo.cgi/boost
Visit our website at http://www.ubs.com

This message contains confidential information and is intended only 
for the individual named.  If you are not the named addressee you 
should not disseminate, distribute or copy this e-mail.  Please 
notify the sender immediately by e-mail if you have received this 
e-mail by mistake and delete this e-mail from your system.
        
E-mails are not encrypted and cannot be guaranteed to be secure or 
error-free as information could be intercepted, corrupted, lost, 
destroyed, arrive late or incomplete, or contain viruses.  The sender 
therefore does not accept liability for any errors or omissions in the 
contents of this message which arise as a result of e-mail transmission.  
If verification is required please request a hard-copy version.  This 
message is provided for informational purposes and should not be 
construed as a solicitation or offer to buy or sell any securities 
or related financial instruments.