PIC'de malloc kullanımı

Bir PIC'de nasıl kullanabilir malloc()ve free()işlevleri kullanabilirim ? stdlib.hBaşlığı kontrol ettim ve onlardan bahsetmedim. MCC18 kullanıyorum.

Bunları kimse kullanmak zorunda mıydı?

Onlara ihtiyacım var çünkü Windows XP'den PIC'ye bir kütüphane taşıyorum. Taşıma rehberi şöyle diyor

İşletim Sisteminin özel işlevlerini PIC işlevlerine uyarla

Ama malloc()ve free()fonksiyonlarının nasıl "tercüme edileceğini" bilmiyorum .

Birçok uygulamada, kişinin bellek ayırması gerekir, ancak sonradan ayrılan bir şeyi tutarken hiçbir şey boşaltmaya gerek yoktur. Böyle bir sistemde, tek yapmanız gereken, mevcut tüm RAM'i kullanarak bir dizi tanımlamak, o dizinin başlangıcına bir işaretçi ayarlamak ve daha sonra güzel bir kolay malloc işlevi kullanmak için bağlayıcıyı kullanmaktır:

char * next_alloc;
void * malloc (int boyutu)
{
    char * this_alloc;
    this_alloc = sonraki_alloc;
    eğer ((END_OF_ALLOC_SPACE - this_alloc) <boyut)
      dönüş -1;
    next_alloc + = boyut;
    this_alloc döndür;
}
geçersiz (void * ptr)
{
    eğer (ptr)
        next_alloc = (karakter *) ptr;
}

Güzel ve kolay ve herhangi bir sayıda tahsis için sadece iki bayt toplam yükü. Bir blokta free () çağrısı, o bloğu ve sonraki her şeyi yeniden yerleştirir.

Biraz daha karmaşık ayırma düzenleri, biri belleğin alt kısmından yukarı doğru hareket eden ve biri belleğin üstünden aşağı doğru giden iki işaretçi kullanılarak ele alınabilir. Yığındaki veriler homojense ve dışarıdaki tüm referansların nerede olduğunu bilirse, sıkıştırıcı bir çöp toplayıcı kullanmak da mümkündür.

malloc()mikrodenetleyicilerde genellikle "kötü bir şey" olarak kabul edilir. Ancak, kesinlikle ihtiyacınız varsa, üçüncü taraf bir sürüm bulmak isteyeceksiniz.

Şanslıysanız, taşıdığınız kod bellek bloklarını yeniden kullanmaya dayanmayabilir. Bu durumda, bir RAM arabelleğine bir işaretçi döndüren ve daha sonra işaretçiyi istenen blok boyutuna göre ilerleten basit bir ayırıcı yazabilirsiniz.

Bu yaklaşımı daha önce PC kütüphanelerini mikrodenetleyicilere taşımak için başarıyla kullandım.

Aşağıda, ayırıcıyı ile kuracak my_malloc_init()ve ile bellek ayıracaksınız my_malloc(). my_free()bağımlılığı tatmin etmek için var ama aslında hiçbir şey yapmayacak. Sonunda tabii ki alanınız bitecek.

Bunu yapmak için, kodunuzun en kötü durumda bellek gereksinimini ölçmeniz (mümkünse bunu bir PC'de yapın) ve HEAP_SIZEbuna göre ayarlayın . Kütüphanenizin dinamik bellek gerektiren kısmını girmeden önce arayınmy_malloc_init() . Tekrar kullanmadan önce, hiçbir şeyin hala göstermediğinden emin olun 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
}

(not: gerçek dünyada işaretçi hizalamasını, yani heap_ptr2 veya 4 bayt yuvarlamayı düşünmeniz gerekebilir )

Başka bir seçenek de, malloc()genellikle bir FreeList gibi sağladığından daha basit bir ayırma yapısı kullanmaktır , ancak bu, değişken boyutlu blokları ayırmanıza izin vermeyebilir.

Bu, sorunuzun cevabı değildir, ancak dinamik bellek ayırma genellikle küçük RAM ortamlarında ve bir işletim sisteminin (örneğin mikrodenetleyici dünyasında) yokluğunda kaşlarını çatır ... gömülü bir ortamda sahip olduğunuz yığın alanı genellikle yüzlerce bayt olarak ölçülen ...

Malloc ve free'i uygulamak esasen bağlantılı "serbest segment" yapılarının bir listesinin bakımıdır ve tahmin edebileceğiniz gibi, serbest segmentlerle ilişkili meta veriler, tipik olarak mevcut olan bellek miktarıyla karşılaştırıldığında önemli değildir. "" bir dinamik bellek havuzunu yönetmek önemli miktarda kullanılabilir kaynak tüketir.

