Skip to main content

Type de données : __VECTOR

Note

Les opérations vectorielles ne sont nativement prises en charge que sur les processeurs 64 bits et n'offrent qu'un avantage de vitesse sur eux. La fiche technique du contrôleur vous informe sur le processeur utilisé sur le contrôleur.

Actuellement, les opérations vectorielles sont nativement prises en charge sur les plates-formes x86-64bit avec SSE2 et ARM64 avec NEON. Sur toutes les autres plates-formes, les opérations vectorielles sont traduites en instructions uniques. Par exemple, une addition vectorielle avec un certain nombre d'additions individuelles est ensuite effectuée.

Les extensions du jeu d'instructions des processeurs sont des extensions SIMD. SIMD (Single Instruction, Multiple Data) désigne une architecture informatique dans laquelle plusieurs ensembles de données similaires peuvent être traités en parallèle et donc plus rapidement avec un seul appel de commande. Avec les opérations vectorielles, par exemple, 4 paires de nombres peuvent être additionnées en même temps.

syntaxe

<variable name> :  __VECTOR[ <vector size> ] OF <element type> := <initialization> ;

<vector size> : 1 |2 | 3 | 4 | 5| 6 | 7| 8
<element type> : REAL | LREAL

L'initialisation des variables est facultative.

Un type de données vectoriel est un tableau de nombres à virgule flottante avec un maximum de 8 éléments. Les opérateurs représentent ce type de données __vc<operator name> à l'élimination. Cela vous permet d'implémenter des opérations vectorielles sans appels de fonction supplémentaires.

Syntaxe d'accès à l'index

<variable name>[ <index> ]
<index> : 0 | 1 | 2| 3 | 4 | 5| 6 | 7

L'accès d'index à une variable vectorielle vous permet d'accéder à un seul élément du vecteur. L'index commence à 0 et monte jusqu'à <taille du vecteur> - 1.

PROGRAM PLC_PRG
VAR
        vcA : __VECTOR[3] OF REAL;
END_VAR

vcA[0] := 1.1;
vcA[1] := 2.2;
vcA[2] := 3.3;

Déterminer la taille de vecteur optimale

Astuce

Utilisez la taille de vecteur optimale en fonction de votre système cible comme taille de vecteur afin de programmer le code le plus efficace possible.

Dans les systèmes cibles dont l'architecture informatique est fondamentalement adaptée au traitement vectoriel, il est déconseillé d'utiliser des vecteurs de toute taille. A savoir, selon le type de traitement de données du processeur, il existe une taille de vecteur optimale. Les vecteurs déclarés avec cette taille de tableau sont traités aussi rapidement que possible. Les vecteurs déclarés comme un plus grand tableau n'ont aucun avantage en termes de vitesse. Les vecteurs déclarés comme un tableau plus petit n'utilisent pas pleinement les capacités du processeur.

Vous pouvez interroger la taille optimale lors de l'exécution. Vous pouvez trouver les informations dans les constantes Constants.vcOptimalREAL pour les vecteurs avec REAL-Éléments et Constants.vcOptimalLREAL pour les vecteurs avec LREAL-Eléments disponibles, les constantes ont le type de données INT. Si une constante supérieure à la taille optimale, la valeur 1 renvoie, cela signifie que le système cible ne dispose pas d'un traitement vectoriel accéléré.

PROGRAM PLC_PRG
VAR
        iOVS_REAL : INT; // Optimal vector size for REAL eleements
        iOVS_LREAL : INT; // Optimal vector size for LREAL eleements
END_VAR

iOVS_REAL := Constants.vcOptimalREAL;
iOVS_LREAL := Constants.vcOptimalLREAL;

Une application s'exécutant sur le système cible CODESYS Control Win V3 x64 est chargé, renvoie les valeurs suivantes à l'exécution :

_cds_img_read_optimal_vector_size.png

Opérateur : __VCADD

L'opérateur calcule la somme de deux vecteurs.

syntaxe

<vector variable> := <1st vector operand> __VCADD <2nd vector operand>;
Exemple 241. Ajouter
FUNCTION_BLOCK FB_ADD
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
    vcResult : __VECTOR[3] OF REAL;
END_VAR
vcResult := vcA __VCADD vcB;


Opérateur : __VCSUB

L'opérateur calcule la différence entre deux vecteurs.

syntaxe

<vector variable> := <vector minuend> __VCSUB <vector subtrahend>;
Exemple 242. Soustraire
FUNCTION_BLOCK FB_SUB
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
    vcResult0 : __VECTOR[3] OF REAL;
    vcResult1 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := vcA __VCSUB vcB;
