lkml.org 
[lkml]   [2007]   [Nov]   [2]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    SubjectRE: Is gcc thread-unsafe?
    Date

    > Another conclusion from the cited text is that in contrast with what
    > was stated before on the gcc mailing list, it is not required to
    > declare thread-shared variables volatile if that thread-shared data is
    > consistently protected by calls to locking functions.
    >
    > Bart Van Assche.

    It all depends upon what threading standard you are using. If GCC is going
    to support POSIX threading, it cannot require that thread-shared data be
    marked 'volatile' since POSIX does not require this.

    It can offer semantic guarantees for volatile-qualified data if it wants to.
    But POSIX provides a set of guarantees that do not require marking data as
    'volatile' and if GCC is going to support POSIX threading, it has to support
    providing those guarantees.

    As far as I know, no threading standard either requires 'volatile' or states
    that it is sufficient for any particular purpose. So there seems to be no
    reason to declare thread-shared variables as
    volatile except as some kind of platform-specific optimization.

    POSIX mutexes are sufficient. They are necessary if there is no other way to
    get the guarantees you need. Nothing prevents GCC from providing any
    guarantees it wants for 'volatile' qualified data. But POSIX mutexes must
    work as POSIX specifies or GCC cannot support POSIX threading.

    This is the nightmare scenario (thanks to Hans-J. Boehm):

    int x;
    bool need_to_lock;
    pthread_mutex_t mutex;

    for(int i=0; i<50; i++)
    {
    if(unlikely(need_to_lock)) pthread_mutex_lock(&mutex);
    x++;
    if(unlikely(need_to_lock)) pthread_mutex_unlock(&mutex);
    }

    Now suppose the compiler optimizes this as follows:

    register=x;
    for(int i=0; i<50; i++)
    {
    if(need_to_lock)
    {
    x=register; pthread_mutex_lock(&mutex) register=x;
    }
    register++;
    if(need_to_lock)
    {
    x=register; pthread_mutex_unlock(&mutex); register=x;
    }
    }
    x=register;

    This is a perfectly legal optimization for single-threaded code. It may in
    fact be an actual optimization. Clearly, it totally destroys threaded code.

    This shows that, unfortunately, the normal assumption that not knowing
    anything about the pthread functions ensures that optimizations won't break
    them is incorrect.

    DS


    -
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to majordomo@vger.kernel.org
    More majordomo info at http://vger.kernel.org/majordomo-info.html
    Please read the FAQ at http://www.tux.org/lkml/

    \
     
     \ /
      Last update: 2007-11-02 18:21    [W:0.031 / U:89.280 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site