Best practice per la definizione delle variabili per la generazione di codice C/C++

Se si desidera generare codice da un blocco MATLAB Function, il codice MATLAB® nel blocco deve essere conforme ai requisiti di generazione di codice C/C++. Alcune pratiche di codifica che funzionano nel codice MATLAB non funzionano durante la generazione di codice. Seguire queste best practice per ottimizzare il codice ed evitare errori di simulazione.

Definizione esplicita delle variabili prima del loro utilizzo

Per la generazione di codice C/C++, è necessario definire esplicitamente i valori e le proprietà delle variabili prima di utilizzarle nelle operazioni o restituirle come output. In questo modo si evitano gli errori che si verificano quando non si definisce la variabile.

Nota

Quando si definiscono le variabili, per impostazione predefinita si tratta di variabili locali che non persistono tra una chiamata di funzione e l'altra. Per rendere le variabili persistenti, utilizzare la funzione persistent.

Definizione delle variabili su tutti i percorsi di esecuzione

È necessario definire una variabile su tutti i percorsi di esecuzione come, ad esempio, i percorsi di esecuzione dettati dalle dichiarazioni if. Considerare questo codice MATLAB che definisce una variabile prima di utilizzarla come input di una funzione:

...
if c <= 0
  x = 11;
end
% Later in your code ...
if c > 0
% Use x in the function foo
  foo(x);
end
...
Il codice assegna x a un valore solo se c <= 0 e utilizza x solo quando c > 0. A seconda del valore di c, questo codice può funzionare in MATLAB senza errori. Tuttavia, la generazione di codice non va a buon fine quando si cerca di generare codice C/C++ da questo codice MATLAB, perché il generatore di codice rileva che x non è definita nel percorso di esecuzione quando c > 0.

Per rendere questo codice adatto alla generazione di codice, definire x prima di utilizzarla:

x = 0;
...
if c <= 0
  x = 11;
end
% Later in your code ...
if c > 0
% Use x in the function foo
  foo(x);
end
...

Definizione di tutti i campi della struttura

È inoltre necessario definire ciascun campo della struttura per tutti i percorsi di esecuzione. Considerare questo codice MATLAB:

...
if c > 0 
  s.a = 11;
  disp(s);
else
  s.a = 12;
  s.b = 12;
end
% Use s in the function foo
foo(s);
...
La prima parte della dichiarazione if utilizza solo il campo a, mentre la dichiarazione else utilizza i campi a e b. Questo codice funziona in MATLAB ma genera un errore di compilazione durante la generazione di codice C/C++. Per evitare questo errore, non aggiungere campi a una struttura dopo averla utilizzata. Per ulteriori informazioni, vedere Structure Limitations for Code Generation (MATLAB Coder).

Per rendere questo codice adatto alla generazione di codice C/C++, definire i campi di s prima di utilizzarli:

...
% Define fields in structure s
s = struct("a", 0, "b", 0);
if c > 0 
  s.a = 11;
  disp(s);
else
  s.a = 12;
  s.b = 12;
end
% Use s in the function foo
foo(s);
...

Massima cautela nella riassegnazione delle proprietà delle variabili

È possibile riassegnare alcune variabili dopo l'assegnazione iniziale con un valore di classe, dimensione o complessità diversa:

  • Variabili a dimensione dinamica. Una variabile può contenere valori che hanno la stessa classe e complessità ma grandezze diverse. Se la dimensione dell'assegnazione iniziale non è costante, la variabile viene dimensionata in modo dinamico nel codice generato. Per ulteriori informazioni, vedere Dati di dimensione variabile

  • Variabili riutilizzate nel codice per scopi diversi. È possibile riassegnare il tipo (classe, dimensione e complessità) di una variabile dopo l'assegnazione iniziale, a condizione che ogni occorrenza della variabile possa avere un solo tipo. In questo caso, la variabile viene rinominata nel codice generato per creare più variabili indipendenti. Per ulteriori informazioni, vedere Reuse the Same Variable with Different Properties.

Tuttavia, se si riassegna il tipo di variabile dopo l'assegnazione iniziale, il codice spesso restituisce un errore di compilazione durante la generazione di codice. In linea generale, assegnare a ciascuna variabile una classe, una dimensione, un tipo e una complessità specifici.

Definizione dei tipi di dato numerici delle variabili

double è il tipo di dato numerico predefinito in MATLAB. Per definire variabili di altri tipi di dato, è necessario definire esplicitamente il tipo di dato nella definizione con il prefisso o l'operatore corretto. Prestare attenzione ai tipi di dato utilizzati in quanto l'utilizzo di variabili assegnate a tipi di dato diversi nel codice può causare errori di mancata corrispondenza tra i tipi.

