User Tools

Site Tools


pads:gaia-apis

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision
Previous revision
pads:gaia-apis [2010/11/10 13:03] gdangelopads:gaia-apis [2017/12/20 07:48] (current) gdangelo
Line 27: Line 27:
 </code> </code>
  
-====  GAIA_Initialize()  ====+ 
 +==== Simulation Management ==== 
 + 
 + 
 +===  GAIA_Initialize()  ===
 <code java> <code java>
 int     GAIA_Initialize (int max_objs_count, int nlp, String RandFile, String cname, String sima_host_name, int sima_port); int     GAIA_Initialize (int max_objs_count, int nlp, String RandFile, String cname, String sima_host_name, int sima_port);
Line 52: Line 56:
 Returns the LP identifier. Returns the LP identifier.
  
 +----
  
-====  GAIA_Finalize()  ====+===  GAIA_Finalize()  ===
 <code java> <code java>
 void    GAIA_Finalize ( ); void    GAIA_Finalize ( );
Line 74: Line 79:
 //none// //none//
  
 +----
  
-====  GAIA_SetFstID()  ====+ 
 +===  GAIA_SetFstID()  ===
 <code java> <code java>
 void    GAIA_SetFstID (int first_id); void    GAIA_SetFstID (int first_id);
Line 90: Line 97:
  
 //none// //none//
- 
  
 **Return value:** **Return value:**
  
 //none// //none//
 +
 +----
  
  
-====  GAIA_SetCountDown()  ====+===  GAIA_GetStep()  ===
 <code java> <code java>
-void    GAIA_SetCountDown (int events);+double  GAIA_GetStep ( );
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * int **events**: interval of events before a new evaluation of the heuristic.+ 
 +//none//
  
 **Description**: **Description**:
  
