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.11 and 1.36

version 1.11, 2002/03/31 00:37:56

version 1.36, 2003/10/30 00:22:39

Line 1

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

//%2003////////////////////////////////////////////////////////////////////////

// Company, L. P., IBM Corp., The Open Group, Tivoli Systems.

// IBM Corp.; EMC Corporation, The Open Group.

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

Line 23

Line 26

// Author: Mike Day (mdday@us.ibm.com)

// Modified By: Markus Mueller

// Roger Kumpf, Hewlett-Packard Company (roger_kumpf@hp.com)

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

#ifndef Pegasus_Thread_h

#define Pegasus_Thread_h

#include <cstring>

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/IPC.h>

#include <Pegasus/Common/Exception.h>

#include <Pegasus/Common/InternalException.h>

#include <Pegasus/Common/DQueue.h>

#include <Pegasus/Common/AcceptLanguages.h> // l10n

// REVIEW: Spend time getting to know this.

#include <Pegasus/Common/Linkage.h>

PEGASUS_NAMESPACE_BEGIN

PEGASUS_USING_STD;

class PEGASUS_COMMON_LINKAGE cleanup_handler

{

Line 145

Line 149

}

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

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

{

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

throw NullPointer() ;

Line 192

Line 196

~Thread();

void run(void);

/**

Start the thread.

@return true if the thread is started successfully, false if the

resources necessary to start the thread are not currently

available. ATTN: The result is undefined for any other

type of failure. (See Bugzilla 972)

Boolean run(void);

// get the user parameter

inline void *get_parm(void) { return _thread_parm; }

Line 220

Line 231

void thread_switch(void);

#if defined(PEGASUS_PLATFORM_LINUX_IX86_GNU) || defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)

#if defined(PEGASUS_PLATFORM_LINUX_GENERIC_GNU)

// suspend this thread

void suspend(void) ;

Line 289

Line 300

delete tsd;

}

// Note: Caller must delete the thread_data object returned (if not null)

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

{

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

Line 296

Line 308

inline void empty_tsd(void) throw(IPCException)

{

_tsd.empty_list();

try

{

_tsd.try_lock();

}

catch(IPCException&)

{

return;

}

thread_data* tsd = _tsd.next(0);

while(tsd)

{

_tsd.remove_no_lock(tsd);

delete tsd;

tsd = _tsd.next(0);

}

_tsd.unlock();

}

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

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

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

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

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

throw(IPCException)

{

PEGASUS_ASSERT(key != NULL);

thread_data *tsd ;

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

delete tsd;

thread_data *ntsd = new thread_data(key);

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

try { _tsd.insert_first(ntsd); }

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(); }

Line 332

Line 362

void detach(void);

// Gets the Thread object associated with the caller's thread.

// Note: this may return NULL if no Thread object is associated

// with the caller's thread.

static Thread * getCurrent(); // l10n

// Sets the Thread object associated with the caller's thread.

// Note: the Thread object must be placed on the heap.

static void setCurrent(Thread * thrd); // l10n

// Gets the AcceptLanguages object associated with the caller's

// Thread.

// Note: this may return NULL if no Thread object, or no

// AcceptLanguages object, is associated with the caller's thread.

static AcceptLanguages * getLanguages(); //l10n

// Sets the AcceptLanguages object associated with the caller's

// Thread.

// Note: a Thread object must have been previously associated with

// the caller's thread.

// Note: the AcceptLanguages object must be placed on the heap.

static void setLanguages(AcceptLanguages *langs); //l10n

// Removes the AcceptLanguages object associated with the caller's

// Thread.

static void clearLanguages(); //l10n

private:

Thread();

static Sint8 initializeKey(); // l10n

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

{

thread_data *tsd = new thread_data(key);

Line 357

Line 426

void *_thread_parm;

PEGASUS_THREAD_RETURN _exit_code;

static Boolean _signals_blocked;

static PEGASUS_THREAD_KEY_TYPE _platform_thread_key; //l10n

static Boolean _key_initialized; // l10n

static Boolean _key_error; // l10n

friend class ThreadPool;

} ;

Line 375

Line 447

~ThreadPool(void);

void allocate_and_awaken(void *parm,

/**

Allocate and start a thread to do a unit of work.

@param parm A generic parameter to pass to the thread

@param work A pointer to the function that is to be executed by

the thread

@param blocking A pointer to an optional semaphore which, if

specified, is signaled after the thread finishes

executing the work function

@return true if the thread is started successfully, false if the

resources necessary to start the thread are not currently

available. ATTN: The result is undefined for any other

type of thread creation failure.

Boolean allocate_and_awaken(void *parm,

PEGASUS_THREAD_RETURN (PEGASUS_THREAD_CDECL *work)(void *),

Semaphore *blocking = 0)

throw(IPCException);

Line 467

Line 552

return _running.count();

}

inline Uint32 pool_count(void)

{

return _pool.count();

}

inline Uint32 dead_count(void)

{

return _dead.count();

}

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

Boolean operator ==(const ThreadPool & p)

{

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

}

Boolean operator ==(const void *p)

{

if((void *)this == p)

return true;

return false;

}

static void kill_idle_threads(void);

private:

ThreadPool(void);

Sint16 _max_threads;

Line 484

Line 593

DQueue<Thread> _dead;

AtomicInt _dying;

static void _sleep_sem_del(void *p);

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

Line 493

Line 601

Thread *_init_thread(void) throw(IPCException);

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

static PEGASUS_THREAD_RETURN _undertaker(void *);

static DQueue<ThreadPool> _pools;

};

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++;

pegasus_yield();

return th;

}

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

{

if(th == 0)

throw NullPointer();

_pool.insert_first(th);

}

#if defined(PEGASUS_OS_TYPE_WINDOWS)

Legend:

Removed from v.1.11
changed lines
	Added in v.1.36

No CVS admin address has been configured