MINIX: Il livello più basso

Il file mpx88.s fa parte dello strato più basso del kernel MINIX. In esso sono descritte ed implementate in assembly tutte le operazioni che consentono di cambiare lo stato di un processo(processing switching) e di gestire lo scambio di messaggi (message handling).

Questo file è utilizzato ogni qual volta si fà riferimento al kernel.
Es. per l’ invio e/o ricezione di messaggi e per la gestione delle interruzioni/trap.
Nei casi di eccezioni hardware, quali TRAP o interruzioni, prima di eseguire il relativo gestore viene chiamata la procedura save() per salvare lo stato della macchina nella tabella dei processi. Successivamente si passa a lavorare sullo stack del kernel e finalmente viene eseguita la reale trap o chiamato il reale gestore di interruzioni scritto in codice C. Al ritorno della chiamata di procedura relativa ai gestori, il numero di processo o task contenuto in ‘cur_proc’ viene messo in esecuzione.
I punti d’ingresso(entry points) definiti in questo file sono:

• minix: inizializza lo stack del kernel e chiama la procedura main(scritta in C )
• s_call: per un processo o task che vuole inviare o ricevere un messaggio
• tty_int: routine d’interruzioni per ogni tasto pressato e rilasciato
• lpr_int: routine d’interruzioni per ogni linea di stampata
• disk_int: routine d’interruzioni per il disco
• wini_int: routine d’interruzioni per Winchester
• clock_int: routine d’interruzioni per il clock (Hz)
• surprise : per altri interrupt(inaspettati)
• trp: per tutte le trap(esclusa trap su divisione)
• divide: per le trap del tipo divide overflow
• restart: per l’inizio dell’ esecuzione di un task o un processo

Queste entry point vengono chiamate prima di eseguire la relativa procedura in C

MINIX
L’entry point per il kernel MINIX setta il DS e l’ SS del kernel all’indirizzo 4 e lo stack pointer sp del kernel viene inizializzato al valore #K_STACK_BYTES(256); infine viene chiamata la procedura main. Tutte queste operazioni vengono chiamate ad interruzioni disabilitate.
Ricordiamo che:

• DS : Data Segment è l’area che contiene i dati del programma
• CS : Code Segment è l’area di memoria che contiene le istruzioni(il testo) del programma
• SS : Stack Segment è l’area di memoria relativa allo stack del programma
• ES: Extra Segment è l’area di memoria per le informazioni extra relative al programma

|*===========================================================================* |* MINIX * |*===========================================================================* MINIX: | this is the entry point for the MINIX kernel.
jmp M.0 | skip over the next few bytes
M.0: cli | disable interrupts
…
mov ax,4 | build has loaded this word with ds value
mov ds,ax | ds now contains proper value
mov ss,ax | ss now contains proper value
mov _scan_code,bx | save scan code for '=' key from bootstrap
mov sp,#_k_stack | set sp to point to the top of the
add sp,#K_STACK_BYTES | kernel stack
call _main | start the main program of MINIX


System Call
Questo entry point inserisce i parametri della funzione sys_call(function, caller, src_dest, m_ptr) nella stack del kernel prima della vera chiamata in codice C.
Al ritorno della procedura per la chiamata di sistema viene mandato un task o un processo in esecuzione(viene chiamata la procedura restart)
I parametri della sys_call vengono recuperati accendendo alla posizione della tabella dei processi relativa al processo o task in esecuzione.


|*===========================================================================* |* s_call * |*===========================================================================* _s_call: | System calls are vectored here.
call save | save the machine state
mov bp,_proc_ptr | use bp to access sys call parameters
push 2(bp) | push(pointer to user message) (was bx)
push (bp) | push(src/dest) (was ax)
push _cur_proc |push caller
push 4(bp) | push(SEND/RECEIVE/BOTH) (was cx)
call _sys_call | sys_call(function, caller, src_dest, m_ptr)
jmp _restart | jump to code to restart proc/task running


Interruzioni e trap.
l’entry point per :

• interruzione da tastiera(tty_int) :
• interruzione stampa di una linea(lpr_int)
• una trap(trp)
• una trap di divisione(divide ,es. divisione per 0)
• altre interruzioni inaspettate(surprise)

si salva lo stato della macchina , si chiama il relativo gestore e si continua l’esecuzione


Es. routine per interruzione d'input da terminale
|*===========================================================================* |* tty_int * |*===========================================================================* _tty_int: | Interrupt routine for terminal input.
call save | save the machine state
call _keyboard | process a keyboard interrupt
jmp _restart | continue execution