-The migration heuristic 3 (MIGR_E3) is based on the events history but differently from MIGR_E2 it is triggered only after given number of events (unicast messages sent by the SE). This API can be used to modify this threshold that is also called E3_EVENT_COUNTDOWN.+Returns the length of the timestep used in the simulation. This parameter is initialized using the **GLOBAL_LA** parameters as defined in the file "**channels.txt**". For example, GLOBAL_LA=1 defines global lookahead (timestepof 1 time-unit, and GLOBAL_LA=0.01 is to define timesteps with a length of 1/100 of time-unit.
  
 **Notes**: **Notes**:
  
-The default value of E3_EVENT_COUNTDOWN is 30 events. +//none//
  
 **Return value:** **Return value:**
  
-//none//+The timestep length (double).
  
 +----
  
-====  GAIA_SetMT()  ====+ 
 +===  GAIA_Register()  ===
 <code java> <code java>
-void    GAIA_SetMT (int new_size);+int     GAIA_Register (int migrable);
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * int **new_size**: it defines the threshold of the migration heuristic;+ 
 +   * int **migrable**: MIGRABLE if the SE can be migrated, NOT_MIGRABLE if the SE can not be relocated;
  
 **Description**: **Description**:
  
-The Migration Threshold (MT) is a value used to limit the migration rate of SEs (default value = 10). Each SE can evaluate the migration heuristic only if its counter has value that is bigger than MT. At bootstrap and at each migration the counter is re-initialized. The detailed semantic of the counter depends on what migration heuristic is used. +This API is used to register a SEthe runtime returns descriptor that will be used to identify the SE. The registration of a SE is required to extend the scope of the SE outside the local LP (to the whole simulation). Only after the registration the SE will be able to send and receive messages, furthermore it could be involved in the migration and load balancing mechanisms.
- +
- +
-^ Migration heuristic      ^  SetHistory() semantic       ^ +
-| MIGR_OFF    |  //none//     | +
-| MIGR_ON / MIGR_E1     Threshold: number of times-steps (since the last reset  | +
-| MIGR_E2  |  Threshold: number of UNICAST events generated (since the last reset) +
- +
-\\+
  
 **Notes**: **Notes**:
  
-Some degree of randomization is included in the mechanism to reduce the "wave effects" of migrating entities. +The registration of a SE is an event that has to be propagated to the whole simulator. Therefore, if the registration of a SE happens at timestep **t**, only starting from timestep **t+1** will be possible to send or receive messages regarding such SE. For example, it is NOT possible to register a new SE at timestep **t** and to immediately send a message from this SE in the same timestep.
  
 **Return value:** **Return value:**
  
-//none//+The descriptor (integer) of the SE.
  
 +----
  
-====  GAIA_SetMF()  ====+ 
 +===  GAIA_TimeAdvance()  ===
 <code java> <code java>
-void    GAIA_SetMF (float migr_factor);+double  GAIA_TimeAdvance ();
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * float **migr_factor**: it defines the relocation threshold of the migration heuristic;+ 
 +//none//
  
 **Description**: **Description**:
  
-All the implemented migration heuristics are based on the evaluation of the outbound UNICAST traffic generated by each Simulated Entity. The migration factor is a tuning parameters of the heuristics: a low value would increase the number of migrations, conversely a higher value would reduce the number of migrations+It is used by the LP to notify to the runtime that the current timestep is ended, and therefore, the local LP is ready to start the next timestep. The LP will remain blocked until the runtime will enable the transition to the next timestep.
  
 **Notes**: **Notes**:
  
-The number of migrations is a trade-off between a high LCR and the overhead due to migrations.+//none//
  
 **Return value:** **Return value:**
  
-//none//+Returns the next timestep value (double). 
 + 
 +---- 
 + 
 + 
 + 
 +==== Migration ====
  
  
-====  GAIA_SetHistorySlots()  ====+===  GAIA_Migrate()  ===
 <code java> <code java>
-void    GAIA_SetHistorySlots (int history_slots);+void    GAIA_Migrate (int id, String data, int size);
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * int **history_slots**: number of slots considered in the history matrix;+   * int **id**: Identifier of the migrating SE; 
 +   * String **data**: A string containing the internal state of the SE; 
 +   * int **size**: String size; 
  
 **Description**: **Description**:
  
-The migration heuristic 1 (MIGR_ON / MIGR_E1) uses a sliding window mechanism to evaluate the communication pattern of each SE (HISTORY_SLOTS, default value = 4). The number of slots composing the sliding windows can be defined at the simulation bootstrap using this API.+It is used by a local LP to migrate a SE to a remote LP. The local LP is **not** free to define what SEs should be migrated. During the simulation execution, the migration mechanism defines what SEs have to be migrated and informs the LP using a "NOTIF_MIGR" message. The other LPs that are not directly involved in the migration will be informed of the event with a "NOTIF_MIGR_EXT".
  
 **Notes**: **Notes**:
  
-Too many slots would reduce the reactivity of the migration mechanismConversely, a too small value would cause an excessive number of migrations.+   * The "NOTIF_MIGR" message and the related migration are **mandatory**. The LPs cannot independently migrate any SE without previously receiving a "NOTIF_MIGR" message. This migration of "notified" SEs have to be done at the end of the timestep in which is received the notification. 
 + 
 +   * The GAIA_Migrate() is implemented using a "EXEC_MIGR" message. Thereforethe LP that receives message of this type is receiving a migrating Simulated Entity.
  
 **Return value:** **Return value:**
Line 190: Line 206:
 //none// //none//
  
 +----
  
-====  GAIA_SetEventHistorySize()  ====+ 
 +===  GAIA_ByteMigrate()  ===
 <code java> <code java>
-void    GAIA_SetEventHistorySize (int size);+void    GAIA_ByteMigrate (int id, byte[] data, int size);
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * int **size**: number of events (FIFO order) considered by the migration heuristic 2 and 3.+   * int **id**: Identifier of the migrating SE; 
 +   * byte[] **data**: A byte-array containing the internal state of the SE; 
 +   * int **size**: String size; 
  
 **Description**: **Description**:
  
-The migration heuristics 2 and 3 (MIGR_E2 / MIGR_E3) are based on the a sliding-windows with the last E2_EVENT_HISTORY_SIZE messages sent by the SE (default value 100). The number of events composing the sliding windows can be defined at the simulation bootstrap using this API.+It is used by a local LP to migrate a SE to a remote LP. The local LP is **not** free to define what SEs should be migrated. During the simulation execution, the migration mechanism defines what SEs have to be migrated and informs the  LP using "NOTIF_MIGR" message. The other LPs that are not directly involved in the migration will be informed of the event with a “NOTIF_MIGR_EXT”
  
 **Notes**: **Notes**:
  
-//none//+   * The "NOTIF_MIGR" message and the related migration are **mandatory**. The LPs cannot independently migrate any SE without previously receiving a "NOTIF_MIGR" message. This migration of “notified” SEs have to be done at the end of the timestep in which is received the notification.  
 + 
 +   * The GAIA_ByteMigrate() is implemented using a “EXEC_MIGR” message. Therefore, the LP that receives a message of this type is receiving a migrating Simulated Entity. 
 + 
 +   * This API has the exactly the same semantic of GAIA_Migrate(). For performance reasons, in this case the SE state is contained in an array instead of a String.
  
 **Return value:** **Return value:**
Line 211: Line 236:
 //none// //none//
  
-====  GAIA_SetMigration()  ====+---- 
 + 
 + 
 +===  GAIA_SetCountDown()  ===
 <code java> <code java>
-void    GAIA_SetMigration (int state);+void    GAIA_SetCountDown (int events);
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * int **state**: it selects the migration heuristic, {MIGR_OFF, MIGR_ON, MIGR_E1, MIGR_E2, MIGR_E3}, default MIGR_OFF;+   * int **events**: interval of events before a new evaluation of the heuristic.
  
 **Description**: **Description**:
  
-All the implemented migration heuristics are based on the evaluation of the outbound UNICAST traffic generated by each SE (also called events).  +The migration heuristic 3 (MIGR_E3) is based on the events history but differently from MIGR_E2 it is triggered only after given number of events (unicast messages sent by the SE). This API can be used to modify this threshold that is also called E3_EVENT_COUNTDOWN.
- +
-^ Migration heuristic      ^  Description        Pros  ^  Cons  ^ +
-| MIGR_OFF    |  //none//      none  |  none  | +
-| MIGR_ON / MIGR_E1    The heuristic is evaluated each time-step. It is based on the last E1_HISTORY_SLOTS timesteps of the simulation. It is implemented a sliding window approach that at each step throws away the oldest events and inserts the more recent ones  |  Very high LCR  \\  Well-suited for communication intensive models  |  In some cases, relevant overhead  |  +
-MIGR_E2   The heuristic is evaluated each time-step. It is based on the sliding-windows with the last E2_EVENT_HISTORY_SIZE messages sent by the SE   Well suited for simulatons in which the communication pattern of entities changes frequently    In some cases, relevant overhead +
-| MIGR_E3  |  The heuristic is evaluated only if the SE has sent at least E3_EVENT_COUNTDOWN events after the last evaluationThe rest of the mechanism is the same as MIGR_E2  |  Well suited for simulatons with a very high number of SEs and in which the communication pattern of entities changes frequently    In some cases slow convergence and slightly lower LCR  | +
- +
-\\ +
  
 **Notes**: **Notes**:
  
-For tuning of the heuristics please see: +The default value of E3_EVENT_COUNTDOWN is 30 events.
-  * GAIA_SetMT(): for an introduction to the Migration Threshold, that is a mechanism that reduces the migration rate of SEs; +
-  * GAIA_SetMF(): for an introduction to the Migration Factor, that is the parameter that is used to evaluate if and where activate the migration mechanism for a SE; +
-  * E2_EVENT_HISTORY_SIZE, default value = 100. It is how many events (FIFO order) are considered by migration heuristics 2 and 3. This value can be changed using the GAIA_SetEventHistorySize() API. +
-  * E3_EVENT_COUNTDOWN, default value = 30. It is the interval of events before a new evaluation of the heuristic. This value can be changed using the GAIA_SetCountDown() API. +
-  * HISTORY_SLOTS, default value = 4. It can be modified in the simulation setup using the GAIA_SetHistorySlots() API.+
  
 **Return value:** **Return value:**
Line 245: Line 259:
 //none// //none//
  
-====  GAIA_SetLoadBalancing()  ====+---- 
 + 
 + 
 +===  GAIA_SetMT()  ===
 <code java> <code java>
-void    GAIA_SetLoadBalancing (int state);+void    GAIA_SetMT (int new_size);
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * int **state**: it turns ON and OFF the load balancing mechanism provided by GAIA+, {LOAD_ON, LOAD_OFF}, default LOAD_OFF;+   * int **new_size**: it defines the threshold of the migration heuristic;
  
 **Description**: **Description**:
  
-The GAIA+ mechanism automatically reacts to heterogeneous hardware (in terms of performancesand background load, dynamically reallocating the SE from the "slow" to the "fast" LPs.+The Migration Threshold (MTis a value used to limit the migration rate of SEs (default value = 10). Each SE can evaluate the migration heuristic only if its counter has a value that is bigger than MT. At bootstrap and at each migration the counter is re-initializedThe detailed semantic of the counter depends on what migration heuristic is used. 
 + 
 + 
 +^ Migration heuristic      ^  SetHistory() semantic       ^ 
 +| MIGR_OFF    |  //none//     | 
 +| MIGR_ON / MIGR_E1     Threshold: number of timesteps (since the last reset)   | 
 +| MIGR_E2  |  Threshold: number of UNICAST events generated (since the last reset) 
 + 
 +\\
  
 **Notes**: **Notes**:
  
-//none//+Some degree of randomization is included in the mechanism to reduce the "wave effects" of migrating entities. 
  
 **Return value:** **Return value:**
Line 265: Line 291:
 //none// //none//
  
 +----
  
-====  GAIA_GetStep()  ====+ 
 +===  GAIA_SetMF()  ===
 <code java> <code java>
-double  GAIA_GetStep ( );+void    GAIA_SetMF (float migr_factor);
 </code> </code>
  
 **Parameters**: **Parameters**:
- +   * float **migr_factor**: it defines the relocation threshold of the migration heuristic;
-//none//+
  
 **Description**: **Description**:
  
-Returns the length of the time-step used in the simulationThis parameter is initialized using the **GLOBAL_LA** parameters as defined in the file "**channels.txt**". For example, GLOBAL_LA=1 defines global lookahead (timestep) of 1 time-unitand GLOBAL_LA=0.01 is to define timesteps with length of 1/100 of time-unit.+All the implemented migration heuristics are based on the evaluation of the outbound UNICAST traffic generated by each Simulated EntityThe migration factor is a tuning parameters of the heuristics: low value would increase the number of migrationsconversely higher value would reduce the number of migrations (default value = 3).
  
 **Notes**: **Notes**:
  
-//none//+The number of migrations is a trade-off between a high LCR and the overhead due to migrations.
  
 **Return value:** **Return value:**
  
-The time-step length (double).+//none//
  
 +----
  
-====  GAIA_Register()  ====+ 
 +===  GAIA_SetHistorySlots()  ===
 <code java> <code java>
-int     GAIA_Register (int migrable);+void    GAIA_SetHistorySlots (int history_slots);
 </code> </code>
  
 **Parameters**: **Parameters**:
- +   * int **history_slots**: number of slots considered in the history matrix;
-   * int **migrable**: MIGRABLE if the SE can be migrated, NOT_MIGRABLE if the SE can not be relocated;+
  
 **Description**: **Description**:
  
-This API is used to register a SE, the runtime returns a descriptor that will be used to identify the SE. The registration of SE is required to extend the scope of the SE outside the local LP (to the whole simulation). Only after the registration the SE will be able to send and receive messages, furthermore it could be involved in the migration and load balancing mechanisms.+The migration heuristic 1 (MIGR_ON / MIGR_E1) uses sliding window mechanism to evaluate the communication pattern of each SE (HISTORY_SLOTS, default value = 4). The number of slots composing the sliding window can be defined at the simulation bootstrap using this API.
  
 **Notes**: **Notes**:
  
-The registration of a SE is an event that has to be propagated to the whole simulatorThereforeif the registration of a SE happens at timestep **t**, only starting from timestep **t+1** will be possible to send or receive messages regarding such SE. For example, it is NOT possible to register a new SE at timestep **t** and to immediately send a message from this SE in the same timestep.+Too many slots would reduce the reactivity of the migration mechanismConverselya too small value would cause an excessive number of migrations.
  
 **Return value:** **Return value:**
  
-The descriptor (integer) of the SE.+//none//
  
 +----
  
-====  GAIA_TimeAdvance()  ====+ 
 +===  GAIA_SetEventHistorySize()  ===
 <code java> <code java>
-double  GAIA_TimeAdvance ();+void    GAIA_SetEventHistorySize (int size);
 </code> </code>
  
 **Parameters**: **Parameters**:
- +   * int **size**: number of events (FIFO order) considered by the migration heuristic 2 and 3.
-//none//+
  
 **Description**: **Description**:
  
-It is used by the LP to notify to the runtime that the current timestep is ended, and therefore, the local LP is ready to start the next timestep. The LP will remain blocked until the runtime will enable the transition to the next timestep.+The migration heuristics 2 and 3 (MIGR_E2 / MIGR_E3) are based on the a sliding window with the last E2_EVENT_HISTORY_SIZE messages sent by the SE (default value 100). The number of events composing the sliding window can be defined at the simulation bootstrap using this API.
  
 **Notes**: **Notes**:
Line 329: Line 358:
 **Return value:** **Return value:**
  
-Returns the next timestep value (double).+//none//
  
 +----
  
-====  GAIA_Migrate()  ====+ 
 +===  GAIA_SetMigration()  ===
 <code java> <code java>
-void    GAIA_Migrate (int id, String data, int size);+void    GAIA_SetMigration (int state);
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * int **id**: Identifier of the migrating SE; +   * int **state**: it selects the migration heuristic, {MIGR_OFF, MIGR_ON, MIGR_E1, MIGR_E2, MIGR_E3}, default MIGR_OFF;
-   * String **data**: A string containing the internal state of the SE; +
-   * int **size**: String size; +
  
 **Description**: **Description**:
  
-It is used by a local LP to migrate a SE to a remote LP. The local LP is **not** free to define what SEs should be migrated. During the simulation execution, the migration mechanism defines what SEs have to be migrated and informs the LP using a "NOTIF_MIGR" message. The other LPs that are not directly involved in the migration will be informed of the event with a "NOTIF_MIGR_EXT".+All the implemented migration heuristics are based on the evaluation of the outbound UNICAST traffic generated by each SE (also called events).
  
-**Notes**:+^ Migration heuristic      ^  Description        Pros  ^  Cons  ^ 
 +| MIGR_OFF    |  //none//      none  |  none  | 
 +| MIGR_ON / MIGR_E1    The heuristic is evaluated each timestep. It is based on the last E1_HISTORY_SLOTS timesteps of the simulation. It is implemented a sliding window approach that at each step throws away the oldest events and inserts the more recent ones  |  Very high LCR  \\  Well-suited for communication intensive models  |  In some cases, relevant overhead  |  
 +| MIGR_E2  |  The heuristic is evaluated each timestep. It is based on the a sliding window with the last E2_EVENT_HISTORY_SIZE messages sent by the SE  |  Well suited for simulations in which the communication pattern of entities changes frequently    In some cases, relevant overhead 
 +| MIGR_E3  |  The heuristic is evaluated only if the SE has sent at least E3_EVENT_COUNTDOWN events after the last evaluation. The rest of the mechanism is the same as MIGR_E2  |  Well suited for simulations with a very high number of SEs and in which the communication pattern of entities changes frequently    In some cases slow convergence and slightly lower LCR  |
  
-   * The "NOTIF_MIGR" message and the related migration are **mandatory**. The LPs cannot independently migrate any SE without previously receiving a "NOTIF_MIGR" message. This migration of "notified" SEs have to be done at the end of the timestep in which is received the notification.+\\
  
-   The GAIA_Migrate() is implemented using "EXEC_MIGR" message. Therefore, the LP that receives message of this type is receiving migrating Simulated Entity.+ 
 +**Notes**: 
 + 
 +For tuning of the heuristics please see: 
 +  * GAIA_SetMT(): for an introduction to the Migration Threshold, that is a mechanism that reduces the migration rate of SEs; 
 +  * GAIA_SetMF(): for an introduction to the Migration Factorthat is the parameter that is used to evaluate if and where activate the migration mechanism for SE; 
 +  * E1_HISTORY_SLOTS, default value = 4. It can be modified in the simulation setup using the GAIA_SetHistorySlots() API. 
 +  * E2_EVENT_HISTORY_SIZE, default value = 100. It is how many events (FIFO order) are considered by migration heuristics 2 and 3. This value can be changed using the GAIA_SetEventHistorySize() API. 
 +  * E3_EVENT_COUNTDOWN, default value = 30. It is the interval of events before new evaluation of the heuristic. This value can be changed using the GAIA_SetCountDown() API.
  
 **Return value:** **Return value:**
Line 357: Line 397:
 //none// //none//
  
 +----
  
-====  GAIA_ByteMigrate()  ====+ 
 +==== Load Balancing ==== 
 + 
 +===  GAIA_SetLoadBalancing()  ===
 <code java> <code java>
-void    GAIA_ByteMigrate (int id, byte[] data, int size);+void    GAIA_SetLoadBalancing (int state);
 </code> </code>
  
 **Parameters**: **Parameters**:
-   * int **id**: Identifier of the migrating SE; +   * int **state**: it turns ON and OFF the load balancing mechanism provided by GAIA+, {LOAD_ON, LOAD_OFF}, default LOAD_OFF;
-   * byte[] **data**: A byte-array containing the internal state of the SE; +
-   * int **size**: String size; +
  
 **Description**: **Description**:
  
-It is used by a local LP to migrate a SE to a remote LP. The local LP is **not** free to define what SEs should be migrated. During the simulation execution, the migration mechanism defines what SEs have to be migrated and informs the  LP using a "NOTIF_MIGRmessage. The other LPs that are not directly involved in the migration will be informed of the event with a “NOTIF_MIGR_EXT”+The GAIA+ mechanism automatically reacts to heterogeneous hardware (in terms of performances) and background loaddynamically reallocating the SE from the "slow" to the "fast" LPs.
  
 **Notes**: **Notes**:
  
-   * The "NOTIF_MIGR" message and the related migration are **mandatory**. The LPs cannot independently migrate any SE without previously receiving a "NOTIF_MIGR" message. This migration of “notified” SEs have to be done at the end of the timestep in which is received the notification. +//none//
  
-   The GAIA_ByteMigrate() is implemented using a “EXEC_MIGR” message. Therefore, the LP that receives a message of this type is receiving a migrating Simulated Entity.+**Return value:**
  
-   * This API has the exactly the same semantic of GAIA_Migrate(). For performance reasons, in this case the SE state is contained in an array instead of a String.+//none//
  
-**Return value:**+----
  
-//none// 
  
 +====  Communication  ====
  
-====  GAIA_Send()  ====+===  GAIA_Send()  ===
 <code java> <code java>
 void    GAIA_Send (int obj_src, int obj_dest, double Ts, String Msg, int Size); void    GAIA_Send (int obj_src, int obj_dest, double Ts, String Msg, int Size);
Line 405: Line 446:
 **Notes**: **Notes**:
  
-The message time-stamp has to respect the constraints given by the synchronization algorithm (time-stepped).+The message time-stamp has to respect the constraints given by the synchronization algorithm (timestepped).
  
 **Return value:** **Return value:**
Line 411: Line 452:
 //none// //none//
  
 +----
  
-====  GAIA_ByteSend()  ====+ 
 +===  GAIA_ByteSend()  ===
 <code java> <code java>
 void    GAIA_ByteSend (int obj_src, int obj_dest, double Ts, byte[] Msg, int Size); void    GAIA_ByteSend (int obj_src, int obj_dest, double Ts, byte[] Msg, int Size);
Line 431: Line 474:
 **Notes**: **Notes**:
  
-   * The message time-stamp has to respect the constraints given by the synchronization algorithm (time-stepped).+   * The message time-stamp has to respect the constraints given by the synchronization algorithm (timestepped).
  
    * This API has the exactly the same semantic of GAIA_Send(). For performance reasons, in this case the message is contained in an array instead of a String.    * This API has the exactly the same semantic of GAIA_Send(). For performance reasons, in this case the message is contained in an array instead of a String.
Line 439: Line 482:
  
 //none// //none//
 +
 +----
  
  
-====  GAIA_Broadcast()  ====+===  GAIA_Broadcast()  ===
 <code java> <code java>
 void    GAIA_Broadcast (int obj_src, double Ts, String Msg, int Size); void    GAIA_Broadcast (int obj_src, double Ts, String Msg, int Size);
Line 459: Line 504:
 **Notes**: **Notes**:
  
-   * The message time-stamp has to respect the constraints given by the synchronization algorithm (time-stepped).+   * The message time-stamp has to respect the constraints given by the synchronization algorithm (timestepped).
  
    * Given that the message is delivered also to the SE that is originating it, it must be carefully managed to avoid loops.    * Given that the message is delivered also to the SE that is originating it, it must be carefully managed to avoid loops.
Line 467: Line 512:
 //none// //none//
  
 +----
  
-====  GAIA_ByteBroadcast()  ====+ 
 +===  GAIA_ByteBroadcast()  ===
 <code java> <code java>
 void    GAIA_ByteBroadcast (int obj_src, double Ts, byte[] Msg, int Size); void    GAIA_ByteBroadcast (int obj_src, double Ts, byte[] Msg, int Size);
Line 486: Line 533:
 **Notes**: **Notes**:
  
-   * The message time-stamp has to respect the constraints given by the synchronization algorithm (time-stepped).+   * The message time-stamp has to respect the constraints given by the synchronization algorithm (timestepped).
  
    * Given that the message is delivered also to the SE that is originating it, it must be carefully managed to avoid loops.    * Given that the message is delivered also to the SE that is originating it, it must be carefully managed to avoid loops.
Line 496: Line 543:
  
 //none// //none//
 +
 +----
  
  
-====  GAIA_Receive()  ====+===  GAIA_Receive()  ===
 <code java> <code java>
 String  GAIA_Receive(int maxlen); String  GAIA_Receive(int maxlen);
Line 525: Line 574:
 Returns the message (String). Returns the message (String).
  
 +----
  
  
-====  GAIA_ByteReceive()  ====+===  GAIA_ByteReceive()  ===
 <code java> <code java>
 byte[]  GAIA_ByteReceive(int maxlen); byte[]  GAIA_ByteReceive(int maxlen);
Line 556: Line 606:
 Returns the message (byte-array). Returns the message (byte-array).
  
-====  GAIA_GetStatistics()  ====+---- 
 + 
 + 
 +==== Statistics ==== 
 + 
 + 
 +===  GAIA_GetStatistics()  ===
 <code java> <code java>
 void  GAIA_GetStatistics(); void  GAIA_GetStatistics();
Line 581: Line 637:
  
 //none// //none//
 +
 +
 +----
  
 ===== C bindings ===== ===== C bindings =====
Line 591: Line 650:
 void    GAIA_SetMF (float); void    GAIA_SetMF (float);
 void    GAIA_SetMT (unsigned int); void    GAIA_SetMT (unsigned int);
 +void GAIA_SetCountDown ( int );
 +void GAIA_SetHistorySlots (int );
 +void GAIA_SetEventHistorySize (int );
 void    GAIA_SetMigration (int); void    GAIA_SetMigration (int);
 void    GAIA_SetLoadBalancing (int); void    GAIA_SetLoadBalancing (int);
Line 604: Line 666:
  
 Please refer to the description of the Java binding to have an introduction to the provided APIs. Please refer to the description of the Java binding to have an introduction to the provided APIs.
- 
  
pads/gaia-apis.1289394214.txt.gz · Last modified: 2010/11/10 13:03 by gdangelo

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki