SysThread.h

Go to the documentation of this file.

/*
 * Copyright (c) 2005 Palmsource, Inc.
 * 
 * This software is licensed as described in the file LICENSE, which
 * you should have received as part of this distribution. The terms
 * are also available at http://www.openbinder.org/license.html.
 * 
 * This software consists of voluntary contributions made by many
 * individuals. For the exact contribution history, see the revision
 * history and logs, available at http://www.openbinder.org
 */

#ifndef _SYSTHREAD_H_
#define _SYSTHREAD_H_

// Include elementary types
#include <PalmTypes.h>

#ifdef __cplusplus
extern "C" {
#endif

// -------------------------------------------------------
// THREAD CONSTANTS
// -------------------------------------------------------


enum {
    sysThreadPriorityLowered        = 100,      
    sysThreadPriorityNormal         = 80,       
    sysThreadPriorityBestApp        = 80,       
    sysThreadPriorityRaised         = 70,       
    sysThreadPriorityTransaction    = 65,       
    sysThreadPriorityDisplay        = 60,       
    sysThreadPriorityUrgentDisplay  = 50,       
    sysThreadPriorityRealTime       = 40,       
    sysThreadPriorityBestUser       = 30,       
    sysThreadPriorityBestSystem     = 5,        

    sysThreadPriorityLow            = sysThreadPriorityLowered, 
    sysThreadPriorityHigh           = sysThreadPriorityRealTime 
};

enum {
    sysThreadStackBasic             = 4*1024,   
    sysThreadStackUI                = 8*1024    
};

typedef enum {
    B_WAIT_FOREVER              = 0x0000,
    B_POLL                      = 0x0300,
    B_RELATIVE_TIMEOUT          = 0x0100,
    B_ABSOLUTE_TIMEOUT          = 0x0200
} timeoutFlagsEnum_t;
typedef uint16_t timeoutFlags_t; 

// -------------------------------------------------------
// THREAD SUPPORT
// -------------------------------------------------------


int32_t SysAtomicInc32(int32_t volatile *ioOperandP);
int32_t SysAtomicDec32(int32_t volatile *ioOperandP);
int32_t SysAtomicAdd32(int32_t volatile *ioOperandP, int32_t iAddend);
uint32_t SysAtomicAnd32(uint32_t volatile *ioOperandP, uint32_t iValue);
uint32_t SysAtomicOr32(uint32_t volatile *ioOperandP, uint32_t iValue);
uint32_t SysAtomicCompareAndSwap32(uint32_t volatile *ioOperandP, uint32_t iOldValue,
                 uint32_t iNewValue);



nsecs_t SysGetRunTime(void);

//@]


typedef uint32_t SysTSDSlotID;
typedef void (SysTSDDestructorFunc)(void*);
enum { sysTSDAnonymous=0 }; // symbolic value for iName in unnamed slots
status_t    SysTSDAllocate(SysTSDSlotID *oTSDSlot, SysTSDDestructorFunc *iDestructor, uint32_t iName);
status_t    SysTSDFree(SysTSDSlotID tsdslot);
void        *SysTSDGet(SysTSDSlotID tsdslot);
void        SysTSDSet(SysTSDSlotID tsdslot, void *iValue);



typedef uint32_t SysThreadExitCallbackID;
typedef void (SysThreadExitCallbackFunc)(void*);
status_t    SysThreadInstallExitCallback(   SysThreadExitCallbackFunc *iExitCallbackP,
                                            void *iCallbackArg,
                                            SysThreadExitCallbackID *oThreadExitCallbackId);
status_t    SysThreadRemoveExitCallback(SysThreadExitCallbackID iThreadCallbackId);



#define sysCriticalSectionInitializer NULL
typedef void * SysCriticalSectionType;

#if (TARGET_HOST == TARGET_HOST_WIN32)
// Not needed for TARGET_HOST_WIN32
#else
#if 1 || TARGET_HOST == TARGET_HOST_PALMOS // FIXME: Linux host/target
void SysCriticalSectionEnter(SysCriticalSectionType *iCS);
void SysCriticalSectionExit(SysCriticalSectionType *iCS);
#endif //TARGET_HOST == TARGET_HOST_PALMOS
#endif // TARGET_HOST == TARGET_HOST_WIN32


#define sysConditionVariableInitializer 0
typedef void * SysConditionVariableType;

#if (TARGET_HOST == TARGET_HOST_WIN32)
// Not needed for TARGET_HOST_WIN32
#else
#if 1 || TARGET_HOST == TARGET_HOST_PALMOS // FIXME: Linux host/target
void SysConditionVariableWait(SysConditionVariableType *iCV, SysCriticalSectionType *iOptionalCS);
void SysConditionVariableOpen(SysConditionVariableType *iCV);
void SysConditionVariableClose(SysConditionVariableType *iCV);
void SysConditionVariableBroadcast(SysConditionVariableType *iCV);
#endif //TARGET_HOST == TARGET_HOST_PALMOS
#endif // TARGET_HOST == TARGET_HOST_WIN32



enum { sysSemaphoreMaxCount = 0xffff };
status_t    SysSemaphoreCreateEZ(uint32_t initialCount, SysHandle* outSemaphore);
status_t    SysSemaphoreCreate( uint32_t initialCount, uint32_t maxCount, uint32_t flags,
                                SysHandle* outSemaphore);
status_t    SysSemaphoreDestroy(SysHandle semaphore);
status_t    SysSemaphoreSignal(SysHandle semaphore);
status_t    SysSemaphoreSignalCount(SysHandle semaphore, uint32_t count);
status_t    SysSemaphoreWait(   SysHandle semaphore,
                                timeoutFlags_t iTimeoutFlags, nsecs_t iTimeout);
status_t    SysSemaphoreWaitCount(  SysHandle semaphore,
                                    timeoutFlags_t iTimeoutFlags, nsecs_t iTimeout,
                                    uint32_t count);


// -------------------------------------------------------
// THREAD GROUPS
// -------------------------------------------------------


struct SysThreadGroupTag;
typedef struct SysThreadGroupTag SysThreadGroupType;
typedef SysThreadGroupType* SysThreadGroupHandle;

SysThreadGroupHandle    SysThreadGroupCreate(void);
status_t                SysThreadGroupDestroy(SysThreadGroupHandle group);
status_t                SysThreadGroupWait(SysThreadGroupHandle group);

// Use this if you don't want the thread in a group.
#define         sysThreadNoGroup    NULL


// -------------------------------------------------------
// THREAD CREATION
// -------------------------------------------------------



typedef void (SysThreadEnterFunc) (void *);
status_t    SysThreadCreateEZ(  const char *name,
                                SysThreadEnterFunc *func, void *argument,
                                SysHandle* outThread);


status_t    SysThreadCreate(SysThreadGroupHandle group, const char *name,
                            uint8_t priority, uint32_t stackSize,
                            SysThreadEnterFunc *func, void *argument,
                            SysHandle* outThread);


status_t    SysThreadStart(SysHandle thread);


int     SysThreadKill(SysHandle thread, int signo);

SysHandle   SysCurrentThread(void);


void        SysThreadExit(void);

status_t    SysThreadDelay(nsecs_t timeout, timeoutFlags_t flags);

#if 0 // FIXME: Missing API, not supportable with pthreads LINUX_DEMO_HACK

status_t    SysThreadSuspend(SysHandle thread);

status_t    SysThreadResume(SysHandle thread);
#endif

status_t    SysThreadChangePriority(SysHandle thread, uint8_t priority);


#ifdef __cplusplus
}   // extern "C"
#endif

#endif // _SYSTHREAD_H_

---

Generated on Wed Dec 28 22:33:28 2005 by Doxygen 1.4.4 for OpenBinder Documentation Version 1.0

PalmSource, Inc. © 2005