vcResult1 := vcB __VCSUB vcA;


Opérateur : __VCMUL

L'opérateur calcule le produit de deux vecteurs ou d'un scalaire (nombre à virgule flottante) avec un vecteur.

syntaxe

<vector variable> := <1st vector operand> __VCMUL <2nd vector operand> | <scalar operand> __VCMUL <vector operand> | <vector operand> __VCMUL <scalar operand> ;
Exemple 243. Multiplier
FUNCTION_BLOCK FB_MUL
VAR
    rScalar : REAL := 1.1;
    vcA : __VECTOR[3] OF REAL;
    vcB : __VECTOR[3] OF REAL;
    vcResult0 : __VECTOR[3] OF REAL;
    vcResult1 : __VECTOR[3] OF REAL;
    vcResult2 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := vcA __VCMUL vcB;
vcResult1 := rScalar __VCMUL vcB;
vcResult2 := vcA __VCMUL 3.3;


Opérateur : __VCDIV

L'opérateur calcule le quotient de deux vecteurs ou un vecteur et un scalaire.

syntaxe

<vector variable> := <vector dividend> __VCDIV <vector divisor> | < vector dividend> __VCMUL <scalar divisor> ;
Exemple 244. Diviser
FUNCTION_BLOCK FB_DIV
VAR
    iScalar : INT := 3;
    rScalar : REAL := 1.5;
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
    vcResult0 : __VECTOR[3] OF REAL;
    vcResult1 : __VECTOR[3] OF REAL;
    vcResult2 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := vcA __VCDIV vcB;
// ERROR CODE vcResult1 := rScalar __VCDIV vcB;
// ERROR CODE vcResult1 := iScalar __VCDIV vcB;
// ERROR CODE vcResult1 := 3.3 __VCDIV vcB;
vcResult2 := vcA __VCDIV 1.5;
vcResult2 := vcA __VCDIV iScalar;
vcResult2 := vcA __VCDIV rScalar;


Opérateur : __VCDOT

L'opérateur calcule le produit scalaire (produit scalaire) de deux vecteurs.

syntaxe

<skalar variable> := <1st vector operand> __VCDOT <2nd vector operand> ;
Exemple 245. produit scalaire
FUNCTION_BLOCK FB_DOT
VAR
    rResult : REAL;
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
END_VAR
rResult := vcA __VCDOT vcB; // = 18


Opérateur : __VCSQRT

L'opérateur calcule la racine carrée de chaque élément du vecteur.

syntaxe

<vector variable> := __VCSQRT( <vector operand> );
Exemple 246. racine carrée
FUNCTION_BLOCK FB_SQRT
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(4, 9, 16);
    vcResult0 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := __VCSQRT(vcA);


Opérateur : __VCMAX

L'opérateur calcule le vecteur maximum de deux vecteurs. Le maximum est déterminé élément par élément.

syntaxe

<vector variable> := __VCMAX( <1st vector operand>, <2nd vector operand>);
Exemple 247. vecteur maximal
FUNCTION_BLOCK FB_MAX
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 6);
    vcResult0 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := __VCMAX(vcA, vcB);


Opérateur : __VCMIN

L'opérateur calcule le vecteur minimum de deux vecteurs. Le minimum est déterminé élément par élément.

syntaxe

<vector variable> := __VCMIN( <1st vector operand>, <2nd vector operand>);
Exemple 248. Exemple de vecteur minimal
FUNCTION_BLOCK FB_MIN
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 6);
    vcResult0 : __VECTOR[3] OF REAL;
END_VAR
vcResult0 := __VCMIN(vcA, vcB);


Opérateur : __VCSET_REAL

L'opérateur place tous les éléments d'un vecteur dans une seule instruction. Les éléments ont le type de données REAL.

syntaxe

<vector variable> := __VCSET_REAL( <first literal>, ( < next literal> )+ ) ;
( ... )+ // number of elements have to match
FUNCTION_BLOCK FB_SET
VAR
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
    vcB : __VECTOR[3] OF REAL := __VCSET_REAL(1, 2, 3);
END_VAR
vcA := __VCSET_REAL(4, 4, 4);
vcB := __VCSET_REAL(1.1, 2.2, 3.3);

Opérateur : __VCSET_LREAL

L'opérateur définit tous les éléments d'un vecteur à la fois dans une instruction. Les éléments ont le type de données LREAL.

