nerthase 2.0 » Mondo Linux

Buddy System con MallocLab

nerthase — Sat, 27 Mar 2010 21:15:46 +0000

Dopo avervi parlato dei vari progetti che ho svolto recentemente in Università, voglio condividere con voi anche un progetto molto interessante che ho realizzato 2 anni fa. Si tratta di un allocatore di memoria, quindi di un argomento abbastanza di basso livello, non facilmente comprensibile ai più novizi. Questo progetto mi è stato assegnato durante il corso di Ingegneria degli Algoritmi dal mio caro prof. Camil Demetrescu, indubbiamente uno dei migliori professori che abbia mai incontrato.

Descrizione

Lo scopo del progetto è quello di realizzare un allocatore di memoria (usando il linguaggio C) e paragonarne l’efficienza con l’allocatore di memoria predefinito di sistema (la classica malloc in C). Per eseguire questi test ho usato un framework chiamato MallocLab che prende in input l’allocatore di memoria da me realizzato, esegue alcuni test su sequenze reali di malloc, free e realloc e assegna un punteggio all’allocatore, in base al suo comportamento rispetto all’allocatore di memoria di sistema.

Di seguito sono disponibili per il download il package di MallocLab ed un suo esempio di uso:

Dopo questa breve introduzione agli strumenti necessari per la comprensione di questo progetto, passo a parlarvi della mia soluzione. Come evidente nel titolo, la mia soluzione per l’allocatore di memoria è basata sulla tecnica del Buddy System.

Il Buddy System o buddy memory allocation è una tecnica di allocazione dinamica della memoria che divide la memoria in partizioni per soddisfare una richiesta di memoria nel miglior modo possibile. Questo sistema suddivide ricorsivamente la memoria in due metà finché il blocco ottenuto è grande appena a sufficienza per l’uso, cioè quando un’ulteriore divisione lo renderebbe più piccolo della dimensione richiesta.

Da questa definizione (tratta da Wikipedia) potete immaginare che il Buddy System lavori come un albero binario. Questo è evidente per quanto riguarda chiamate alla funzione malloc, mentre è meno intuitivo quando si libera una porzione di memoria con la funzione free. In questo caso, il blocco viene liberato, e se possibile, viene riunito con il blocco fratello (per questo è necessario immaginare che il Buddy System lavori come un grande albero binario).

Soluzione adottata

Di seguito un segmento della relazione del progetto, per capire meglio la tecnica utilizzata:

Soluzione adottata

Il progetto è stato sviluppato usando la tecnica del Buddy System Binario come strategia di allocazione di memoria.

Categorie e dimensioni dei blocchi

Nel Buddy System Binario adottato si hanno le stesse proprietà descritte nelle specifiche, in particolare, le categorie di blocchi, e quindi la dimensione dei blocchi utilizzati, è 2k con k = 6, 7, …, 24, (ovvero dimensioni che vanno da 64 Bytes, a 16 Mega Bytes).

Il limite inferiore di 64B è stato fissato perché sperimentalmente è stato trovato che non venivano effettuate eccessive richieste di blocchi di dimensione inferiore ai 64B.

Il limite superiore di 16MB è stato dettato dal driver, in quanto impone un limite di 20MB alla dimensione dell’heap, e quindi era inutile considerare blocchi di dimensione superiore ai 16 MB (ovvero 32MB, 64MB, …).

Per tenere traccia delle 19 categorie, viene mantenuto in memoria un array con indici da 0 a 18, e nella cella di posizione i dell’array, viene mantenuta una lista collegata dei blocchi liberi appartenenti a quella categoria.

Operazione di fusione di blocchi compagni

Nella soluzione adottata, inoltre, la fusione di blocchi compagni non viene effettuata appena possibile, ma viene effettuata ogni 1500 chiamate alla funzione mm_free; in particolare vengono esaminati tutti i blocchi liberi presenti in memoria, e si verifica se è possibile fonderli con i rispettivi compagni. In questo modo il costo medio della funzione mm_free diminuisce, in quanto solo una chiamata ogni 1500 provoca rallentamento dovuto alla fusione dei blocchi.