Bilmiyorum eğer C18 standart kütüphane destekler mallocve freeancak Mikroçip Uygulaması Not AN914 gösterileri kendi uygulamak nasıl.

Her durumda, Thomas ve diğer posterler, çok küçük RAM alanlarıyla PIC'lerde dinamik bellek kullanmanın tehlikeyle dolu olduğunu öne sürdüler . Daha gelişmiş sanal bellek eksikliği nedeniyle bitişik alanınız hızla tükenebilirTam işletim sistemlerinin size sağladığı yöneticilerinin da başarısız tahsislere ve çökmelere neden olur. Daha da kötüsü, deterministik olmayabilir ve muhtemelen hata ayıklamak için bir acı olacaktır.

Yaptığınız şey çalışma zamanında gerçekten dinamik olarak belirlenirse (çoğu gömülü şey için nadirdir) ve sadece birkaç özel durumda yer ayırmanız gerekiyorsa , görebiliyor mallocve freekabul edilebilir olabiliyordum .

PIC, bellek açısından ne kadar büyük?

malloc bellek ayırmanın çok verimsiz bir yoludur. Bununla ilgili sorun, belleğin sık sık serbest kalma ve malloklarla parçalanabilmesidir ve sadece birkaç kilobayt bellekle, ayırma başarısızlıkları çok yaygındır. Daha küçük bir çip veya daha erken bir PIC18 kullanıyorsanız, Microchip'in uygulanması çok zor (veya bazı durumlarda imkansız bile) olduğu veya olması için yeterince kullanılmadığı için malloc desteği yoktur. buna değer. Bahsetmiyorum, ama aynı zamanda oldukça yavaş, zaten mevcut olan bir statik tamponu kullanmak için 1 döngüye ve bir malloc yapmak için 100'lerden 1000'e kadar döngüye bakıyorsunuz.

Statik olarak ayırmak istiyorsanız, siz sprintf işlevleriniz için bir tampon (varsa, yaklaşık 128 bayt), SD kartınız için bir tampon (varsa) vb. Malloc ihtiyacını ortadan kaldırana kadar oluşturun. İdeal olarak, sadece kesinlikle ihtiyacınız olan yerde kullanırsınız ve statik ayırma ile kurtulamazsınız, ancak bu durumlar genellikle nadirdir ve belki de daha büyük / daha güçlü mikrodenetleyicilere bakmanız gerektiğinin bir işaretidir.

PIC18'de bir "işletim sistemi" geliştiriyor / taşıyorsanız ve mikrodenetleyicileri destekliyorsa, muhtemelen statik ayırma desteği vardır. Örneğin, SQLite3 statik ayırmayı destekler - büyük bir arabellek dizisi tahsis edersiniz ve mikro denetleyiciler için olmasa bile mümkün olduğunda bunu kullanır. Değilse, küçük bir PIC18 için tasarlandığından emin misiniz?

Gömülü yazılımınızı düşünüyorsanız malloc()ve free()uC / OS-II ve OSMemGet()ve OSMemPut(). malloc()Rastgele bir bellek bloğu atamanıza izin verirken , OSMem*()önceden ayrılmış bir havuzdan size sabit boyutlu bir blok verin. Bu yaklaşımı malloc(), statik tahsinin esnekliği ve sağlamlığı arasında iyi bir denge buluyorum .

AFAIK, bunu doğru bir şekilde yapabilmek için gerçekten bir çeşit bellek yönetim birimi (MMU) olan bir cihaza bakmanız gerekiyor. PIC18 serisi için dinamik ayırma mekanizmaları mevcut olsa da, gerçekten o kadar sağlam olmayacaklar - ve PIC18 serisinin sınırlarını zorlayan bellenim üzerinde çalışan biri olarak konuşurken, almayacağınızı söyleyebilirim. tüm ek yükü bir bellek yöneticisine harcarsanız, orada büyük bir uygulama.

Daha iyi çözüm: ne yaptığını ve neden dinamik ayırmaya ihtiyaç duyduğunu anlamaya çalışın. Statik ayırmayla çalışacak şekilde yeniden çarpanlara ekleyemeyeceğinize bakın. (Bu mümkün olmayabilir - eğer kütüphane / uygulama serbestçe ölçeklenen bir şey yapacak şekilde tasarlanmışsa veya kabul edebileceği girdi miktarı sınırlarına sahip değilse.) Ama bazen, eğer gerçekten ne yapmaya çalıştığınız konusunda, bunun yerine statik ayırmayı kullanmanın (hatta muhtemelen oldukça kolay) olduğunu görebilirsiniz.