pegasus/src/Pegasus/Common/Thread.h - diff

Return to Thread.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/Thread.h between version 1.1.2.5 and 1.5

version 1.1.2.5, 2001/07/31 12:54:35

version 1.5, 2001/12/25 08:26:09

Line 1

//%/////////////////////////////////////////////////////////////////////////////

//%///////////-*-c++-*-//////////////////////////////////////////////////////

Line 29

#ifndef Pegasus_Thread_h

#define Pegasus_Thread_h

#include <Pegasus/Common/IPC.h>

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/IPC.h>

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/DQueue.h>

// REVIEW: Spend time getting to know this.

PEGASUS_NAMESPACE_BEGIN

class PEGASUS_EXPORT cleanup_handler

class PEGASUS_COMMON_LINKAGE cleanup_handler

{

public:

cleanup_handler( void (*routine)(void *), void *arg ) : _routine(routine), _arg(arg) {}

~cleanup_handler() {; }

inline Boolean operator==(const void *key) const

{

if(key == (void *)_routine)

return true;

return false;

}

inline Boolean operator ==(const cleanup_handler & b) const

{

return(operator==((const void *)b._routine));

}

private:

void execute(void) { _routine(_arg); }

cleanup_handler();

void (*_routine)(void *);

inline Boolean operator==(void *key) { if(key == (void *)_routine) return true; return false; }

void *_arg;

PEGASUS_CLEANUP_HANDLE _cleanup_buffer;

template<class cleanup_handler> friend class DQueue;

friend class DQueue<class cleanup_handler>;

friend class Thread;

};

///////////////////////////////////////////////////////////////////////////////

class PEGASUS_EXPORT SimpleThread

class PEGASUS_COMMON_LINKAGE thread_data

{

public:

SimpleThread( PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *start )(void *),

static void default_delete(void *data);

void *parameter, Boolean detached );

~SimpleThread();

void run(void);

Uint32 threadId(void);

// get the user parameter

void *get_parm(void);

// cancellation must be deferred (not asynchronous)

// for user-level threads the thread itself can decide

// when it should die.

void cancel(void);

void kill(int signum);

// cancel if there is a pending cancellation request

void test_cancel(void);

// for user-level threads - put the calling thread

// to sleep and jump to the thread scheduler.

// platforms with preemptive scheduling and native threads

// can define this to be a no-op.

// platforms without preemptive scheduling like NetWare

// or gnu portable threads will have an existing

// routine that can be mapped to this method

void thread_switch(void);

// suspend this thread

void suspend(void) ;

// resume this thread

void resume(void) ;

void sleep(Uint32 msec) ;

// block the calling thread until this thread terminates

void join( PEGASUS_THREAD_RETURN *ret_val);

// stack of functions to be called when thread terminates

thread_data( Sint8 *key ) : _delete_func(NULL) , _data(NULL), _size(0)

// will be called last in first out (LIFO)

{

void cleanup_push( void (*routine) (void *), void *parm );

PEGASUS_ASSERT(key != NULL);

void cleanup_pop(Boolean execute) ;

size_t keysize = strlen(key);

_key = new Sint8 [keysize + 1];

memcpy(_key, key, keysize);

_key[keysize] = 0x00;

PEGASUS_THREAD_TYPE self(void) ;

}

private:

thread_data(Sint8 *key, size_t size) : _delete_func(default_delete), _size(size)

SimpleThread();

{

PEGASUS_ASSERT(key != NULL);

size_t keysize = strlen(key);

_key = new Sint8 [keysize + 1];

memcpy(_key, key, keysize);

_key[keysize] = 0x00;

_data = ::operator new(_size) ;

PEGASUS_THREAD_HANDLE _handle;

}

Boolean _is_detached;

Boolean _cancel_enabled;

Boolean _cancelled;

//PEGASUS_SEM_HANDLE _suspend_count;

thread_data(Sint8 *key, size_t size, void *data) : _delete_func(default_delete), _size(size)

Semaphore _suspend;

{

PEGASUS_ASSERT(key != NULL);

PEGASUS_ASSERT(data != NULL);

size_t keysize = strlen(key);

// always pass this * as the void * parameter to the thread

_key = new Sint8[keysize + 1];

// store the user parameter in _thread_parm

memcpy(_key, key, keysize);

_key[keysize] = 0x00;

_data = ::operator new(_size);

memcpy(_data, data, size);

}