Informazioni di controllo

Il modo in cui vengono gestite le informazioni di controllo, differiscono leggermente a seconda dello stato del blocco:

Sia per i blocchi liberi che per i blocchi allocati, vengono mantenute informazioni necessarie per identificare il tipo e lo stato del blocco:

la categoria a cui il blocco appartiene, e quindi indirettamente la dimensione del blocco;
un valore che indica se il blocco è attualmente in uso o è libero.

Per i blocchi liberi oltre alle informazioni usate per i blocchi allocati (necessarie per identificare il tipo e lo stato del blocco), vengono mantenute delle informazioni per gestire le liste collegate dei blocchi liberi:

un valore che indica se il blocco ha un successore nella lista dei blocchi liberi della stessa categoria;
l’indirizzo del successore. Queste informazioni vengono mantenute secondo il seguente schema:
Le informazioni in rosso sono considerate per i soli blocchi liberi, in particolare, nei blocchi in uso, i 4 Byte riservati all’indirizzo del blocco successore nella lista collegata, diventano parte del Payload del blocco.

Vantaggi:

semplicità di implementazione, per quanto riguarda i controlli da effettuare;
allineamento agli 8 Byte implicito, in quanto una volta allineato il primo blocco, tutti gli altri risulteranno allineati perché tutti di dimensione multipla di 8 Byte;
velocità di esecuzione, dovuta soprattutto ai punti precedenti;
occupazione minima delle informazioni di controllo, che praticamente sono contenute in un solo Byte.

Svantaggi:

si hanno solamente 19 categorie, e l’intervallo tra una categoria e quella successiva non è minimale;
la memoria non utilizzata, ma allocata, in un blocco è al più pari alla metà della dimensione del blocco, in quanto per una richiesta di 2k + 1 Bytes, viene allocato un blocco di dimensione 2k+1 Bytes.

Implementazione in C

Di seguito il codice C del mio allocatore di 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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368

#include "mm.h"
#include "memlib.h"

team_t team = {
/* Team name */
"N Team",
/* First member's full name */
"nerthase",
/* First member's email address */
"webmaster@nerthase.com",
/* Second member's full name (leave blank if none) */
"",
/* Second member's email address (leave blank if none) */
""
};

typedef unsigned int u_int;

#define STRUCT_ELEM 19
#define STRUCT_ELEM_SIZE 4
#define STRUCT_SIZE ( STRUCT_ELEM * STRUCT_ELEM_SIZE )
#define HEADER_SIZE 1

#define PACK(index, state) ( ((index) | ((state) << 7)) & 0x9F ) //vedi righe seguenti per la struttura
#define SET_HEADER(addr, byte) { *(addr) = (byte); } //inserisce nel byte all'indirizzo addr, il byte byte
#define SET_NEXT(addr, next) { if ((next) != 0) { *(addr) = ((*(addr)) | 0x40); *((u_int *) ((addr) + HEADER_SIZE)) = (next); } else { *(addr) = ((*(addr)) & 0xBF); } } //imposta il next nel blocco di indirizzo addr

#define INDEX(header) ( (*((char *) (header))) & 0x1F ) //l'indice della categoria è nei 5 bit meno significativi del primo byte del blocco
#define STATUS(header) ( ((*((char *) (header))) & 0x80) >> 7 ) //lo stato è nel bit più significativo del primo byte del blocco
#define HAS_NEXT(header) ( ((*((char *) (header))) & 0x40) >> 6 ) //il bit che mi indica se un blocco ha un next, è il secondo bit del primo byte
#define NEXT(header) ( (HAS_NEXT((header))) ? ((char *) (*((u_int *) ((header) + HEADER_SIZE)))) : 0) //il next è nei byte 2-5 del blocco

