module xdc.runtime.knl.SemThread

SemThread Manager. [EXPERIMENTAL]

C synopsis
XDCscript usage
XDCspec declarations
Individual elements
Additional documentation

This module manages semaphores through its proxy ISemThreadSupport interface. It has a module wide config parameter Proxy which needs to be bound to an OS specific delegate before this module can be used. [ more ... ]

XDCspec summary sourced in xdc/runtime/knl/SemThread.xdc

module SemThread { ...

// inherits xdc.runtime.knl.ISemaphore

// inherits xdc.runtime.IModule

instance: ...

C synopsis target-domain

#include <xdc/runtime/knl/SemThread.h>

module-wide constants & types

#define SemThread_FOREVER// Used as the timeout value to specify wait forever (UInt)~(0)

typedef enum SemThread_Mode// Types of semaphores {

SemThread_Mode_COUNTING// Counting semaphore,

SemThread_Mode_BINARY// Binary Semaphore

} SemThread_Mode;

typedef enum SemThread_PendStatus// Error codes returned by Semaphore_pend {

SemThread_PendStatus_ERROR,

SemThread_PendStatus_TIMEOUT,

SemThread_PendStatus_SUCCESS

} SemThread_PendStatus;

module-wide built-ins

Types_ModuleId SemThread_Module_id// Get this module's unique id( );

Bool SemThread_Module_startupDone// Test if this module has completed startup( );

IHeap_Handle SemThread_Module_heap// The heap from which this module allocates memory( );

per-instance object types

typedef struct SemThread_Object// Opaque internal representation of an instance object SemThread_Object;

typedef SemThread_Object *SemThread_Handle// Client reference to an instance object;

typedef struct SemThread_Struct// Opaque client structure large enough to hold an instance object SemThread_Struct;

SemThread_Handle SemThread_handle// Convert this instance structure pointer into an instance handle( SemThread_Struct *structP );

SemThread_Struct *SemThread_struct// Convert this instance handle into an instance structure pointer( SemThread_Handle handle );

per-instance config parameters

typedef struct SemThread_Params// Instance config-params structure {

IInstance_Params *instance;

ISemaphore_Mode mode// Semaphore mode. Default is COUNTING;

} SemThread_Params;

Void SemThread_Params_init// Initialize this config-params structure with supplier-specified defaults before instance creation( SemThread_Params *params );

per-instance creation

SemThread_Handle SemThread_create// Allocate and initialize a new instance object and return its handle( Int count, const SemThread_Params *params, Error_Block *eb );

Void SemThread_construct// Initialize a new instance object inside the provided structure( SemThread_Struct *structP, Int count, const SemThread_Params *params, Error_Block *eb );

per-instance deletion

Void SemThread_delete// Finalize and free this previously allocated instance object, setting the referenced handle to NULL( SemThread_Handle *handleP );

Void SemThread_destruct// Finalize the instance object inside the provided structure( SemThread_Struct *structP );

per-instance functions

Int SemThread_pend// Wait for the semaphore to become available( SemThread_Handle handle, UInt timeout, Error_Block *eb );

Bool SemThread_post// Increment the semaphore count( SemThread_Handle handle, Error_Block *eb );

per-instance convertors

ISemaphore_Handle SemThread_Handle_upCast// unconditionally move one level up the inheritance hierarchy( SemThread_Handle handle );

SemThread_Handle SemThread_Handle_downCast// conditionally move one level down the inheritance hierarchy; NULL upon failure( ISemaphore_Handle handle );

per-instance built-ins

Int SemThread_Object_count// The number of statically-created instance objects( );

SemThread_Handle SemThread_Object_get// The handle of the i-th statically-created instance object (array == NULL)( SemThread_Object *array, Int i );

SemThread_Handle SemThread_Object_first// The handle of the first dynamically-created instance object, or NULL( );

SemThread_Handle SemThread_Object_next// The handle of the next dynamically-created instance object, or NULL( SemThread_Handle handle );

IHeap_Handle SemThread_Object_heap// The heap used to allocate dynamically-created instance objects( );

Types_Label *SemThread_Handle_label// The label associated with this instance object( SemThread_Handle handle, Types_Label *buf );

String SemThread_Handle_name// The name of this instance object( SemThread_Handle handle );

XDCscript usage meta-domain

var SemThread = xdc.useModule('xdc.runtime.knl.SemThread');

local proxy modules

SemThread.Proxy// Proxy that needs to be bound to an OS specific delegate = ISemThreadSupport.Module null

SemThread.Proxy.delegate$ = ISemThreadSupport.Module null

SemThread.Proxy.abstractInstances$ = false

module-wide constants & types

const SemThread.FOREVER// Used as the timeout value to specify wait forever = ~(0);

values of type SemThread.Mode// Types of semaphores

const SemThread.Mode_COUNTING// Counting semaphore;

const SemThread.Mode_BINARY// Binary Semaphore;

values of type SemThread.PendStatus// Error codes returned by Semaphore_pend

const SemThread.PendStatus_ERROR;

const SemThread.PendStatus_TIMEOUT;

const SemThread.PendStatus_SUCCESS;

module-wide config parameters

SemThread.common$// Common module configuration parameters = Types.Common$ undefined;

per-instance config parameters

var params = new SemThread.Params// Instance config-params object;

params.mode// Semaphore mode. Default is COUNTING = ISemaphore.Mode ISemaphore.Mode_COUNTING;

per-instance creation

var inst = SemThread.create// Create an instance-object( Int count, params );

XDCspec declarations sourced in xdc/runtime/knl/SemThread.xdc

package xdc.runtime.knl;

module SemThread inherits ISemaphore {

local proxy modules

proxy Proxy inherits ISemThreadSupport;

module-wide constants & types

const UInt FOREVER// Used as the timeout value to specify wait forever = ~(0);

enum Mode// Types of semaphores {

Mode_COUNTING// Counting semaphore,

Mode_BINARY// Binary Semaphore

};

enum PendStatus// Error codes returned by Semaphore_pend {

PendStatus_ERROR,

PendStatus_TIMEOUT,

PendStatus_SUCCESS

};

module-wide config parameters

metaonly config Types.Common$ common$// Common module configuration parameters;

instance:

per-instance config parameters

config ISemaphore.Mode mode// Semaphore mode. Default is COUNTING = ISemaphore.Mode_COUNTING;

per-instance creation

create// Create an instance-object( Int count );

per-instance functions

Int pend// Wait for the semaphore to become available( UInt timeout, Error.Block *eb );

Bool post// Increment the semaphore count( Error.Block *eb );

}

DETAILS

Here is an example showing how the proxy is bound to an BIOS 6.x specific delegate.

var SemThread = xdc.useModule('xdc.runtime.knl.SemThread'); SemThread.Proxy = xdc.useModule('ti.sysbios.xdcruntime.SemThreadSupport');

Typically the package containing the delegates have a Settings module that will bind all xdc.runtime.knl proxies. The following example sets up all the xdc.runtime.knl proxies.

xdc.useModule("ti.sysbios.xdcruntime.Settings");

proxy SemThread.Proxy