bottleros/Kernel/memManagerNaive.c

#ifndef BUDDY

#include "memManager.h"
// #include <stdio.h>
#include <string.h>
#include <assert.h>
#include "video.h"

#define MANAGED_MEMORY_SIZE 1024 * 1024 * 64

// char mem[MANAGED_MEMORY_SIZE];
// char mem2[MANAGED_MEMORY_SIZE];

typedef struct MemoryManagerCDT {
	char *nextAddress;
    // char *lastAddress;
    char *initialAddress;
} MemoryManagerCDT;

MemoryManagerADT createMemoryManager(void *const restrict memoryForMemoryManager, void *const restrict managedMemory) {
	MemoryManagerADT memoryManager = (MemoryManagerADT) memoryForMemoryManager;
	memoryManager->nextAddress = managedMemory;
    // char * aux = managedMemory;
    // memoryManager->lastAddress = aux - 1;
    memoryManager->initialAddress = managedMemory;

	return memoryManager;
}

void *allocMemory(MemoryManagerADT const restrict memoryManager, const size_t memoryToAllocate) {
	char *allocation = memoryManager->nextAddress;
    if (memoryToAllocate + memoryManager->nextAddress > memoryManager->initialAddress + MANAGED_MEMORY_SIZE){
        return NULL;
    }

	memoryManager->nextAddress += memoryToAllocate;
    // if (!(memoryManager->nextAddress -1 == (memoryManager->lastAddress += memoryToAllocate)))
    //     return NULL;

	return (void *) allocation;
}

// Esto es mejor para independizarnos del puntero a memoryManager! Y poder llamar desde distintos lugares (sin la referencia del memManager) a malloc...

static MemoryManagerADT memoryManager;
char initMemoryManager(void *const restrict memoryForMemoryManager, void *const restrict managedMemory) {
    return ((memoryManager = createMemoryManager(memoryForMemoryManager, managedMemory)) == NULL) ? EXIT_FAILURE : EXIT_SUCCESS;
}

void * memMalloc(const size_t memoryToAllocate) {
    return allocMemory(memoryManager, memoryToAllocate);
}


// SACAR DESPUÉS! ES SOLO PARA TESTEO...

char testOne() {
    void * alloc1 = memMalloc(100);
    void * alloc2 = memMalloc(200);
    void * alloc3 = memMalloc(300);

    memset(alloc1, 1, 100);
    memset(alloc2, 2, 200);
    memset(alloc3, 3, 300);

    for (int i = 0; i < 600; i++) {
        if (i < 100) {
            if (!(*((char *) alloc1+i) == 1)) {
    			printStringLen(13, "alloc1 -- ERROR", 31); 
    			// printStringLen(13, *((char *) alloc1+i), 1); 
				new_line();
				return EXIT_FAILURE;
			}
        } else if (i < 300) {
            if (!(*((char *) alloc1+i) == 2)) {
    			printStringLen(13, "alloc2 -- ERROR", 31); 
				new_line();
				return EXIT_FAILURE;
			}
        } else if (i < 600) {
            if (!(*((char *) alloc1+i) == 3)) {
    			printStringLen(13, "alloc3 -- ERROR", 31); 
				new_line();
				return EXIT_FAILURE;
			}
        }
    }

    return EXIT_SUCCESS;
}

static unsigned long int next = 1;
int rand(void) // RAND_MAX assumed to be 32767
{
    next = next * 1103515245 + 12345;
    return (unsigned int)(next/65536) % 32768;
}

char testTwo() {
    void * ptr;
    while (ptr != NULL){
        ptr = memMalloc((rand() % 2000) + 1);
        if (!((char *) memoryManager->nextAddress >= memoryManager->initialAddress)) {
    			printStringLen(13, "allocRand1 -- ERROR", 31); 
				new_line();
				return EXIT_FAILURE;
		}
        if (!((char *) memoryManager->nextAddress <= memoryManager->initialAddress + MANAGED_MEMORY_SIZE)) {
    			printStringLen(13, "allocRand2 -- ERROR", 31); 
				new_line();
				return EXIT_FAILURE;
        }
		// if (!((char *) memoryManager->lastAddress >= memoryManager->initialAddress)) {
        // }
        // if (!((char *) memoryManager->lastAddress <= memoryManager->initialAddress + MANAGED_MEMORY_SIZE)) {
        // }
    }

    return EXIT_SUCCESS;

}

/*
int main() {
	static MemoryManagerADT memoryManager;
    static MemoryManagerADT memoryManager2;

    void * memoryForMemoryManager = (void *) 0x700000;
    // void * memoryForMemoryManager = malloc(sizeof(void *));
	if (memoryForMemoryManager == NULL) {
        return 1;
	}

	void *managedMemory = (void *) 0x700016;// malloc(MANAGED_MEMORY_SIZE);
	if (managedMemory == NULL) {
        return 1;
	}


    void * memoryForMemoryManager2 = (void *) 0x700008;
    // void * memoryForMemoryManager2 = malloc(sizeof(void *));
	memoryManager = createMemoryManager(memoryForMemoryManager, managedMemory);

    void * alloc1 = allocMemory(memoryManager, 100);
    void * alloc2 = allocMemory(memoryManager, 200);
    void * alloc3 = allocMemory(memoryManager, 300);

    memset(alloc1, 1, 100);
    memset(alloc2, 2, 200);
    memset(alloc3, 3, 300);

    for (int i = 0; i < 600; i++) {
        if (i < 100) {
            assert(*((char *) alloc1+i) == 1);
        } else if (i < 300) {
            assert(*((char *) alloc1+i) == 2);
        } else if (i < 600) {
            assert(*((char *) alloc1+i) == 3);
        }
    }

    managedMemory = (void *) (0x700016 + 600);
	memoryManager2 = createMemoryManager(memoryForMemoryManager2, managedMemory);

    void * ptr;
    while (ptr != NULL){
        ptr = allocMemory(memoryManager2, (rand() % 2000) + 1);
        assert ((char *) memoryManager2->nextAddress >= mem2);
        assert ((char *) memoryManager2->nextAddress <= mem2 + MANAGED_MEMORY_SIZE);
		assert ((char *) memoryManager2->lastAddress >= mem2);
        assert ((char *) memoryManager2->lastAddress <= mem2 + MANAGED_MEMORY_SIZE);
    }
}
*/

#endif