Vous pouvez utiliser l'opérateur partout où les variables sont valides, comme dans les affectations dans les implémentations ou comme paramètres dans les appels de fonction.

syntaxe

<vector variable> := __VCSET_LREAL( <first literal>, ( < next literal> )+ ) ;
( ... )+ // number of elements have to match
FUNCTION_BLOCK FB_SET
VAR
    vclA : __VECTOR[3] OF LREAL := __VCSET_LREAL(3, 3, 3);
    vclB : __VECTOR[3] OF LREAL := __VCSET_LREAL(1, 2, 3);
END_VAR
vclA := __VCSET_LREAL(-1.7976931348623158E+308, 0.0, 1.7976931348623158E+308);
vclB := __VCSET_LREAL(-1.7976931348623158E+308, 0.0, 1.7976931348623158E+308);

Opérateur : __VCLOAD_REAL

L'opérateur interprète toute zone mémoire comme un vecteur. Ceci est utile pour connecter des variables vectorielles au code existant. L'opérateur prend 2 paramètres. Le premier paramètre spécifie le nombre d'éléments vectoriels. Le deuxième paramètre est un pointeur vers le REAL-Données.

Important

__VCLOAD_REAL(<n>,<ptr>) lire <n> valeurs REAL consécutives à l'adresse <ptr>. Si moins de <n> Les valeurs à cette adresse peuvent faire planter le contrôleur ou lire de la mémoire indésirable.

syntaxe

<vector variable> := __VCLOAD_REAL( <vector size>, <pointer to data of type REAL> ) ;
<vector size> : 2 | 3 | 4 | 5| 6 | 7| 8
Exemple 249. Vectoriser
FUNCTION_BLOCK FB_LOAD
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
    rData : ARRAY[0..2] OF REAL := [1.234, 5.678, 9.123];
    vcA : __VECTOR[3] OF REAL := __VCSET_REAL(3, 3, 3);
END_VAR

vcA := __VCLOAD_REAL(3, ADR(rData[0]));


Opérateur : __VCLOAD_LREAL

L'opérateur interprète toute zone mémoire comme un vecteur. Ceci est utile pour connecter des variables vectorielles au code existant. L'opérateur prend 2 paramètres. Le premier paramètre spécifie le nombre d'éléments vectoriels. Le deuxième paramètre est un pointeur vers le LREAL-Données.

Important

__VCLOAD_LREAL (<n>,<ptr>) lit <n> valeurs LREAL successives au <ptr> adresse. S'il y a moins de <n> valeurs à cette adresse, cela peut entraîner le plantage du contrôleur ou la lecture de mémoire indésirable.

syntaxe

<vector variable> := __VCLOAD_LREAL( <vector size>, <pointer to data of type LREAL> );
<number of vector elements> : 1 | 2 | 3 | 4 | 5| 6 | 7| 8
Exemple 250. Vectoriser
FUNCTION_BLOCK FB_LOAD
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
    rData : ARRAY[0..3] OF LREAL := [-1.7976931348623158E+308, 1.6E+308, 1.7E+308, -1.6E+308];
    vcA : __VECTOR[3] OF LREAL := __VCSET_LREAL(1, 2, 3);
END_VAR

vcA := __VCLOAD_LREAL(3, ADR(rData[0]));


Opérateur : __VCSTORE

L'opérateur enregistre/copie le contenu du vecteur à l'adresse mémoire spécifiée. Le nombre et le type d'éléments sont automatiquement extraits de la variable vectorielle.

Important

__VCSTORE(<n>,<ptr>) écrit <n> valeurs consécutives à l'adresse <ptr>. Si moins de <n> Les valeurs à cette adresse peuvent faire planter le contrôleur ou écrire de la mémoire indésirable.

syntaxe

__VCSTORE( <pointer to data>, <vector variable> );
Exemple 251. Enregistrer sur ordinateur
FUNCTION_BLOCK FB_STORE
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
        rData : ARRAY[0..2] OF REAL := [1, 2, 3];
        pData: POINTER TO REAL := ADR(rData[0]);

        lrData : ARRAY [0..3] OF LREAL := [1, 2, 3, 4];
        plData: POINTER TO LREAL := ADR(lrData[0];


        vcA : __VECTOR[3] OF REAL := __VCSET_REAL( 1.234, 5.678, 9.123);
        vclA : __VECTOR[4] OF LREAL := __VCSET_LREAL(-1.7976931348623158E+308, 1.6E+308, 1.7E+308, -1.6E+308);
END_VAR

__VCSTORE(pData, vcA);
__VCSTORE(plData, vclA);


Dans cette section​: