observer_proxy.h

Go to the documentation of this file.

/*
    Copyright (c) 2005-2020 Intel Corporation

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
*/

#ifndef _TBB_observer_proxy_H
#define _TBB_observer_proxy_H

#if __TBB_SCHEDULER_OBSERVER

#include "scheduler_common.h" // to include task.h
#include "tbb/task_scheduler_observer.h"
#include "tbb/spin_rw_mutex.h"
#include "tbb/aligned_space.h"

namespace tbb {
namespace internal {

class observer_list {
    friend class arena;

    // Mutex is wrapped with aligned_space to shut up warnings when its destructor
    // is called while threads are still using it.
    typedef aligned_space<spin_rw_mutex>  my_mutex_type;

    observer_proxy* my_head;

    observer_proxy* my_tail;

    my_mutex_type my_mutex;

    arena* my_arena;


    inline static void remove_ref_fast( observer_proxy*& p );

    void do_notify_entry_observers( observer_proxy*& last, bool worker );

    void do_notify_exit_observers( observer_proxy* last, bool worker );

public:
    observer_list () : my_head(NULL), my_tail(NULL) {}


    void clear ();

    void insert ( observer_proxy* p );

    void remove ( observer_proxy* p );


    void remove_ref( observer_proxy* p );

    typedef spin_rw_mutex::scoped_lock scoped_lock;

    spin_rw_mutex& mutex () { return my_mutex.begin()[0]; }

    bool empty () const { return my_head == NULL; }


    inline void notify_entry_observers( observer_proxy*& last, bool worker );

    inline void notify_exit_observers( observer_proxy*& last, bool worker );
}; // class observer_list


class observer_proxy {
    friend class task_scheduler_observer_v3;
    friend class observer_list;

    atomic<int> my_ref_count;
    observer_list* my_list;

    observer_proxy* my_next;

    observer_proxy* my_prev;
    task_scheduler_observer_v3* my_observer;
    char my_version;

#if __TBB_ARENA_OBSERVER
    interface6::task_scheduler_observer* get_v6_observer();
#endif
#if __TBB_ARENA_OBSERVER
    bool is_global(); //TODO: move them back inline when un-CPF'ing
#endif

    observer_proxy( task_scheduler_observer_v3& );

#if TBB_USE_ASSERT
    ~observer_proxy();
#endif /* TBB_USE_ASSERT */

    observer_proxy& operator = ( const observer_proxy& );
}; // class observer_proxy

inline void observer_list::remove_ref_fast( observer_proxy*& p ) {
    if( p->my_observer ) {
        // Can decrement refcount quickly, as it cannot drop to zero while under the lock.
        int r = --p->my_ref_count;
        __TBB_ASSERT_EX( r, NULL );
        p = NULL;
    } else {
        // Use slow form of refcount decrementing, after the lock is released.
    }
}

inline void observer_list::notify_entry_observers( observer_proxy*& last, bool worker ) {
    if ( last == my_tail )
        return;
    do_notify_entry_observers( last, worker );
}

inline void observer_list::notify_exit_observers( observer_proxy*& last, bool worker ) {
    if ( !last )
        return;
    __TBB_ASSERT(is_alive((uintptr_t)last), NULL);
    do_notify_exit_observers( last, worker );
    __TBB_ASSERT(last, NULL);
    poison_value(last);
}

extern padded<observer_list> the_global_observer_list;

} // namespace internal
} // namespace tbb

#endif /* __TBB_SCHEDULER_OBSERVER */

#endif /* _TBB_observer_proxy_H */