ts_idle,

ts_asleep,

ts_busy,

ts_done

ts_none,

ts_removed,

ts_lent

wk_failed,

wk_from_asleep,

wk_from_idle

//! Thread not doing anything useful, but running and looking for work.

ts_idle,

//! Thread not doing anything useful and is asleep */

ts_asleep,

//! Thread is enlisted into OpenMP team

ts_omp_busy,

//! Thread is busy doing TBB work.

ts_tbb_busy,

//! For tbb threads only

ts_done,

ts_created,

ts_started,

ts_visited,

//! For omp threads only

ts_none,

ts_deactivated,

ts_reactivated

typedef ::rml::job job_type;

omp_client* client;

void* cookie;

omp_client::size_type index;

tbb::atomic<job_type*> job;

#if TBB_USE_ASSERT

omp_connection_v2* server;

#endif /* TBB_USE_ASSERT */

omp_dispatch_type() {job=NULL;}

void consume();

void produce( omp_client& c, job_type* j, void* cookie_, omp_client::size_type index_ PRODUCE_ARG( omp_connection_v2& s )) {

__TBB_ASSERT( j, NULL );

__TBB_ASSERT( !job, "job already set" );

client = &c;

#if TBB_USE_ASSERT

server = &s;

#endif /* TBB_USE_ASSERT */

cookie = cookie_;

index = index_;

// Must be last

job = j;

}

friend class thread_map;

tbb::atomic<int> my_ref_count;

ref_count(int k ) {my_ref_count=k;}

~ref_count() {__TBB_ASSERT( !my_ref_count, "premature destruction of refcounted object" );}

//! Add one and return new value.

int add_ref() {

int k = ++my_ref_count;

__TBB_ASSERT(k>=1,"reference count underflowed before add_ref");

return k;

}

//! Subtract one and return new value.

int remove_ref() {

int k = --my_ref_count;

__TBB_ASSERT(k>=0,"reference count underflow");

return k;

}

friend class thread_map;

friend class omp_connection_v2;

friend class server_thread;

friend class tbb_server_thread;

friend class omp_server_thread;

template<typename Connection> friend void make_job( Connection& c, typename Connection::server_thread_type& t );

typedef int thread_state_rep_t;

//! Ctor

server_thread_rep( bool assigned, IScheduler* s, IExecutionResource* r, thread_map& map, rml::client& cl ) :

uid( GetExecutionContextId() ), my_scheduler(s), my_proxy(NULL),

my_thread_map(map), my_client(cl), my_job(NULL)

{

my_state = assigned ? ts_busy : ts_idle;

my_extra_state = ts_none;

terminate = false;

my_execution_resource = r;

}

//! Dtor

~server_thread_rep() {}

//! Synchronization routine

inline rml::job* wait_for_job() {

if( !my_job ) my_job = my_job_automaton.wait_for_job();

return my_job;

}

// Getters and setters

inline thread_state_t read_state() const { thread_state_rep_t s = my_state; return static_cast<thread_state_t>(s); }

inline void set_state( thread_state_t to ) {my_state = to;}

inline void set_removed() { __TBB_ASSERT( my_extra_state==ts_none, NULL ); my_extra_state = ts_removed; }

inline bool is_removed() const { return my_extra_state==ts_removed; }

inline bool is_lent() const {return my_extra_state==ts_lent;}

inline void set_lent() { my_extra_state=ts_lent; }

inline void set_returned() { my_extra_state=ts_none; }

inline IExecutionResource* get_execution_resource() { return my_execution_resource; }

inline IVirtualProcessorRoot* get_virtual_processor() { return (IVirtualProcessorRoot*)get_execution_resource(); }

//! Enlist the thread for work

inline bool wakeup( thread_state_t to, thread_state_t from ) {

__TBB_ASSERT( from==ts_asleep && (to==ts_idle||to==ts_busy||to==ts_done), NULL );

return my_state.compare_and_swap( to, from )==from;

}