I punti di ingresso alla chiamata delle routine di interruzione per :

• il floppy disk
• winchester disk
• clock

hanno un comportamento analogo; per chiamare la funzione interrupt(definita in codice C,proc.c) vengono copiati i parametri nello stack del kernel.

Es. Nella routine di interruzione per il floppy disk viene costruito il messaggio di interruzione da inviare; successivamente viene inpilato nello stack insieme all’argomento FLOPPY che identifica il destinatario.
Infine viene chiamata la funzione interrupt.
In questo caso gli argomenti passati alla funzione sono FLOPPY, &intmess.
Se la routine chiamata fosse stata di clock o winchester, i parametri passati alla funzione interrupt sarebbero rispettivamente [CLOCK, &intmess] o [WINI, &intmess]

|*===========================================================================* |* disk_int * |*===========================================================================* _disk_int: | Interrupt routine for the floppy disk.
call save | save the machine state
mov _int_mess+2,*DISKINT| build message for disk task
mov ax,#_int_mess | prepare to call interrupt(FLOPPY, &intmess)
push ax | push second parameter
mov ax,*FLOPPY | prepare to push first parameter
push ax | push first parameter
call _interrupt | this is the call
jmp _restart | continue execution



idle
l’entry point idle fa attesa attiva aspettando un interruzione
idle: | executed when there is no work
sti | enable interrupts
L3: wait | just idle while waiting for interrupt
jmp L3 | loop until interrupt


Save
Questo è il punto di ingresso utilizzato per salvare lo stato del sistema, quindi le informazioni relative al processo in esecuzione, nella tabella dei processi.
Nel dettaglio, vengono recuperati dallo stack del programma attualmente in esecuzione i valori della program status word (psw), del segmento del codice(cs) e il program counter(pc) e salvati nella tabella dei processi.
Successivamente si salvano i registri relativi al processo, che in ordine di inserimento sono : sp,es,bp,di,si,dx,cx,bx,ax.
La procedura termina con un salto all’indirizzo del chiamante(indirizzo di ritorno della save)

Nota: _proc_ptr ritorna la posizione(indirizzo) nella tabella dei processi del processo in esecuzione.

|*===========================================================================* |* save * |*===========================================================================* save: | save the machine state in the proc table
. ..
pop ds_save | stack: psw/cs/pc/ret addr
pop ret_save | stack: psw/cs/pc
mov bx_save,bx | save bx for later ; we need a free register
mov bx,_proc_ptr | start save set up; make bx point to save area
add bx,*OFF | bx points to place to store cs
pop PC-OFF(bx) | store pc in proc table
pop csreg-OFF(bx) | store cs in proc table
pop PSW-OFF(bx) | store psw
mov ssreg-OFF(bx),ss | store ss
…
push ds_save | start saving all the registers, sp first
push es | save es between sp and bp
mov es,bx | es now references kernel memory too
push bp | save bp
push di | save di
push si | save si
push dx | save dx
push cx | save cx
push bx_save | save original bx
push ax | all registers now saved
…
mov ax,ret_save | ax = address to return to
jmp (ax) | return to caller; Note: sp points to saved ax

Restart
Complementare a Save, questo entry point inizializza ed esegue un processo o un task.
Se il sistema è attivo, i valori psw, cs, sp e dei registri del processo da mandare in esecuzione, contenuti nella tabella dei processi, vengono ripristinati inserendoli nello stack.

|*===========================================================================* |* restart * |*===========================================================================* _restart: | This routine sets up and runs a proc or task.
cmp _cur_proc,#IDLE | restart user; if cur_proc = IDLE, go idle je idle | no user is runnable, jump to idle routine
cli | disable interrupts
mov sp,_proc_ptr | return to user, fetch regs from proc table
pop ax | start restoring registers
pop bx | restore bx
pop cx | restore cx
pop dx | restore dx
pop si | restore si
pop di | restore di
mov lds_low,bx | lds_low contains bx
mov bx,sp | bx points to saved bp register
mov bp,SPLIM-ROFF(bx) | splimit = p_splimit
mov splimit,bp | ditto
mov bp,dsreg-ROFF(bx) | bp = ds
mov lds_low+2,bp | lds_low+2 contains ds
pop bp | restore bp
pop es | restore es
mov sp,SP-ROFF(bx) | restore sp
mov ss,ssreg-ROFF(bx) | restore ss using the value of ds push PSW-ROFF(bx) | push psw
push csreg-ROFF(bx) | push cs
push PC-ROFF(bx) | push pc
lds bx,lds_low | restore ds and bx in one fell swoop
iret | return to user or task


