Semaforisem_wait(sem);
| Esegue counter-- e nel caso aggiunge a waiting il processo. | sem_signal(sem);
| Rilascia un gettone. Esegue counter++ ed estrae dalla lista dei waiting. | sem_ini($gettoni);
| Restituisce il primo semaforo libero inserendovi $gettoni gettoni. 0xFFFFFFFF se qualcosa è andato storto. | sem_valid(id);
| Verifica la validità di un semaforo. |
Mutex: $gettone = 1
Sync: $gettone = 0
Nota: tutti gli errori sono 0xFFFFFFFF
Attenzione: Tutti gli id sono natl Processides_p(id);
| Restituisce un des_proc* a partire dall'id. | c_abort_p();
| Porta all'interruzione del processo. Non effettua return ed è utile nei casi di errore. | p->contesto[I_RAX] = $value;
| Ritorno della funzione di value. | rimozione_lista($lista);
| Rimuove la testa dalla lista (max prio) | inspronti();
| Inserisce esecuzione in testa a pronti |
Preemptiondes_proc* work = rimozione_lista($lista);
inspronti();
inserimento_lista(pronti, work);
schedulatore();
|
Alla fine ci sarà sicuramente uno tra il processo in esecuzione e work attivo Utilitàflog(MODE, "msg"); | Mostra a schermo il messaggio msg |
LOG_DEBUG: costante per debug
LOG_INFO: costante per informazioni
LOG_WARN: costante per avviso Tab itertab_iter it(tab, begin, dim);
| Utile per scorrere le entrate dell'albero degli indirizzi | it.down();
| Per scorrere in profondità, vedi vm.h | it.is_leaf();
| restituisce true se è una foglia | tab_entry& e = it.get_e();
| Restituisce un riferimento al descrittore corrente | vaddr v = it.get_v();
| Restituisce l'indirizzo virtuale asdsociato alla entry in it | paddr p = extr_IND_FISICO($e);
| Restituisce l'indirizzo fisico associato alla entry | set_IND_FISICO($e, $paddr);
| Setta l'indirizzo fisico corrispondente alla entry $e | alloca_tab();
| Alloca un frame libero destinato a contenere una tabella di traduzione restituendo l'indirizzo del frame | copy_des(paddr src, paddr dst, natl i, natl n);
| Copia 'n' descrittori da src in dst a partire dall'indice i | set_des(paddr dst, natl i, natl n, tab_entry e);
| Setta il valore 'e' su 'n' descrittori a partire dall'indice 'i' |
Utilizzo tab_iterfor (tab_iter it(p->cr3, ini_utn_p, dim); it; it.next()) {
if (!it.is_leaf())
continue;
tab_entry& e = it.get_e();
vaddr v = it.get_v();
paddr p = extr_IND_FISICO(e); // or set
/* e &= ~BIT_RW;
abbiamo modificato RW: invalidamo
le entrate nel TLB
invalida_entrata_TLB(v);*/
}
|
Memoria Virtualetrasforma(vaddr);
| Restituisce il paddr relativo a un vaddr | tipo_livello_accesso
| Vedere le note | alloca_frame();
| restituisce l'indirizzo del frame caricato | rilascia_frame($paddr);
| Libera il frame in cui è contenuto $paddr | paddr base = p & ~0xFFF;
| base di un frame | natl indice = p / DIM_PAGINA;
| Indice di frame | invalida_entrata_TLB($vaddr);
| Invalida l'entrata del TLB del processo in esecuzione | cr0 | Abilita la paginazione | cr1 | Non implementato | cr2 | Indirizzo che ha causato page fault | cr3 | paddr albero di traduzione del processo | vdf[]; | array dei descrittori di frame | memcpy( (void) dst, (void) src, int nbytes);
| copia da dst a src nbytes | map(p->cr3, vaddr begin, vaddr end, FLAGS, putpaddr);
| Mappa gli indirizzi fisici passati da putpaddr nell'intervallo [begin, end) restituendo il primo che non è riuscito a tradurre | unmap(p->cr3, vaddr begin, vaddr end, getpaddr);
| Rimuove le traduzioni nell'intervallo [begin, end) da p->cr3 |
- tipo: ini, fin
- livello: utn, sis
- accesso: p, c
Livello tabelle: 4, 3, 2, 1
FLAGS: bit_RW, bit_US | | Funtoreclass Funtore{
public:
paddr pa[DIM_PAGINA];
natl i;
// init di i a 0
Funtore() : i(0) {}
// per la map
paddr operator()(vaddr v){
return pa[i++];
}
// per la unmap
void operator()(vaddr, paddr p, int){
pa[i++] = p;
// oppure trasforma(v);
}
}; // attento a ; !!!
|
Elimina da listades_proc elimina_da_lista(des_proc& testa, des_proc* p){
des_proc *prec = &testa, scorri = testa;
while (scorri && scorri != p) {
prec = &scorri->puntatore;
scorri = scorri->puntatore;
}
if (scorri)
*prec = scorri->puntatore;
return scorri;
}
|
Rimuove dalla lista puntata da $testa il des_proc* p. I/Oaccess(vaddr b, natq dim, bool w, bool s);
| Controlla il cavallo di Troia per w(ritable) e s(hared) | z = inputx(reg);
| Inserisce il valore al registro reg in z | outputx(value, reg);
| Inserisce nel registro reg il valore value | des_x y = new(align_val_t{dim}) des_x;
| Allinea il nuovo valore in memoria | natl spostabili = DIM_PAGINA - (paddr & 0xFFF);
| Calcola il numero di byte spostabili per esaurire il frame |
x: b(yte), l(ong), q(uad) Approccio I/O- Quando viene chiamata l'interruzione?
- Chi prepara il descrittore?
- Cosa deve fare l'interruzione?
- Come rispondiamo all'interruzione?
- Come ci prepariamo alla prossima interruzione?
Nota: nei casi, perlomeno di lettura, potrebbe essere sensato impostare i valori passati come parametri dalla primitiva all'interno del descrittore. Sarà poi l'interruzione (se chiamata ogni tot) a sistemare questi valori già inizializzati con i valori aggiornati. Se invece dovesse essere richiamata solo alla fine del processo, sarà compito della read fare tutto il processo e abilitare le interruzioni alla fine facendo riattivare la estern_ce
Nota2: quando in una read viene passato un buffer, questo dovrà essere copiato nel descrittore in quanto è il buffer in cui la periferica dovrà scrivere i valori che dovremo leggere.
Nota3: se il passaggio di byte tra utente e periferica viene effettuato tramite un buffer di appoggio intermedio, dobbiamo necessariamente usare la memcpy, in quanto questi dati devono essere copiati in una zona di memoria. |
Estern CE// chiamata dalla periferica con un'interruzione
extern "C" void estern_ce(natl id){
// recuperare periferica
for(;;){
// sem_wait(mutex);
// libera il sync occupato nella primitiva
// sem_signal(sync);
// sem_signal(mutex);
wfi();
}
}
|
Metodi di scorrimento tab_iterit.post(); it; it.next_post()
| Effettua un accesso posticipato. Viene solitamente utilizzato quando devo cancellare un albero. | tab_iter it(esecuzione->cr3, v, n); it; it.next()
| Effettua un accesso anticipato. Viene solitamente utilizzato quando si deve semplicemente scorrere l'albero per farci operazioni di qualsiasi tipo. |
inspronti e inserimento_lista(pronti, esecuzione)La primitiva
inspronti();
inserisce il processo in esecuzione in testa alla coda pronti. | La primitiva
inserimento_lista(pronti, esecuzione);
inserisce il processo in esecuzione nella coda pronti in maniera ordinata. Quindi, se nella coda pronti c'è un processo P1 con priorità uguale a quella del processo in esecuzione, quest'ultimo verrà inserito nella lista dopo il processo P1. | inspronti(); : esecuzione -> P1
| inserimento_lista(pronti, esecuzione); : P1 -> esecuzione
|
Primitive con tipo di ritornoSe abbiamo una primitiva del tipo
bool primitiva(parametri)
dovremo implementarla in due modi diversi nel modulo sistema e nel modulo I/O.
SISTEMA: non possiamo farle restituire un tipo (deve essere void), quindi il valore di ritorno dovremo inserirlo nel contesto del processo in esecuzione.
extern "C" void primitiva(parametri) {
//operazioni
esecuzione->contesto[I_RAX] = valore_ritorno;
}
I/O: possiamo utilizzare i tipi di ritorno delle primitive nel seguente modo:
extern "C" bool primitiva(parametri) {
//operazioni
return valore_ritorno;
} |
|
Created By
Metadata
Comments
No comments yet. Add yours below!
Add a Comment
Related Cheat Sheets
More Cheat Sheets by Gray00