//! Enlist the thread for.

thread_grab_t try_grab_for();

//! Destroy the client job associated with the thread

template<typename Connection> bool destroy_job( Connection* c );

//! Try to re-use the thread

void revive( IScheduler* s, IExecutionResource* r, rml::client& c ) {

// the variables may not have been set before a thread was told to quit

__TBB_ASSERT( my_scheduler==s, "my_scheduler has been altered?\n" );

my_scheduler = s;

__TBB_ASSERT( &my_client==&c, "my_client has been altered?\n" );

if( r ) my_execution_resource = r;

my_client = c;

my_state = ts_idle;

__TBB_ASSERT( my_extra_state==ts_removed, NULL );

my_extra_state = ts_none;

}

const int uid;

IScheduler* my_scheduler;

IThreadProxy* my_proxy;

tbb::atomic<IExecutionResource*> my_execution_resource; /* for non-masters, it is IVirtualProcessorRoot */

thread_map& my_thread_map;

rml::client& my_client;

job* my_job;

job_automaton my_job_automaton;

tbb::atomic<bool> terminate;

tbb::atomic<thread_state_rep_t> my_state;

tbb::atomic<thread_extra_state_t> my_extra_state;

friend class tbb_connection_v2;

friend class omp_connection_v2;

friend class tbb_server_thread;

friend class omp_server_thread;

friend class thread_map;

template<typename Connection> friend void make_job( Connection& c, typename Connection::server_thread_type& t );

server_thread( bool is_tbb, bool assigned, IScheduler* s, IExecutionResource* r, thread_map& map, rml::client& cl ) : server_thread_rep(assigned,s,r,map,cl), tbb_thread(is_tbb) {}

~server_thread() {}

unsigned int GetId() const __TBB_override { return uid; }

IScheduler* GetScheduler() __TBB_override { return my_scheduler; }

IThreadProxy* GetProxy() __TBB_override { return my_proxy; }

void SetProxy( IThreadProxy* thr_proxy ) __TBB_override { my_proxy = thr_proxy; }

bool tbb_thread;

friend class tbb_connection_v2;

tbb_server_thread( bool assigned, IScheduler* s, IExecutionResource* r, tbb_connection_v2* con, thread_map& map, rml::client& cl ) : server_thread(true,assigned,s,r,map,cl), my_conn(con) {

activation_count = 0;

}

~tbb_server_thread() {}

void Dispatch( DispatchState* ) __TBB_override;

inline bool initiate_termination();

bool sleep_perhaps();

//! Switch out this thread

bool switch_out();

tbb_connection_v2* my_conn;

tbb::atomic<int> activation_count;

friend class omp_connection_v2;

omp_server_thread( bool assigned, IScheduler* s, IExecutionResource* r, omp_connection_v2* con, thread_map& map, rml::client& cl ) :

server_thread(false,assigned,s,r,map,cl), my_conn(con), my_cookie(NULL), my_index(UINT_MAX) {}

~omp_server_thread() {}

void Dispatch( DispatchState* ) __TBB_override;

inline void* get_cookie() {return my_cookie;}

inline ::__kmp::rml::omp_client::size_type get_index() {return my_index;}

inline IExecutionResource* get_execution_resource() { return get_execution_resource(); }

inline bool initiate_termination() { return destroy_job( (omp_connection_v2*) my_conn ); }

void sleep_perhaps();

omp_connection_v2* my_conn;

void* my_cookie;

::__kmp::rml::omp_client::size_type my_index;

omp_dispatch_type omp_data;

unsigned int GetId() const __TBB_override {return uid;}

void Statistics( unsigned int* /*pTaskCompletionRate*/, unsigned int* /*pTaskArrivalRate*/, unsigned int* /*pNumberOfTaskEnqueued*/) __TBB_override {}

SchedulerPolicy GetPolicy() const __TBB_override { __TBB_ASSERT(my_policy,NULL); return *my_policy; }

