Uso di malloc in PIC

Come posso usare malloc()e free()funzioni in un PIC? Ho controllato l' stdlib.hintestazione e non si fa menzione di loro. Sto usando MCC18.

Qualcuno ha dovuto usarli?

Ho bisogno di loro perché sto effettuando il porting di una libreria da Windows XP al PIC. La guida al porting dice a

adattare le funzioni specifiche del sistema operativo a quelle dei miei PIC

Ma non so come "tradurre" le funzioni malloc()e free().

In molte applicazioni, sarà necessario allocare memoria, ma non sarà necessario liberare nulla mantenendo qualcosa che è stato allocato dopo di esso. Su un tale sistema, tutto ciò che occorre fare è utilizzare il linker per definire un array usando tutta la RAM disponibile, impostare un puntatore all'inizio di tale array e quindi utilizzare una funzione malloc facile e intuitiva:

char * next_alloc;
void * malloc (int size)
{
    char * this_alloc;
    this_alloc = next_alloc;
    if ((END_OF_ALLOC_SPACE - this_alloc) <dimensione)
      ritorno -1;
    next_alloc + = size;
    restituisce this_alloc;
}
void free (void * ptr)
{
    if (ptr)
        next_alloc = (char *) ptr;
}

Simpatico e semplice, con solo due byte di sovraccarico totale per qualsiasi numero di allocazioni. La chiamata gratuita () su un blocco dislocerà quel blocco e tutto ciò che lo segue.

I modelli di allocazione leggermente più complicati possono essere gestiti utilizzando due puntatori: uno che alloca gli oggetti dal fondo della memoria verso l'alto e uno che va dall'alto verso il basso verso il basso. È anche possibile utilizzare un garbage collector compattante se i dati nell'heap sono omogenei e si sa dove si trovano tutti i riferimenti esterni ad esso.

malloc()nei microcontrollori è generalmente considerata una "cosa negativa". Ma, se ne hai assolutamente bisogno, ti consigliamo di trovare una versione di terze parti.

Se sei fortunato, il codice che stai trasferendo potrebbe non fare affidamento sul riutilizzo di blocchi di memoria. In questo caso, è possibile scrivere un semplice allocatore che restituisce un puntatore in un buffer RAM, quindi fa avanzare il puntatore in base alla dimensione del blocco richiesta.

Ho usato con successo questo approccio prima di eseguire il porting delle librerie PC su microcontrollori.

Di seguito, dovresti impostare l'allocatore con my_malloc_init()e allocare memoria con my_malloc(). my_free()è lì per soddisfare la dipendenza ma in realtà non farà nulla. Alla fine rimarrai senza spazio, ovviamente.

Per far funzionare tutto ciò, dovrai misurare il requisito di memoria peggiore del tuo codice (fallo su un PC se possibile), quindi imposta di HEAP_SIZEconseguenza. Prima di accedere alla parte della libreria che richiede memoria dinamica, chiamare my_malloc_init(). Prima di riutilizzarlo, assicurarsi che nulla punti ancora heap.

uint8_t heap[HEAP_SIZE];
uint8_t *heap_ptr;

void my_malloc_init(void)
{
    heap_ptr = heap;
}

void *my_malloc(size_t len)
{
    uint8_t *p = heap_ptr;
    heap_ptr += len;
    if (heap_ptr >= heap + HEAP_SIZE)
        return NULL;
    else
        return p;
}

void my_free(void)
{
    // do nothing
}

