Accorgimenti per scrivere codice in modo efficiente

[lemure64]

Ciao Forum,

Vorrei fare una specie di punto della situazione delle mie competenze, che non sono elevate dato che programmo per hobby, sono un dilettante e come tale relativamente isolato dal contatto con il "fare" in squadre di persone più esperte (per non parlare di come trovare letteratura adatta se non spulciando in rete). Soffro inoltre di una serie di imprinting acquisiti all'epoca delle CPU 8088 con compilatori il cui livello di ottimizzazione non era quello di oggi, le abitudini erano diverse e così via. La mia enorme resistenza a cambiare abitudini ha fatto il resto del pasticcio

Per dare un'idea del tipo di cose che vorrei sapere prendo spunto dal progettino su Arduino di cui ho parlato altrove.

1) Sono abituato all'idea che passare variabili a una funzione implica copiarle sullo stack e che questo è più lento che usare variabili globali. Per questo motivo con Arduino (sperando di imparare a usare anche dei micro) ho la tendenza a creare variabili globali sia per il passaggio di argomenti sia per esempio per gli indici nei loop, così evito anche l'allocazione delle variabili locali. Beninteso sono coscientissimo dei pericoli di questo approccio (perché ovviamente tendo a riutilizzare le variabili di quel genere e posso sempre dimenticare di aver chiamato in un ciclo "for" una funzione che le usa a sua volta, disastro garantito) e quando scrivo cose che devono girare su PC e la velocità non è un problema non mi faccio alcuno scrupolo a privilegiare modularità e chiarezza. Ma su un micro è diverso, o almeno credo sia diverso. Almeno per le funzioni più critiche tendo a fare così. Vorrei avere un criterio per capire quando è il caso e quando no, possibilmente evitando strumenti di profilazione; queste sono cose che vengono dopo e non sostituiscono un approccio intelligente.

2) Altro ordine di problemi è che non so cosa fa il compilatore e mi spiego tramite un altro problema che ho trovato. Vorrei fermare l'esecuzione per periodi molto brevi inferiori al ms e non volendo contare sul timer interno, ho creato una funzione che si limita a incrementare una variabile per un certo numero di cicli, da tarare poi in fase di verifica. Ma mi è preso il sospetto che il compilatore si accorga che quella variabile incrementata (ovviamente globale, anche per tentare di ingannarlo rispetto al problema di cui sto parlando) non fa niente, non è usata da niente, possa accorgersene e saltare a pie' pari la compilazione di una funzione che non fa nulla. Per quanto ne so, nell'ambito delle variabili locali a una funzione se ne accorge e non compila le parti inutili, ma non è sempre quello che si vuole

3) Tipi. Altro dilemma tipico che incontro sempre è che molto spesso ho valori piccoli che stanno benissimo in un "uint8_t", ma altrettanto spesso sono limiti superiori nei cicli "for". Per quanto ne so i contatori di GCC sono sempre tipo int o long e nel caso di cui sto dicendo il compilatore è costretto a creare una o due variabili temporanee nascoste convertendo tutto in intero o nel più piccolo tipo che possa usare per i contatori. Inutile dire che vorrei sapere se è davvero così, cosa accade e come regolarmi per bilanciare velocità e spazio.

Sono solo esempi, non chiedo la risposta ai problemi specifici anche se qualsiasi osservazione generale che da essi possa nascere è ovviamente benvenutissima. Li ho esposti solo per permettere di tarare possibili risposte. Chiedo se c'è un po' di materiale e letteratura in cui questi problemi vengano trattati e in cui siano codificate una serie di buone regole per scrivere bene senza fare acrobazie con costrutti troppo dipendenti dall'hardware, dato che non vorrei avvicinarmi troppo al silicio se così posso dire.

Cosa posso leggere di utile? Grazie moltissime per qualsiasi suggerimento e lettura consigliata.

[GioArca67]

1) non vedo particolari problemi a parte quanto già scritto

2)
delayMicroseconds() ?
volatile xxxx_t zzz; zzz viene messa subito in memoria e non subisce ottimizzazioni
asm volatile("" : "+g" (i) : :); dentro un loop o __asm__ volatile... a seconda se usi -ansi

3) lo standard C C++ prevede la promozione a int di interi di dimensione inferiore a int per poi eseguire le operazioni matematiche, consente però anche al compilatore di ottimizzare come vuole e ricorda che non usi GCC o G++ ma avr-gcc che è specifico per quelle MCU, e che dovrebbe ottimizzare l'uso dei registri e delle operazioni elementari sulla dimensione di base dei registri (8 bit per atmega328) quindi avr-gcc dovrebbe accorgersi che non serve usare 2 registri
e quindi compilare i++ con

inc r24
ovvero adi r24,0x01

ed in vari casi l'ottimizzazione funziona come anche riportato in vari forum

[luxinterior]

