simple and portable malloc library

Question

I am currently developing on the Sega Saturn.

The console has several dedicated chips; some of which have their own dedicated RAM and/or VRAM. An example would be how main RAM is split into two different 1MB zones.

I am searching for a generic, portable, and small malloc library that will allow me to declare different RAM zones and then allow me to malloc or free within those zones.

An example would be the vdp2 graphic chip. It has a dedicated VRAM zone for the color palette of screen mode 8b.

Here, I could use a classic method and preload palettes that worked for all game graphics, but why not only load palettes that are actually in use by my current graphics?

Here I need a system to allocate and free colors (palette entries), but I wish it to fail if the user attempts to allocate more than 255 colors - as this is the maximum palette size.

Basically, I want to be able to declare a few dynamic memory zones and alloc/free into them:

u32 palRam  = defineMallocZone(COLOR_PALETTE,COLOR_PALETTE_SIZE);
u32 m68kRam = defineMallocZone(M68KVRAM,M68KVRAMSIZE);
u32 highRam = defineMallocZone(HIGHRAM,1024*1024);

u16* my64colors = (u16*)magicMalloc(palRam,64*sizeof(u16));

The main malloc of the tool-chain that came with the Saturn did not worked out of the box, so I quickly wrote this shit:

#define mallocSizeK 512
#define mallocSizeB mallocSizeK*1024

void * mymalloc(u32 n)
{   static u8 m[mallocSizeB];
    static u32 c=0;
    if(!n) return (void*)&c;
    while(n%4) n++;
    u32 nn = c+n;
    if(nn > mallocSizeB) return 0;
    u8 * p = &m[c]; c = nn; memset(p,0,n);
    return (void*)p;
}

It's ok for my current tests, but it won't be fine in the long run, (It really need a free! But this is not what I want overall =) )

To summarize, I need a minimalistic, basic, and simple piece of code to do handle memory zones as outlined above. For now, the memory management algorithm need not be efficient, I just want it to work. Or maybe can you send me a link to a classic and simple memory management algorithm that I can try to implement myself?

edit > ok i done it myself, here is a gist

not very evolved but work fine with this test :

u32* b1 = bnew(M68KVRAM,512);
void*mtest[500]; u32 allocSize = 8;
u32 n = 0, nb=0, total=0;

while(n<500){
    u32 sz = rand()%(allocSize*1024);
    void *a = bmalloc(b1,sz);
    if(!a) break;
    memset(a,1,sz);
    mtest[n++] = a;
    total += sz;
};

nb = n; printlr("allocated %u/512 kb in %u 0~%uk blocs",total>>10,nb,allocSize);

printl("free them all .. ");
u32 freertn = 0; for(n=0;n<nb;n++) freertn |= (u32)bfree(b1,mtest[n]);
if(freertn) printlr("fail"); else printlr("ok");

*mtest = bmalloc(b1,512*1024);
if(*mtest) memset(*mtest,200,512*1024);
printlr("final 512k allocation return : 0x%x",*mtest);

It's hard to tell what you're asking for. Are you looking for malloc libraries? malloc examples? a free to go along with your malloc? Please edit this and include one concise question. — jwheron, Jul 24 '13 at 16:29

score 2 · Accepted Answer · edited May 23 '17 at 12:08

2

Basically, you need two memory management routines: One that stores its internal working in one part of RAM while managing another (in this case, VRAM), and the other could be any normal malloc routine. For VRAM, do you need it to handle both 16 and 256 color palettes or just 256? If a single size, then a "Unit Allocator" type algorithm would suit you just fine.

For your main RAM, a linked list style algorithm would probably be sufficient. An implementation is done here, but with just a little bit of leg work, you can find MANY, MANY implementations on the internet.

I haven't looked at the Saturn myself in 16 years, so this was a fun thing to read and edit for you :)

edited May 23 '17 at 12:08

Community

1
1

answered Jul 24 '13 at 18:41

Michael Dorgan

12,453
3
31
61

yes, palette is not a great example as it must support sharing colors between sprites and get fixed size memory, so a dedicated code will be required, but i want be abble to give only 64 or 96 colors to this system without recompute his ram offset and just let it be dynamic. i want support all kind of palette mode the saturn get, each vdp2 background can get his own color mode, resolution and palette, but it's just a possible use case, why i require a generic system. Implementations you linked are simple, i +1 for it and try implement my own free :) thx for edit, yet i'm not english ^^ – r043v Jul 24 '13 at 20:33
You got your point across just fine :) I just cleaned it up a little for other, non-console people to understand a bit better. – Michael Dorgan Jul 24 '13 at 21:20

simple and portable malloc library

1 Answers1