[C] interfaccia per un gestore di memoria statica

[noodles83]

Mi è stato assegnato questo piccolo progetto da fare in C, ma ho alcuni dubbi che vorrei mi aiutaste a chiarirmi.

IL PROBLEMA:
Come parte dello sviluppo di una nuova consolle per videogiochi, siete stati incaricati di sviluppare il codice che si occuperà della
memorizzazione dei dati dei giochi (missioni svolte, livelli superati, opzioni di gioco, caratteristiche dei personaggi, ecc.). A causa di
limitazione dell'hardware, è disponibile per la memorizzazione di questi dati solo un banco di memoria statica di 64Kb. Tale memoria
viene gestita a pagine di 512 byte: ogni gioco eseguito sulla console (identificato da un codice identificativo unico, assegnato dal
produttore) può chiedere al gestore memoria di memorizzare un numero di pagine comprese fra 1 e 64 (ovvero, fra 512 e 32768
bytes). Nel caso non ci sia memoria disponibile nell'ambito dei 64Kb, il gestore deve abbandonare le pagine più vecchie fra quelle
memorizzate (si perdono cioè i dati memorizzati dal gioco che non è stato usato da più tempo per far spazio a quelli del gioco
attualmente in uso) e utilizzarle per soddisfare la richiesta corrente.

Si noti che tutti i dati di servizio necessari a gestire la memoria statica devono essere a loro volta conservati all'interno di tale
memoria (altrimenti, sarebbero persi allo spegnimento e successivo avvio della console); a tale scopo deve essere dedicato il minor
numero possibile di pagine, per lasciare maggior spazio ai dati dei giochi.


Mi devo costruire una API e va bene... ho pensato di usare un array bidimensionale per la memoria.

typedef unsigned char BYTE;
static BYTE pages[128][512];

Quello che mi turba, da nubbio, è la parte in corsivo... penso di non aver capito bene il problema. Dovrei salvare nella struttara dati che ho fatto tutte le variabili globali e quelle strutture ausiliare che eventualmente uso? E' questo il senso della cosa?

Mi continua però a sfuggire sempre qualcosa... primo... come è possibile fare una cosa del genere, per esempio salvare una struct in un array di byte?
secondo. perchè quello che inserisco in quell'array di byte dovrebbe essere preservato da un riavvio della console?

[cionci]

Perché hai usato la parola "static" nella dichiarazione ?

Quello scritto in corsivo significa che devi usare una o più pagine per andare a memorizzare i dati della tabella LRU (Least Recently Used) e la tabella della pagine occupate. Esistono diverse politiche più o meno efficienti e più o meno avide di memoria per gestire un algoritmo di rimpiazzamento LRU, ma spero che te le abbiano insegnate.

Ti consiglio di usare direttamente un vettore monodimensionale per la memoria. Ti dovrebbe rendere molto più semplice l'accesso per la scrittura e la lettura delle tabelle di cui sopra.

[noodles83]

Originariamente inviato da cionci

Perché hai usato la parola "static" nella dichiarazione ?

perchè credo che non debba essere pubblica, no?

Come politica di rimpiazzamento avevo appunto in mente una cosa del genere, ma quello non è il mio problema.
Il mio problema indipendetemente dal tipo di politica utilizzata capire come poter memorizzare a loro volta queste tabelle o queste informazioni di rilocazione su l'array di byte.

[cionci]

Originariamente inviato da noodles83

perchè credo che non debba essere pubblica, no?

Forse per un progetto del genere è ammissibile.

Originariamente inviato da noodles83

Si non capisco però come poter memorizzare una tabella nell'array di byte...

Lavorando sugli indirizzi con i puntatori.
&memory[page * 512] ti ritorna l'indirizzo dell'inizio della pagina. Se io voglio lavorare a byte sulla pagina 1 posso tranquillamente fare:

char *lru = &memory[1]; /*indirizzo della pagina 1*/

Poi per accedere ai vari byte: lru[i] = 1;

Ovviamente sarai tu a doverti limitare sulla dimensione di lru e della tabella della memoria usata.

[noodles83]

scusa, avevo modificato il post precedente...

[noodles83]

magari sarò duro io... è molto probabile, ma il mio problema è un'altro.