//arg è la dimensione del blocco, res sarà l'indice dei blocchi più piccoli che possono contenere quella dimensione
#define SIZE2INDEX(res, size) { size_t _tmp = 32; for (res = 6 ; res < STRUCT_ELEM + 6 ; ++res) { _tmp = _tmp * 2; if (_tmp >= (size)) break; } res = res - 6; }

//esp è l'indice nella struttura, res sarà la dimensione dei blocchi a indice esp
#define INDEX2SIZE(res, index) { int _esp; int _i = (index) + 6; res = 32; for (_esp = 6 ; _esp <= _i ; ++_esp) { res = res * 2; } }

//calcola l'indirizzo di struct[i]
#define STRUCT(i) ( (heap_addr) + 4*(i) )

//inserisce un blocco nella struttura (in testa alla lista)
#define ADD_BLOCK(addr) { int _i = INDEX(addr); SET_NEXT((addr), (*((u_int *) (STRUCT(_i))))); *((u_int *) STRUCT(_i)) = ((u_int) (addr)); }

//rimuove il primo blocco di indice i, cancella l'header, e "ritorna" l'indirizzo del blocco appena eliminato
#define REMOVE_FIRST_BLOCK(b_addr, index) { b_addr = ((char *) (*((u_int *) STRUCT(index)))); *((u_int *) STRUCT(index)) = ((u_int) NEXT(b_addr)); SET_HEADER(b_addr, PACK(0, 0)); }

int c;
char *heap_addr;
size_t heap_size; //taglia dell'heap effettivo, quindi senza la struttura

char *get_buddy (char *addr)
{
size_t size;
u_int offset, min, max;
char *buddy;
INDEX2SIZE(size, INDEX(addr));

min = ((u_int) heap_addr) + STRUCT_SIZE;
max = ((u_int) heap_addr) + STRUCT_SIZE + heap_size;
offset = ((u_int) addr) - min;

if ( (offset % (size * 2)) == 0 )
{
buddy = addr + size;
}
else
{
buddy = addr - size;
}

//verifico se il buddy è nell'heap
if ( (u_int) buddy < min || (u_int) buddy >= max) return 0;

if ( INDEX(addr) != INDEX(buddy) ) return 0;
if ( STATUS(buddy) != 0) return 0;

return buddy;
}

void remove_block (char *addr)
{
int index = INDEX(addr);
char *p, *next;

p = (char *) (*((u_int *) STRUCT(index)));

if ( p == addr )
{
REMOVE_FIRST_BLOCK(p, index);
return;
}

//scandisco la lista fino a che non mi posiziono su blocco prima di quello da rimuovere
next = NEXT(p);
while (next != addr)
{
p = next;
next = NEXT(p);
}

//rimuovo il blocco
SET_NEXT(p, (u_int) NEXT(addr));
//elimino le informazioni dal blocco
SET_HEADER(addr, PACK(0, 0));
}

int coalesce (char *addr)
{
char *buddy, *new_addr;
int index = INDEX(addr) + 1;
if (index == 1) return 0;

//trovo il buddy
buddy = get_buddy(addr);
if (buddy == 0) return 0;

//stabilisco come sono ordinati
new_addr = (buddy > addr) ? addr : buddy;

//li rimuovo
remove_block(buddy);
remove_block(addr);

//inserisco il blocco di dimensione doppia
SET_HEADER(new_addr, PACK(index, 0));
ADD_BLOCK(new_addr);

return 1;
}

void split (int i) //Splitta il primo blocco di indice i nella struttura
{
char *b_addr;
char *addr1, *addr2;
size_t size;
INDEX2SIZE(size, i - 1);

//rimuovo il blocco dalla struttura
REMOVE_FIRST_BLOCK(b_addr, i);

//splitto il blocco
addr1 = b_addr;
addr2 = b_addr + size;

//preparo i due nuovi blocchi e li inserisco nella struttura
SET_HEADER(addr1, PACK(i - 1, 0));
ADD_BLOCK(addr1);

SET_HEADER(addr2, PACK(i - 1, 0));
ADD_BLOCK(addr2);
}