(nota: nel mondo reale, potrebbe essere necessario considerare l'allineamento del puntatore, ovvero arrotondare per eccesso heap_ptrdi 2 o 4 byte)

Un'altra opzione è quella di utilizzare una struttura di allocazione più semplice di quella malloc()normalmente fornita, come una FreeList , sebbene ciò non consenta di allocare blocchi di dimensioni variabili.

Questa non è una risposta alla tua domanda, ma l'allocazione dinamica della memoria è generalmente disapprovata in piccoli ambienti RAM e in assenza di un sistema operativo (ad esempio nel mondo dei microcontrollori) ... lo spazio heap che hai a disposizione in un ambiente incorporato è in genere misurato in centinaia di byte ...

L'implementazione di malloc e free è essenzialmente il mantenimento di un elenco collegato di strutture di "segmenti liberi" e, come puoi immaginare, i metadati associati ai segmenti liberi non sono privi di sostanza se confrontati con la quantità di memoria normalmente disponibile ... che è il "sovraccarico" "della gestione di un pool di memoria dinamica consuma una quantità significativa delle risorse disponibili.

Non so se la libreria standard C18 supporta malloce free, ma la nota sull'app Microchip AN914 mostra come è possibile implementare la propria.

In ogni caso, Thomas e altri manifesti hanno suggerito che l'uso della memoria dinamica sui PIC con il loro spazio RAM molto ridotto è pieno di pericoli. Puoi esaurire rapidamente lo spazio contiguo a causa della mancanza di gestori di memoria virtuale più avanzati che ti danno il sistema operativo completo, portando a allocazioni e arresti anomali non riusciti. Peggio ancora, potrebbe non essere deterministico e probabilmente sarà un problema per il debug.

Se ciò che stai facendo è veramente determinato dinamicamente in fase di esecuzione (raro per la maggior parte delle cose incorporate) e hai solo bisogno di allocare spazio in un paio di occasioni molto speciali , potrei vedere malloced freeessere accettabile.

Bene, quanto è grande il tuo PIC in termini di memoria?

malloc è un modo molto inefficiente di allocare memoria. Il problema è che la memoria può essere frammentata con frequenti frees e malloc e con solo pochi kilobyte di memoria, gli errori di allocazione sono fin troppo comuni. È abbastanza probabile che se stai usando un chip più piccolo o un PIC18 precedente non c'è supporto per malloc, poiché Microchip lo considerava molto difficile da implementare (o forse addirittura impossibile in alcuni casi) o non abbastanza usato per essere ne e 'valsa la pena. Per non parlare, ma è anche piuttosto lento, stai guardando 1 ciclo per usare un buffer statico già disponibile e da 100 a 1.000 di cicli per fare un malloc.

Se si desidera allocare staticamente, creare cose come un buffer per le funzioni sprintf (se presenti, circa 128 byte), un buffer per la scheda SD (se presente) e così via, fino a quando non si rimuove la necessità di malloc. Idealmente, lo usi solo dove ne hai assolutamente bisogno e non riesci a cavartela con l'allocazione statica, ma queste situazioni sono di solito rare e forse un segno che dovresti guardare microcontrollori più grandi / più potenti.

E se stai sviluppando / porting un "sistema operativo" sul PIC18 e se supporta i microcontrollori probabilmente ha il supporto per l'allocazione statica. Ad esempio, SQLite3 supporta l'allocazione statica: lo si assegna a un array di buffer di grandi dimensioni e lo utilizza laddove possibile, anche se non è per i microcontrollori. In caso contrario, sei sicuro che sia progettato per un piccolo PIC18?

Se stai considerando malloc()e free()per il tuo software incorporato ti suggerisco di dare un'occhiata a uC / OS-II e OSMemGet()e OSMemPut(). Mentre malloc()ti consente di allocare un blocco arbitrario di memoria, OSMem*()ti dà un blocco di dimensioni fisse da un pool pre-allocato. Trovo questo approccio un buon equilibrio tra la flessibilità malloc()e la solidità dell'allocazione statica.

AFAIK, per farlo correttamente, devi davvero guardare un dispositivo con una sorta di unità di gestione della memoria (MMU). Mentre esistono meccanismi di allocazione dinamica per la serie PIC18, non saranno davvero così solidi - e parlando come qualcuno che ha lavorato sul firmware che spinge i limiti della serie PIC18, posso dire che non otterrai un'applicazione considerevole in là se spendi tutto il sovraccarico in un gestore di memoria.

Soluzione migliore: cerca di capire cosa sta facendo e perché ha bisogno di allocazione dinamica. Verifica se non riesci a ricodificarlo per funzionare con allocazione statica. (Può darsi che ciò non sia semplicemente possibile - se la libreria / applicazione è progettata per fare qualcosa che si ridimensiona liberamente o non ha limiti della quantità di input che può accettare.) Ma a volte, se pensi davvero su ciò che stai cercando di fare, potresti scoprire che è possibile (e forse anche abbastanza semplice) utilizzare l'allocazione statica.