le costanti utilizzate in mpx88.s e contenute in com.h sono:
K_STACK_BYTES = 256 | dimensione kernel stack
WINI = -6 |identificativo per task che si occupa del wininchester disk
FLOPPY = -5 |identificativo per il task floppy disk
CLOCK = -3 | identificativo per il task clock
IDLE = -999 | costante che identifica sistema inattivo
DISKINT = 1 | per identicare il tipo del mess. di interruzione disk
CLOCK_TICK = 2 | per identicare il tipo del mess. di interruzione clock

MINIX: I processi

Il file proc.c contiene tutte le principali operazioni compiute dai processi e per la gestione dei messaggi. La comunicazione tra processi,in MINIX, è effettuata attraverso lo scambio di messaggi, utilizzando delle procedure chiamate send e receive.

Le procedure che descriverò, contenute nel file proc.c cono:

• system call : chiamata quando un processo o task vogliono eseguire una SEND e/o RECIVE
• interrupt : utilizzato dalla routine delle interruzioni per inviare il messaggio di interrupt ad un task
• ready: prende un processo della lista pronti e lo mette in esecuzione
• unready: rimuove il processo dalla lista pronti
• sched: se un processo è da tanto tempo in esecuzione, ne viene schedulato un altro
• pick_proc: porta un processo in esecuzione
• send: invia un messaggio tra pocessi
• receive: per la ricezione di messaggi tra pocessi
  

interrupt

