detail/lightweight_mutex.hpp

From: Tom Matelich (tmatelich_at_[hidden])
Date: 2002-08-15 14:53:26

I'm attempting to go to Boost 1.28 on our HPUX 10.20 boxes.  I've run into a
problem with an assumption about the type of pthread_mutexattr_t.
detail\lwm_pthreads.hpp calls:

        pthread_mutex_init(&m_, 0);

HP's pthread.h (10.20 uses DCE) has that defined as:

int pthread_mutex_init  (pthread_mutex_t *,pthread_mutexattr_t);

after tracing the typedef's down to <dce/cma.h>, I found pthread_mutexattr_t
is this:

typedef struct CMA_T_HANDLE {
    cma_t_address	field1;
    short int		field2;
    short int		field3;
    } cma_t_handle;

where cma_t_address is a void*.

The error message is:
.../boost/detail/lwm_pthreads.hpp: In method
`boost::detail::lightweight_mutex::lightweight_mutex()':
.../boost/detail/lwm_pthreads.hpp:40: conversion from `int' to non-scalar
type `CMA_T_HANDLE' requested

I'm not sure what solution to use here.  Ifdefs are troublesome because it
is hard to distinguish between HP 10.x and 11.x, which use different
threading models.  I don't know a lot about threads on HP, we use ACE so
that we don't have to.  One thing I do remember is that they conform to a
fairly old revision of POSIX.

I think attachments are prohibited on this list, so I will append pthread.h
and dce/cma.h below.

Thanks for your help,

Tom

<"pthread.h">
/*
 * (c) Copyright 1990, 1991, 1992, 1993 OPEN SOFTWARE FOUNDATION, INC. 
 * ALL RIGHTS RESERVED 
 * COPYRIGHT NOTICE
 * Copyright (c) 1990, 1991, 1992, 1993, 1994 Open Software Foundation, Inc.
 * ALL RIGHTS RESERVED (DCE).  See the file named COPYRIGHT.DCE for
 * the full copyright text.
 */
/*
 * @(#)HP DCE/9000 1.5 
 * @(#)Module: pthread.h $Revision: /main/HPDCE02/5 $ $Date: 1995/07/11
17:25 UTC $
 */
/*
 */
/*
 *      %W%     (DEC OSF/1)    %G%
 */
/*
 *  Copyright (c) 1990, 1992 by
 *  Digital Equipment Corporation, Maynard Massachusetts.
 *  All rights reserved.
 *
 *  This software is furnished under a license and may be used and  copied
 *  only  in  accordance  with  the  terms  of  such  license and with the
 *  inclusion of the above copyright notice.  This software or  any  other
 *  copies  thereof may not be provided or otherwise made available to any
 *  other person.  No title to and ownership of  the  software  is  hereby
 *  transferred.
 *
 *  The information in this software is subject to change  without  notice
 *  and  should  not  be  construed  as  a commitment by DIGITAL Equipment
 *  Corporation.
 *
 *  DIGITAL assumes no responsibility for the use or  reliability  of  its
 *  software on equipment which is not supplied by DIGITAL.
 */

/*
 *  FACILITY:
 *
 *	Common Multithread Architecture (CMA) services; POSIX 1003.4
interface
 *
 *  ABSTRACT:
 *
 *	External definitions for CMA's pthreads services
 *
 *  AUTHORS:
 *
 *	Dave Butenhof
 *
 *  CREATION DATE:
 * 
 *	20 February 1990
 *
 *  MODIFIED BY:
 *
 *	Dave Butenhof
 *	Paul Curtin
 *	Webb Scales
 */

#ifndef PTHREAD
#define PTHREAD

#if !defined(__STDC__) && defined(_CMA_HP_INT_NONANSI)
# include <dce/pthread_int.h>
#else
#ifdef vms
# include <cma.h>
#else# include <dce/cma.h>
# include <signal.h>
#endif
#ifdef __cplusplus
extern "C" {
#endif
/*
 * The implementation makes these basic decisions
 */

#ifndef _POSIX_THREADS
# define _POSIX_THREADS
#endif#ifndef _POSIX_THREAD_ATTR_STACKSIZE
# define _POSIX_THREAD_ATTR_STACKSIZE
#endif#if _CMA_KTHREADS_ != _CMA__MACH
# define _POSIX_THREADS_REALTIME_SCHEDULING	1
#else#if defined (_POSIX_THREADS_REALTIME_SCHEDULING)
# undef _POSIX_THREADS_REALTIME_SCHEDULING
#endif#endif#ifndef _POSIX_THREADS_PER_PROCESS_SIGNALS_1
# define _POSIX_THREADS_PER_PROCESS_SIGNALS_1	1
#endif
/*
 * Implement push and pop for cancellation handlers, using TRY and ENDTRY
 */

#define pthread_cleanup_push(routine,arg)	\
    { \
    pthread_cleanup_t _XXX_proc = (pthread_cleanup_t)(routine); \
    pthread_addr_t _XXX_arg = (arg); \
    int _XXX_completed = 0; \
    TRY {

#define pthread_cleanup_pop(execute)	\
    _XXX_completed = 1;} \
    FINALLY { \
        int _XXX_execute = execute; \
        if ((! _XXX_completed) || (_XXX_execute)) _XXX_proc (_XXX_arg);} \
    ENDTRY}

#define pthread_equal_np(thread1,thread2) \
    (((thread1).field1 == (thread2).field1) \
    && ((thread1).field2 == (thread2).field2) \
    && ((thread1).field3 == (thread2).field3))

#define pthread_equal(thread1,thread2) \
    (((thread1).field1 == (thread2).field1) \
    && ((thread1).field2 == (thread2).field2) \
    && ((thread1).field3 == (thread2).field3))

#define pthread_getunique_np(handle) \
    ((unsigned int)((pthread_t *)handle)->field2)

/*
 * Sample decisions for the environment types
 */

typedef	cma_t_key		pthread_key_t;

typedef cma_t_address		pthread_addr_t;

/*
 * For compatibility with OSF/1 pthreads
 */
typedef pthread_addr_t		any_t;
typedef void (*pthread_cleanup_t)  (pthread_addr_t);

/*
 * Sample decision for a one-time initialization control block and its
 * initialization macro.
 *
 * Declare a one time initialization control block as:
 *
 *	static pthread_once_t	block = pthread_once_init;
 */
typedef cma_t_once	pthread_once_t;

#define pthread_once_init	cma_once_init

#define CANCEL_ON	1
#define CANCEL_OFF	0

/*
 * The following are the portable pthread definitions
 */

/*
 * Operations on Handles
 */

/*
 * Operations on attributes objects
 */

typedef cma_t_attr	pthread_attr_t;

/*
 * An attributes object is created to specify the attributes of other CMA
 * objects that will be created.
 */

int pthread_attr_create  (pthread_attr_t *);

/*
 * An attributes object can be deleted when it is no longer needed.
 */

int pthread_attr_delete  (pthread_attr_t *);

/*
 * Operations on threads
 */

typedef cma_t_thread		pthread_t;
typedef cma_t_start_routine	pthread_startroutine_t;
/*
 * For compatibility with OSF/1 pthreads
 */
typedef pthread_startroutine_t	pthread_func_t;

#define PTHREAD_INHERIT_SCHED	((int)cma_c_sched_inherit)
#define PTHREAD_DEFAULT_SCHED	((int)cma_c_sched_use_default)

#define SCHED_FIFO		((int)cma_c_sched_fifo)
#define SCHED_RR		((int)cma_c_sched_rr)
#define SCHED_FG_NP		((int)cma_c_sched_throughput)
#define SCHED_BG_NP		((int)cma_c_sched_background)

/* For compatibility with namespace collision due to POSIX.4 includes */
#ifndef _SYS_SCHED_INCLUDED
# define SCHED_OTHER		((int)cma_c_sched_throughput)
#endif
#define PRI_FIFO_MIN		((int)cma_c_prio_fifo_min)
#define PRI_FIFO_MAX		((int)cma_c_prio_fifo_max)
#define PRI_RR_MIN		((int)cma_c_prio_rr_min)
#define PRI_RR_MAX		((int)cma_c_prio_rr_max)
#define PRI_FG_MIN_NP		((int)cma_c_prio_through_min)
#define PRI_FG_MAX_NP		((int)cma_c_prio_through_max)
#define PRI_BG_MIN_NP		((int)cma_c_prio_back_min)
#define PRI_BG_MAX_NP		((int)cma_c_prio_back_max)
#define PRI_OTHER_MIN		((int)cma_c_prio_through_min)
#define PRI_OTHER_MAX		((int)cma_c_prio_through_max)

/*
 * Operations to define thread creation attributes
 */

/*
 * Set or obtain the default thread priority.
 */
int pthread_attr_setprio  (pthread_attr_t *,int);

int pthread_attr_getprio  (pthread_attr_t);

/*
 * Set or obtain the default scheduling algorithm
 */
int pthread_attr_setsched  (pthread_attr_t	*,int);

int pthread_attr_getsched  (pthread_attr_t);

/*
 * Set or obtain whether a thread will use the default scheduling
attributes,
 * or inherit them from the creating thread.
 */
int pthread_attr_setinheritsched  (pthread_attr_t *,int);

int pthread_attr_getinheritsched  (pthread_attr_t);

/*
 * Set or obtain the default stack size
 */
int pthread_attr_setstacksize  (pthread_attr_t *,long);

long pthread_attr_getstacksize  (pthread_attr_t);

/*
 * Set or obtain the default guard size
 */
int pthread_attr_setguardsize_np  (pthread_attr_t *,long);

long pthread_attr_getguardsize_np  (pthread_attr_t);

/*
 * The following procedures can be used to control thread creation,
 * termination and deletion.
 */

/*
 * To create a thread object and runnable thread, a routine must be
specified
 * as the new thread's start routine.  An argument may be passed to this
 * routine, as an untyped address; an untyped address may also be returned
as
 * the routine's value.  An attributes object may be used to specify details
 * about the kind of thread being created.
 */
int pthread_create  (pthread_t
*,pthread_attr_t,pthread_startroutine_t,pthread_addr_t);

/*
 * A thread object may be "detached" to specify that the return value and
 * completion status will not be requested.
 */
int pthread_detach  (pthread_t *);

/* 
 * A thread may terminate it's own execution.
 */
void pthread_exit  (pthread_addr_t);

/* 
 * A thread can await termination of another thread and retrieve the return
 * value of the thread.
 */
int pthread_join  (pthread_t,pthread_addr_t *);

/*
 * Thread Scheduling Operations
 */

/*
 * The current user_assigned priority of a thread can be changed.
 */
int pthread_setprio  (pthread_t,int);

/*
 * The current user_assigned scheduler algorithm of a thread can be changed.
 */
int pthread_setscheduler  (pthread_t,int,int);

/*
 * A thread may tell the scheduler that its processor can be made available.
 */
void pthread_yield  (void);

/*
 * Thread Information Operations
 */

/*
 * A thread may obtain a copy of its own thread handle.
 */
pthread_t pthread_self  (void);

/*
 * The current user_assigned priority of a thread can be read.
 */
int pthread_getprio  (pthread_t);

/*
 * The current user_assigned scheduler algorithm of a thread can be read.
 */
int pthread_getscheduler  (	pthread_t);

/*
 * Operations on Mutexes
 */

#define MUTEX_FAST_NP		0
#define MUTEX_RECURSIVE_NP	1
#define MUTEX_NONRECURSIVE_NP	2

typedef cma_t_attr	pthread_mutexattr_t;
typedef	cma_t_mutex	pthread_mutex_t;

int pthread_mutexattr_create  (pthread_mutexattr_t *);

int pthread_mutexattr_delete  (pthread_mutexattr_t *);

int pthread_mutexattr_setkind_np  (pthread_mutexattr_t *,int);

int pthread_mutexattr_getkind_np  (pthread_mutexattr_t);

/* 
 * The following routines create, delete, lock and unlock mutexes.
 */
int pthread_mutex_init  (pthread_mutex_t *,pthread_mutexattr_t);

int pthread_mutex_destroy  (pthread_mutex_t *);

int pthread_mutex_lock  (pthread_mutex_t *);

int pthread_mutex_trylock  (pthread_mutex_t *);

int pthread_mutex_unlock  (pthread_mutex_t *);

/*
 * Operations on condition variables
 */

typedef cma_t_attr	pthread_condattr_t;
typedef cma_t_cond	pthread_cond_t;

int pthread_condattr_create  (pthread_condattr_t *);

int pthread_condattr_delete  (pthread_condattr_t *);

/*
 * A thread can create and delete condition variables.
 */
int pthread_cond_init  (pthread_cond_t *,pthread_condattr_t);

int pthread_cond_destroy  (pthread_cond_t *);

/*
 * A thread can signal to and broadcast on a condition variable.
 */
int pthread_cond_broadcast  (pthread_cond_t *);

int pthread_cond_signal  (pthread_cond_t *);

int pthread_cond_signal_int_np  (pthread_cond_t *);

/*
 * A thread can wait for a condition variable to be signalled or broadcast.
 */
int pthread_cond_wait  (pthread_cond_t *,pthread_mutex_t *);

/*
 * Operations for timed waiting
 */

/*
 * A thread can perform a timed wait on a condition variable.
 */
int pthread_cond_timedwait  (pthread_cond_t *,pthread_mutex_t *,struct
timespec *);

/*
 * Operations for client initialization.
 */
 typedef void (*pthread_initroutine_t)  (void);

int pthread_once  (pthread_once_t *,pthread_initroutine_t);

/*
 * Operations for per-thread context
 */

typedef cma_t_destructor	pthread_destructor_t;

/*
 * A unique per-thread context key can be obtained for the process
 */
int pthread_keycreate  (pthread_key_t *,pthread_destructor_t);

/*
 * A thread can set a per-thread context value identified by a key.
 */
int pthread_setspecific  (pthread_key_t,pthread_addr_t);

/*
 * A thread can retrieve a per-thread context value identified by a key.
 */
int pthread_getspecific  (pthread_key_t,pthread_addr_t *);

/*
 * Operations for alerts.
 */

/*
 * The current thread can request that a thread terminate it's execution.
 */

int pthread_cancel  (pthread_t);

/*
 * The current thread can poll for alert delivery.
 */
void pthread_testcancel  (void);

/*
 * The current thread can enable or disable alert delivery (PTHREAD
 * "cancels"); it can control "general cancelability" (CMA "defer") or
 * just "asynchronous cancelability" (CMA "asynch disable").
 */
int pthread_setasynccancel  (int);

int pthread_setcancel  (int);

_CMA_IMPORT_ pthread_attr_t		pthread_attr_default;
_CMA_IMPORT_ pthread_mutexattr_t	pthread_mutexattr_default;
_CMA_IMPORT_ pthread_condattr_t		pthread_condattr_default;

/*
 * Define nonportable extensions
 */

extern int pthread_get_expiration_np  (struct timespec *,struct timespec
*);

extern int pthread_delay_np  (struct timespec *);

#if (_CMA_UNIX_TYPE == _CMA__SVR4)
extern unsigned int pthread_delay_unsigned_np  (unsigned int );
#endif /* (_CMA_UNIX_TYPE == _CMA__SVR4) */

extern void pthread_lock_global_np  (void);

extern void pthread_unlock_global_np  (void);

# if _CMA_OS_ != _CMA__VMS
extern int pthread_signal_to_cancel_np  (sigset_t *,pthread_t *);
# endif
#ifdef __hpux
extern int pthread_is_multithreaded_np (void);
#endif
#ifdef __cplusplus
}
#endif
#endif  /* _CMA_HP_INT_NONANSI */

#endif
</"pthread.h">

<"dce/cma.h">
/*
 * (c) Copyright 1990, 1991, 1992, 1993 OPEN SOFTWARE FOUNDATION, INC. 
 * ALL RIGHTS RESERVED 
 * COPYRIGHT NOTICE
 * Copyright (c) 1990, 1991, 1992, 1993, 1994 Open Software Foundation, Inc.
 * ALL RIGHTS RESERVED (DCE).  See the file named COPYRIGHT.DCE for
 * the full copyright text.
 *
 * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems
 * Burlington, MA, USA
 */
/*
 * @(#)HP DCE/9000 1.5 
 * @(#)Module: cma.h $Revision: /main/HPDCE02/3 $ $Date: 1995/09/07 19:35
UTC $
 */
/*
 */
/*
 *	%W%	(DEC OSF/1)	%G%
 */
/*
 *  Copyright (c) 1988, 1992 by
 *  Digital Equipment Corporation, Maynard Massachusetts.
 *  All rights reserved.
 *
 *  This software is furnished under a license and may be used and  copied
 *  only  in  accordance  with  the  terms  of  such  license and with the
 *  inclusion of the above copyright notice.  This software or  any  other
 *  copies  thereof may not be provided or otherwise made available to any
 *  other person.  No title to and ownership of  the  software  is  hereby
 *  transferred.
 *
 *  The information in this software is subject to change  without  notice
 *  and  should  not  be  construed  as  a commitment by DIGITAL Equipment
 *  Corporation.
 *
 *  DIGITAL assumes no responsibility for the use or  reliability  of  its
 *  software on equipment which is not supplied by DIGITAL.
 */

/*
 *  FACILITY:
 *
 *	Digital's Proprietary Interface to DECthreads (CMA)
 *
 *  ABSTRACT:
 *
 *	External definitions for CMA services
 *
 *  AUTHORS:
 *
 *	Dave Butenhof
 *
 *  CREATION DATE:
 * 
 *	2 November 1988
 *
 *  MODIFIED BY:
 *
 *	Dave Butenhof
 *	Bob Conti
 *	Paul Curtin
 *	Hans Oser
 *	Webb Scales
 */

#ifndef CMA_INCLUDE
#define CMA_INCLUDE

/*
 * Define a symbol which client code can test to determine whether the 
 * underlying threads package is DECthreads or not.  This is especially
 * important to clients of the Pthreads interface who may want to use
 * certain DECthreads extensions, such as the global lock and non-real-time
 * scheduling policies, on the DECthreads platform while maintaining 
 * portability to a "vanilla" pthreads implementation.
 */
#define _DECTHREADS_	1

/*
 * The implementation makes these basic decisions
 */

#if defined(vms) || defined(__vms) || defined (VMS) || defined(__VMS) ||
defined(__vms__)
# include <cma_config.h>		/* configuration symbols */
#else# include <dce/cma_config.h>		/* configuration symbols */
#endif
/* For HP_UX, specifies which version of the operating system we are
building on */
#if _CMA_VENDOR_ == _CMA__HP
# include <dce/hpdce_platform.h>
#endif
/* Fix ordering problem with "wait" definition in HP-UX 1010 header files */
#if defined(__hpux1010p)
#  define wait cma_wait
#endif
#if (_CMA_UNIX_TYPE ==  _CMA__SVR4) && (_CMA_REENTRANT_CLIB_)
# if defined _libcma_code_
# include <cma_libc_redefs.h>
# endif#endif
#if _CMA_OS_ != _CMA__VMS
# include <sys/types.h>
# include <sys/time.h>
#endif
#if _CMA_OS_ == _CMA__VMS
# include <exc_handling.h>		/* Bring in exception services */
#else# include <dce/exc_handling.h>		/* Bring in exception
services */
#endif
#if (_CMA_OSIMPL_ == _CMA__OS_OSF) && _CMA_REENTRANT_CLIB_
# define _REENTRANT	1		/* Enable reentrant errno.h */
#endif
#if (_CMA_VENDOR_ == _CMA__HP) && _CMA_REENTRANT_CLIB_
# ifndef _REENTRANT
#  define _REENTRANT    1
# endif#endif

#ifdef __cplusplus
extern "C" {
#endif
/*
 * Sample decisions for the environment types
 */

typedef int			cma_t_integer;

typedef unsigned int		cma_t_boolean;

typedef unsigned int		cma_t_natural;

typedef float			cma_t_interval;

typedef	int			cma_t_key;

typedef int			cma_t_status;

typedef	int			cma_t_priority;

#if _CMA_VOID_
typedef void			*cma_t_address;
#elsetypedef char			*cma_t_address;
#endif
#define cma_c_false	(cma_t_boolean)0
#define cma_c_true	(cma_t_boolean)1
#define cma_c_null_ptr	(cma_t_address)0

#define cma_c_prio_fifo_min	16
#define cma_c_prio_fifo_mid	24
#define cma_c_prio_fifo_max	31
#define cma_c_prio_rr_min	16
#define cma_c_prio_rr_mid	24
#define cma_c_prio_rr_max	31
#define cma_c_prio_through_min	8
#define cma_c_prio_through_mid	12
#define cma_c_prio_through_max	15
#define cma_c_prio_back_min	1
#define cma_c_prio_back_mid	4
#define cma_c_prio_back_max	7
#define cma_c_prio_ada_low_min	0
#define cma_c_prio_ada_low_mid	4
#define cma_c_prio_ada_low_max	7

/*
 * The implementation of the cma_t_date_time type should match the "native
 * time" of the platform: that allows clients to use the full set of
platform
 * time operations, rather than just "cma_get_expiration", to compute and
 * test timed waits.
 *
 * This section assumes the platform is either "VMS" or "UNIX-ish".  Others
 * will require changes.
 */
#if _CMA_OS_ == _CMA__VMS
typedef struct CMA_T_DATE_TIME {
    unsigned long int	low;
    unsigned long int	high;
    }				cma_t_date_time;
#elsetypedef struct timeval		cma_t_date_time;
#endif
#ifdef __hpux
/*
 * Structure for C++ callbacks
 */
typedef struct CB_STRUCT {
        void (*start)();
        void (*end)();
        void (*out)();
        void (*in)();
} _ctxcb_spec_t;
#endif
/* 
 * Sample decisions for what handles shall be 
 */

typedef struct CMA_T_HANDLE {
    cma_t_address	field1;
    short int		field2;
    short int		field3;
    } cma_t_handle;

#define cma_thread_get_unique(handle) \
    ((unsigned int)((cma_t_thread *)handle)->field2)

#define cma_c_handle_size sizeof(cma_t_handle)

typedef	cma_t_handle	cma_t_mutex;	/* Needed for CMA_ONCE_BLOCK */

/*
 * Predefined null handle
 */
#ifndef _CMA_SUPPRESS_EXTERNALS_
_CMA_IMPORT_ cma_t_handle	cma_c_null;
#endif
/*
 * Sample decision for a one-time initialization control block and its
 * initialization macro.
 *
 * Declare a one time initialization control block as:
 *
 *	static cma_t_once	block = cma_once_init;
 */
typedef struct CMA_T_ONCE {
    cma_t_integer	field1;
    cma_t_integer	field2;
    cma_t_integer	field3;
    }				cma_t_once;

#define cma_once_init	{0, 0, 0}

/* 
 * Sample decision for a variable to save the current alert state.
 */
typedef struct CMA_T_ALERT_STATE {
    cma_t_integer	state1;
    cma_t_integer	state2;
    }				cma_t_alert_state;

/*
 * The following are the portable CMA definitions
 */

/*
 * Operations on Handles
 */

/*
 * The value of a handle can be assigned the value of another handle.	
 */

extern void cma_handle_assign (cma_t_handle *, cma_t_handle *);

/*
 * The value of a handle can be compared to the value of another handle.
 */

extern cma_t_boolean cma_handle_equal (	cma_t_handle *, cma_t_handle *);

/*
 * Operations on attributes objects
 */

typedef cma_t_handle	cma_t_attr;

/*
 * An attributes object is created to specify the attributes of other CMA
 * objects that will be created.
 */

extern void cma_attr_create (cma_t_attr	*,cma_t_attr *);

/*
 * An attributes object can be deleted when it is no longer needed.
 */

extern void cma_attr_delete (cma_t_attr	*);

/*
 * Operations on threads
 */

typedef cma_t_handle	cma_t_thread;
typedef cma_t_address	(*cma_t_start_routine) (cma_t_address);

typedef enum CMA_T_EXIT_STATUS {
    cma_c_term_error		= 0,
    cma_c_term_normal		= 1,
    cma_c_term_alert		= 2
    }				cma_t_exit_status;

typedef enum CMA_T_SCHED_INHERIT {
    cma_c_sched_inherit = 0,
    cma_c_sched_use_default = 1
    }				cma_t_sched_inherit;

typedef enum CMA_T_SCHED_POLICY {
    cma_c_sched_fifo = 0,
    cma_c_sched_rr = 1,
    cma_c_sched_throughput = 2,
    cma_c_sched_background = 3,
    cma_c_sched_ada_low = 4
    }				cma_t_sched_policy;

#define cma_c_sched_default	cma_c_sched_throughput
#define cma_c_sched_other	cma_c_sched_default

/*
 * The following procedures can be used to control thread creation,
 * termination and deletion.
 */

/*
 * To create a thread object and runnable thread, a routine must be
specified
 * as the new thread's start routine.  An argument may be passed to this
 * routine, as an untyped address; an untyped address may also be returned
as
 * the routine's value.  An attributes object may be used to specify details
 * about the kind of thread being created.
 */
extern void cma_thread_create (cma_t_thread *,cma_t_attr
*,cma_t_start_routine,cma_t_address);

/*
 * A thread object may be "detached" to specify that the return value and
 * completion status will not be requested.
 */
extern void cma_thread_detach (cma_t_thread *);

/* 
 * A thread may terminate it's own execution.
 */
extern void cma_thread_exit_error (void);

extern void cma_thread_exit_normal (cma_t_address);

/* 
 * A thread can await termination of another thread and retrieve the return
 * value and completion status of the thread.
 */
extern void cma_thread_join (cma_t_thread *,cma_t_exit_status
*,cma_t_address *);

/*
 * Operations to define thread creation attributes
 */

/*
 * Set or obtain the default thread priority.
 */
extern void cma_attr_set_priority (cma_t_attr *,cma_t_priority);

extern void cma_attr_get_priority (cma_t_attr *,cma_t_priority *);

/*
 * Set or obtain the default scheduling algorithm
 */
extern void cma_attr_set_sched (cma_t_attr *,cma_t_sched_policy
,cma_t_priority);

extern void cma_attr_get_sched (cma_t_attr *,cma_t_sched_policy *);

/*
 * Set or obtain whether a thread will use the default scheduling
attributes,
 * or inherit them from the creating thread.
 */
extern void cma_attr_set_inherit_sched (cma_t_attr *,cma_t_sched_inherit);

extern void cma_attr_get_inherit_sched (cma_t_attr *,cma_t_sched_inherit *);

/*
 * Set or obtain the default stack size
 */
extern void cma_attr_set_stacksize (cma_t_attr *,cma_t_natural);

extern void cma_attr_get_stacksize (cma_t_attr *,cma_t_natural *);

/*
 * Set or obtain the default guard size
 */
extern void cma_attr_set_guardsize (cma_t_attr *,cma_t_natural);

extern void cma_attr_get_guardsize (cma_t_attr *,cma_t_natural *);

/*
 * Thread Scheduling Operations
 */

/*
 * The current user_assigned priority of a thread can be changed.
 */
extern void cma_thread_set_priority (cma_t_thread *,cma_t_priority);

/*
 * The current user_assigned scheduler algorithm of a thread can be changed.
 */
extern void cma_thread_set_sched (cma_t_thread
*,cma_t_sched_policy,cma_t_priority);

/*
 * A thread may tell the scheduler that its processor can be made available.
 */
extern void cma_yield (void);

#ifndef _HP_CMA_PERF_
extern void cma_yield_noselect (void);
#endif /* _HP_CMA_PERF_ */

/*
 * A thread may enter a wait state for a speciifed period of time.
 */
extern void cma_delay (cma_t_interval);

/*
 * Thread Information Operations
 */

/*
 * A thread may obtain a copy of its own thread handle.
 */
extern void cma_thread_get_self (cma_t_thread *);

/*
 * The current user_assigned priority of a thread can be read.
 */
extern void cma_thread_get_priority (cma_t_thread *,cma_t_priority *);

/*
 * The current user_assigned scheduler algorithm of a thread can be read.
 */
extern void cma_thread_get_sched (cma_t_thread *,cma_t_sched_policy *);

/*
 * Operations on Mutexes
 */

typedef enum CMA_T_MUTEX_KIND {
    cma_c_mutex_fast = 0,
    cma_c_mutex_recursive = 1,
    cma_c_mutex_nonrecursive = 2
    }				cma_t_mutex_kind;

/*
 * Operations to define mutex creation attributes
 */

/*
 * Set or obtain whether mutex locks can nest.
 */
extern void cma_attr_set_mutex_kind (cma_t_attr *,cma_t_mutex_kind);

extern void cma_attr_get_mutex_kind (cma_t_attr*,cma_t_mutex_kind *);

/* 
 * The following routines create, delete, lock and unlock mutexes.
 */
extern void cma_mutex_create  (cma_t_mutex *,cma_t_attr *);

extern void cma_mutex_delete  (cma_t_mutex *);

extern void cma_mutex_lock  (cma_t_mutex *);

extern cma_t_boolean cma_mutex_try_lock  (cma_t_mutex *);

extern void cma_mutex_unlock  (cma_t_mutex *);

extern void cma_lock_global  (void);

extern void cma_unlock_global  (void);

/*
 * Operations on condition variables
 */

typedef cma_t_handle	cma_t_cond;

/*
 * A thread can create and delete condition variables.
 */
extern void cma_cond_create  (cma_t_cond *,cma_t_attr *);

extern void cma_cond_delete  (cma_t_cond *);

/*
 * A thread can signal to and broadcast on a condition variable.
 */
extern void cma_cond_broadcast  (cma_t_cond *);

extern void cma_cond_signal  (cma_t_cond *);

extern void cma_cond_signal_int  (cma_t_cond *);

/*
 * A thread can wait for a condition variable to be signalled or broadcast.
 */
extern void cma_cond_wait  (cma_t_cond *,cma_t_mutex *);

/*
 * Operations for timed waiting
 */

/*
 * A thread can perform a timed wait on a condition variable.
 */
extern cma_t_status cma_cond_timed_wait  (cma_t_cond *,cma_t_mutex
*,cma_t_date_time *);

/*
 * A thread may perform some operations on absolute date-time and intervals.
 */

extern void cma_time_get_expiration  (cma_t_date_time *,cma_t_interval );

/*
 * Operations for CMA and client initialization.
 */

/*
 * Initialize the CMA facility.
 */
extern void
cma_init  (void);

/*
 * A thread can declare a one-time initialization routine.  The address of
 * the init block and routine are passed as parameters.
 */
typedef void	(*cma_t_init_routine)  (cma_t_address);

extern void 
cma_once  (cma_t_once *_block,cma_t_init_routine,cma_t_address);

/*
 * Operations for per-thread context
 */
typedef void	(*cma_t_destructor)  (cma_t_address);

/*
 * A unique per-thread context key can be obtained for the process
 */
extern void cma_key_create  (cma_t_key *,cma_t_attr *,cma_t_destructor);

/*
 * A thread can set a per-thread context value identified by a key.
 */
extern void cma_key_set_context  (cma_t_key,cma_t_address);

/*
 * A thread can retrieve a per-thread context value identified by a key.
 */
extern void cma_key_get_context  (cma_t_key,cma_t_address *_value);

/*
 * Operations for alerts.
 */

/*
 * The current thread can request that a thread terminate it's execution.
 */

extern void cma_thread_alert  (cma_t_thread *);

/*
 * The current thread can poll for alert delivery.
 */
extern void cma_alert_test  (void);

/*
 * The current thread can disable asynchronous alert delivery, restore the
 * previous state of asynchronous alert delivery, or enable asynchronous
 * alert delivery.
 */
extern void cma_alert_disable_asynch  (cma_t_alert_state *);

extern void cma_alert_disable_general  (cma_t_alert_state *);

extern void cma_alert_enable_asynch  (void);

extern void cma_alert_enable_general  (cma_t_alert_state *);

extern void cma_alert_restore  (cma_t_alert_state *);

/*
 * Operations on stacks
 */

typedef	cma_t_handle	cma_t_stack_np;
typedef void	(*cma_t_call_routine)  (void);

/*
 * Allocate stack space
 */
extern void cma_stack_allocate_np  (cma_t_integer,cma_t_address *);

/*
 * Assign a stack to a thread
 */
extern void cma_stack_assign_np  (cma_t_stack_np *,cma_t_thread *);

/*
 * Call a routine on a new stack
 */
extern void cma_stack_call_routine_np  (cma_t_stack_np
*,cma_t_call_routine,cma_t_address,cma_t_address *);

/*
 * Check stack limit
 */
extern cma_t_boolean cma_stack_check_limit_np  (cma_t_integer);

/*
 * Create a new stack
 */
extern void cma_stack_create_np  (cma_t_stack_np *,cma_t_attr *);

/*
 * Delete a stack
 */
extern void cma_stack_delete_np  (cma_t_stack_np *);

/*
 * Debug threads
 */
extern void
cma_debug  (void);

extern void cma_debug_cmd  (char *, ...);

#ifndef _CMA_SUPPRESS_EXTERNALS_
_CMA_IMPORT_ void (*cma_g_debug) (void);
#endif
#ifdef __cplusplus
}
#endif
# if defined(_HP_LIBC_R) && defined(__hpux1010p)
#  define sigaction _sigaction_sys
# endif
# if _CMA_OS_ == _CMA__VMS
#  include <cma_px.h>
# else#  include <dce/cma_px.h>
# endif
#if _CMA_UNIPROCESSOR_
# if _CMA_OS_ == _CMA__VMS
#  include <cmalib_crtlx.h>
# else#  include <dce/cmalib_crtlx.h>
# endif#endif
# ifndef _CMA_NOWRAPPERS_
#  if !_CMA_REENTRANT_CLIB_
#   if _CMA_OS_ == _CMA__VMS
#    include <cmalib_crtlx.h>
#   else#    include <dce/cma_errno.h>
#    include <dce/cmalib_crtlx.h>
#    include <dce/cma_stdio.h>
#   endif#  elif (_CMA_UNIX_TYPE == _CMA__SVR4)
        /*
        *	SVR4 reentrant libraries do not have per-thread errno.
        */
#   include <dce/cma_errno.h>
#  endif#  if _CMA_OS_ == _CMA__UNIX
#   include <dce/cma_ux.h>
#  endif#  if _CMA_OS_ == _CMA__VMS
#   include <cma_sigwait.h>
#  else#   include <dce/cma_sigwait.h>
#  endif# endif
# ifdef _HP_LIBC_R
#  undef wait
#  include <cma_libc_calls.h>
# endif

#endif
</"dce/cma.h>

-----------------------------------------------------------------------
DISCLAIMER:  Information contained in this message and/or
attachment(s) may contain confidential information of Zetec, Inc.
If you have received this transmission in error, please notify
the sender by return email.
-----------------------------------------------------------------------