void AddVirtualProcessors( IVirtualProcessorRoot** vproots, unsigned int count ) __TBB_override { if( !my_conn.is_closing() ) my_conn.add_virtual_processors( vproots, count); }

void RemoveVirtualProcessors( IVirtualProcessorRoot** vproots, unsigned int count ) __TBB_override;

void NotifyResourcesExternallyIdle( IVirtualProcessorRoot** vproots, unsigned int count ) __TBB_override { __TBB_ASSERT( false, "This call is not allowed for TBB" ); }

void NotifyResourcesExternallyBusy( IVirtualProcessorRoot** vproots, unsigned int count ) __TBB_override { __TBB_ASSERT( false, "This call is not allowed for TBB" ); }

scheduler( Connection& conn );

virtual ~scheduler() { __TBB_ASSERT( my_policy, NULL ); delete my_policy; }

static scheduler* create( Connection& conn ) {return new scheduler( conn );}

const int uid;

Connection& my_conn;

SchedulerPolicy* my_policy;

thread_scavenger_thread( IScheduler* s, IVirtualProcessorRoot* r, thread_map& map ) :

uid( GetExecutionContextId() ), my_scheduler(s), my_virtual_processor_root(r), my_proxy(NULL), my_thread_map(map)

{

my_state = ts_busy;

#if TBB_USE_ASSERT

activation_count = 0;

#endif

}

~thread_scavenger_thread() {}

unsigned int GetId() const __TBB_override { return uid; }

IScheduler* GetScheduler() __TBB_override { return my_scheduler; }

IThreadProxy* GetProxy() __TBB_override { return my_proxy; }

void SetProxy( IThreadProxy* thr_proxy ) __TBB_override { my_proxy = thr_proxy; }

void Dispatch( DispatchState* ) __TBB_override;

inline thread_state_t read_state() { return my_state; }

inline void set_state( thread_state_t s ) { my_state = s; }

inline IVirtualProcessorRoot* get_virtual_processor() { return my_virtual_processor_root; }

const int uid;

IScheduler* my_scheduler;

IVirtualProcessorRoot* my_virtual_processor_root;

IThreadProxy* my_proxy;

thread_map& my_thread_map;

tbb::atomic<thread_state_t> my_state;

#if TBB_USE_ASSERT

tbb::atomic<int> activation_count;

#endif

tbb::atomic<uintptr_t> head;

tbb::atomic<uintptr_t> tail;

static const uintptr_t empty = 0; // connection scavenger thread empty list

static const uintptr_t plugged = 1; // end of use of the list

static const uintptr_t plugged_acked = 2; // connection scavenger saw the plugged flag, and it freed all connections

friend void assist_cleanup_connections();

/*

tbb::atomic<thread_state_t> state;

/* We steal two bits from a connection pointer to encode

// FIXME: pad these?

thread_monitor monitor;

HANDLE thr_handle;

#if TBB_USE_ASSERT

tbb::atomic<int> n_scavenger_threads;

#endif

connection_scavenger_thread() : thr_handle(NULL) {

state = ts_asleep;

#if TBB_USE_ASSERT

n_scavenger_threads = 0;

#endif

}

~connection_scavenger_thread() {}

void wakeup() {

if( state.compare_and_swap( ts_busy, ts_asleep )==ts_asleep )

monitor.notify();

}

void sleep_perhaps();

void process_requests( uintptr_t conn_ex );

static __RML_DECL_THREAD_ROUTINE thread_routine( void* arg );

void launch() {

thread_monitor::launch( connection_scavenger_thread::thread_routine, this, NULL );

}

template<typename Server, typename Client>

void add_request( generic_connection<Server,Client>* conn_to_close );

template<typename Server, typename Client>

uintptr_t grab_and_prepend( generic_connection<Server,Client>* last_conn_to_close );

//! A value in the map

class value_type {

public:

server_thread& thread() {

__TBB_ASSERT( my_thread, "thread_map::value_type::thread() called when !my_thread" );

return *my_thread;

}

rml::job& job() {

__TBB_ASSERT( my_job, "thread_map::value_type::job() called when !my_job" );

return *my_job;

}

value_type() : my_thread(NULL), my_job(NULL) {}

server_thread& wait_for_thread() const {

for(;;) {

server_thread* ptr=const_cast<server_thread*volatile&>(my_thread);

if( ptr )

return *ptr;

__TBB_Yield();

}

}

/** Shortly after when a connection is established, it is possible for the server

rml::job* wait_for_job() const {

if( !my_job ) {

my_job = my_automaton.wait_for_job();

}

return my_job;

}

private:

server_thread* my_thread;

/** Marked mutable because though it is physically modified, conceptually it is a duplicate of

mutable rml::job* my_job;

job_automaton my_automaton;

// FIXME - pad out to cache line, because my_automaton is hit hard by thread()

friend class thread_map;

};

typedef tbb::concurrent_vector<value_type,tbb::zero_allocator<value_type,tbb::cache_aligned_allocator> > array_type;

friend class thread_map;

template<typename Server, typename Client> friend class generic_connection;

friend class tbb_connection_v2;

friend class omp_connection_v2;

//! Integral type that can hold a thread_state_t

typedef int thread_state_rep_t;

tbb::atomic<thread_state_rep_t> state;

thread_monitor monitor;

bool is_omp_thread;

tbb::atomic<thread_state_rep_t> my_extra_state;

server_thread* link;

thread_map_base::array_type::iterator my_map_pos;

rml::server *my_conn;

rml::job* my_job;

job_automaton* my_ja;

size_t my_index;

tbb::atomic<bool> terminate;

omp_dispatch_type omp_dispatch;

#if TBB_USE_ASSERT

//! Flag used to check if thread is still using *this.

bool has_active_thread;

#endif /* TBB_USE_ASSERT */

//! Volunteer to sleep.

void sleep_perhaps( thread_state_t asleep );

//! Destroy job corresponding to given client

/** Return true if thread must quit. */

template<typename Connection>

bool destroy_job( Connection& c );

//! Do terminate the thread

/** Return true if thread must quit. */

bool do_termination();

void loop();

static __RML_DECL_THREAD_ROUTINE thread_routine( void* arg );

server_thread();

~server_thread();

//! Read the thread state

thread_state_t read_state() const {

thread_state_rep_t s = state;

__TBB_ASSERT( unsigned(s)<=unsigned(ts_done), "corrupted server thread?" );

return thread_state_t(s);

}

//! Read the tbb-specific extra thread state

thread_state_t read_extra_state() const {

thread_state_rep_t s = my_extra_state;

return thread_state_t(s);

}

//! Launch a thread that is bound to *this.

void launch( size_t stack_size );

//! Attempt to wakeup a thread

/** The value "to" is the new state for the thread, if it was woken up.

bool wakeup( thread_state_t to, thread_state_t from );

//! Attempt to enslave a thread for OpenMP/TBB.

/** Returns true if state is successfully changed. 's' takes either ts_omp_busy or ts_tbb_busy */

bool try_grab_for( thread_state_t s );

#if _WIN32||_WIN64

//! Send the worker thread to sleep temporarily

void deactivate();

//! Wake the worker thread up

void reactivate();

#endif /* _WIN32||_WIN64 */

struct list_thread: server_thread {

list_thread* next;

};

//! Root of atomic linked list of list_thread

/** ABA problem is avoided because items are only atomically pushed, never popped. */

tbb::atomic<list_thread*> my_root;

tbb::cache_aligned_allocator<padded<list_thread> > my_allocator;

//! Construct empty bag

private_thread_bag() {my_root=NULL;}

//! Create a fresh server_thread object.

server_thread& add_one_thread() {

list_thread* t = my_allocator.allocate(1);

new( t ) list_thread;

// Atomically add to list

list_thread* old_root;

do {

old_root = my_root;

t->next = old_root;

} while( my_root.compare_and_swap( t, old_root )!=old_root );

return *t;

}

