Métrique

//Declaration
FUNCTION FUN1 : INT
VAR_INPUT
    a,b : INT;
END_VAR
VAR
    c,d,e : INT;
END_VAR
VAR_STAT
    f,g,h : INT;
END_VAR

//Implementation
c := b;
d := a;
e := a+b;

Hypothèse : Pour le calcul, supposons un CODESYS Control Win qui utilise le générateur de code x86.

L'exemple ci-dessus a une taille d'appelant de 8 octets : 4 octets pour les deux INT inputs et 4 octets pour la valeur de retour. L'appareil a un alignement de pile de 4 octets, de sorte qu'il y a un espace de 2 octets. La taille de l'appelant est de 8 octets : trois variables locales de 2 octets chacune plus l'espace de 2 octets pour l'alignement de la pile. En conséquence, la taille totale de la pile de FUN1 fait 16 octets.

VAR_STAT n'est pas stocké sur la pile et n'augmente donc pas la taille de la pile d'un POU.

//Declaration PLC_PRG
PROGRAM PLC_PRG
VAR
    myFB : FB1;
END_VAR

//Implementation
myFB(b := FALSE);

//Declaration FB1
FUNCTION_BLOCK FB1
VAR_INPUT
    b : BOOL;
END_VAR
VAR
    i : INT;
END_VAR

//Implementation
METH(i);
IF b THEN
    METH(i*i);
END_IF

//Declaration FB1.METH
METHOD METH : BOOL
VAR_INPUT
    i : INT;
END_VAR

//Implementation
METH := i >= 42;

Si PLC_PRG est appelé dans une tâche, alors cet appel est également compté.

FB1 a exactement un appel (en PLC_PRG).

METH a deux appels, tous deux en FB1.

FUNCTION_BLOCK FB
//...

FUNCTION_BLOCK FB2 EXTENDS FB
//...

FUNCTION_BLOCK FB3 EXTENDS FB2
//...

Chaque bloc fonction est appelé individuellement PROGRAM. Chaque PROGRAM a sa propre tâche.

Le Tâches appelées la métrique renvoie en 1 pour FB3 et 2 pour FB2 parce que les appels de FB3 et FB2 sont comptés. La métrique donne 3 pour FB parce que dans ce cas, les appels de FB3, FB2, et FB sont comptés.

//GVL
VAR_GLOBAL
    gvla : INT;
    gvlb : INT;
    gvlc : INT;
END_VAR

/PRG declaration
PROGRAM PRG
VAR
    x : INT := GVL.gvlc;
    y : INT;
END_VAR

//PRG implementation
x := GVL.gvla;
y := GVL.gvla*GVL.gvlb;

Le PRG le programme utilise 3 variables de GVL: gvla, gvlb, et gvlc.

//Declaration
PROGRAM PRG
VAR
    xVar : BOOL:= %IX0.0; // +1 direct address access
    byVar : BYTE;
END_VAR

//Implementation
xVar := %IX0.0; // +1 direct address access
%QX0.0 := xVar; // +1
%MX0.1 := xVar; // +1
%MB1 := byVar; // +1

L'exemple dispose de 5 accès directs aux adresses.

//Declaration
FUNCTION_BLOCK FB
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
    i,j,k,l : INT;
    m,n,o : BOOL;
END_VAR

Dans le bloc fonction, 7 variables locales sont déclarées.

FUNCTION_BLOCK FB
VAR_INPUT
    i : INT;
    r : REAL;
END_VAR

Dans le bloc fonction, 2 variables d'entrée sont déclarées : i et r.

METHOD METH : BOOL
VAR_INPUT
    j : INT;
    l : LREAL;
END_VAR

La méthode a 2 entrées : j et l

FUNCTION_BLOCK FB
VAR_OUTPUT
    i : INT;    // +1 output
    r : REAL;   // +1 output
END_VAR

Le bloc fonction possède 2 variables de sortie : i et r

METHOD METH : BOOL
VAR_INPUT
    j : INT;
    l : LREAL;
END_VAR

La méthode a 3 sorties : METH, j, et l

METHOD METH1                    // +0 outputs (no return type)
VAR_OUTPUT
    ar : ARRAY[0..10] OF INT;   // +1 output
    l : LREAL;                  // +1 output
END_VAR

Le METH1 La méthode a 2 sorties : ar et i

//Declaration:
FUNCTION POU : BOOL
VAR_INPUT
END_VAR
VAR
    c : INT := 100; // statements in the declaration are not counted
END_VAR
VAR_OUTPUT
    test : INT;
    i : INT;
END_VAR

//Implementation:
IF TRUE THEN //if statement: +1
    test := 0; // +1
