C/Visual C - por favor simulacion de administracion de memoria

 
Vista:

por favor simulacion de administracion de memoria

Publicado por luis enrique (2 intervenciones) el 12/10/2001 05:37:00
por favor necesito ayuda a quien me pueda guiar a realizar una simulacion de aministrcion de memoria en lenguaje c , te agradeceria.


luis bye
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Simulación de administración de memoria en C

Publicado por Alejandro (913 intervenciones) el 16/10/2024 22:44:33
Luis, para realizar una simulación de administración de memoria en C, puedes implementar un simple gestor de memoria que simule la asignación y liberación de bloques de memoria. Aquí te dejo un ejemplo básico que puedes usar como punto de partida.

Ejemplo de simulación de administración de memoria



Este ejemplo simula un gestor de memoria que utiliza un enfoque de "first fit" para la asignación de memoria.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
 
#define MEMORY_SIZE 1024 // Tamaño total de la memoria
#define BLOCK_SIZE 128   // Tamaño de cada bloque
 
typedef struct Block {
    bool isFree;         // Indica si el bloque está libre
    size_t size;        // Tamaño del bloque
    struct Block* next; // Puntero al siguiente bloque
} Block;
 
Block memory[MEMORY_SIZE / BLOCK_SIZE]; // Simulación de memoria
 
void initializeMemory() {
    for (int i = 0; i < MEMORY_SIZE / BLOCK_SIZE; i++) {
        memory[i].isFree = true; // Todos los bloques están libres al inicio
        memory[i].size = BLOCK_SIZE;
        memory[i].next = (i < (MEMORY_SIZE / BLOCK_SIZE) - 1) ? &memory[i + 1] : NULL;
    }
}
 
void* allocateMemory(size_t size) {
    for (int i = 0; i < MEMORY_SIZE / BLOCK_SIZE; i++) {
        if (memory[i].isFree && memory[i].size >= size) {
            memory[i].isFree = false; // Marcar el bloque como ocupado
            return (void*)&memory[i]; // Retornar la dirección del bloque
        }
    }
    return NULL; // No hay suficiente memoria
}
 
void freeMemory(void* ptr) {
    Block* block = (Block*)ptr;
    block->isFree = true; // Marcar el bloque como libre
}
 
void printMemoryStatus() {
    for (int i = 0; i < MEMORY_SIZE / BLOCK_SIZE; i++) {
        printf("Block %d: %s\n", i, memory[i].isFree ? "Free" : "Occupied");
    }
}
 
int main() {
    initializeMemory();
    printMemoryStatus();
 
    // Simulación de asignación de memoria
    void* ptr1 = allocateMemory(128);
    printf("\nAllocated 128 bytes.\n");
    printMemoryStatus();
 
    void* ptr2 = allocateMemory(64);
    printf("\nAllocated 64 bytes.\n");
    printMemoryStatus();
 
    // Liberar memoria
    freeMemory(ptr1);
    printf("\nFreed 128 bytes.\n");
    printMemoryStatus();
 
    return 0;
}

Explicación del código



1. Estructura `Block`: Define un bloque de memoria que contiene información sobre si está libre, su tamaño y un puntero al siguiente bloque.

2. Inicialización de memoria: La función `initializeMemory` inicializa todos los bloques de memoria como libres.

3. Asignación de memoria: La función `allocateMemory` busca un bloque libre que sea lo suficientemente grande y lo marca como ocupado.

4. Liberación de memoria: La función `freeMemory` marca un bloque como libre.

5. Estado de la memoria: La función `printMemoryStatus` imprime el estado de cada bloque de memoria.

Consideraciones



- Este es un ejemplo básico y no maneja fragmentación ni coalescencia de bloques libres.
- Puedes expandir este código para incluir diferentes estrategias de asignación (como "best fit" o "worst fit") y manejar la fragmentación.
- Asegúrate de probar y ajustar el código según tus necesidades.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar