module ti.sdo.ipc.gates.GatePetersonN

IGateMPSupport gate based on the Peterson's algorithm

C synopsis
Individual elements
Configuration settings
Individual elements

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

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

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

Functions
Void	GatePetersonN_construct// Initialize a new instance object inside the provided structure(GatePetersonN_Struct structP, IGateProvider_Handle localGate, const GatePetersonN_Params params, Error_Block *eb);
GatePetersonN_Handle	GatePetersonN_create// Allocate and initialize a new instance object and return its handle(IGateProvider_Handle localGate, const GatePetersonN_Params params, Error_Block eb);
Void	GatePetersonN_delete// Finalize and free this previously allocated instance object, setting the referenced handle to NULL(GatePetersonN_Handle *handleP);
Void	GatePetersonN_destruct// Finalize the instance object inside the provided structure(GatePetersonN_Struct *structP);
Void	GatePetersonN_Params_init// Initialize this config-params structure with supplier-specified defaults before instance creation(GatePetersonN_Params *params);
Functions common to all IGateProvider modules
Bool	GatePetersonN_query// Runtime test for a particular gate quality(Int qual);
Functions common to all IGateMPSupport modules
SizeT	GatePetersonN_sharedMemReq// Amount of shared memory required for creation of each instance(IGateMPSupport_Params *params);
Functions common to all target instances
	GatePetersonN_handle// Convert this instance structure pointer into an instance handle, GatePetersonN_Handle_downCast// conditionally move one level down the inheritance hierarchy; NULL upon failure, GatePetersonN_Handle_downCast2// conditionally move 2 levels down the inheritance hierarchy; NULL upon failure, GatePetersonN_Handle_label// The label associated with this instance object, GatePetersonN_Handle_name// The name of this instance object, GatePetersonN_Handle_upCast// unconditionally move one level up the inheritance hierarchy, GatePetersonN_Handle_upCast2// unconditionally move 2 levels up the inheritance hierarchy, GatePetersonN_Object_count// The number of statically-created instance objects, GatePetersonN_Object_first// The handle of the first dynamically-created instance object, or NULL, GatePetersonN_Object_get// The handle of the i-th statically-created instance object (array == NULL), GatePetersonN_Object_heap// The heap used to allocate dynamically-created instance objects, GatePetersonN_Object_next// The handle of the next dynamically-created instance object, or NULL, GatePetersonN_struct// Convert this instance handle into an instance structure pointer
Functions common to all target modules
	GatePetersonN_Module_getMask// Returns the diagnostics mask for this module, GatePetersonN_Module_hasMask// Test whether this module has a diagnostics mask, GatePetersonN_Module_heap// The heap from which this module allocates memory, GatePetersonN_Module_id// Get this module's unique id, GatePetersonN_Module_setMask// Set the diagnostics mask for this module, GatePetersonN_Module_startupDone// Test if this module has completed startup
Defines
#define	GatePetersonN_Q_BLOCKING// Blocking quality (Int)1
#define	GatePetersonN_Q_PREEMPTING// Preempting quality (Int)2
Typedefs
typedef GatePetersonN_Object *	GatePetersonN_Handle// Client reference to an instance object;
typedef struct	GatePetersonN_Object// Opaque internal representation of an instance object GatePetersonN_Object;
typedef struct	GatePetersonN_Params// Instance config-params structure ...
typedef struct	GatePetersonN_Struct// Opaque client structure large enough to hold an instance object GatePetersonN_Struct;
Constants
extern const UInt	GatePetersonN_MAX_NUM_PROCS// ;
extern const UInt	GatePetersonN_numInstances// Maximum number of instances supported by the GatePetersonN module;

DETAILS

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

Each GatePetersonN 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
                             |  enteredStage[0]           | 4
                             |  (PADDING if aligned)      |
                             |----------------------------|
                             |  enteredStage[1]           | 4
                             |  (PADDING if aligned)      |
                             |----------------------------|
                                      . . . 
                             |----------------------------|
                             |  enteredStage[N-1]         | 4
                             |  (PADDING if aligned)      |
                             |----------------------------|
                             |  lastProcEnteringStage[1]  | 4
                             |  (PADDING if aligned)      |
                             |----------------------------|
                                      . . . 
                             |----------------------------|
                             |  lastProcEnteringStage[N-1]| 4
                             |  (PADDING if aligned)      |
                             |----------------------------|

const GatePetersonN_Q_BLOCKING