Io ho questo array di byte, facciamolo mono-dimensionale, che in effetti è meglio.

Ho una struct così fatta:
typedef struct data{
long game_id; /* ID univoco del gioco*/
short block_id; /* ID del blocco*/
int pageSize; /* lunghezza in byte del blocco*/
}DATA;

se voglio salvare questa stuttura nell'array di byte, come faccio? devo usare memcpy()?

E come mi verrebbe "mappata" sull'array? fatemi un esempio per capire... mettiamo cosa una volta salvata voglia accedere al block_ID di questa struct.

[cionci]

BYTE memory[65536];

DATA *mytable;

//supponiamo di volerlo memorizzare nella seconda pagina
mytable = (DATA *)&memory[2*512];
//calcolo la quantità di strutture data che possono essere contenute nel blocco (anche se non serve, giusto per farti capire)
int mytable_size = 512 / sizeof(DATA);

mytable lo tratti esattamente come un normale vettore di DATA ed hai a disposizione mytable_size elementi per non sforare i limiti della pagina (cosa che probabilmente dovrai tenere di conto).

[noodles83]

Originariamente inviato da cionci

BYTE memory[65536];

DATA *mytable;

//supponiamo di volerlo memorizzare nella seconda pagina
mytable = (DATA *)&memory[2*512];
//calcolo la quantità di strutture data che possono essere contenute nel blocco (anche se non serve, giusto per farti capire)
int mytable_size = 512 / sizeof(DATA);

mytable lo tratti esattamente come un normale vettore di DATA ed hai a disposizione mytable_size elementi per non sforare i limiti della pagina (cosa che probabilmente dovrai tenere di conto).

per prima cosa ti ringrazione per la pazienza e l'aiuto che mi stai dando.

mmm... vediamo se ho capito. In questo modo posso continuare ad accedere a memory byte a byte, ma nello stesso tempo usare mytable come se l'array fosse fatto di strutture DATA, operando però sulla stesso spazio di memoria. Giusto?

[cionci]

Sì...ed è la stessa cosa che si fa con malloc...infatti malloc ritorna un puntatore a void che viene poi castato al tipo di dato che ci interessa.
In pratica anche le tue API dovranno ritornare al gioco un puntatore a void

PS: 2*512 è la terza pagina

[noodles83]

Originariamente inviato da cionci

Sì...ed è la stessa cosa che si fa con malloc...infatti malloc ritorna un puntatore a void che viene poi castato al tipo di dato che ci interessa.
In pratica anche le tue API dovranno ritornare al gioco un puntatore a void

PS: 2*512 è la terza pagina

perfetto. Inizio a vedere uno spiraglio di luce... Grazie.

Vedo nel pomeriggio di iniziare a buttare giù qualcosa di concreto.

[noodles83]

mi è venuto un dubbio...

se ho:
DATA* mytable=(DATA*)&memory[125];

se faccio:
mytable=mytable+1;

mytable punta all'area di memoria memory[126], cioè al byte successivo?

oppure mytable si sposta di una grandezza pari sizeof(DATA) ?

[cionci]

Si sposta di una grandezza pari a siezof(DATA).

[marra11mg]

ma le pagine che riservi per ogni gioco, possono essere in ordine sparso oppure basta che sono contigue?
In quest'ultimo caso sarebbe molto più semplice, potendo riservare 2kb alla tabella e usando gli altri 62k per salvare i giochi

[noodles83]

@marra11mg: possono essere anche i ordine sparso.

Vi chiedo ancora aiuto... ho un problema piccolo e uno grosso.

PROBLEMA PICCOLO:
vorrei sapere che warning è questo che mi viene sempre prodotto e non riesco ad eliminare?

In file included from memManager.c:8:
memManager.h:23: warning: no semicolon at end of struct or union

ne sapete qualcosa?


PROBLEMA GROSSO:
sto implementando questa funzione int psave(long game_id, short block_id, byte *buffer, int size);
vi riporto un pezzo di codice...

typedef unsigned char byte; /*posto in memManager.h*/
byte memory[65536]; /*è fuori dalla funzione, posta come variabile globale*/

