Valutazione prestazioni (Benchmark) nei sistemi PLC

Nel contesto dell’automazione industriale moderna, i Programmable Logic Controller (PLC) rappresentano il cuore dei sistemi di controllo. Con l’evoluzione delle tecnologie e l’aumento della complessità degli impianti, non è più sufficiente considerare solo il numero di I/O (Input/Output). L’esigenza di eseguire operazioni sempre più complesse nel minor tempo possibile rende fondamentale valutare le prestazioni dell’hardware, e i benchmark diventano uno strumento essenziale per verificare se un microcontrollore è in grado di reggere i ritmi della produzione.

I nostri sistemi programmabili sono basati su microcontrollori Cortex-M, sviluppati da Arm Ltd. per applicazioni embedded e IoT. La famiglia Cortex è progettata per offrire un equilibrio ottimale tra prestazioni, consumi energetici e scalabilità, garantendo al contempo affidabilità nei sistemi real-time come i PLC industriali. L’architettura interna di questi microcontrollori integra due elementi fondamentali che influiscono direttamente sulle prestazioni: la pipeline e la memoria cache.

La pipeline è una tecnica che consente alla CPU di eseguire più istruzioni in parallelo suddividendole in fasi: fetch, decode, execute, memory access e write-back. Ogni fase lavora su una parte diversa dell’istruzione, migliorando il throughput complessivo e permettendo di sfruttare al massimo le risorse della CPU.

La memoria cache è una memoria ad altissima velocità integrata all’interno del microcontrollore. Contiene i dati e le istruzioni più frequentemente utilizzati, riducendo drasticamente i tempi di accesso rispetto alla memoria principale (Flash o RAM). Questo si traduce in un’esecuzione più veloce del programma e in una maggiore efficienza del ciclo di scansione, senza compromettere il determinismo necessario per il controllo industriale.

Risultati benchmark

Quando si eseguono test di benchmark su un sistema embedded, la presenza della pipeline e della memoria cache influiscono in modo significativo sui risultati, LogicLab inoltre nella compilazione del programma effettua ulteriori ottimizzazioni. Tutti questi elementi determinano come e quando le istruzioni vengono eseguite e come avviene l’accesso ai dati, influenzando i tempi di esecuzione in base alla sequenzialità delle istruzioni da eseguire nel programma. Ecco quindi che è molto difficile eseguire comparazioni di velocità di esecuzione tra programmi. Per nostri sistemi programmabili forniamo dati di benchmark relativi a:

• Elaborazione logica: Velocità ed impegno di memoria programma per operazioni logiche. Il programma di benchmark esegue 1000 istruzioni sequenziali di tipo logico (AND, OR, XOR, NOT).
• Calcoli matematici su numeri interi: Velocità ed impegno di memoria programma per calcoli matematici. Il programma di benchmark esegue 1000 istruzioni sequenziali di tipo (ADD, SUB, MUL, DIV) su numeri interi.
• Calcoli matematici in floating point: Velocità ed impegno di memoria programma per calcoli matematici. Il programma di benchmark esegue 1000 istruzioni sequenziali di tipo (ADD, SUB, MUL, DIV) su numeri in virgola mobile.

Come sono eseguiti i benchmark

I programmi di benchmark sono sono inseriti in FB (Function Block) e sono scritti in linguaggio IL (Instruction List), fanno riferimento a variabili globali allocate in memoria DB 100 per evitare il più possibile le ottimizzazioni in compilazione da parte di LogicLab. Per l’esecuzione dei benchmark si utilizzano programmi in ST (Structured Text) eseguiti in task Slow. Il programma istanzia il FB di benchmark e lo esegue calcolandone il tempo di esecuzione con la differenza tra il tempo di sistema prima e dopo l’esecuzione.

Di seguito un estratto del programma di benchmark Mdp049 con l’esecuzione del test di elaborazione logica. Per calcolare il valore medio del tempo di esecuzione si è utilizzato il FB Average.

PROGRAM ST_Logic
VAR
    TimeBf : UDINT; (* Time buffer (uS) *)
    FBTest : IL_Logic; (* FB esecuzione istruzioni *)
    TAverage : Average; (* Time average *)
    TTime : ARRAY[0..2] OF UDINT; (* Test time [Min, Act, Max] *)
END_VAR

// *****************************************************************************
// PROGRAM "ST_Logic" 
// *****************************************************************************
// Benchmark istruzioni logiche.
// Per calcolare impegno memoria commentare/scommentare FBTest().
// -----------------------------------------------------------------------------

    // -------------------------------------------------------------------------
    // CALCOLO TEMPO ESECUZIONE
    // -------------------------------------------------------------------------
    // Calcolo tempo esecuzione.

    TimeBf:=SysTimeGetUs(); //Time buffer (uS)
    FBTest(); //FB esecuzione istruzioni

    TTime[1]:=SysTimeGetUs()-TimeBf; //Test time [Min, Act, Max]
    IF (TTime[1] < TTime[0]) THEN TTime[0]:=TTime[1]; END_IF;
    IF (TTime[1] > TTime[2]) THEN TTime[2]:=TTime[1]; END_IF;
    TAverage(Value:=TO_REAL(TTime[1]), Coefficient:=1500.0); //Time average

    // -------------------------------------------------------------------------
    // INIZIALIZZAZIONE
    // -------------------------------------------------------------------------
    // Eseguo inizializzazione.

    IF (SysFirstLoop) THEN
        TTime[0]:=TTime[1]; //Test time [Min, Act, Max]
        TTime[2]:=TTime[1]; //Test time [Min, Act, Max]
    END_IF;

// [End of file]

Considerazioni finali

Non dobbiamo farci ingannare dai risultati dei benchmark. Come si può osservare dai dati, la velocità di esecuzione del Cortex-M7 può risultare inferiore rispetto al Cortex-M33 in alcuni test specifici. Tuttavia, questo risultato è valido solo in condizioni molto particolari, tipicamente quando si esegue un insieme di istruzioni semplici e ripetitive, come quelle utilizzate nei benchmark sintetici.

Questi test, infatti, tendono a stressare solo una parte limitata dell’architettura, senza rappresentare la complessità reale delle applicazioni industriali. In particolare, non considerano pienamente fattori come l’accesso a memoria non lineare, la gestione di strutture dati complesse, le comunicazioni su bus industriali o le operazioni di conversione e trattamento dei dati. In scenari applicativi reali, come quelli tipici dei PLC, il Cortex-M7 esprime invece un potenziale nettamente superiore. Grazie alla presenza di una pipeline più profonda, di una cache più ampia e di unità di calcolo ottimizzate per operazioni ad alte prestazioni, quindi il Cortex-M7 risulta significativamente più efficiente nell’esecuzione di programmi complessi.

Questo evidenzia un punto fondamentale: i benchmark semplici non sempre rappresentano le reali prestazioni operative di un sistema embedded. Solo l’analisi di carichi di lavoro realistici permette di valutare correttamente l’efficienza di un’architettura in ambito industriale.