END_IF

WHILE test = 1 DO //while statement: +1
    ; // empty statements do not add to the statement count
END_WHILE

FOR c := 0 TO 10 BY 2 DO //for statement: +1
    i := i+i; // +1
END_FOR

{text 'simple text pragma'} //pragmas are not counted
test := 2; //+1

L'exemple comporte 6 instructions.

Partie déclaration :

FUNCTION_BLOCK FB //comments in the declaration are counted, as well
VAR_TEMP
    hugo : INT;
END_VAR

Mise en œuvre:

hugo := hugo + 1;
//Declaration: 40 letters non comment; 50 letters comment
//Implementation: 13 letters non comment; 152 letters comment
// 100 * 202 / 255 -> 79% comments

Le calcul du pourcentage 100 * 202 / 255 renvoie 79%.

// every POU has an initial cyclomatic complexity of 1, since it has at least 1 branch
IF b1 THEN                // +1 for the THEN branch
    ;
    ELSIF b2 THEN        // +1 for the THEN branch of the IF inside the else
        ;
ELSE                    
    IF b3 OR b4 THEN    // +1 for the THEN branch
        ;
    END_IF
END_IF

L'extrait de code a une complexité cyclomatique de 4.

// every POU has an initial cyclomatic complexity of 1, since it has at least 1 branch
CASE a OF
    1:	;    // +1
    2:	;    // +1
    3,4,5:	;    // +1
ELSE    // the ELSE statement does not increase the cyclomatic complexity
    ;
END_CASE

L'extrait de code a une complexité cyclomatique de 4.

// every POU has an initial cyclomatic complexity of 1, since it has at least 1 branch
WHILE b1 DO    // +1 for the WHILE loop
    ;
END_WHILE

REPEAT    // +1 for the REPEAT loop
    ;
    UNTIL b2
END_REPEAT

FOR a := 0 TO 100 BY 2 DO    // +1 for the REPEAT loop
    ;
END_FOR

L'extrait de code a une complexité cyclomatique de 4.

Les déclarations suivantes augmentent également la complexité cyclomatique :

//Declaration
FUNCTION FUN : STRING
VAR_INPUT
    condition_return : BOOL;
    condition_jmp : BOOL;
END_VAR
VAR
END_VAR

//Implementation
// every POU has an initial cyclomatic complexity of 1, since it has at least 1 branch
JMP(condition_jmp) lbl;    //Conditional jumps increase the cyclomatic complexity by 1

FUN := 'u';
RETURN(condition_return);    //Conditional returns increase the cyclomatic complexity by 1, too

lbl:
FUN := 't';

L'extrait de code a une complexité cyclomatique de 3.

Les instructions qui manipulent le flux de contrôle augmentent la complexité cognitive de 1

IF TRUE THEN    // +1 cognitive complexity
    ;
END_IF

WHILE TRUE DO    //+1 cognitive complexity
    ;
END_WHILE

FOR i := 0 TO 10 BY 1 DO    //+1 cognitive complexity
    ;
END_FOR

REPEAT    //+1 cognitive complexity
    ;
UNTIL TRUE
END_REPEAT

L'extrait de code a une complexité cognitive de 4.

Lors de l'imbrication du flux de contrôle, un incrément de 1 est ajouté pour chaque niveau d'imbrication.

IF TRUE THEN                        //+1 cognitive complexity
    WHILE TRUE DO                   //+2 (+1 for the loop itself, +1 for the nesting inside the IF)
        FOR i := 0 TO 10 BY 1 DO    //+3 (+1 for the FOR loop itself, +2 for the nesting inside the WHILE and the IF)
			;
        END_FOR
    END_WHILE

    REPEAT                          //+2 (+1 for the loop itself, +1 for the nesting inside the IF)
        ;
        UNTIL TRUE
    END_REPEAT
END_IF

L'extrait de code a une complexité cognitive de 8.

Les expressions booléennes jouant un rôle majeur dans la compréhension du code source, elles sont également prises en compte lors du calcul de la complexité cognitive.

Comprendre les expressions booléennes associées au même opérateur booléen n'est pas aussi difficile que comprendre une expression booléenne contenant des opérateurs booléens alternés. Par conséquent, toute chaîne d’opérateurs booléens identiques dans une expression augmente la complexité cognitive.

b := b1;    //+0: a simple expression, containing no operators, has no increment

L'expression simple sans opérateur a un incrément de 0.

b := b1 AND b2;    //+1: one chain of AND operators

L'expression avec un AND le lien a un incrément de 1.

b := b1 AND b2 AND b3;    //+1: one more AND, but the number of chains of operators does not change