PEGASUS_THREAD_RETURN ( PEGASUS_THREAD_CDECL *_start)(void *) ;

~thread_data()

{

if( _data != NULL)

if(_delete_func != NULL)

_delete_func( _data );

if( _key != NULL )

delete [] _key;

}

void *_thread_parm;

void put_data(void (*del)(void *), size_t size, void *data ) throw(NullPointer)

} ;

{

if(_data != NULL)

if(_delete_func != NULL)

_delete_func(_data);

///////////////////////////////////////////////////////////////////////////////

_delete_func = del;

_data = data;

_size = size;

return ;

}

static void default_delete(void * data) { delete [] (char *) data; }

size_t get_size(void) { return _size; }

class PEGASUS_EXPORT thread_data

void get_data(void **data, size_t *size)

{

if(data == NULL || size == NULL)

throw NullPointer();

*data = _data;

*size = _size;

return;

public:

thread_data( Sint8 *key ) : _delete_func(NULL) , _data(NULL), _size(0)

{

PEGASUS_ASSERT(key != NULL);

_key = strdup(key) ;

}

thread_data(Sint8 *key, int size)

void copy_data(void **buf, size_t *size) throw(BufferTooSmall, NullPointer)

{

PEGASUS_ASSERT(key != NULL);

if((buf == NULL) || (size == NULL))

_delete_func = default_delete;

throw NullPointer() ;

_data = new char [size];

*buf = ::operator new(_size);

_size = size;

*size = _size;

memcpy(*buf, _data, _size);

return;

}

thread_data(Sint8 *key, int size, void *data)

inline Boolean operator==(const void *key) const

{

PEGASUS_ASSERT(key != NULL);

if ( ! strcmp(_key, (Sint8 *)key))

PEGASUS_ASSERT(data != NULL);

return(true);

_delete_func = default_delete;

return(false);

_data = new char [size];

memcpy(_data, data, size);

_size = size;

}

inline Boolean operator==(const thread_data& b) const

~thread_data() { if( _data != NULL) _delete_func( _data ); }

void *get_data(void );

Uint32 get_size(void);

void *put_data(void (*delete_func) (void *), Uint32 size, void *data )

{

void *old_data = data;

return(operator==((const void *)b._key));

_delete_func = delete_func;

_data = data;

_size = size;

return(old_data);

}

private:

inline Boolean operator ==(void *key) { if ( ! strcmp(_key, (Sint8 *)key)) return(true); return(false); }

void (*_delete_func) (void *data) ;

thread_data();

void *_data;

Uint32 _size;

size_t _size;

Sint8 *_key;

template<class thread_data> friend class DQueue;

friend class DQueue<thread_data>;

friend class Thread;

};

///////////////////////////////////////////////////////////////////////////

class PEGASUS_EXPORT Thread

class PEGASUS_COMMON_LINKAGE ThreadPool;

class PEGASUS_COMMON_LINKAGE Thread

{

public:

Line 216

Line 204

// cancel if there is a pending cancellation request

void test_cancel(void);

Boolean is_cancelled(void);

// for user-level threads - put the calling thread

// to sleep and jump to the thread scheduler.

// platforms with preemptive scheduling and native threads

Line 226

Line 216

void thread_switch(void);

#ifdef PEGASUS_PLATFORM_LINUX_IX86_GNU

// suspend this thread

// void suspend(void) ;

void suspend(void) ;

// resume this thread

// void resume(void) ;

void resume(void) ;

#endif

void sleep(Uint32 msec) ;

static void sleep(Uint32 msec) ;

// block the calling thread until this thread terminates

void join(void );

Line 252

Line 244

{

thread_data *tsd = new thread_data(key, size, buffer);

try { _tsd.insert_first(tsd); }

catch(IPCException& e) { delete tsd; throw; }

catch(IPCException& e) { e = e; delete tsd; throw; }

}

// get the buffer associated with the key

Line 267

Line 259

return(NULL);

}

inline void *try_reference_tsd(Sint8 *key) throw(IPCException)

{

_tsd.try_lock();

thread_data *tsd = _tsd.reference((void *)key);

if(tsd != NULL)

return((void *)(tsd->_data) );

else

return(NULL);

}

// release the lock held on the tsd

// NOTE: assumes a corresponding and prior call to reference_tsd() !!!

inline void dereference_tsd(void) throw(IPCException)

Line 282

Line 285

delete tsd;

}

inline void *remove_tsd(Sint8 *key) throw(IPCException)

