Maschera (informatica)
Argomenti alle funzioniModifica
Nei linguaggi di programmazione come il C, i campi bit sono un modo utile per passare un insieme di argomenti booleani nominati a una funzione. Per esempio, nell’API grafica OpenGL, c’è un comando, glClear() che cancella lo schermo o altri buffer. Può cancellare fino a quattro buffer (i buffer di colore, profondità, accumulazione e stencil), quindi gli autori dell’API avrebbero potuto fargli prendere quattro argomenti. Ma poi una chiamata ad esso sarebbe apparsa come
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
che non è molto descrittivo. Invece ci sono quattro bit di campo definiti, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT e GL_STENCIL_BUFFER_BIT e glClear() è dichiarato come
void glClear(GLbitfield bits);
Quindi una chiamata alla funzione assomiglia a questa
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Internamente, una funzione che prende un bitfield come questo può usare il binario and per estrarre i singoli bit. Per esempio, un’implementazione di glClear() potrebbe assomigliare a:
void glClear(GLbitfield bits) { if ((bits & GL_COLOR_BUFFER_BIT) != 0) { // Clear color buffer. } if ((bits & GL_DEPTH_BUFFER_BIT) != 0) { // Clear depth buffer. } if ((bits & GL_ACCUM_BUFFER_BIT) != 0) { // Clear accumulation buffer. } if ((bits & GL_STENCIL_BUFFER_BIT) != 0) { // Clear stencil buffer. }}
Il vantaggio di questo approccio è che l’overhead degli argomenti della funzione è diminuito. Poiché la dimensione minima del dato è un byte, separare le opzioni in argomenti separati significherebbe sprecare sette bit per argomento e occupare più spazio nello stack. Invece, le funzioni tipicamente accettano uno o più interi a 32 bit, con fino a 32 bit di opzione in ciascuno. Anche se elegante, nell’implementazione più semplice questa soluzione non è sicura per il tipo. Un GLbitfield è semplicemente definito come un unsigned int, così il compilatore permetterebbe una chiamata senza senso a glClear(42) o anche glClear(GL_POINTS). In C++ un’alternativa sarebbe quella di creare una classe per incapsulare l’insieme di argomenti che glClear potrebbe accettare e potrebbe essere incapsulato in modo pulito in una libreria.
Maschere inverseModifica
Le maschere sono usate con gli indirizzi IP nelle IP ACL (Access Control Lists) per specificare cosa dovrebbe essere permesso e negato. Per configurare gli indirizzi IP sulle interfacce, le maschere iniziano con 255 e hanno i valori grandi sul lato sinistro: per esempio, l’indirizzo IP 209.165.202.129 con una maschera 255.255.255.224. Le maschere per le ACL IP sono il contrario: per esempio, la maschera 0.0.0.255. Questo è talvolta chiamato una maschera inversa o una maschera jolly. Quando il valore della maschera viene scomposto in binario (0 e 1), i risultati determinano quali bit di indirizzo devono essere considerati nell’elaborazione del traffico. Uno 0 indica che i bit di indirizzo devono essere considerati (corrispondenza esatta); un 1 nella maschera è un “non importa”. Questa tabella spiega ulteriormente il concetto.
Mask esempio:
indirizzo di rete (traffico da elaborare) 10.1.1.0
mask0.0.0.255
indirizzo di rete (binario)00001010.00000001.00000001.00000000
maschera (binario)00000000.00000000.00000000.11111111
In base alla maschera binaria, si può vedere che le prime tre serie (ottetti) devono corrispondere esattamente all’indirizzo di rete binario dato (00001010.00000001.00000001). L’ultima serie di numeri è fatta di “non importa” (.11111111). Pertanto, tutto il traffico che inizia con 10.1.1. corrisponde poiché l’ultimo ottetto è “non importa”. Pertanto, con questa maschera, gli indirizzi di rete da 10.1.1.1 a 10.1.1.255 (10.1.1.x) vengono processati.
Sottrai la maschera normale da 255.255.255.255 per determinare la maschera inversa ACL. In questo esempio, la maschera inversa è determinata per l’indirizzo di rete 172.16.1.0 con una maschera normale di 255.255.255.0.
255.255.255.255 – 255.255.255.0 (maschera normale) = 0.0.0.255 (maschera inversa)
Equivalenti ACL
L’origine/sorgente-wildcard di 0.0.0.0/255.255.255.255 significa “qualsiasi”.
L’origine/wildcard di 10.1.1.2/0.0.0.0 è uguale a “host 10.1.1.2”
Maschere immagineModifica
In computer grafica, quando una data immagine è destinata ad essere posta sopra uno sfondo, le aree trasparenti possono essere specificate attraverso una maschera binaria. In questo modo, per ogni immagine prevista ci sono in realtà due bitmap: l’immagine reale, in cui alle aree inutilizzate viene dato un valore di pixel con tutti i bit impostati su 0s, e una maschera aggiuntiva, in cui alle aree corrispondenti dell’immagine viene dato un valore di pixel con tutti i bit impostati su 0s e alle aree circostanti un valore di tutti i bit impostato su 1s. Nell’esempio a destra, i pixel neri hanno i bit tutti zero e i pixel bianchi hanno i bit tutti uno.
Al momento dell’esecuzione, per mettere l’immagine sullo schermo sopra lo sfondo, il programma maschera prima i bit del pixel dello schermo con la maschera dell’immagine alle coordinate desiderate usando l’operazione bitwise AND. Questo preserva i pixel dello sfondo delle aree trasparenti mentre azzera i bit dei pixel che saranno oscurati dall’immagine sovrapposta.
Poi, il programma rende i bit del pixel dell’immagine combinandoli con i bit del pixel dello sfondo usando l’operazione bitwise OR. In questo modo, i pixel dell’immagine sono posizionati in modo appropriato mantenendo i pixel circostanti dello sfondo. Il risultato è un composto perfetto dell’immagine sullo sfondo.
Questa tecnica è usata per dipingere i cursori dei dispositivi di puntamento, nei tipici videogiochi 2-D per i personaggi, i proiettili e così via (gli sprite), per le icone delle GUI, e per la titolazione dei video e altre applicazioni di miscelazione delle immagini.
Anche se correlati (per il fatto di essere usati per gli stessi scopi), i colori trasparenti e i canali alfa sono tecniche che non coinvolgono il mixaggio dei pixel dell’immagine tramite mascheramento binario.
Tabelle di hashingModifica
Per creare una funzione di hashing per una tabella di hash, spesso si usa una funzione che ha un grande dominio. Per creare un indice dall’output della funzione, si può prendere un modulo per ridurre la dimensione del dominio in modo che corrisponda alla dimensione dell’array; tuttavia, è spesso più veloce su molti processori limitare la dimensione della tabella hash a potenze di due dimensioni e usare invece una bitmask.
Un esempio di modulo e mascheramento in C:
#include <stdint.h>#include <string.h>int main(void) { const uint32_t NUM_BUCKETS = 0xFFFFFFFF; // 2^32 - 1 const uint32_t MAX_RECORDS = 1<<10; // 2^10 const uint32_t HASH_BITMASK = 0x3FF; // (2^10)-1 char **token_array = NULL; // Handle memory allocation for token_array… char token = "some hashable value"; uint32_t hashed_token = hash_function(token, strlen(token), NUM_BUCKETS); // Using modulo size_t index = hashed_token % MAX_RECORDS; // OR // Using bitmask size_t index = hashed_token & HASH_BITMASK; *(token_array+index) = token; // Free the memory from token_array … return 0;}