メトリクス

//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;

仮定: 計算のために、次のことを仮定します。 CODESYS Control Win x86 コードジェネレーターを使用します。

上の例の呼び出し元のサイズは 8 バイトです。つまり、2 つの呼び出し元のサイズは 4 バイトです。 INT inputs 戻り値用の 4 バイト。デバイスのスタック アライメントは 4 バイトであるため、2 バイトのギャップがあります。呼び出し元のサイズは 8 バイトです。それぞれ 2 バイトの 3 つのローカル変数に、スタック アライメント用の 2 バイトのギャップを加えたものです。その結果、スタックの合計サイズは、 FUN1 は 16 バイトです。

VAR_STAT スタックに格納されないため、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;

もし PLC_PRG タスク内で呼び出された場合、この呼び出しもカウントされます。

FB1 呼び出しが 1 つだけあります ( PLC_PRG）。

METH 2 つの呼び出しがあり、両方とも FB1。

FUNCTION_BLOCK FB
//...

FUNCTION_BLOCK FB2 EXTENDS FB
//...

FUNCTION_BLOCK FB3 EXTENDS FB2
//...

各関数ブロックは独自に呼び出されます。 PROGRAM。それぞれ PROGRAM には独自のタスクがあります。

の タスクで呼び出される メトリクスは 1 を返します FB3 と2 FB2 なぜなら、からの電話は FB3 そして FB2 カウントされます。メトリクスの結果は 3 になります。 FB この場合、からの呼び出しは FB3、 FB2、 そして FB カウントされます。

//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;

の PRG プログラムは次の 3 つの変数を使用します GVL: gvla、 gvlb、 そして 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

この例には 5 つの直接アドレス アクセスがあります。

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

ファンクションブロック内では7つのローカル変数が宣言されています。

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

関数ブロックでは、2 つの入力変数が宣言されています。 i そして r。

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

このメソッドには 2 つの入力があります。 j そして l

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

関数ブロックには 2 つの出力変数があります。 i そして r

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

このメソッドには 3 つの出力があります。 METH、 j、 そして l

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

の METH1 メソッドには 2 つの出力があります。 ar そして 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

この例には 6 つのステートメントがあります。

宣言部分:

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

実装：

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

パーセンテージ 100 * 202 / 255 を計算すると、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

コード スニペットの循環複雑度は 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

コード スニペットの循環複雑度は 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

コード スニペットの循環複雑度は 4 です。

次のステートメントも循環的複雑さを増大させます。

//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';

コード スニペットの循環複雑度は 3 です。

制御フローを操作するステートメントは認知の複雑さを 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

コード スニペットの認知複雑度は 4 です。

制御フローをネストする場合、ネストのレベルごとに 1 ずつ追加されます。

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

コード スニペットの認知複雑度は 8 です。

ブール式はソース コードを理解する上で重要な役割を果たすため、認知の複雑さを計算するときにも考慮されます。

同じブール演算子に関連付けられたブール式を理解することは、交互のブール演算子を含むブール式を理解することほど難しくありません。したがって、式内に同一のブール演算子が連鎖すると、認知の複雑さが増大します。

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

演算子のない単純な式の増分は 0 です。

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

を使った表現は、 AND リンクの増分は 1 です。

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

この式にはもう 1 つあります AND。ただし、同じ演算子であるため、同じ演算子で形成されるチェーンの数は変わりません。

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

式には次のような連鎖があります。 AND 演算子と一連の OR オペレーター。これにより、増分は 2 になります。

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

コード スニペットの増分は 3 です。

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

単項演算子 NOT 認知の複雑さでは考慮されていません。

構造化テキストには、制御フローを変更する追加のステートメントと式があります。

次のステートメントには、認知の複雑さが増すというペナルティが課されます。

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 そして RETURN ステートメントは認知の複雑さを増加させません。

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

MyBaseFB は、それ自体が他の機能ブロックを拡張しない機能ブロックであるため、DIT は 0 です。

のために AChildFBに到達するには 1 つのステップが必要であるため、DIT は 1 です。 MyBaseFB。

AGrandChildFB DIT は 2 です。次の手順が 1 つ必要です。 AChildFB そしてもう一つは MyBaseFB。

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

MyBaseFB 子オブジェクトは 1 つだけあります: AChildFB、これには 1 つの子オブジェクトがあり、 AGrandChildFB。 AGrandChildFB には子オブジェクトがありません。

//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)

コード スニペットの複雑さを参照すると、次のようになります。

6 _{使用される変数の数} / 7 _{変数アクセス数} = 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);

SFC の上記のコード スニペットには 4 つの分岐があります: 3 つの代替分岐と 1 つの並列分岐です。

SFC のコード スニペットには 10 のステップがあります。