Está en la página 1de 5

El administrador de memoria funciona manteniendo un seguimiento del listado de cada locación

de memoria, ya sea asignada o libre.

El trabajo del administrador de memoria es asignar memoria, administrar asignando direccione de


memoria. A un cargador de programa que carga otro programa en la memoria principal utilizando
las direcciones de memoria provistas por el administrador de memoria.

Usando la llamada al sistema sbrk() la cual provee un valor entero positivo incrementa el tamaño
del montículo en la memoria principal

Considere muchos procesos que necesitan ser asignados en memoria, si se asigna memoria para
un procesos y se mueve al segundo proceso para la asignación de un bloque de memoria,
entonces como se mantendrá un seguimiento del último bloque de memoria asignado?, para esto
necesitamos almacenar metada con los bloques de asignación de memoria como un puntero a un
puntero al siguiente bloque, direcciones de memoria, esta libre etc.

Así esto formara una estructura de datos (lista ligada) como se presenta a continuación.

Entonces el bloque de dirección de memoria es almacenado usado la llamada sbrk().

En la siguiente imagen el breack point es el puntero apuntado por sbrk(0), si se necesita


incrementar la memoria se llamará a sbrk() entonces el break point se incrementará.
Ejemplo

typedef struct __s_block{

struct __s_block *next;

bool isfree;

size_t size;

void *memoryAddress;

}_SBLOCK;

#define BLOCK_SIZE sizeof(_SBLOCK)

Donde

next : Puntero que apunta al siguiente bloque te memoria.


isfree : Para verificar si un bloque de memoria está disponible o no

size : Tamaño de asignación in la memoria


memoryAddress : Indica donde inicia la dirección de memoria donde está asignada la memoria.
BLOCK_SIZE : Tamaño de la estructura.

Función de asignación de memoria.


_SBLOCK *allocateMemBlock(size_t size)
{
_SBLOCK *block = (_SBLOCK*)sbrk(0);
void *memadr = (void*)sbrk(0);
void *allocate_mem = (void*)sbrk(BLOCK_SIZE + size);

if(allocate_mem == (void*)-1){
return NULL;
}else{
block->next = NULL;
block->isfree = false;
block->size = size;
block->memoryAddress = memadr+BLOCK_SIZE;
return block;
}
}

Esta funciona toma un argumento de cómo se quiere asignar memoria.

Se presenta el programa de asignación de memoria. Este es un ejemplo del administrador de


memoria en el sistema operativo.

#include<stdio.h>
#include<stdbool.h>

typedef struct __s_block{


struct __s_block *next;
bool isfree;
size_t size;
void *memoryAddress;
}_SBLOCK;

#define BLOCK_SIZE sizeof(_SBLOCK)

_SBLOCK *allocateMemBlock(size_t size)


{
_SBLOCK *block = (_SBLOCK*)sbrk(0);
void *memadr = (void*)sbrk(0);
void *allocate_mem = (void*)sbrk(BLOCK_SIZE + size);

if(allocate_mem == (void*)-1){
return NULL;
}else{
block->next = NULL;
block->isfree = false;
block->size = size;
block->memoryAddress = memadr+BLOCK_SIZE;
return block;
}
}

//allocate next memory block


void allocateNextMemBlock(size_t size, _SBLOCK **head)
{
_SBLOCK *current = *head;
void *allocate_mem = NULL;
void *memadr = (void*)sbrk(0);

if(current==NULL){
*head = allocateMemBlock(size);
}else{
while(current->next != NULL){
current = current->next;
}
_SBLOCK *newblock = sbrk(0);

allocate_mem = (void*)sbrk(BLOCK_SIZE + size);


if(allocate_mem == (void*) - 1){ }
else{
newblock->next = NULL;
newblock->isfree = false;
newblock->size = size;
newblock->memoryAddress = memadr+BLOCK_SIZE;
current->next = newblock;
}
}
}

void freeMemBlock(_SBLOCK **head)


{
if(*head == NULL){}
else{
(*head)->isfree = true;
}
}

void printMemBlocks(_SBLOCK *current)


{
while(current != NULL){
printf("isfree = %d, size = %d, memoryAddress = %p, current = %p,
next-node = %p\n",
current->isfree, current->size, current->memoryAddress,
current, current->next);
current = current->next;
}
}

int main()
{
_SBLOCK *sMemBlock = NULL;
allocateNextMemBlock(10,&sMemBlock);
allocateNextMemBlock(35,&sMemBlock);
allocateNextMemBlock(62,&sMemBlock);
printMemBlocks(sMemBlock);
printf("\nAfter freeing second node\n");
freeMemBlock(&(sMemBlock->next));
printMemBlocks(sMemBlock);

return 0;
}

Compile usando gcc –w <nombre_archivo>.c

Ejecute ./a.out

También podría gustarte