{

return(_tsd.remove((void *)key));

}

inline void empty_tsd(void) throw(IPCException)

{

_tsd.empty_list();

}

// create or re-initialize tsd associated with the key

// if the tsd already exists, return the existing buffer

thread_data *put_tsd(Sint8 *key, void (*delete_func)(void *), Uint32 size, void *value) throw(IPCException)

thread_data *put_tsd(Sint8 *key, void (*delete_func)(void *), Uint32 size, void *value)

throw(IPCException)

{

PEGASUS_ASSERT(key != NULL);

PEGASUS_ASSERT(delete_func != NULL);

thread_data *tsd ;

tsd = _tsd.remove((void *)key); // may throw an IPC exception

thread_data *ntsd = new thread_data(key);

ntsd->put_data(delete_func, size, value);

try { _tsd.insert_first(ntsd); }

catch(IPCException& e) { delete ntsd; throw; }

catch(IPCException& e) { e = e; delete ntsd; throw; }

return(tsd);

}

inline PEGASUS_THREAD_RETURN get_exit(void) { return _exit_code; }

inline PEGASUS_THREAD_TYPE self(void) {return pegasus_thread_self(); }

PEGASUS_THREAD_HANDLE getThreadHandle() {return _handle;}

inline Boolean operator==(const void *key) const

{

if ( (void *)this == key)

return(true);

return(false);

}

inline Boolean operator==(const Thread & b) const

{

return(operator==((const void *)&b ));

}

void detach(void);

private:

Thread();

inline void create_tsd(Sint8 *key ) throw(IPCException)

{

thread_data *tsd = new thread_data(key);

try { _tsd.insert_first(tsd); }

catch(IPCException& e) { delete tsd; throw; }

catch(IPCException& e) { e = e; delete tsd; throw; }

}

PEGASUS_THREAD_HANDLE _handle;

Boolean _is_detached;

Line 319

Line 347

// store the user parameter in _thread_parm

PEGASUS_THREAD_RETURN ( PEGASUS_THREAD_CDECL *_start)(void *) ;

DQueue<cleanup_handler> _cleanup;

DQueue<class cleanup_handler> _cleanup;

DQueue<thread_data> _tsd;

DQueue<class thread_data> _tsd;

void *_thread_parm;

PEGASUS_THREAD_RETURN _exit_code;

static Boolean _signals_blocked;

friend class ThreadPool;

} ;

#if 0

class PEGASUS_COMMON_LINKAGE ThreadPool