1) Potresti dichiarare static la variabile dentro la funzione.In questo modo finisce nel data segment e non sullo stack e mantiene il valore assegnato.
Tutto sommato il passaggio di variabili sullo stack non è che porti via chissà che tempo se vuoi ottimizzare puoi usare un puntatore: una sola variabile con cui accedere a tutto quello che vuoi.

2) Mio parere: in un sistema embedded mai e poi mai arrestare l'esecuzione anche per pochi us con dei cicli anche perché se ti cambiano la frequenza del clock devi ritarare tutti i cilci. Se non hai un sistema operativo ti conviene usare la programmazione a stati il processo in attesa abbandona l'esecuzione e rientra periodicamente per controllare la fine del periodo di attesa.

3) Secondo me non puoi prescindere dalle dimensioni dei registri del micro In questo caso devi necessariamente interessarti all'HW. Non conosco Arudino ma se iil micro è 8bit la variabile uint8_t sarebbe l'ideale. Comunque sono cose a cui spesso pensano i compilatori che ottimizzano al meglio l'uso dei registri per gestire la variabile.

[GioArca67]

Se non hai SO non hai processi e thread.

[drGremi]

Se non hai SO non hai processi e thread.

Per sistemi monocore e molto "scarsi" come arduino puoi usare i protothread, mentre in chip nuovi come l'STM32H745ZIT6 sono veramente multicore. Puoi avere processi e thread anche senza sistema operativo.

Comunque nell'ottica di una libreria bisogna decidere il rapporto tra ottimizzazione e manutenibilità. Non esagererei con le variabili globali. Personalmente (ma poi ognuno dirà la sua) se non serve ottimizzare non si deve ottimizzare, quello si fa solo se le performance non sono adeguate. Inoltre (ovviamente dipende dal caso) a volte è preferibile comunque non ottimizzare troppo il codice e o ottimizzare il compilatore, oppure fare un upgrade del microcontrollore. Anche perché i costi di progettazione spesso sono i maggiori, quindi accorciare i tempi di sviluppo è un grossissimo vantaggio.

ho la tendenza a creare variabili globali sia per il passaggio di argomenti sia per esempio per gli indici nei loop

Sinceramente non lo farei. Per gli indici nei loop proprio no, mentre per il resto o usi i puntatori (che magari dichiari come constant). Inoltre prediligerei una programmazione orientata agli oggetti.

ho creato una funzione che si limita a incrementare una variabile per un certo numero di cicli, da tarare poi in fase di verifica

Questo anche non lo farei proprio, il risultato è non deterministico e soprattutto il codice non va tarato. Deve funzionare.
Come già detto da GioArca delayMicroseconds è una valida soluzione.

Chiedo se c'è un po' di materiale e letteratura in cui questi problemi vengano trattati e in cui siano codificate una serie di buone regole per scrivere bene senza fare acrobazie con costrutti troppo dipendenti dall'hardware, dato che non vorrei avvicinarmi troppo al silicio se così posso dire

Vedo se riesco a trovare qualche guida carina (può essermi utile anche da spammare altrove). Comunque possiamo iniziare da

• non usare variabili globali, soprattutto col C++ se ne ha sempre meno bisogno;
• se possibile usare librerie standard (non reinventare la ruota);
• programmazione orientata agli oggetti;
• non creare classi/funzioni "dio" in modo da rendere il codice riutilizzabile;
• non pensare subito all'ottimizzazione;
• scegliere uno stile di codice e seguirlo pedissequamente (magari anche usando una funzione dell'editor per auto indentare soprattutto se si lavora in più persone).

Comunque oltre tutte queste "pippe" se funziona devi essere soddisfatto, poi in programmazione di micro si fanno un sacco di "porcate" che a volte sono quasi necessarie e in un altro contesto non sarebbero accettabili.

vorrei sapere prendo spunto dal progettino su Arduino di cui ho parlato altrove

Potresti iniziare pubblicandolo, le ottimizzazioni le farai con calma (magari così a tempo perso gli si da una occhiata e può saltare fuori qualche suggerimento da lì). Non penso nessuno ti criticherà per quello che scrivi se non in maniera costruttiva (e se non è così mi dispiace per loro) e nessuno in nessun caso ti metterà "alla gogna".
Io il primo codice che ho fatto visionare ad altri devo essere sincero mi vergognavo, ma alla fine col senno di poi me ne sarei dovuto fregare. Si impara (e soprattutto su molte cose sono scuole di pensiero, per dire io ti ho detto programmazione orientata agli oggetti, ci saranno in molti che non saranno d'accordo, soprattutto per i micro)

[GioArca67]

Per sistemi monocore e molto "scarsi" come arduino puoi usare i protothread, mentre in chip nuovi come l'STM32H745ZIT6 sono veramente multicore. Puoi avere processi e thread anche senza sistema operativo.

Sull'STM32H7 gira freeRTOS per le funzionalità di gestione dei task/thread/processi

Protothread implementa uno scheduler minimale