Ad esempio, questo codice definisce la variabile x come un doppio e y come un intero a 8 bit:

x = 15;
y = uint8(x);

Per ulteriori informazioni sui tipi supportati in MATLAB, vedere Tipi numerici.

Definizione delle matrici prima dell'assegnazione delle variabili indicizzate

L'aumento di una variabile scrivendo un elemento oltre la sua dimensione attuale provoca un errore in fase di compilazione o di runtime, a meno che non si utilizzi l'indicizzazione end + 1 o non si definisca prima la variabile come variabile a dimensione variabile. Vedere Code Generation for Arrays That Grow Via end+1 Indexing (MATLAB Coder) e Generate Code for Variable-Size Arrays (MATLAB Coder). È inoltre possibile specificare che le variabili di output siano a dimensione variabile nel riquadro Symbols e nel Property Inspector. Vedere Declare Variable-Size MATLAB Function Block Variables. Per evitare errori legati alla dimensione senza utilizzare l'indicizzazione end + 1 o definire array a dimensione variabile, definire la dimensione massima dell'array prima di assegnare i valori ai suoi elementi.

Ad esempio, questa assegnazione produce un errore al momento della generazione di codice:

g = zeros(3,3);
g(5,2) = 14.6;

Correggere questo codice definendo una matrice g di sufficiente dimensione:

g = zeros(5,5);
g(5,2) = 14.6;

Per ulteriori informazioni sull'indicizzazione delle matrici, vedere Incompatibility with MATLAB in Matrix Indexing Operations for Code Generation (MATLAB Coder).

Finalità di indicizzazione degli array utilizzando vettori a dimensione fissa

Sebbene la generazione di codice supporti array a dimensione variabile, tali array richiedono un impiego di memoria supplementare che può rallentare le prestazioni. Quando possibile, utilizzare vettori a valore costante per indicizzare gli array. Ad esempio: 

...
% extract 7 elements from A using a constant-value vector
B = A(1:7);
...
In questo esempio, il generatore di codice riconosce che B ha una dimensione fissa.

Se si indicizza in un array utilizzando l'operatore colon e valori variabili, il generatore di codice non sempre determina correttamente se la dimensione dell'array è fissa o variabile. Ad esempio, entrambi i seguenti array sono a dimensione fissa, indipendentemente dal valore di i:

...
% extract 7 elements from A using a fixed-size vector
B = A(i-1:i+5);
C = A(-1+2*i:5+2*i);
...
Quando il valore di i è noto al momento della generazione di codice, il generatore di codice riconosce sia B che C come array a dimensione fissa. Tuttavia, quando il valore di i non è noto al momento della generazione di codice, il generatore di codice riconosce B come a dimensione fissa ma definisce C come a dimensione variabile. Di conseguenza, si può provare a definire un array la cui dimensione non cambia e che dovrebbe quindi essere a dimensione fissa, ma il generatore di codice interpreta e specifica l'array come a dimensione variabile.

In alcuni casi, è possibile riscrivere il codice MATLAB per forzare il generatore di codice a riconoscere che la dimensione dell'array definito non cambia. Ad esempio, è possibile riscrivere la definizione di C sopra riportata per estrarre l'espressione di indicizzazione dell'array dalle operazioni matematiche che coinvolgono la variabile (i), che è sconosciuta al momento della generazione di codice:

...
% extract 7 elements from A using a fixed-size vector
C = A(2*i+(-1:5));
...
Dopo questa riscrittura, il generatore di codice riconosce C come array a dimensione fissa.

In alcuni altri schemi di codice, gli indici degli array includono variabili che influenzano la dimensione dell'array, ma queste variabili sono note in fase di compilazione. In queste situazioni, l'array estratto è in realtà a dimensione fissa, ma il generatore di codice potrebbe non identificarlo come tale e trattarlo come a dimensione variabile. Occasionalmente, è inoltre possibile riscrivere tale codice per generare array a dimensione fissa. In questo esempio, gli array D_varSize e D_fixSize sono identici. Tuttavia, il generatore di codice definisce D_varSize come a dimensione variabile e D_fixSize come a dimensione fissa:

...
width = 25;              
D_varSize = A(i-width:i+width);  % D_varSize is variable-size if i is unknown at compile time 
D_fixSize = A(i+(-width:width)); % D_fixSize is fixed-size whether or not i is unknown at compile time
...

Vedi anche

| |

Argomenti