void expand_heap ()
{
int index;
char *new;
size_t max;
INDEX2SIZE(max, 18);

if (heap_size < max)
{
new = (char *) mem_sbrk(heap_size);
//inserisco il nuovo blocco nella struttura
SIZE2INDEX(index, heap_size);
SET_HEADER(new, PACK(index, 0));
ADD_BLOCK(new);
heap_size = heap_size * 2;
}
else //vuol dire che l'heap è arrivato a 16M, quindi posso permettermi solo altri 4M (quasi :D)
{
size_t size;
INDEX2SIZE(size, 11); //alloco blocchi di dimensione fissa 128k (11)
new = (char *) mem_sbrk(size);
SIZE2INDEX(index, size);
SET_HEADER(new, PACK(index, 0));
ADD_BLOCK(new);
if(coalesce(new));
heap_size = heap_size + size;
}
}

int find_block (size_t size) //trova un blocco libero che può contenere size byte e ne restituisce l'indice, altrimenti -1
{
int i, index;
size_t b_size;
SIZE2INDEX(index, size); //ottengo l'indice del blocco più piccolo che può contenere size byte

search:
//trovo il primo blocco disponibile
for (i = index ; i < STRUCT_ELEM ; ++i)
{
INDEX2SIZE(b_size, i); //ottengo la taglia dei blocchi di indice i
if (b_size > heap_size) //se sono di taglia maggiore della dimensione dell'heap, devo sicuramente espandere
{
expand_heap();
if ((i = i - 2) == index - 2) i = index - 1; //riaggiusto gli indici in modo da riconsiderare il blocco appena creato
}
else
{
if ( *(STRUCT(i)) == 0); //se non ci sono blocchi nella struttura di dimensione adeguata, continuo a cercare oltre
else
{
break;
}
}
}
if (i == STRUCT_ELEM) //return -1;
{
expand_heap();
goto search;
}

//splitto il blocco fino ad arrivare ad uno di dimensione b_size
for ( ; i > index ; --i) split(i);

return index;
}

int mm_init(void)
{
int i;
u_int *p;

//allineo l'heap a 8 byte (in realtà allineo la parte del blocco che restituisco nella malloc)
for (i = 1 ; i <= 8 ; ++i)
{
u_int tmp = (u_int) mem_sbrk(1); //alloco un byte per volta
if (((tmp + STRUCT_SIZE) % 8) == 6) break;
//quando il byte allocato ha come resto 6, significa che il prossimo blocco allocato sarà allineato a 7 byte
//ma l'indirizzo che restituisco nella malloc, sarà allocato quindi a 8 byte come richiesto
}

INDEX2SIZE(heap_size, 6);
heap_addr = (char *) mem_sbrk(STRUCT_SIZE + heap_size);

for (i = 0 ; i < STRUCT_ELEM ; ++i)
{
//scrivo 0 in tutte le celle della struttura (4 byte)
*((u_int *) STRUCT(i)) = 0;
}

SIZE2INDEX(i, heap_size); //trovo l'indice del blocco di dimensione heap_size
p = (u_int *) STRUCT(i); //ottengo l'indirizzo all'interno della struttura dei blocchi di quella dimensione

*p = (u_int) (heap_addr + STRUCT_SIZE); //inserisco il primo blocco allocato, quello di dimensione heap_size
SET_HEADER((char *) *p, PACK(i, 0)); //imposto adeguatamente l'header del blocco

return 0;
}

void *mm_malloc(size_t size)
{
char *block;
int index;

index = find_block(HEADER_SIZE + size);
if (index == -1) return NULL;

REMOVE_FIRST_BLOCK(block, index);
SET_HEADER(block, PACK(index, 1));

return block + 1;
}

void mm_free(void *ptr)
{
char *b_addr = ((char *) ptr) - 1;
int index = INDEX(b_addr);

SET_HEADER(b_addr, PACK(index, 0));
ADD_BLOCK(b_addr);

if ((++c % 1500) == 0)
{
int i;
char *addr = 0;

for (i = 0 ; i < STRUCT_ELEM ; ++i)
{
addr = (char *) (*((u_int *) STRUCT(i)));

while (1)
{
char *tmp = addr;
if (addr == 0) break;
addr = NEXT(addr);
coalesce(tmp);
}
}
}
}