//! Destroy the bag and threads in it.

~private_thread_bag() {

while( my_root ) {

// Unlink thread from list.

list_thread* t = my_root;

my_root = t->next;

// Destroy and deallocate the thread.

t->~list_thread();

my_allocator.deallocate(static_cast<padded<list_thread>*>(t),1);

}

}

typedef rml::client::size_type size_type;

//! ctor

thread_map( wait_counter& fc, ::rml::client& client ) :

all_visited_at_least_once(false), my_min_stack_size(0), my_server_ref_count(1),

my_client_ref_count(1), my_client(client), my_factory_counter(fc)

{ my_unrealized_threads = 0; }

//! dtor

~thread_map() {}

typedef array_type::iterator iterator;

iterator begin() {return my_array.begin();}

iterator end() {return my_array.end();}

void bind();

void unbind();

void assist_cleanup( bool assist_null_only );

/** Returns number of unrealized threads to create. */

size_type wakeup_tbb_threads( size_type n );

bool wakeup_next_thread( iterator i, tbb_connection_v2& conn );

void release_tbb_threads( server_thread* t );

void adjust_balance( int delta );

//! Add a server_thread object to the map, but do not bind it.

/** Return NULL if out of unrealized threads. */

value_type* add_one_thread( bool is_omp_thread_ );

void bind_one_thread( rml::server& server, value_type& x );

void remove_client_ref();

int add_server_ref() {return my_server_ref_count.add_ref();}

int remove_server_ref() {return my_server_ref_count.remove_ref();}

::rml::client& client() const {return my_client;}

size_type get_unrealized_threads() { return my_unrealized_threads; }

private_thread_bag my_private_threads;

bool all_visited_at_least_once;

array_type my_array;

size_t my_min_stack_size;

tbb::atomic<size_type> my_unrealized_threads;

//! Number of threads referencing *this, plus one extra.

/** When it becomes zero, the containing server object can be safely deleted. */

ref_count my_server_ref_count;

//! Number of jobs that need cleanup, plus one extra.

/** When it becomes zero, acknowledge_close_connection is called. */

ref_count my_client_ref_count;

::rml::client& my_client;

//! Counter owned by factory that produced this thread_map.

wait_counter& my_factory_counter;

// Add one to account for the thread referencing this map hereforth.

server_thread& t = x.thread();

my_server_ref_count.add_ref();

my_client_ref_count.add_ref();

#if TBB_USE_ASSERT

__TBB_ASSERT( t.add_ref()==1, NULL );

#else

t.add_ref();

#endif

// Have responsibility to start the thread.

t.my_conn = &server;

t.my_ja = &x.my_automaton;

t.launch( my_min_stack_size );

