LAPI_Rmw Subroutine

Online bearbeiten

Zweck

Stellt Basiselemente für die Datensynchronisation bereit

Bibliothek

Verfügbarkeitsbibliothek (liblapi_r.a)

C-Syntax

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

FORTRAN-Syntax

include 'lapif.h'
 
LAPI_RMW(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 in_val
INTEGER prev_tgt_val
TYPE (LAPI_CNTR_T) :: org_cntr
INTEGER ierror

Beschreibung

Type of call: Punkt-zu-Punkt-Kommunikation (nicht blockierend)

Verwenden Sie diese Subroutine, um zwei unabhängige Datenteile zu synchronisieren, z. B. zwei Tasks, die eine gemeinsame Datenstruktur gemeinsam nutzen. Die Operation wird in der Zieltask (tgt) ausgeführt und ist atomar. Die Operation nimmt einen Eingabewert (in_val) vom Ursprung und führt eine von vier Operationen (op) für eine Variable aus ( tgt_var) auf dem Ziel (tgt), und ersetzt dann die Zielvariable (tgt_var) durch die Ergebnisse der Operation (op). Der ursprüngliche Wert (prev_tgt_val) der Zielvariablen (Zielvariable) wird an den Ursprung zurückgegeben.

Die Operationen (op) werden über den Kontext ausgeführt, auf den hndlverweist. Das Ergebnis der Ausführung dieser Aufrufe ist, als ob der folgende Code atomar ausgeführt wurde:

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

Erläuterungen:

f (a, b) = a + b für FETCH_AND_ADD

f (a, b) = a | b für FETCH_AND_OR (bitweise oder)

f (a, b) = b für SWAP

Für COMPARE_AND_SWAPwird in_val als Zeiger auf ein Array von zwei ganzen Zahlen behandelt. op ist die folgende atomare Operation:

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

Alle LAPI_Rmw -Aufrufe sind nicht blockierend. Verwenden Sie die Subroutinen LAPI_Getcntr und LAPI_Waitcntr , um die Fertigstellung zu testen. LAPI_Rmw enthält keinen Zielzähler (tgt_cntr), daher geben LAPI_Rmw -Aufrufe keinen Hinweis auf die Beendigung der Zieltask (tgt).

Parameter

INPUT
hndl
Gibt die LAPI-Kennung an.
Operation
Gibt die auszuführende Operation an. Gültige Operationen sind:
  • COMPARE_AND_SWAP
  • FETCH_AND_ADD
  • FETCH_AND_OR
  • SWAP
tgt
Gibt die Task-ID der Zieltask an, in der sich die Variable 'read-modify-write' (Rmw) befindet Der Wert dieses Parameters muss im Bereich 0 < = tgt < NUM_TASKSliegen.
Zielvariable
Gibt die Zielvariable Rmw (read-modify-write) (in FORTRAN) oder ihre Adresse (in C) an. Der Wert dieses Parameters darf nicht NULL (in C) oder LAPI_ADDR_NULL (in FORTRAN) sein.
in_val
Gibt den Wert an, der an die Operation übergeben wird (op). Dieser Wert kann nicht NULL (in C) oder LAPI_ADDR_NULL (in FORTRAN) sein.
Ein-/Ausgabe
vorheriges_Zielwert
Gibt die Position am Ursprung an, an der die vorherige tgt_var in der Zieltask gespeichert wird, bevor die Operation (op) ausgeführt wird. Der Wert dieses Parameters kann NULL (in C) oder LAPI_ADDR_NULL (in FORTRAN) sein.
org_cntr
Gibt die Adresse des Ursprungszählers (in C) oder den Ursprungszähler (in FORTRAN) an. Wenn prev_tgt_val festgelegt ist, Der Ursprungszähler (org_cntr) wird erhöht, wenn prev_tgt_val an die Ursprungsseite zurückgegeben wird. Wenn prev_tgt_val nicht festgelegt ist, Der Ursprungszähler (org_cntr) wird nach Abschluss der Operation (op) auf der Zielseite aktualisiert.
Ausgabe
ierror
Gibt einen FORTRAN-Rückkehrcode an Dies ist immer der letzte Parameter.

Einschränkungen

LAPI-Statistiken werden nicht für die Kommunikation über gemeinsam genutzten Speicher und die Datenübertragung oder für Nachrichten berichtet, die eine Task an sich selbst sendet.

C-Beispiele

  1. So synchronisieren Sie einen Datenwert zwischen zwei Tasks (mit FETCH_AND_ADD):
    {

       int local_var;
       int *addr_list;

       /* both tasks initialize local_var to a value       */

       /* local_var addresses are exchanged and stored     */
       /* in addr_list (using LAPI_Address_init).          */
       /* addr_list[tgt] now contains the 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_Rmw(hndl, FETCH_AND_ADD, tgt, addr_list[tgt],
                value, prev_tgt_val, &org_cntr);

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

}
  2. So synchronisieren Sie einen Datenwert zwischen zwei Tasks (mit SWAP):
    
{

      int local_var;
      int *addr_list;

      /* local_var addresses are exchanged and stored  */
      /* in addr_list (using LAPI_Address_init).       */
      /* 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 remote task  */
      LAPI_Rmw(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. Gehen Sie wie folgt vor, um einen Datenwert bedingt auszutauschen (mit COMPARE_AND_SWAP):
    
{

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

      /* local_var addresses are exchanged and stored        */
      /* in addr_list (using LAPI_Address_init).             */
      /* 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 remote task            */
			
      in_val[0] = comparator;
      in_val[1] = value;

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

      /* local_var on the 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.                       */

}

Rückgabewerte

LAPI_ERFOLG
Gibt an, dass der Funktionsaufruf erfolgreich ausgeführt wurde.
LAPI_ERR_HNDL_UNGÜLTIG
Gibt an, dass die übergebene hndl ungültig ist (nicht initialisiert oder beendet).
LAPI_ERR_IN_VAL_NULL
Gibt an, dass der Zeiger auf in_val NULL ist (in C) oder dass der Wert von in_val LAPI_ADDR_NULL ist (in FORTRAN).
LAPI_ERR_RMW_OP
Gibt an, dass op nicht gültig ist.
LAPI_ERR_TGT
Gibt an, dass die übergebene tgt außerhalb des im Job definierten Taskbereichs liegt.
LAPI_ERR_TGT_GELÖSCHT
Gibt an, dass die Subroutine früh zurückgegeben wurde, weil LAPI_Purge_totask() aufgerufen wurde.
LAPI_ERR_TGT_VAR_NULL
Gibt an, dass die tgt_var -Adresse NULL (in C) oder der Wert von tgt_var LAPI_ADDR_NULL (in FORTRAN) ist.

Position

/usr/lib/liblapi_r.a