LAPI_Rmw64 Sous-routine

Editer en ligne

Objectif

Fournit des primitives de synchronisation de données pour les applications 64 bits.

Bibliothèque

Bibliothèque de disponibilité (liblapi_r.a)

Syntaxe C

#include <lapi.h>
 
int LAPI_Rmw64(hndl, op, tgt, tgt_var, in_val, prev_tgt_val, org_cntr)
 
lapi_handle_t hndl;
Rmw_ops_t op;
uint tgt;
long long *tgt_var;
long long *in_val;
long long *prev_tgt_val;
lapi_cntr_t *org_cntr;

Syntaxe FORTRAN

include 'lapif.h'
 
LAPI_RMW64(hndl, op, tgt, tgt_var, in_val, prev_tgt_val, org_cntr,  ierror)

INTEGER hndl
INTEGER op
INTEGER tgt
INTEGER (KIND=LAPI_ADDR_TYPE) :: tgt_var
INTEGER (KIND=LAPI_LONG_LONG_TYPE) :: in_val, prev_tgt_val
TYPE (LAPI_CNTR_T) :: org_cntr
INTEGER ierror

Descriptif

Communication point à point Type of call: (non bloquante)

Cette sous-routine est la version 64 bits de LAPI_Rmw. Il est utilisé pour synchroniser deux pièces indépendantes de données 64 bits, telles que deux tâches partageant une structure de données commune. L'opération est effectuée à la tâche cible (Tgt) et est atomique. L'opération prend une valeur d'entrée (_val) à partir de l'origine et effectue l'une des quatre opérations (Opp.) sur une variable (Var_tgt) sur la cible (Tgt), puis remplace la variable cible (Var_tgt) par les résultats de l'opération (Opp.). La valeur d'origine (Valeur_tgt) de la variable cible (Var_tgt) est renvoyée à l'origine.

Les opérations (Opp.) sont effectuées sur le contexte désigné par Hndl. Le résultat de l'exécution de ces appels est comme si le code suivant était exécuté atomiquement:

*prev_tgt_val = *tgt_var;
*tgt_var      = f(*tgt_var, *in_val);

où :

F (a, b) = a + b pour FETCH_AND_ADD

F (a, b) = a | b pour FETCH_AND_OR (bitwise ou)

f (a, b) = b pour SWAP

Pour COMPARE_AND_SWAP, in_val est traité comme un pointeur vers un tableau de deux entiers et op est l'opération atomique suivante:

if(*tgt_var == in_val[0])  {
   *prev_tgt_val = TRUE;
   *tgt_var      = in_val[1];
} else {
   *prev_tgt_val = FALSE;
}

Cette sous-routine peut également être utilisée sur un processeur 32 bits.

Tous les appels LAPI_Rmw64 ne sont pas bloquants. Pour tester l'achèvement, utilisez les sous-routines LAPI_Getcntr et LAPI_Waitcntr . LAPI_Rmw64 n'inclut pas de compteur cible (tgt_cntr), de sorte que les appels LAPI_Rmw64 ne fournissent aucune indication d'achèvement sur la tâche cible (tgt).

Paramètres

ENTREE
Hndl
Indique le descripteur LAPI.
Opp.
Indique l'opération à effectuer. Les opérations valides sont les suivantes:
  • COMPARE_AND_SWAP
  • FETCH_AND_ADD
  • FETCH_AND_OR
  • SWAP
Tgt
Indique l'ID tâche de la tâche cible dans laquelle se trouve la variable read-modify-write (Rmw64). La valeur de ce paramètre doit être comprise dans la plage 0 < = tgt < NUM_TASKS.
Var_tgt
Indique la variable read-modify-write (Rmw64) cible (dans FORTRAN) ou son adresse (en C). La valeur de ce paramètre ne peut pas être NULL (en C) ou LAPI_ADDR_NULL (en FORTRAN).
_val
Indique la valeur transmise à l'opération (Opp.). Cette valeur ne peut pas être NULL (en C) ou LAPI_ADDR_NULL (en FORTRAN).
Entrée-sortie
Valeur_tgt
Indique l'emplacement à l'origine dans lequel le fichier Var_tgt précédent sur la tâche cible est stocké avant l'exécution de l'opération (Opp.). La valeur de ce paramètre peut être NULL (en C) ou LAPI_ADDR_NULL (en FORTRAN).
Org_cntr
Indique l'adresse du compteur d'origine (en C) ou le compteur d'origine (dans FORTRAN). Si Valeur_tgt est défini, le compteur d'origine (Org_cntr) est incrémenté lorsque Valeur_tgt est renvoyé au côté de l'origine. Si Valeur_tgt n'est pas défini, le compteur d'origine (Org_cntr) est mis à jour une fois que l'opération (Opp.) est terminée sur le côté cible.
Sortie
Ierror
Indique un code retour FORTRAN. C'est toujours le dernier paramètre.

