Per,
I've updated the headers as per your feedback below.
You'll find the new headers attached.
See embedded comments ...
Bojsen, Per wrote:
> Hi John,
>
> I reviewed the C++ header and had a few comments:
>
> 1) The #define's for SCEMI_(MAJOR|MINOR|PATCH)_VERSION and
> SCEMI_VERSION_STRING's that we agreed to a long time ago
> are missing.
johnS:
Added,
#define SCEMI_MAJOR_VERSION 1
#define SCEMI_MINOR_VERSION 0
#define SCEMI_PATCH_VERSION 1
#define SCEMI_VERSION_STRING "1.0.1"
to both headers as per spec.
>
> 2) The file is #include'ing <stdlib.h>. I assume that is to
> get NULL? It might be nice to add a comment to that effect
> and to use the C++'ified <cstdlib> header instead. In
> any event, #include'ing <stdlib.h> is not mandated, right?
> It is meant to be an example?
johnS:
Removed #include <stdlib.h>, changed all to NULL's to 0's
instead.
>
> 3) Should we add comments to the typedef's for SceMiU32 and
> SceMiU64 that they are examples and not mandated? The
> typedef for SceMiU32 might actually define a 64-bit unsigned
> integer on a 64-bit platform depending on the compiler,
> compiler flags, etc. It is a shame that <cstddef> is not
> universally available or we could have based these types on
> uint32_t and uint64_t.
johnS:
Following the guideline of the SystemVerilog DPI header files,
I left the typedefs unchanged.
Basically as long as the data type can represent that number
of bits at a minimum, it will be OK if, on a given platform,
say 'typedef unsigned SceMiU32' represents more than 32 bits.
As might be the case on a 64 bit machine.
You just don't want it representing less.
Let me know if you think there are issues with this. If so
perhaps I should submit errata proposals to the SV-DPI committee
as well.
>
> 4) There is an inconsistency in how callbacks are defined. The
> error and info handler types are defined with C linkage, but
> all other callback types are defined with C++ linkage. I
> think we should be consistent. If all callbacks are defined
> with C linkage, then C callback functions can be used and
> C and C++ SCE-MI code can be mixed more freely. On the
> other hand, C linkage prevents static member functions from
> being used as callbacks. Personally, I don't currently see
> mixing of C and C++ SCE-MI code as a big issue and I would
> favor that all callbacks in the C++ API have C++ linkage.
johnS:
I changed all the callback typedefs in the C++ header to have
extern "C" linkage. The static member function should not be
an issue because you can always more or less acheive the same
effect by making an ANSI C linkage function a friend of a C++
class. This is quite a common use model with SCE-MI applications.
>
> 5) There is a lot of #ifdef __cplusplus code. This is redundant
> because we know this is C++ code. On the same note, we can
> remove the definition of bool.
johnS:
These were removed as was the typedef int bool.
On a related note I changed the 'bool pending' arg of the g
function typedef to 'int pending' instead. This removes
dependency on the "to bool or not to bool' quirck between
ANSI C and C++. In otherwords, since C++ define bool but
ANSI C doesn't, let's make our life easier by removing this
dependency entirely.
This means we need to make a change to the spec to change all
references to 'bool pending' to 'int pending'. This only affects
things related to the g() function so it is a simple change.
I also removed "extern C" enclosures in ANSI C file as
these are not needed. (But they are in C++ file).
>
> Some nits:
>
> 6) The assigments of the enum values in the definitions of
> SceMiErrorType and SceMiInfoType are redundant and not in
> the spec.
johnS:
Fixed. Enum values removed as per spec.
>
> 7) The name of the first argument of the SceMiParameters constructor
> is `paramsFile' in the spec but `paramfile' in the header.
johnS:
Fixed.
>
> 8) The default value for the SceMiEC * parameter of NumberOfObjects()
> is `NULL' in the spec but `0' in the header. I know, these are
> supposed to be the same, but some users might get confused.
johnS:
We need to change to 0 in spec to match removal of all NULLs
from header.
>
> 9) The PortWidth() methods return `unsigned' in the spec but
> `const unsigned' in the header file. Making integer return types
> const does not make much sense to me.
johnS:
Fixed. 'const unsigned' changed to 'unsigned'.
>
> 10) Most methods in SceMiMessageData have `unsigned int' replaced
> with `unsigned' in the header file.
johnS:
Fixed: All 'unsigned' changed to 'unsigned int'.
>
> I think the biggest issue is the missing #define's and what to do with
> the function pointer types re C versus C++ linkage.
johnS:
I think we've resolved both.
>
> Per
>
-- johnS
______________________________/\/ \ \
John Stickley \ \ \
Principal Engineer \ \________________
Mentor Graphics - MED \_
17 E. Cedar Place \ john_stickley@mentor.com
Ramsey, NJ 07446 \ Phone: (201) 818-2585
________________________________________________________________
//
// scemi.h - SCE-MI C++ Interface
//
#ifndef INCLUDED_SCEMI
#define INCLUDED_SCEMI
class SceMiParameters;
class SceMiMessageData;
class SceMiMessageInPortProxy;
class SceMiMessageOutPortProxy;
#define SCEMI_MAJOR_VERSION 1
#define SCEMI_MINOR_VERSION 0
#define SCEMI_PATCH_VERSION 1
#define SCEMI_VERSION_STRING "1.0.1"
/* 32 bit unsigned word type for building and reading messages */
typedef unsigned int SceMiU32;
/* 64 bit unsigned word used for CycleStamps */
typedef unsigned long long SceMiU64;
extern "C" {
typedef int (*SceMiServiceLoopHandler)(void* context, int pending);
};
/*
* struct SceMiEC - SceMi Error Context
*/
typedef enum {
SceMiOK,
SceMiError
} SceMiErrorType;
typedef struct {
const char* Culprit; /* The offending function */
const char* Message; /* Descriptive message describing problem */
SceMiErrorType Type; /* Error code describing the nature of the error */
int Id; /* A code to uniquely identify each error */
} SceMiEC;
extern "C" {
typedef void (*SceMiErrorHandler)(void* context, SceMiEC* ec);
};
/*
* struct SceMiIC - SceMi Informational Message Context
*/
typedef enum {
SceMiInfo,
SceMiWarning,
SceMiNonFatalError
} SceMiInfoType;
typedef struct {
const char* Originator;
const char* Message;
SceMiInfoType Type;
int Id;
} SceMiIC;
extern "C" {
typedef void (*SceMiInfoHandler)(void* context, SceMiIC* ic);
};
/*
* struct SceMiMessageInPortBinding
*
* Description
* -----------
* This structure defines a tray of callback functions that support
* propagation of message input readiness back to the software.
*
* If an input ready callback is registered (optionally) on a given
* input port, the port will dispatch the callback whenever becomes
* ready for more input.
*
* Note: All callbacks must take their data and return promptly as they
* are called possibly deep down in a non-preemptive thread. Typically,
* the callback might to some minor manipulation to the context object
* then return and let a suspended thread resume and do the main processing
* of the received transaction.
*/
extern "C" {
typedef struct {
/*
* This is the user's context object pointer.
* The application is free to use this pointer for any purposes it
* wishes. Neither the class SceMi nor class MessageInputPortProxy do
* anything with this pointer other than store it and pass it when
* calling functions.
*/
void* Context;
/*
* Receive a response transaction. This function is called when data
* from the message output port arrives. This callback acts as a proxy
* for the message output port of the transactor.
*/
void (*IsReady)(
void* context);
/*
* This function is called from the MessageInputPortProxy destructor
* to notify the user code that the reference to the 'context' pointer
* has been deleted.
*/
int (*Close)(
void* context);
} SceMiMessageInPortBinding;
};
/*
* struct SceMiMessageOutPortBinding
*
* Description
* -----------
* This structure defines a tray of callback functions are passed to the class
* SceMi when the application model binds to a message output port proxy and
* which are called on message receipt and close notification. It is the means
* by which the MessageOutputPort forwards received transactions to the C model.
*
* Note: All callbacks must take their data and return promptly as they
* are called possibly deep down in a non-preemptive thread. Typically,
* the callback might to some minor manipulation to the context object
* then return and let a suspended thread resume and do the main processing
* of the received transaction.
*
* Additionally, the message data passed into the receive callback is
* not guaranteed to remain the same once the callback returns. All
* data therein then must be processed while inside the callback.
*/
extern "C" {
typedef struct {
/*
* This is the user's context object pointer.
* The application is free to use this pointer for any purposes it
* wishes. Neither the class SceMi nor class SceMiMessageOutPortProxy do
* anything with this pointer other than store it and pass it when
* calling callback functions Receive and Close.
*/
void* Context;
/*
* Receive a response transaction. This function is called when data
* from the message output port arrives. This callback acts as a proxy
* for the message output port of the transactor.
*/
void (*Receive)(
void* context,
const SceMiMessageData* data);
/*
* This function is called from the MessageOutputPortProxy destructor
* to notify the user code that the reference to the 'context' pointer
* has been deleted.
*/
int (*Close)(
void* context);
} SceMiMessageOutPortBinding;
};
class SceMiParameters {
public:
// CREATORS
//
// This constructor initializes some parameters from the
// parameters file in the config directory, and some other
// parameters directly from the config file.
//
SceMiParameters(
const char* paramsfile,
SceMiEC* ec = 0);
~SceMiParameters();
// ACCESSORS
//
// This accessor returns the number of instances of objects of
// the specified objectKind name.
//
unsigned int NumberOfObjects(
const char* objectKind, // Input: Object kind name.
SceMiEC* ec = 0) const; // Input/Output: Error status.
//
// These accessors return an integer or string attribute values of the
// given object kind. It is considered an error if the index > number
// returned by ::NumberOfObjects() or the objectKind and attributeName
// arguments are unrecognized.
//
int AttributeIntegerValue(
const char* objectKind, // Input: Object kind name.
unsigned int index, // Input: Index of object instance.
const char* attributeName, // Input: Name of attribute being read.
SceMiEC* ec = 0) const; // Input/Output: Error status.
const char* AttributeStringValue(
const char* objectKind, // Input: Object kind name.
unsigned int index, // Input: Index of object instance.
const char* attributeName, // Input: Name of attribute being read.
SceMiEC* ec = 0) const; // Input/Output: Error status.
// MANIPULATORS
//
// These manipulators override an integer or string attribute values of the
// given object kind. It is considered an error if the index > number
// returned by ::NumberOfObjects(). or the objectKind and attributeName
// arguments are unrecognized.
//
void OverrideAttributeIntegerValue(
const char* objectKind, // Input: Object kind name.
unsigned int index, // Input: Index of object instance.
const char* attributeName, // Input: Name of attribute being read.
int value, // Input: New integer value of attribute.
SceMiEC* ec = 0); // Input/Output: Error status.
void OverrideAttributeStringValue(
const char* objectKind, // Input: Object kind name.
unsigned int index, // Input: Index of object instance.
const char* attributeName, // Input: Name of attribute being read.
const char* value, // Input: New string value of attribute.
SceMiEC* ec = 0); // Input/Output: Error status.
};
//
// class SceMiMessageInPortProxy
//
// Description
// -----------
// The class SceMiMessageInPortProxy presents a C++ proxy for a transactor
// message input port. The input channel to that transactor is represented
// by the Send() method.
//
class SceMiMessageInPortProxy {
public:
// ACCESSORS
const char* TransactorName() const;
const char* PortName() const;
unsigned int PortWidth() const;
//
// This method sends message to the transactor input port.
//
void Send(
const SceMiMessageData &data, // Message payload to be sent.
SceMiEC* ec = 0);
//
// Replace port binding.
// The binding argument represents a callback function and context
// pointer tray (see comments in scemicommontypes.h for struct
// SceMiMessageInPortBinding).
//
void ReplaceBinding(
const SceMiMessageInPortBinding* binding = 0,
SceMiEC* ec = 0);
};
//
// class SceMiMessageOutPortProxy
//
// Description
// -----------
// The class SceMiMessageOutPortProxy presents a C++ proxy for a transactor
// message output port.
//
class SceMiMessageOutPortProxy {
public:
// ACCESSORS
const char* TransactorName() const;
const char* PortName() const;
unsigned int PortWidth() const;
//
// Replace port binding.
// The binding argument represents a callback function and context
// pointer tray (see comments in scemicommontypes.h for struct
// SceMiMessageOutPortBinding).
//
void ReplaceBinding(
const SceMiMessageOutPortBinding* binding = 0,
SceMiEC* ec = 0);
};
//
// class SceMiMessageData
//
// Description
// -----------
// The class SceMiMessageData represents a fixed length array of data which
// is transferred between models.
//
class SceMiMessageData {
public:
// CREATORS
//
// Constructor: The message in port proxy for which
// this message data object must be suitably sized.
//
SceMiMessageData(
const SceMiMessageInPortProxy& messageInPortProxy,
SceMiEC* ec = 0);
~SceMiMessageData();
// Return size of vector in bits
unsigned int WidthInBits() const;
// Return size of array in 32 bit words.
unsigned int WidthInWords() const;
void Set( unsigned i, SceMiU32 word, SceMiEC* ec = 0);
void SetBit( unsigned i, int bit, SceMiEC* ec = 0);
void SetBitRange(
unsigned int i, unsigned int range, SceMiU32 bits, SceMiEC* ec = 0);
SceMiU32 Get( unsigned i, SceMiEC* ec = 0) const;
int GetBit( unsigned i, SceMiEC* ec = 0) const;
SceMiU32 GetBitRange(
unsigned int i, unsigned int range, SceMiEC* ec = 0) const;
SceMiU64 CycleStamp() const;
};
//
// class SceMi
//
// Description
// -----------
// This file defines the public interface to class SceMi.
//
class SceMi {
public:
//
// Check version string against supported versions.
// Returns -1 if passed string not supported.
// Returns interface version # if it is supported.
// This interface version # can be passed to SceMi::Init().
//
static int Version(
const char* versionString);
//
// This function wraps constructor of class SceMi. If an instance
// of class SceMi has been established on a prior call to the
// SceMi::Init() function, that pointer is returned since a single
// instance of class SceMi is reusable among all C models.
// Returns NULL if error occurred, check ec for status or register
// an error callback.
//
// The caller is required to pass in the version of SceMi it is
// expecting to work with. Call SceMi::Version to convert a version
// string to an integer suitable for this version's "version" argument.
//
// The caller is also expected to have instantiated a SceMiParameters
// object, and pass a pointer to that object into this function.
//
static SceMi*
Init(
int version,
const SceMiParameters* parameters,
SceMiEC* ec = 0);
//
// Shut down the SCEMI interface.
//
static void
Shutdown(
SceMi* mct,
SceMiEC* ec = 0);
//
// Create proxy for message input port.
//
// Pass in the instance name in the bridge netlist of
// the transactor and port to which binding is requested.
//
// The binding argument is a callback function and context
// pointer tray. For more details, see the comments in
// scemicommontypes.h by struct SceMiMessageInPortBinding.
//
SceMiMessageInPortProxy*
BindMessageInPort(
const char* transactorName,
const char* portName,
const SceMiMessageInPortBinding* binding = 0,
SceMiEC* ec = 0);
//
// Create proxy for message output port.
//
// Pass in the instance name in the bridge netlist of
// the transactor and port to which binding is requested.
//
// The binding argument is a callback function and context
// pointer tray. For more details, see the comments in
// scemicommontypes.h by struct SceMiMessageOutPortBinding.
//
SceMiMessageOutPortProxy*
BindMessageOutPort(
const char* transactorName,
const char* portName,
const SceMiMessageOutPortBinding* binding = 0,
SceMiEC* ec = 0);
//
// Service arriving transactions from the portal.
// Messages enqueued by SceMiMessageOutPortProxy methods, or which are
// are from output transactions that pending dispatch to the
// SceMiMessageOutPortProxy callbacks, may not be handled until
// ServiceLoop() is called. This function returns the # of output
// messages that were dispatched.
//
// Regarding the service loop handler (aka "g function"):
// If g is NULL, check for transfers to be performed and
// dispatch them returning immediately afterwards. If g is
// non-NULL, enter into a loop of performing transfers and
// calling 'g'. When 'g' returns 0 return from the loop.
// When 'g' is called, an indication of whether there is at
// least 1 message pending will be made with the 'pending' flag.
//
// The user context object pointer is uninterpreted by
// ServiceLoop() and is passed straight to the 'g' function.
//
int
ServiceLoop(
SceMiServiceLoopHandler g = 0,
void* context = 0,
SceMiEC* ec = 0);
//
// Register an error handler which is called in the event
// that an error occurs. If no handler is registered, the
// default error handler is called.
//
static void
RegisterErrorHandler(
SceMiErrorHandler errorHandler,
void* context);
//
// Register an info handler which is called in the event
// that a text message needs to be issued. If no handler
// is registered, the message is printed to stdout in
// Ikos message format.
//
static void
RegisterInfoHandler(
SceMiInfoHandler infoHandler,
void* context);
};
#endif
/*
* scemi.h
*
* This file is the header file for the SCEMI C API.
*/
#ifndef INCLUDED_SCEMI
#define INCLUDED_SCEMI
typedef void SceMi;
typedef void SceMiParameters;
typedef void SceMiMessageData;
typedef void SceMiMessageInPortProxy;
typedef void SceMiMessageOutPortProxy;
#define SCEMI_MAJOR_VERSION 1
#define SCEMI_MINOR_VERSION 0
#define SCEMI_PATCH_VERSION 1
#define SCEMI_VERSION_STRING "1.0.1"
/* 32 bit unsigned word type for building and reading messages */
typedef unsigned int SceMiU32;
/* 64 bit unsigned word used for CycleStamps */
typedef unsigned long long SceMiU64;
typedef int (*SceMiServiceLoopHandler)(void* context, int pending);
/*
* struct SceMiEC - SceMi Error Context
*/
typedef enum {
SceMiOK,
SceMiError
} SceMiErrorType;
typedef struct {
const char* Culprit; /* The offending function */
const char* Message; /* Descriptive message describing problem */
SceMiErrorType Type; /* Error code describing the nature of the error */
int Id; /* A code to uniquely identify each error */
} SceMiEC;
typedef void (*SceMiErrorHandler)(void* context, SceMiEC* ec);
/*
* struct SceMiIC - SceMi Informational Message Context
*/
typedef enum {
SceMiInfo,
SceMiWarning,
SceMiNonFatalError
} SceMiInfoType;
typedef struct {
const char* Originator;
const char* Message;
SceMiInfoType Type;
int Id;
} SceMiIC;
typedef void (*SceMiInfoHandler)(void* context, SceMiIC* ic);
/*
* struct SceMiMessageInPortBinding
*
* Description
* -----------
* This structure defines a tray of callback functions that support
* propagation of message input readiness back to the software.
*
* If an input ready callback is registered (optionally) on a given
* input port, the port will dispatch the callback whenever becomes
* ready for more input.
*
* Note: All callbacks must take their data and return promptly as they
* are called possibly deep down in a non-preemptive thread. Typically,
* the callback might to some minor manipulation to the context object
* then return and let a suspended thread resume and do the main processing
* of the received transaction.
*/
typedef struct {
/*
* This is the user's context object pointer.
* The application is free to use this pointer for any purposes it
* wishes. Neither the class SceMi nor class MessageInputPortProxy do
* anything with this pointer other than store it and pass it when
* calling functions.
*/
void* Context;
/*
* Receive a response transaction. This function is called when data
* from the message output port arrives. This callback acts as a proxy
* for the message output port of the transactor.
*/
void (*IsReady)(
void* context);
/*
* This function is called from the MessageInputPortProxy destructor
* to notify the user code that the reference to the 'context' pointer
* has been deleted.
*/
int (*Close)(
void* context);
} SceMiMessageInPortBinding;
/*
* struct SceMiMessageOutPortBinding
*
* Description
* -----------
* This structure defines a tray of callback functions are passed to the class
* SceMi when the application model binds to a message output port proxy and
* which are called on message receipt and close notification. It is the means
* by which the MessageOutputPort forwards received transactions to the C model.
*
* Note: All callbacks must take their data and return promptly as they
* are called possibly deep down in a non-preemptive thread. Typically,
* the callback might to some minor manipulation to the context object
* then return and let a suspended thread resume and do the main processing
* of the received transaction.
*
* Additionally, the message data passed into the receive callback is
* not guaranteed to remain the same once the callback returns. All
* data therein then must be processed while inside the callback.
*/
typedef struct {
/*
* This is the user's context object pointer.
* The application is free to use this pointer for any purposes it
* wishes. Neither the class SceMi nor class SceMiMessageOutPortProxy do
* anything with this pointer other than store it and pass it when
* calling callback functions Receive and Close.
*/
void* Context;
/*
* Receive a response transaction. This function is called when data
* from the message output port arrives. This callback acts as a proxy
* for the message output port of the transactor.
*/
void (*Receive)(
void* context,
const SceMiMessageData* data);
/*
* This function is called from the MessageOutputPortProxy destructor
* to notify the user code that the reference to the 'context' pointer
* has been deleted.
*/
int (*Close)(
void* context);
} SceMiMessageOutPortBinding;
/*
* Register an error handler which is called in the event
* that an error occurs. If no handler is registered, the
* default error handler is called. The errorHandler will
* pass back the 'context' object registered by the user
* when making this function call. The system makes no
* assumptions about the 'context' pointer and will not
* modify it.
*/
void
SceMiRegisterErrorHandler(
SceMiErrorHandler errorHandler,
void* context);
/*
* Register an info handler which is called in the event
* that an informational text message needs to be printed.
* If no handler is registered, the message is printed to stdout.
*/
void SceMiRegisterInfoHandler(
SceMiInfoHandler infoHandler,
void* context );
/*
* Check version string against supported versions.
* Return -1 if passed string not supported.
* Return interface version # if it is supported. This interface
* version # can be passed to the SceMiInit() function.
*/
int
SceMiVersion(
const char* versionString);
/*
* This function wraps constructor of class SceMi. If an instance
* of class SceMi has been established on a prior call to the
* the SceMiInit() function, that pointer is returned since a single
* instance of class SceMi is reusable among all C models.
*
* The caller must provide the interface version # it is expecting
* to work with. If the caller requests an unsupported version,
* an error is returned.
*
* The caller must also provide a pointer to a filled-in SceMiParameters
* struct that contains global interface specification parameters.
*
* Returns NULL if error occurred, check ec for status or register
* an error callback.
*/
SceMi*
SceMiInit(
int version,
const SceMiParameters* parameters,
SceMiEC* ec);
/*
* Shut down the specified SCEMI interface.
*/
void
SceMiShutdown(
SceMi* mctHandle,
SceMiEC* ec);
/*
* Create proxy for message input port.
*
* The caller must provide the handle to the initialized SceMi system,
* as well as the name of the transactor and port to which binding
* is requested.
*
* The 'binding' input is a callback function and context pointer tray.
* See the comments in scemitypes.h for struct SceMiMessageInPortBinding.
*/
SceMiMessageInPortProxy*
SceMiBindMessageInPort(
SceMi* mctHandle,
const char* transactorName,
const char* portName,
const SceMiMessageInPortBinding* binding,
SceMiEC* ec);
/*
* Create proxy for message output port.
*
* The caller must provide the handle to the initialized SceMi system,
* as well as the name of the transactor and port to which binding
* is requested.
*
* The 'binding' input is a callback function and context pointer tray.
* See the comments in scemitypes.h for struct SceMiMessageOutPortBinding.
*/
SceMiMessageOutPortProxy*
SceMiBindMessageOutPort(
SceMi* mctHandle,
const char* transactorName,
const char* portName,
const SceMiMessageOutPortBinding* binding,
SceMiEC* ec);
/*
* Service arriving transactions from the portal.
* Messages enqueued by SceMiMessageOutPortProxy methods, or which are
* are from output transactions that pending dispatch to the
* SceMiMessageOutPortProxy callbacks, may not be handled until
* ServiceLoop() is called. This function returns the # of output
* messages that were dispatched.
*
* The 'g' input is a pointer to a user-defined service function.
* If g is NULL, check for transfers to be performed and
* dispatch them returning immediately afterwards. If g is
* non-NULL, enter into a loop of performing transfers and
* calling 'g'. When 'g' returns 0 return from the loop.
* When 'g' is called, an indication of whether there is at
* least 1 message pending will be made with the 'pending' flag.
*
* The 'context' input is a user context object pointer.
* This pointer is uninterpreted by the SceMiServiceLoop()
* method and is passed on to the 'g' callback function.
*/
int
SceMiServiceLoop(
SceMi* mctHandle,
SceMiServiceLoopHandler g,
void* context,
SceMiEC* ec);
SceMiParameters*
SceMiParametersNew(
const char* paramsFile,
SceMiEC* ec);
unsigned int
SceMiParametersNumberOfObjects(
const SceMiParameters* parametersHandle,
const char* objectKind,
SceMiEC* ec);
int
SceMiParametersAttributeIntegerValue(
const SceMiParameters* parametersHandle,
const char* objectKind,
unsigned int index,
const char* attributeName,
SceMiEC* ec);
const char*
SceMiParametersAttributeStringValue(
const SceMiParameters* parametersHandle,
const char* objectKind,
unsigned int index,
const char* attributeName,
SceMiEC* ec);
void
SceMiParametersOverrideAttributeIntegerValue(
SceMiParameters* parametersHandle,
const char* objectKind,
unsigned int index,
const char* attributeName,
int value,
SceMiEC* ec);
void
SceMiParametersOverrideAttributeStringValue(
SceMiParameters* parametersHandle,
const char* objectKind,
unsigned int index,
const char* attributeName,
const char* value,
SceMiEC* ec);
/*
* SceMiMessageData initialization function.
* This is called to construct a new SceMiMessageData object.
*/
SceMiMessageData*
SceMiMessageDataNew(
const SceMiMessageInPortProxy* messageInPortProxyHandle,
SceMiEC* ec);
/*
* Destroy a SceMiMessageData object previously returned from
* SceMiMessageDataNew.
*/
void
SceMiMessageDataDelete(
SceMiMessageData* messageDataHandle);
/*
* Return size of message data array in 32 bit words.
*/
unsigned int
SceMiMessageDataWidthInBits(
const SceMiMessageData* messageDataHandle);
/*
* Return size of array in 32 bit words.
*/
unsigned int
SceMiMessageDataWidthInWords(
const SceMiMessageData* messageDataHandle);
/*
* Set value of message data word at given index.
*/
void
SceMiMessageDataSet(
SceMiMessageData* messageDataHandle,
unsigned int i,
SceMiU32 word,
SceMiEC* ec);
/*
* Set bit in message data word at given index.
*/
void
SceMiMessageDataSetBit(
SceMiMessageData* messageDataHandle,
unsigned int i,
int bit,
SceMiEC* ec);
/*
* Set bit range in message data word at given index.
*/
void SceMiMessageDataSetBitRange(
SceMiMessageData* messageDataHandle,
unsigned int i,
unsigned int range,
SceMiU32 bits,
SceMiEC *ec);
/*
* Return value of message data word at given index.
*/
SceMiU32
SceMiMessageDataGet(
const SceMiMessageData* messageDataHandle,
unsigned int i,
SceMiEC* ec);
/*
* Return value of bit in message data word at given index.
*/
int
SceMiMessageDataGetBit(
const SceMiMessageData* messageDataHandle,
unsigned int i,
SceMiEC* ec);
/*
* Return value of bit range in message data word at given index.
*/
SceMiU32
SceMiMessageDataGetBitRange(
const SceMiMessageData *messageDataHandle,
unsigned int i,
unsigned int range,
SceMiEC *ec);
/*
* Get cyclestamp.
*/
SceMiU64
SceMiMessageDataCycleStamp(
const SceMiMessageData* messageDataHandle);
/*
* This method sends a message with the specified payload to the
* transactor input port. The data will transparently be delivered
* to the transactor as 1 or more chunks.
*/
void
SceMiMessageInPortProxySend(
SceMiMessageInPortProxy* messageInPortProxyHandle,
const SceMiMessageData* messageDataHandle,
SceMiEC* ec);
const char*
SceMiMessageInPortProxyTransactorName(
const SceMiMessageInPortProxy* messageInPortProxyHandle);
const char*
SceMiMessageInPortProxyPortName(
const SceMiMessageInPortProxy* messageInPortProxyHandle);
unsigned int
SceMiMessageInPortProxyPortWidth(
const SceMiMessageInPortProxy* messageInPortProxyHandle);
const char*
SceMiMessageOutPortProxyTransactorName(
const SceMiMessageOutPortProxy* messageOutPortProxyHandle);
const char*
SceMiMessageOutPortProxyPortName(
const SceMiMessageOutPortProxy* messageOutPortProxyHandle);
unsigned int
SceMiMessageOutPortProxyPortWidth(
const SceMiMessageOutPortProxy* messageOutPortProxyHandle);
#endif
Received on Fri Aug 20 15:54:21 2004
This archive was generated by hypermail 2.1.8 : Fri Aug 20 2004 - 15:54:22 PDT