/*nella funzione che sto implementando scrivo*/
mytable=(DATA*)&memory[0];
mytable->gioco=game_id;
mytable->blocco=block_id;
mytable->blocco_size=size+sizeof(DATA);
mytable->pages= n;
mytable->flag=1;
mytable->time=time(NULL);
memcpy(&memory[sizeof(DATA)],buffer,size); /*copio i dati in memoria*/

se provo a fare printf("%s", memory[sizeof(DATA)]) mi da segmentation fault.... come mai???

[cionci]

C'è scritto cosa significa.
Devi mettere un punto e virgolo dopo la parentesi chiusa della dichiarazione di una struct.

[noodles83]

Originariamente inviato da cionci

C'è scritto cosa significa.
Devi mettere un punto e virgolo dopo la parentesi chiusa della dichiarazione di una struct.

c è il punto e virgola...

typedef struct data{

long gioco; /* ID univoco del gioco*/
short blocco; /* ID del blocco*/
int blocco_size;/* lunghezza in byte dei dati del blocco*/
int pages; /* numero di pagine occupate dal blocco*/
int flag; /* flag che indica con 0 se il blocco è libero, 1 altrimenti.*/
time_t time /* data dell'ultimo riferimento al blocco*/
} DATA;

[noodles83]

che imbecille!! mancava il punto e virgola alla variabile time....

e per il problema grosso invece? c è una spiegazione?

[cionci]

Originariamente inviato da noodles83

@marra11mg: possono essere anche i ordine sparso.

Vi chiedo ancora aiuto... ho un problema piccolo e uno grosso.

PROBLEMA PICCOLO:
vorrei sapere che warning è questo che mi viene sempre prodotto e non riesco ad eliminare?

In file included from memManager.c:8:
memManager.h:23: warning: no semicolon at end of struct or union

ne sapete qualcosa?


PROBLEMA GROSSO:
sto implementando questa funzione int psave(long game_id, short block_id, byte *buffer, int size);
vi riporto un pezzo di codice...

typedef unsigned char byte; /*posto in memManager.h*/
byte memory[65536]; /*è fuori dalla funzione, posta come variabile globale*/

/*nella funzione che sto implementando scrivo*/
mytable=(DATA*)&memory[0];
mytable->gioco=game_id;
mytable->blocco=block_id;
mytable->blocco_size=size+sizeof(DATA);
mytable->pages= n;
mytable->flag=1;
mytable->time=time(NULL);
memcpy(&memory[sizeof(DATA)],buffer,size); /*copio i dati in memoria*/

se provo a fare printf("%s", memory[sizeof(DATA)]) mi da segmentation fault.... come mai???

memcpy(&memory[sizeof(DATA)],buffer,size); /*copio i dati in memoria*/

Che cosa vuoi fare con questa istruzione ? Perché indicizzi memory con sizeof(DATA) ?

printf("%s", memory[sizeof(DATA)]);

Che senso ha ? C'è una stringa a quell'indirizzo ? Se vuoi stampare una stringa devi usare &memory[sizeof(DATA)], se non c'è una stringa a quell'indirizzo allora proprio non ha senso quella stampa.
In memory[sizeof(DATA)] c'è il primo byte di buffer.

[noodles83]

Originariamente inviato da cionci

memcpy(&memory[sizeof(DATA)],buffer,size); /*copio i dati in memoria*/

Che cosa vuoi fare con questa istruzione ? Perché indicizzi memory con sizeof(DATA) ?

in byte *buffer ho una stringa che voglio copiare in memoria a partire da memory[sizeof(DATA)]

Originariamente inviato da cionci

printf("%s", memory[sizeof(DATA)]);

Che senso ha ? C'è una stringa a quell'indirizzo ? Se vuoi stampare una stringa devi usare &memory[sizeof(DATA)], se non c'è una stringa a quell'indirizzo allora proprio non ha senso quella stampa.
In memory[sizeof(DATA)] c'è il primo byte di buffer.

si voglio stamapare la stringa. però devo dire che in buffer ho inserito con un cliclo un carattere alla volta.

[cionci]

Originariamente inviato da noodles83

si voglio stamapare la stringa.

Allora devi usare la & davanti a memory. Spero che tu abbia copiato anche il carattere di finestringa.