class PEGASUS_EXPORT Aggregator {

{

public:

Aggregator();

ThreadPool(Sint16 initial_size,

~Aggregator();

Sint8 *key,

Sint16 min,

Sint16 max,

struct timeval & alloc_wait,

struct timeval & dealloc_wait,

struct timeval & deadlock_detect);

~ThreadPool(void);

void allocate_and_awaken(void *parm,

PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *work)(void *))

throw(IPCException);

void kill_dead_threads( void )

throw(IPCException);

void get_key(Sint8 *buf, int bufsize);

inline Boolean operator==(const void *key) const

{

if ( ! strncmp( reinterpret_cast<Sint8 *>(const_cast<void *>(key)), _key, 16 ))

return(true);

return(false);

}

inline Boolean operator==(const ThreadPool & b) const

{

return(operator==((const void *) b._key ));

}

void started(void);

inline void set_min_threads(Sint16 min)

void completed(void);

{

void remaining(int operations);

_min_threads = min;

void put_result(CIMReference *ref);

}

inline Sint16 get_min_threads(void) const

{

return _min_threads;

}

inline void set_max_threads(Sint16 max)

{

_max_threads = max;

}

inline Sint16 get_max_threads(void) const

{

return _max_threads;

}

inline void set_allocate_wait(const struct timeval & alloc_wait)

{

_allocate_wait.tv_sec = alloc_wait.tv_sec;

_allocate_wait.tv_usec = alloc_wait.tv_usec;

}

inline struct timeval *get_allocate_wait(struct timeval *buffer) const

{

if(buffer == 0)

throw NullPointer();

buffer->tv_sec = _allocate_wait.tv_sec;

buffer->tv_usec = _allocate_wait.tv_usec;

return buffer;

}

inline void set_deallocate_wait(const struct timeval & dealloc_wait)

{

_deallocate_wait.tv_sec = dealloc_wait.tv_sec;

_deallocate_wait.tv_usec = dealloc_wait.tv_usec;

}

inline struct timeval *get_deallocate_wait(struct timeval *buffer) const

{

if(buffer == 0)

throw NullPointer();

buffer->tv_sec = _deallocate_wait.tv_sec;

buffer->tv_usec = _deallocate_wait.tv_usec;

return buffer;

}

inline void set_deadlock_detect(const struct timeval & deadlock)

{

_deadlock_detect.tv_sec = deadlock.tv_sec;

_deadlock_detect.tv_usec = deadlock.tv_usec;

}

inline struct timeval * get_deadlock_detect(struct timeval *buffer) const

{

if(buffer == 0)

throw NullPointer();

buffer->tv_sec = _deadlock_detect.tv_sec;

buffer->tv_usec = _deadlock_detect.tv_usec;

return buffer;

}

inline Uint32 running_count(void)

{

return _running.count();

}

static Boolean check_time(struct timeval *start, struct timeval *interval);

private:

int _reference_count;

ThreadPool(void);

Sint16 _max_threads;

Sint16 _min_threads;

AtomicInt _current_threads;

struct timeval _allocate_wait;

struct timeval _deallocate_wait;

struct timeval _deadlock_detect;

static PEGASUS_THREAD_RETURN PEGASUS_THREAD_CDECL _loop(void *);

Semaphore _waiters;

Sint8 _key[17];

Semaphore _pool_sem;

DQueue<Thread> _pool;

DQueue<Thread> _running;

DQueue<Thread> _dead;

AtomicInt _dying;

static void _sleep_sem_del(void *p);

void _check_deadlock(struct timeval *start) throw(Deadlock);

Boolean _check_deadlock_no_throw(struct timeval *start);

Boolean _check_dealloc(struct timeval *start);

Thread *_init_thread(void) throw(IPCException);

void _link_pool(Thread *th) throw(IPCException);

static PEGASUS_THREAD_RETURN _undertaker(void *);

// keep track of the thread running this operation so we can kill

// it if necessary

Thread _owner;

// this is a phased aggregate. when it is complete is will

// be streamed to the client regardless of the state of

// siblings

Boolean _is_phased;

int _total_values;

int _completed_values;

int _total_child_values;

int _completed_child_values;

int _completion_state;

struct timeval _last_update;

time_t lifetime;

Aggregator *_parent;

// children may be phased or not phased

DQueue _children;

// empty results that are filled by provider

DQueue _results;

// array of predicates for events and

// stored queries (cursors)

Array _filter;

} ;

inline void ThreadPool::_sleep_sem_del(void *p)

{

if(p != 0)

{

delete (Semaphore *)p;

}

inline void ThreadPool::_check_deadlock(struct timeval *start) throw(Deadlock)

{

if (true == check_time(start, &_deadlock_detect))

throw Deadlock(pegasus_thread_self());

return;

}

inline Boolean ThreadPool::_check_deadlock_no_throw(struct timeval *start)

{

return(check_time(start, &_deadlock_detect));

}

inline Boolean ThreadPool::_check_dealloc(struct timeval *start)

{

return(check_time(start, &_deallocate_wait));

}

inline Thread *ThreadPool::_init_thread(void) throw(IPCException)

{

Thread *th = (Thread *) new Thread(&_loop, this, false);

// allocate a sleep semaphore and pass it in the thread context

// initial count is zero, loop function will sleep until

// we signal the semaphore

Semaphore *sleep_sem = (Semaphore *) new Semaphore(0);

th->put_tsd("sleep sem", &_sleep_sem_del, sizeof(Semaphore), (void *)sleep_sem);

struct timeval *dldt = (struct timeval *) ::operator new(sizeof(struct timeval));

th->put_tsd("deadlock timer", thread_data::default_delete, sizeof(struct timeval), (void *)dldt);

// thread will enter _loop(void *) and sleep on sleep_sem until we signal it

th->run();

_current_threads++;

return th;

}

inline void ThreadPool::_link_pool(Thread *th) throw(IPCException)

{

if(th == 0)

throw NullPointer();

_pool.insert_first(th);

_pool_sem.signal();

}

#if defined(PEGASUS_OS_TYPE_WINDOWS)

# include "ThreadWindows_inline.h"

#elif defined(PEGASUS_OS_TYPE_UNIX)

# include "ThreadUnix_inline.h"

#endif

PEGASUS_NAMESPACE_END

Legend:

Removed from v.1.1.2.5
changed lines
	Added in v.1.5

No CVS admin address has been configured