Restrictions

Les statistiques LAPI sont Pas pour la communication de mémoire partagée et le transfert de données, ou pour les messages qu'une tâche envoie à elle-même.

C Exemples

  1. Pour synchroniser une valeur de données entre deux tâches (avec FETCH_AND_ADD):
    {

      long long local_var;
      long long *addr_list;

      /* both tasks initialize local_var to a value        */

      /* local_var addresses are exchanged and stored      */
      /* in addr_list (using LAPI_Address_init64)          */
      /* addr_list[tgt] now contains address of            */
      /* local_var on tgt                                  */
      .
      .
      .
      /* add value to local_var on some task               */

      /* use LAPI to add value to local_var on remote task */
      LAPI_Rmw64(hndl, FETCH_AND_ADD, tgt, addr_list[tgt],
                 value, prev_tgt_val, &org_cntr);

      /* local_var on remote task has been increased       */
      /* by value.  prev_tgt_val now contains value of     */
      /* local_var on remote task before the addition      */

}
  2. Pour synchroniser une valeur de données entre deux tâches (avec SWAP):
    
{

      long long local_var;
      long long *addr_list;

      /* local_var addresses are exchanged and stored           */
      /* in addr_list (using LAPI_Address_init64).              */
      /* addr_list[tgt] now contains the address of             */
      /* local_var on tgt.                                      */
      .
      .
      .
      /* local_var is assigned some value                       */

      /* assign local_var to local_var on the remote task       */
      LAPI_Rmw64(hndl, SWAP, tgt, addr_list[tgt],
                 local_var, prev_tgt_val, &org_cntr);

      /* local_var on the remote task is now equal to local_var */
      /* on the local task. prev_tgt_val now contains the value */
      /* of local_var on the remote task before the swap.       */

}
  3. Pour permuter de manière conditionnelle une valeur de données (avec COMPARE_AND_SWAP):
    
{

      long long local_var;
      long long *addr_list;
      long long in_val[2];

      /* local_var addresses are exchanged and stored        */
      /* in addr_list (using LAPI_Address_init64).           */
      /* addr_list[tgt] now contains the address of          */
      /* local_var on tgt.                                   */
      .
      .
      .
      /* if local_var on remote_task is equal to comparator, */
      /* assign value to local_var on the remote task        */
			
      in_val[0] = comparator;
      in_val[1] = value;

      LAPI_Rmw64(hndl, COMPARE_AND_SWAP, tgt, addr_list[tgt],
                 in_val, prev_tgt_val, &org_cntr);

      /* local_var on remote task is now in_val[1] if it     */
      /* had previously been equal to in_val[0]. If the      */ 
      /* swap was performed, prev_tgt_val now contains       */ 
      /* TRUE; otherwise, it contains FALSE.                 */

}

Valeurs renvoyées

LAPI_SUCCESS
Indique que l'appel de fonction a abouti.
LAPI_ERR_HNDL_INVALID
Indique que le Hndl transmis n'est pas valide (non initialisé ou à l'état arrêté).
LAPI_ERR_IN_VAL_NULL
Indique que le pointeur in_val est NULL (en C) ou que la valeur de in_val est LAPI_ADDR_NULL (en FORTRAN).
ECHEC DE LAPI_ERR_RMW_OP
Indique que Opp. n'est pas valide.
ERR_ERR_TGT
Indique que le Tgt transmis ne correspond pas à la plage de tâches définie dans le travail.
LAPI_ERR_TGT_PURGÉ
Indique que la sous-routine a été renvoyée tôt car LAPI_Purge_totask() a été appelé.
LAPI_ERR_TGT_VAR_NULL
Indique que l'adresse tgt_var est NULL (en C) ou que la valeur de tgt_var est LAPI_ADDR_NULL (en FORTRAN).

Emplacement

/usr/lib/liblapi_r.a