module ti.sdo.ipc.gates.GatePeterson

IGateMPSupport gate based on the Peterson algorithm

C synopsis
Individual elements
XDCscript usage
Individual elements

This module implements the ti.sdo.ipc.interfaces.IGateMPSupport interface using the Peterson Algorithm in shared memory. This implementation works for only 2 processors. [ more ... ]

C synopsis target-domain sourced in ti/sdo/ipc/gates/GatePeterson.xdc

#include <ti/sdo/ipc/gates/GatePeterson.h>

Functions
Void	GatePeterson_construct// Initialize a new instance object inside the provided structure(GatePeterson_Struct structP, IGateProvider_Handle localGate, const GatePeterson_Params params, Error_Block *eb);
GatePeterson_Handle	GatePeterson_create// Allocate and initialize a new instance object and return its handle(IGateProvider_Handle localGate, const GatePeterson_Params params, Error_Block eb);
Void	GatePeterson_delete// Finalize and free this previously allocated instance object, setting the referenced handle to NULL(GatePeterson_Handle *handleP);
Void	GatePeterson_destruct// Finalize the instance object inside the provided structure(GatePeterson_Struct *structP);
Void	GatePeterson_Params_init// Initialize this config-params structure with supplier-specified defaults before instance creation(GatePeterson_Params *params);
Functions common to all IGateProvider modules
Bool	GatePeterson_query// Runtime test for a particular gate quality(Int qual);
Functions common to all IGateMPSupport modules
SizeT	GatePeterson_sharedMemReq// Amount of shared memory required for creation of each instance(IGateMPSupport_Params *params);
Functions common to all target instances
	GatePeterson_handle// Convert this instance structure pointer into an instance handle, GatePeterson_Handle_downCast// conditionally move one level down the inheritance hierarchy; NULL upon failure, GatePeterson_Handle_downCast2// conditionally move 2 levels down the inheritance hierarchy; NULL upon failure, GatePeterson_Handle_label// The label associated with this instance object, GatePeterson_Handle_name// The name of this instance object, GatePeterson_Handle_upCast// unconditionally move one level up the inheritance hierarchy, GatePeterson_Handle_upCast2// unconditionally move 2 levels up the inheritance hierarchy, GatePeterson_Object_count// The number of statically-created instance objects, GatePeterson_Object_first// The handle of the first dynamically-created instance object, or NULL, GatePeterson_Object_get// The handle of the i-th statically-created instance object (array == NULL), GatePeterson_Object_heap// The heap used to allocate dynamically-created instance objects, GatePeterson_Object_next// The handle of the next dynamically-created instance object, or NULL, GatePeterson_struct// Convert this instance handle into an instance structure pointer
Functions common to all target modules
	GatePeterson_Module_getMask// Returns the diagnostics mask for this module, GatePeterson_Module_hasMask// Test whether this module has a diagnostics mask, GatePeterson_Module_heap// The heap from which this module allocates memory, GatePeterson_Module_id// Get this module's unique id, GatePeterson_Module_setMask// Set the diagnostics mask for this module, GatePeterson_Module_startupDone// Test if this module has completed startup
Defines
#define	GatePeterson_Q_BLOCKING// Blocking quality (Int)1
#define	GatePeterson_Q_PREEMPTING// Preempting quality (Int)2
Typedefs
typedef GatePeterson_Object *	GatePeterson_Handle// Client reference to an instance object;
typedef struct	GatePeterson_Object// Opaque internal representation of an instance object GatePeterson_Object;
typedef struct	GatePeterson_Params// Instance config-params structure ...
typedef struct	GatePeterson_Struct// Opaque client structure large enough to hold an instance object GatePeterson_Struct;
Constants
extern const Error_Id	GatePeterson_E_gateRemotelyOpened// Error raised when gate cannot be opened because of the opener's ID;
extern const UInt	GatePeterson_numInstances// Maximum number of instances supported by the GatePeterson module;

DETAILS

This module implements the ti.sdo.ipc.interfaces.IGateMPSupport interface using the Peterson Algorithm in shared memory. This implementation works for only 2 processors.

Each GatePeterson instance requires a small piece of shared memory. The base address of this shared memory is specified as the 'sharedAddr' argument to the create. The amount of shared memory consumed by a single instance can be obtained using the sharedMemReq call.

Shared memory has to conform to the following specification. Padding is added between certain elements in shared memory if cache alignment is required for the region in which the instance is placed.

              shmBaseAddr -> --------------------------- bytes
                             |  version                | 4
              (Attrs struct) |  creatorProcId          | 2
                             |  openerProcId           | 2
                             |  (PADDING if aligned)   | 
                             |-------------------------|
                             |  flag[0]                | 2
                             |  (PADDING if aligned)   | 
                             |-------------------------|
                             |  flag[1]                | 2
                             |  (PADDING if aligned)   | 
                             |-------------------------|
                             |  turn                   | 2
                             |  (PADDING if aligned)   | 
                             |-------------------------|

const GatePeterson_Q_BLOCKING