/* Must wake thread up so it can fill in its "my_job" field in *this.

__TBB_ASSERT( t.state!=ts_tbb_busy, NULL );

t.wakeup( ts_idle, ts_asleep );

++my_factory_counter;

my_min_stack_size = my_client.min_stack_size();

__TBB_ASSERT( my_unrealized_threads==0, "already called bind?" );

my_unrealized_threads = my_client.max_job_count();

// Ask each server_thread to cleanup its job for this server.

for( iterator i=begin(); i!=end(); ++i ) {

server_thread& t = i->thread();

t.terminate = true;

t.wakeup( ts_idle, ts_asleep );

}

// Remove extra ref to client.

remove_client_ref();

// To avoid deadlock, the current thread *must* help out with cleanups that have not started,

// because the thread that created the job may be busy for a long time.

for( iterator i = begin(); i!=end(); ++i ) {

rml::job* j=0;

job_automaton& ja = i->my_automaton;

if( assist_null_only ? ja.try_plug_null() : ja.try_plug(j) ) {

if( j ) {

my_client.cleanup(*j);

} else {

// server thread did not get a chance to create a job.

}

remove_client_ref();

}

}

__TBB_ASSERT(n>0,"must specify positive number of threads to wake up");

iterator e = end();

for( iterator k=begin(); k!=e; ++k ) {

// If another thread added *k, there is a tiny timing window where thread() is invalid.

server_thread& t = k->wait_for_thread();

thread_state_t thr_s = t.read_state();

if( t.read_extra_state()==ts_created || thr_s==ts_tbb_busy || thr_s==ts_done )

continue;

if( --the_balance>=0 ) { // try to withdraw a coin from the deposit

while( !t.try_grab_for( ts_tbb_busy ) ) {

thr_s = t.read_state();

if( thr_s==ts_tbb_busy || thr_s==ts_done ) {

// we lost; move on to the next.

++the_balance;

goto skip;

}

}

if( --n==0 )

return 0;

} else {

// overdraft.

++the_balance;

break;

}

skip:

;

}

return n<my_unrealized_threads ? n : size_type(my_unrealized_threads);

friend class omp_connection_v2;

typedef ::std::hash_map<uintptr_t,server_thread*> hash_map_type;

size_t my_min_stack_size;

size_t my_unrealized_threads;

::rml::client& my_client;

//! Counter owned by factory that produced this thread_map.

wait_counter& my_factory_counter;

//! Ref counters

ref_count my_server_ref_count;

ref_count my_client_ref_count;

// FIXME: pad this?

hash_map_type my_map;

bool shutdown_in_progress;

std::vector<IExecutionResource*> original_exec_resources;

tbb::cache_aligned_allocator<padded<tbb_server_thread> > my_tbb_allocator;

tbb::cache_aligned_allocator<padded<omp_server_thread> > my_omp_allocator;

tbb::cache_aligned_allocator<padded<thread_scavenger_thread> > my_scavenger_allocator;

IResourceManager* my_concrt_resource_manager;

IScheduler* my_scheduler;

ISchedulerProxy* my_scheduler_proxy;

tbb::atomic<thread_scavenger_thread*> my_thread_scavenger_thread;

#if TBB_USE_ASSERT

tbb::atomic<int> n_add_vp_requests;

tbb::atomic<int> n_thread_scavengers_created;

#endif

thread_map( wait_counter& fc, ::rml::client& client ) :

my_min_stack_size(0), my_client(client), my_factory_counter(fc),

my_server_ref_count(1), my_client_ref_count(1), shutdown_in_progress(false),

my_concrt_resource_manager(NULL), my_scheduler(NULL), my_scheduler_proxy(NULL)

{

my_thread_scavenger_thread = NULL;

#if TBB_USE_ASSERT

n_add_vp_requests = 0;

n_thread_scavengers_created;

#endif

}

~thread_map() {

__TBB_ASSERT( n_thread_scavengers_created<=1, "too many scavenger thread created" );

// if thread_scavenger_thread is launched, wait for it to complete

if( my_thread_scavenger_thread ) {

__TBB_ASSERT( my_thread_scavenger_thread!=c_claimed, NULL );

while( my_thread_scavenger_thread->read_state()==ts_busy )

__TBB_Yield();

thread_scavenger_thread* tst = my_thread_scavenger_thread;

my_scavenger_allocator.deallocate(static_cast<padded<thread_scavenger_thread>*>(tst),1);

}

// deallocate thread contexts

for( hash_map_type::const_iterator hi=my_map.begin(); hi!=my_map.end(); ++hi ) {

server_thread* thr = hi->second;

if( thr->tbb_thread ) {

while( ((tbb_server_thread*)thr)->activation_count>1 )

__TBB_Yield();

((tbb_server_thread*)thr)->~tbb_server_thread();

my_tbb_allocator.deallocate(static_cast<padded<tbb_server_thread>*>(thr),1);

} else {

((omp_server_thread*)thr)->~omp_server_thread();

my_omp_allocator.deallocate(static_cast<padded<omp_server_thread>*>(thr),1);

}

}

if( my_scheduler_proxy ) {

my_scheduler_proxy->Shutdown();

my_concrt_resource_manager->Release();

__TBB_ASSERT( my_scheduler, NULL );

delete my_scheduler;

} else {

__TBB_ASSERT( !my_scheduler, NULL );

}

}

typedef hash_map_type::key_type key_type;

typedef hash_map_type::value_type value_type;

typedef hash_map_type::iterator iterator;

iterator begin() {return my_map.begin();}

iterator end() {return my_map.end();}

iterator find( key_type k ) {return my_map.find( k );}

iterator insert( key_type k, server_thread* v ) {

std::pair<iterator,bool> res = my_map.insert( value_type(k,v) );

return res.first;

}

void bind( IScheduler* s ) {

++my_factory_counter;

if( s ) {

my_unrealized_threads = s->GetPolicy().GetPolicyValue( MaxConcurrency );

__TBB_ASSERT( my_unrealized_threads>0, NULL );

my_scheduler = s;

my_concrt_resource_manager = CreateResourceManager(); // reference count==3 when first created.

my_scheduler_proxy = my_concrt_resource_manager->RegisterScheduler( s, CONCRT_RM_VERSION_1 );

my_scheduler_proxy->RequestInitialVirtualProcessors( false );

}

}

bool is_closing() { return shutdown_in_progress; }

void unbind( rml::server& server, ::tbb::spin_mutex& mtx );

void add_client_ref() { my_server_ref_count.add_ref(); }

void remove_client_ref();

void add_server_ref() {my_server_ref_count.add_ref();}

int remove_server_ref() {return my_server_ref_count.remove_ref();}

int get_server_ref_count() { int k = my_server_ref_count.my_ref_count; return k; }

void assist_cleanup( bool assist_null_only );

void adjust_balance( int delta );

int current_balance() const {int k = the_balance; return k;}

::rml::client& client() const {return my_client;}

void register_as_master( server::execution_resource_t& v ) const { (IExecutionResource*&)v = my_scheduler_proxy ? my_scheduler_proxy->SubscribeCurrentThread() : NULL; }

// Remove() should be called from the same thread that subscribed the current h/w thread (i.e., the one that

// called register_as_master() ).

void unregister( server::execution_resource_t v ) const {if( v ) ((IExecutionResource*)v)->Remove( my_scheduler );}

void add_virtual_processors( IVirtualProcessorRoot** vprocs, unsigned int count, tbb_connection_v2& conn, ::tbb::spin_mutex& mtx );

void add_virtual_processors( IVirtualProcessorRoot** vprocs, unsigned int count, omp_connection_v2& conn, ::tbb::spin_mutex& mtx );

void remove_virtual_processors( IVirtualProcessorRoot** vproots, unsigned count, ::tbb::spin_mutex& mtx );

void mark_virtual_processors_as_lent( IVirtualProcessorRoot** vproots, unsigned count, ::tbb::spin_mutex& mtx );

void create_oversubscribers( unsigned n, std::vector<server_thread*>& thr_vec, omp_connection_v2& conn, ::tbb::spin_mutex& mtx );

void wakeup_tbb_threads( int c, ::tbb::spin_mutex& mtx );

void mark_virtual_processors_as_returned( IVirtualProcessorRoot** vprocs, unsigned int count, tbb::spin_mutex& mtx );

inline void addto_original_exec_resources( IExecutionResource* r, ::tbb::spin_mutex& mtx ) {

::tbb::spin_mutex::scoped_lock lck(mtx);

__TBB_ASSERT( !is_closing(), "trying to register master while connection is being shutdown?" );

original_exec_resources.push_back( r );

}

#if !__RML_REMOVE_VIRTUAL_PROCESSORS_DISABLED

void allocate_thread_scavenger( IExecutionResource* v );

#endif

inline thread_scavenger_thread* get_thread_scavenger() { return my_thread_scavenger_thread; }