Quando occorre una interruzione viene chiamata la funzione interrupt, la quale prova ad inviare un messaggio di interruzione al task con identificatore passato come argomento
PUBLIC interrupt(task, m_ptr)
int task; /* number of task to be started */
message *m_ptr; /* interrupt message to send to the task */
{/* An interrupt has occurred. Schedule the task that handles it. */

il messaggio di interruzione ha come sorgente la costante che identifica l'hardware, definita nel file com.h,il destinatario ed il puntatore al buffer del messaggio
if (mini_send(HARDWARE, task, m_ptr) != OK) {
/* The message could not be sent to the task; it was not waiting. */

Se l'invio del messaggio di interruzione fallisce, (es. non era in attesa di riceverlo), si setta nella bitmap busy_map per ricordarsi cheil task destinatario è occupato e si salva il riferimento al messaggio di interruzione nel vettore message *task_mess[NR_TASKS+1] (contiene i puntatori ai messaggi dei task occupati).

Nel caso in cui la send è stata eseguita con successo, quindi l'interruzione hardware è stata inviata correttamente, si resetta a zero il bit nella busy_map per identificare che il task è di nuovo libero.
busy_map &= ~this_bit; /* turn off the bit in case it was on */
old_map = busy_map;

Se vi è qualche altro task che ha un interruzione pendente, allora la richiesta viene soddisfatta inviandogli il messaggio di interruzione ed si aggiorna la bitmap relativa ai task occupati
if (old_map != 0) {
for (i = 2; i <= NR_TASKS; i++) {
/* Check each task looking for one with a pending interrupt. */
if ( (old_map>>i) & 1) {/* Task 'i' has a pending interrupt. */
n = mini_send(HARDWARE, -i, task_mess[i]);
if (n == OK) busy_map &= ~(1 << i);

Infine, si controlla se la lista pronti relativa ai taks non è vuota e se c'è
una processo utente in esecuzione, allora porto il task in esecuzione
/* If a task has just been readied and a user is running, run the task. */
if (rdy_head[TASK_Q] != NIL_PROC && (cur_proc >= 0 || cur_proc == IDLE))
pick_proc();

System Call

Solo le system call posso eseguire le procedure send e/o receive, per l'invio e/o ricezione dei messaggi.
Tali chiamate sono eseguite quando viene fatta una trap al kernel con una istruzione INT.
La trap viene catturata e chiamate le procedure send e/o receive .

le System Call prendono come parametri:

• il tipo di funzione da eseguire
• il chiamante, identifica il processo che ha chiamato la sys_call.
• l'identificatore del processo mittente(in caso di receive) e/o destinatario(in caso di send) del messaggio
• il puntatore al messaggio

PUBLIC sys_call(function, caller, src_dest, m_ptr)
int function; /* SEND, RECEIVE, or BOTH */
int caller; /* who is making this call */
int src_dest; /* source to receive from or dest to send to */
message *m_ptr; /* pointer to message */

Le uniche chiamate di sistema consentite ai processi utente sono dove sono presenti sia la send che la receive, altrimenti nel registro per il codice di ritorno da system call del processo chiamante verrà assegnato un codice di errore.
if (function != BOTH && caller >= LOW_USER) {
rp->p_reg[RET_REG] = E_NO_PERM; /* users only do BOTH */
return;}

Negli altri casi si limita ha chiamare le procedure send e/o receive a secondo dei casi
if (function & SEND)
n = mini_send(caller, src_dest, m_ptr); /* func = SEND or BOTH */
if (function & RECEIVE)
n = mini_rec(caller, src_dest, m_ptr); /* func = RECEIVE or BOTH */

Send

La procedura send è utilizzata per inviare un messaggio tra due processi.
Se il destinatario è in attesa di questa comunicazione il messaggio viene copiato nell'area di memoria della parte DATI del processo destinatario ed in seguito ne viene fatta la sveglia.

Nel caso contrario, se il destinatario non è in attesa di ricevere o è in attesa di ricevere da un altro processo, il mittente(il chiamante della send) passa in attesa ed il messaggio viene messo in coda.
In minix i processi utente posso inviare solo al File System ed al processo
gestore della memoria.

I parametri sono:

• identificatore processo mittente(il chiamante),
  
• identificatore processo destinatario
  
• il puntatore al messaggio da recapitare.
  

PUBLIC int mini_send(caller, dest, m_ptr)
int caller; /* who is trying to send a message? */
int dest; /* to whom is message being sent? */
message *m_ptr; /* pointer to message buffer */

Dagli identificatori, passati come argomento alla procedura, si accede alla tabella dei processi e si recuperano gli indirizzi del processo chiamante e del processo destinatario.

Vengono fatti controlli di validazione per verificare se il destinatario è ancora in vita e se l'intero messaggio può essere contenuto nel segmento DATI dell'aera di memoria del
processo chiamante('caller')
if (dest_ptr->p_flags & P_SLOT_FREE)
return(E_BAD_DEST); /*dead dest */
if (vhi < vlo || vhi - caller_ptr->p_map[D].mem_vir >= len)
return(E_BAD_ADDR);

Se il destinatario era bloccato in attesa di questo messaggio viene chiamata la routine
cp_mess[src, src_clicks, src_offset, dst_clicks, dst_offset] che esegue una copia veloce di un messaggio da una parte ad un altro qualsiasi indirizzo di memoria e svegliato il destinatario,se il processo diventa runnable(dest_ptr->p_flags == 0) viene inserito nella propria lista pronti(ready).
N.B.Dopo la sveglia il destinatario si troverà il messaggio nella sua memoria DATI.
/* Check to see if 'dest' is blocked waiting for this message. */
if ( (dest_ptr->p_flags & RECEIVING) &&
(dest_ptr->p_getfrom == ANY || dest_ptr->p_getfrom == caller) ) {
/* Destination is indeed waiting for this message. */
cp_mess(caller, caller_ptr->p_map[D].mem_phys, m_ptr,
dest_ptr->p_map[D].mem_phys,
dest_ptr->p_messbuf);
dest_ptr->p_flags &= ~RECEIVING; /* deblock destination */
if (dest_ptr->p_flags == 0) ready(dest_ptr);
}

cp_mess è implementata direttamente in assembly,contenuta nel file klib88.asm, durante il trasferimento copia l'identificatore del processo mittente nella prima parole del messaggio
In tal modo il processo destinatario potra ricavare l'indirizzo del processo accedendo alla tabella dei processi.
le restanti 11 parole del messaggio vengono copiate contenuto dall'area DATI del mittente al 'area DATI del destinatari.
Un messaggio è composto da 12 parole.Ricordiamo che in minix una parola è composta da 16-bit(2byte), di conseguenza l'intero messaggio consta di 24byte
;===========================================================================
; cp_mess
;===========================================================================
Msize = 12 ; size of a message in 16-bit words
cp_mess:
...
mov es:[di],ax ; copy sender's process number to dest message
...
mov cx,Msize-1 ; remember, first word doesn't count
rep movsw ; iterate cx times to copy the message
...

ret ; that's all folks!

Nella situazione in cui il destinatario non è in attesa di ricevere la comunicazione viene salvato il puntatore al messaggio ed attraverso la procedura unready il caller passa in stato di attesa per invio non riuscito
/* Destination is not waiting. Block and queue caller. */
if (caller == HARDWARE) return(E_OVERRUN);
caller_ptr->p_messbuf = m_ptr;
caller_ptr->p_flags |= SENDING;
unready(caller_ptr);

Infine il puntatore al processo mittente(caller) viene inserito nella lista dei processi che hanno comunicazioni pendenti

Receive

E' la procedura complementare alla Send; utilizzata quando un processo o task vuole ricevere un messaggio.
In questo caso i parametri sono:

• identificatore processo che vuole ricevere(il chiamante),
• identificatore processo del mittente atteso
• il puntatore al buffer per il messaggio
  

PRIVATE int mini_rec(caller, src, m_ptr)
int caller; /*process trying to get message */
int src; /* which message source is wanted (or ANY) */
message *m_ptr; /* pointer to message buffer */

Se la coda dei processi che hanno provato ad inviare un messaggio al chiamante non è vuota , (bloccati perché il destinatario non era in attesa del messaggio), si cerca un mittente con il messaggio desiderato (ANY, prende il primo messaggio presente in coda).
Tale messaggio viene acquisisce attraverso cp_mess (descritta in precedenza), che fa la copia dalla memoria fisica dell'area dati del processo sender alla memoria fisica della parte dati del processo destinatario.
Dopo la copia si sblocca il mittente, attraverso la procedura ready che inserisce il descrittore di processo mittente nella opportuna lista pronti, di conseguenza viene aggiornata la coda dei processi delle comunicazione pendenti con il chiamante, eliminando il processo mittente utilizzato per la receive.
caller_ptr = proc_addr(caller);/* pointer to caller's proc structure */
/* Check to see if a message from desired source is already available. */
sender_ptr = caller_ptr->p_callerq;
while (sender_ptr != NIL_PROC) {
sender = sender_ptr - proc - NR_TASKS;
if (src == ANY || src == sender) {
/* An acceptable message has been found. */
cp_mess(sender, sender_ptr->p_map[D].mem_phys, sender_ptr->p_messbuf,
caller_ptr->p_map[D].mem_phys, m_ptr);
sender_ptr->p_flags &= ~SENDING; /* deblock sender */
if (sender_ptr->p_flags == 0) ready(sender_ptr);

Se il messaggio richiesto non è ancora disponibile, si salva lo stato della comicazione e si blocca il chiamante.
caller_ptr->p_getfrom = src;
caller_ptr->p_messbuf = m_ptr;
caller_ptr->p_flags |= RECEIVING;
unready(caller_ptr);

Infine si verifica se ci sono segnali pendenti da parte del kernel al processo gestore memoria, quindi viene chiamata la procedura assembly inform(MM_PROC_NR) per informare il gestore
if (sig_procs > 0 && caller == MM_PROC_NR && src == ANY) inform(MM_PROC_NR);

pick_proc

Questa funzione è utilizzata principalmente per settare 'cur_proc' e 'proc_ptr',rispettivamente l'identificatore al processo corrente e il puntatore alla tabella dei processi
Se il sistema è inattivo 'cur_proc' e 'proc_ptr' vengono settati ad un valore speciale IDLE, per identificare lo stato di inattività.
Per impostare il processo corrente controlla se è presente un processo nelle liste pronti, in ordine di priorità, verifica : quella dei task, dei processi server e di quelli utente.
register int q; /* which queue to use */
if (rdy_head[TASK_Q] != NIL_PROC) q = TASK_Q;
else if (rdy_head[SERVER_Q] != NIL_PROC) q = SERVER_Q;
else q = USER_Q;
if (rdy_head[q] != NIL_PROC) {
/* Someone is runnable. */
cur_proc = rdy_head[q] - proc - NR_TASKS;
proc_ptr = rdy_head[q];

Se è in esecuzione il task per il controllo del ciclo di clock, 'cur_proc' = CLOCKTASK.
Viene settato anche il puntatore al processo bill_ptr che conta i cicli di clock della CPU.

ready

La ready inserisce il puntatore al processo(al descrittore di processo), passato come argomento, alla propria lista pronti ricavandola dall'identificatore del processo.
PUBLIC ready(rp)
lock(); /* disable interrupts */
r = (rp - proc) - NR_TASKS; /* task or proc number */
q = (r < 0 ? TASK_Q : r < LOW_USER ? SERVER_Q : USER_Q);
...
// aggiunge rp in rdy_head[q]
..
restore(); /* restore interrupts to previous state */

Tutte le operazioni vengono effettuate ad interruzioni disabilitate, chiamanto la procedura lock definita a livello assembler e alla fine viene chiamata la procura assembly restore ripristinare le interruzioni allo stato precedente.
In tal modo siamo sicuri queste operazioni vengono eseguite in maniera indivisibile, senza essere interrotte da interruzioni.
Il codice assembly delle per le operazioni lock e restore sono presenti nel file klib88.asm
;===========================================================================
; lock
;===========================================================================
; Disable CPU interrupts.
lock:
pushf ; save flags on stack
cli ; disable interrupts
pop lockvar ; save flags for possible restoration later
ret ; return to caller

;===========================================================================
; restore
;===========================================================================
; Restore enable/disable bit to the value it had before last lock.
restore:
push lockvar ; push flags as they were before previous lock
popf ; restore flags
ret ; return to caller

unready

Rimuove il processo ,il cui puntatore è passato come parametro, dalla sua lista pronti.
Il codice è simile alla ready, ma in questo caso viene fatta la rimozione anzichè l'inserzione dalla lista rdy_head[q].
Un processo può essere in stato unready anche se un segnale di kill l'ha terminato.
Anche in questa procedura su utilizza la lock e restore per le stesse motivazioni della procedura descritta in precedenza

sched

Descrive la politica di scheduling per i processi utente. Se un processo è da troppo tempo in esecuzione ed un altro è presente in lista pronti. Il processo corrente viene inserito in fondo alla lista pronti utente.
La procedura viene eseguita ad interruzioni disabilitae
PUBLIC sched(){
lock(); /* disable interrupts */
if (rdy_head[USER_Q] == NIL_PROC) {
restore(); /* restore interrupts to previous state */
return;
}/* One or more user processes queued. */
rdy_tail[USER_Q]->p_nextready = rdy_head[USER_Q];
rdy_tail[USER_Q] = rdy_head[USER_Q];
rdy_head[USER_Q] = rdy_head[USER_Q]->p_nextready;
rdy_tail[USER_Q]->p_nextready = NIL_PROC;
pick_proc();
restore(); /* restore interrupts to previous state */

Per capire meglio uso che i processi fanno delle primitive di comunicazione mi rifaccio al classio esempio di un processo 'APPL' che vuole leggere dal disco; 'DRIVER' è il processo gestore del disco con il quale altri processi attraverso opportune send e/o receive
Nel compilato del processo APPL ci sarà il riferimento alle procedure di comunicazione che il kernel minix mette a disposizione.

Es. In pseudocodice,nel compilato dei processi, avremo:
APPL:
...
send(driver,“LETTURA N parole”)
recieve(driver,risultato)
...

DRIVER:
...
recieve(appl,“LETTURA N parole ”)
send(appl,letti())
...

Il prossimo post su minix descriverò file mpx88.asm che contiene lo strato più basso del kernel Minix, sono quasi 300 righe di codice assembly utilizzare per implementare lo switching dei processi, gestione dei messaggi, la procedura save() che contiene il codice per salvare lo stato della macchina quando occorre una Trap o un' Int,etc

Daniele Licari

GYM Concept Car

GYM Concept Car è un progetto di Da Feng, uno studente di design della Coventry University, che quest'anno ha proposto un auto elettrica, dal designin parte ispirato dagli aerei da combattimento WW2, con all'interno attrezzature da palestra, quali: step machine, vogatore,brench press, spinte per braccia e spalle L'auto ha un unico sedile e telaio in lega di magnesio e carbonio.

Progetto curioso, quanto inutile

C++0x : il nuovo standard

Questo periodo è di grande attesa per i devoti al C++. Dopo circa dieci anni dalla prima ISO standard, C++ si appresta ad essere rivoluzionato.
L'intenzione, con il nuovo standard, è di riportare interesse sul linguaggio e migliorare le performance.
C++0x, il nuovo standard atteso per il 2009, avrà un nuovo insieme di features, le caratteristiche principali sono:

• multithreading: supporto ai multi-thread.
  

• concetti: permette ai programmatori di specificare vincoli sui parametri dei template in modo da facilitare l'uso dei generici. Esempio di concetto:
  

concept LessThanComparable {
bool operator<(const T& x, const T& y); } template
requires LessThanComparable
const T& min(const T& x, const T& y) {
return x < y ? x : y; }

• hash table: quattro nuovi containers non ordinati (std::unordered_map, std::unordered_multimap, std::unordered_set, std::unordered_mutiset )

• rvalue reference: limita la duplicazione di risorse quando non è necessario

• puntatori intelligenti(smart pointer): automatizza l'uso di risorse con puntatori shared_ptr condivisi, superando le limitazioni del std::auto_ptr del C++98.
  

• Deduzione dinamica del tipo: le nuove keyword auto e decltype permetteranno di ricavare il tipo di un espressione a run-time senza che viene dichiarata esplicitamente.
  

auto func(int x)->double {return pow(x);}

• Lambda expressions e chiusure: lambda expressions è una funzione senza nome, definita dov'è chiamata.esempio:
  

//a lambda expression is used as an argument
myfunc([](int x, int y) -> int {return x+y;} )

• Caratteristiche che semplificano i compiti ricorrenti.es. Un puntatore nullo letterale chiamato nullptr, enumerations fortemente tipato, delegating and inheriting constructors
• alignof e alignas: due nuovi operatori,per avere il controllare su compilazione ed esecuzione nell'ambiente di programmazione, si può decidere l'allineamento in memoria dei dati
• constexpr: nuova parola chiave che permette al programmatore di dichiarare che un determinato oggetto o espressione viene valutata e inizializzato a tempo di compilazione. Al contrario di const che si limita a constatare che l'oggetto in questione non cambi il suo stato dopo l'inizializzazione.
  

const int y=func(); //dynamic initialization
int buff[y]; //error, y isn't a compile-time constant
constexpr int f(int x){
return x * x; } //mandatory compile-time evaluation
int arr[f(3)];//OK, array's size is 9

• nuovi algoritmi
• Compatibile con i standard precedenti

[rif.]
The State of the Language: An Interview with Bjarne Stroustrup, devx.com

Overview: C++ Gets an Overhaul, devx.com

Daniele Licari

MINIX : Task per gestire la memoria

memory.c contiene il task gestore dei drivers per i quattro file speciali :

• /dev/null - null device (data sink)
• /dev/mem - absolute memory
• /dev/kmem - kernel virtual memory
• /dev/ram - RAM disk

rispettivamente dispositivo nullo, memoria assoluta, memoria virtuale del kernel e RAM.
La funzione di mem_task e' quella di ricevere i messaggi, in base al codice operativo eseguire operazioni di lettura,scrittura,setup e ritornare l'esito al mittente. Gli unici tipi di messaggio consentiti sono: lettura,scrittura e setup.
Tutti i messaggi sono nella forma :

• Tipo di operazione
• Identificatore del dispositivo(per identificare i 4 driver)
• Il processo che vuole utilizzare l'I/O
• Lunghezza del messaggio in byte
• Posizione da cui cominciare a leggere/scrivere
• Puntatore al buffer del messaggio

L'Esito,nel caso di opcode di lettura/scrittura, è dato dal numero di byte trasferiti quando e' positivo o dal codice di errore quando negativo.
Nel caso in cui stiamo rispondendo ad un messaggio di setup, e' dato dal flag OK o dal codice errore di I/O .
Il messaggio di risposta e della forma:

Ogni dispositivo ha associato due variabili : ram_origin,per l'indirizzo di partenza della memoria. ram_limit,per indirizzo limite

#define NR_RAMS 4 /* number of RAM-type devices */
PRIVATE message mess; /* message buffer */
PRIVATE phys_bytes ram_origin[NR_RAMS]; /* origin of each RAM disk */
PRIVATE phys_bytes ram_limit[NR_RAMS]; /* limit of RAM disk per minor dev. */

In fase di inizializzazione viene settata la dimensione della memoria fisica e di quella virtuale.
/* Initialize this task. */
ram_origin[KMEM_DEV] = (phys_bytes) get_base() << CLICK_SHIFT;
ram_limit[KMEM_DEV] = (sizes[0] + sizes[1]) << CLICK_SHIFT;
ram_limit[MEM_DEV] = MEM_BYTES;

le operazioni eseguite dal task stanno all'interno di un ciclo infinito
while (TRUE) {
/* First wait for a request to read or write. */
receive(ANY, &mess);
if (mess.m_source < 0)
panic("mem task got message from ", mess.m_source);
caller = mess.m_source;
proc_nr = mess.PROC_NR;
/* Now carry out the work. It depends on the opcode. */
switch(mess.m_type) {
case DISK_READ: r = do_mem(&mess); break;
case DISK_WRITE: r = do_mem(&mess); break;
case DISK_IOCTL: r = do_setup(&mess); break;
default: r = EINVAL; break;
}
/* Finally, prepare and send the reply message. */
mess.m_type = TASK_REPLY;
mess.REP_PROC_NR = proc_nr;
mess.REP_STATUS = r;
send(caller, &mess);
}

Passiamo ora a descrivere la procedura do_mem chiamata in causa da richieste di lettura o scrittura.
Se il mittente ha fatto riferimento al dispositivo nullo /dev/null, con codice operativo di lettura ritorna un errore; in caso di scrittura si ha esito positivo.

Nel caso in cui il dispositivo con il quale il mittente voglia comunicare sia la memoria fisica,virtuale o ram(/dev/mem,/dev/kmem,/dev/ram) e' necessario verificare se l'indirizzo nel quale il mittente vuole accedere si trovi compreso tra l'indirizzo di origine e di fine del dispositivo, ram_origin[device]< POSITION <ram_limit[device].

In caso di esito negativo la procedura termina con errore, diversamente si ricava l'indirizzo fisico nella sezione dati del processo mittente tramite la funzione umap(trasforma indirizzi logici in fisici) contenuta nelfile system.c che discuteremo nei prossimi post.
user_phys = umap(rp, D, (vir_bytes) m_ptr->ADDRESS, (vir_bytes) count);

Successivamente, se il codice operativo è di lettura, il trasferimento avviene da memoria fisica all'area dati del processo mittente. In caso di scrittura da area dati del processo a memoria fisica
if (m_ptr->m_type == DISK_READ)
phys_copy(mem_phys, user_phys, (long) count);
else
phys_copy(user_phys, mem_phys, (long) count);
return(count);

Nel caso in cui il tipo del messaggio è IOCTL(Cotrollo), viene chiamata la funzione do_setup, utilizzata per settare origine e limite del dispositivo con identificatore contenuto nel messaggio

Realizzare un grafico di funzione in Phyton.

Da poco ho iniziato la mia avventura con Phyton ed è sorprendente quanto sia flessibile,
il binding dinamico ti semplifica la vita in fase di stesura. Il problema stà nel fatto di essere troppo pignolo a run-time e a causa dell'identazione che dà la semantica al programma.
Ogni tanto spuntano fuori "indetationerror" senza una logica spiegazione.
Comunque quì allego la mia prima applicazione(applicazioncina);il codice è tutto commentato.
Risultato per la funzione y=x^2/20




Codice.
ho diviso l'applicazione in due parti.
Il main, dove vi è definata la funzione.

#!/usr/bin/python
# -*- coding: UTF-8 -*-

import plot
# salvo la lista dei punti nel file result.txt
# apro il file in scrittura
f = open("result.txt","w")
# vettore di punti da visualizzare
plotList = [];
# voglio visualizzare la funz y=x^2/20 nel range x=[-60,60]
for x in range(-60,60):
y=(x**2)/20
f.write(str([x,y])+"\n")
plotList.append([x,y])

f.close()
print " Fine! Il risultato e' stato salvato nel file result.txt ";

#Visualizzo il plot, passo la lista di punti come arcomento
plot.view(plotList)


l'altra parte, plot.y, contiene il codice del plot.

from Tkinter import *

def view(pointList):
root = Tk()
root.title('MyPlot')
#origine delle assi
originX = 100
originY = 250

try:
#creo un canvas
canvas = Canvas(root, width=500, height=300, bg = 'white')
canvas.pack()
# aggiungo pulsante di quit
Button(root, text='Quit', command=root.quit).pack()

# creo assi
canvas.create_line(originX ,originY ,400,250, width=2)
canvas.create_line(originX ,originY ,100,50, width=2)

for i in range(11):
x = originX + (i * 30)
canvas.create_line(x,originY ,x,originY -5 , width=2)
canvas.create_text(x,originY +4, text='%d'% (10*i), anchor=N)

#salvo il punto iniziale e lo trasformo in cordinate cartesiane traslate all'origine
initp = pointList[0];
oldp = [(originX + initp[0]),(originY - initp[1])]


for p in pointList :
xx = originX + p[0]
yy = originY - p[1]
#creo le linee per unire i punti di colore blu
canvas.create_line(oldp[0],oldp[1],xx , yy, fill="blue")
oldp = [xx,yy]

except:
print 'An error has occured!'

root.mainloop()