L'expression a un de plus AND. Mais comme il s'agit du même opérateur, le numéro de la chaîne formée avec des opérateurs identiques ne change pas.

b := b1 AND b2 OR b3;    //+2: one chain of AND operators and one chain of OR operators

L'expression a une chaîne de AND opérateurs et une chaîne de OR les opérateurs. Cela donne un incrément de 2.

b := b1 AND b2 OR b3 AND b4 AND b5;    //+3

L'extrait de code a un incrément de 3.

b := b1 AND NOT b2 AND b3;    //+1: the unary NOT operator is not considered in the cognitive complexity

L'opérateur unaire NOT n’est pas considéré dans la complexité cognitive.

Le texte structuré contient des instructions et expressions supplémentaires qui modifient le flux de contrôle.

Les énoncés suivants sont pénalisés par un accroissement de complexité cognitive :

aNewLabel:
x := MUX(i, a,b,c); //+1 for MUX operator
y := SEL(b, i,j);   //+1 for SEL operator
JMP aNewLabel;      //+1 for JMP to label

EXIT et RETURN les déclarations n’augmentent pas la complexité cognitive.

FUNCTION_BLOCK MyBaseFB
// ...
FUNCTION_BLOCK AChildFB EXTENDS MyBaseFB
// ...
FUNCTION_BLOCK AGrandChildFB EXTENDS AChildFB
// ...

MyBaseFB a un DIT de 0 car il s’agit lui-même d’un bloc fonction qui n’étend aucun autre bloc fonction.

Pour AChildFB, le DIT est 1 car une étape est nécessaire pour arriver à MyBaseFB.

AGrandChildFB a un DIT de 2 : une étape est nécessaire pour AChildFB et un autre à MyBaseFB.

FUNCTION_BLOCK MyBaseFB
// ...
FUNCTION_BLOCK AChildFB EXTENDS MyBaseFB
// ...
FUNCTION_BLOCK AGrandChildFB EXTENDS AChildFB
// ...

MyBaseFB n'a qu'un (1) objet enfant : AChildFB, qui à son tour a un objet enfant, AGrandChildFB. AGrandChildFB n'a pas d'objets enfants.

//Declaration FB1
FUNCTION_BLOCK FB1
VAR
    d,x,y : INT;
END_VAR

//Implementation
x := METH(d+10);
y := FUN(42, 0.815);

//Declaration FB1.METH
METHOD METH : INT
VAR_INPUT
    i : INT;
END_VAR

//Implementation
METH := FUN(CUBE(i), 3.1415);

//Declaration CUBE
FUNCTION CUBE : INT
VAR_INPUT
    i : INT;
END_VAR

//Implementation
CUBE := i*i*i;

//Declaration Function FUN
FUNCTION FUN : INT
VAR_INPUT
    a : INT;
    lr : LREAL;
END_VAR

//Implementation
FUN := LREAL_TO_INT(lr*10)*a;

// Declaration
FUNCTION_BLOCK FB_Child EXTENDS FB_Base objects // +0 for EXTENDS
VAR_INPUT
END_VAR
VAR_OUTPUT
END_VAR
VAR
    i_fb1 : FB1; // +1 instantiated here
    i_fb2 : FB2; // +1 instantiated here
END_VAR

//Implementation
i_fb3(); // +0 instantiated in FB_Base, no increment for call

//Declaration
PROGRAM PRG
VAR
    i, j : INT;
    k : INT := GVL.m;
    b, c : BOOL;
    myFB : FB;
END_VAR

//Implementation
myFB(paramA := b);      // +3 accesses (myFB, paramA and b)
i := j;                 // +2 accesses (i and j)
j := GVL.d;             // +2 accesses (j and GVL.d)

Référencement de la complexité dans les résultats de l'extrait de code :

6 _{nombre de variables utilisées} / 7 _{nombre d'accès aux variables} = 0,85

//Declaration
FUNCTION_BLOCK FB
VAR_INPUT
    a : BOOL;
END_VAR
VAR_OUTPUT
END_VAR
VAR
    i,b : BOOL;
END_VAR

//Implementation
i := 42;
//FB.ACT
i:= 0;

//FB.METH Declaration
METHOD METH : BOOL
VAR_INPUT
	c : BOOL;
END_VAR

//Implementation
METH := c;
i := 1;

//FB.SecondMETH Declaration
METHOD SecondMETH : INT
VAR_INPUT
END_VAR

//Implementation
SecondMETH := SEL(c,3,4);

L'extrait de code ci-dessus dans SFC comporte 4 branches : 3 branches alternatives et 1 branche parallèle.

L'extrait de code dans SFC comporte 10 étapes.