void split_2 (char *block) // Splitta un blocco che non è nella struttura
// In particolare lascia la prima metà di blocco invariata
// e la seconda la azzera e la inserisce nella struttura
{
char *addr1, *addr2;
size_t size;
int i = INDEX(block);
INDEX2SIZE(size, i - 1);

//splitto il blocco
addr1 = block;
addr2 = block + size;

// Il primo blocco cambia solo di dimensione
SET_HEADER(addr1, PACK(i - 1, 1));

// Il secondo invece viene anche inserito nella struttura
SET_HEADER(addr2, PACK(i - 1, 0));
ADD_BLOCK(addr2);
}

void *mm_realloc(void *ptr, size_t new_size)
{
char *old = ((char *) ptr) - 1;
char *new;
size_t old_size, const_old_size;
int i;
int old_index = INDEX(old);

//ottengo la taglia del blocco vecchio
INDEX2SIZE(old_size, old_index);
const_old_size = old_size;

if (new_size < old_size && new_size > (old_size / 2)) return old + 1;

if (new_size < old_size) //sono sicuro che è anche minore della metà
{
int new_index;
SIZE2INDEX(new_index, new_size); //è sicuramente minore di old_index

for (i = old_index ; i > new_index ; --i) split_2(old);

return old + 1;
}

while (new_size >= old_size) // vedo se posso fare il coalesce con il blocco alla sua destra
{
char *buddy = get_buddy(old);
if ((u_int) buddy == 0 || (u_int) buddy < (u_int) old) goto nuovo;
else //posso unire i 2 blocchi
{
remove_block(buddy);

old_size = old_size * 2;
old_index = old_index + 1;

SET_HEADER(old, PACK(old_index, 1));
}
}

// se arrivo qui, significa che facendo il coalesce progressivo di blocchi vicini, sono arrivato ad un blocco della taglia desiderata :D
return old + 1;

nuovo: // non posso fare altro che allocare un nuovo blocco e copiare il contenuto
new = mm_malloc(new_size);

for (i = 0 ; i < const_old_size ; ++i)
{
*(new + i) = *(old + 1 + i);
}

mm_free(ptr);
return new;
}

Lo sviluppo di questo progetto mi ha richiesto molto tempo e fatiche, ma devo dire che ne è valsa indubbiamente la pena, in quanto ho scoperto che il C è un linguaggio dalle potenzialità infinite. Concludendo, vi metto a disposizione per il download, il mio allocatore e la relazione (molto semplice) che ho scritto per presentare il progetto:

Se avete dubbi o domande su tecniche utilizzate, non fatevi alcun problema a chiedere.

jDownloader: RapidShare e MegaUpload senza limiti

nerthase — Sat, 27 Feb 2010 21:14:08 +0000

jDownloader è un utilissimo programma open source scritto completamente in Java, e quindi compatibile con tutti i sistemi operativi che lo supportano. Il suo scopo è quello di scaricare file da siti come RapidShare e MegaUpload, ma anche tanti altri come loro. jDownloader si occuperà di attendere la disponibilità del download al posto nostro, ed effettuerà anche il bypass dei codici CAPTCHA spesso utilizzati da siti del genere.

Ma le novità e le potenzialità di jDownloader non sono finite qui. Esso infatti è in grado di effettuare il download di filmati di YouTube, MegaVideo e quanto altro possiate immaginare. Inoltre ha anche l’opzione per effettuare i download usufruendo di un account premium in vostro possesso. E se invece non possedete un account premium, jDownloader si occuperà di effettuare un cambio di IP per il vostro computer, in modo da evitare controlli e barriere applicati da alcuni siti di File Sharing.

Dopo questa breve panoramica per questo meraviglioso software, veniamo ad una breve guida di configurazione ed utilizzo:

Dopo l’installazione, è necessario settare alcune impostazioni iniziali per l’utilizzo del software,

Impostiamo il percorso per i nostri download ed il comportamento che jDownloader dovrà adottare per i file scaricati. Queste semplici impostazioni sono già sufficienti per iniziare ad effettuare il download dei nostri file.

Come vi dicevo prima, jDownload è in grado di cambiare l’IP del nostro computer mediante una riconnessione del router. Questa impostazione è molto utile nel caso di siti di File Sharing che effettuano controlli su IP. Basterà individuare il modello del nostro router, selezionare “Ottieni IP router” ed infine “Crea script di riconnessione“. Automaticamente jDownloader creerà uno script ad hoc per il nostro router in grado di effettuare una riconnessione, e quindi il cambio di IP.

Per chi di noi possiede un account premium, può usarlo tramite jDownloader per scaricare al massimo della velocità con il massimo della comodità. Sono supportati più di 100 servizi di Hosting.

jDownloader ha la possibilità di intercettare il contenuto degli appunti di sistema. In pratica ci basterà individuare su internet l’elenco dei link del file che vogliamo scaricare, copiarli e spostarci su jDownloader. Il programma avrà già intercettato i nostri appunti, e sarà in corso l’analisi dei link. Se al termine dell’analisi i file che si desidera scaricare sono tutti online, basterà premere il tasto “Continua” per iniziare il download.

jDownloader è in grado di estrarre i file una volta scaricati, anche se protetti da password, e di unirli in un unico file, come da origine. Voi non dovrete fare assolutamente nulla.

. . .

jDownloader è un software molto completo e funzionale. Lo sviluppatore rilascia continui aggiornamenti, che ne garantiscono il funzionamento continuo. Adesso vi lascio alcuni link per il download del programma e delle dipendenze necessarie:

Generatore di Password

nerthase — Sat, 27 Feb 2010 00:09:13 +0000

Dopo aver visto come creare una password sicura, e come evitare di farsi rubare la propria password, non poteva mancare un programma per la generazione di password robuste, ma allo stesso tempo facili da ricordare.

Il programma da me realizzato, si chiama Mnemonic Password Generator, e ha lo scopo di generare una password diversa per ogni servizio che voi utilizzate. Questa password inoltre, sarà basata su vostri dati personali, e quindi facile da ricordare. Ad esempio, basterà dire al programma che io mi chiamo Mario, nato a Settembre, e che voglio una password per Twitter, ed una possibile password che il programma mi proporrà, potrebbe essere mario09twitter. Come potete vedere questa password è molto facile da ricordare, ma ha tutti gli elementi necessari per durare a lungo contro attacchi di hacker, cracker e malintenzionati.

Mnemonic Password Generator è stato realizzato in Java ed offre tutte i controlli necessari a personalizzare la propria password preferendo facilità o sicurezza. Il programma non fa alcun uso delle password generate e/o dei dati inseriti. Questi ultimi sono richiesti al solo scopo di generare una password che sia adatta a voi, e quindi facile da ricordare. MPG (sigla del programma) memorizza i dati da voi inseriti (ma non la password) in un file temporaneo sul vostro computer. L’unico scopo di questo salvataggio, è di evitarvi di riempire tutti i campi ogni volta. Potete, comunque, in qualunque momento eliminare il file contenente questi dati.

Il programma Mnemonic Password Generator è disponibile per il download per diverse piattaforme:

Mnemonic Password Generator compatibile con Windows XP / Vista / Seven

Non necessita di installazione. Applicazione portabile.

Mnemonic Password Generator compatibile con Mac OS X v10.5 e successive

Versione sviluppata su piattaforma Mac OS X 10.6 e quindi pienamente compatibile.

Mnemonic Password Generator compatibile con Linux ed altre piattaforme

Versione Universal Binary dell’applicazione. Funziona su qualsiasi sistema.

Per malfunzionamenti o problemi di vario genere, sono a vostra completa disposizione.