Mask (databehandling)
Argument till funktionerRedigera
I programmeringsspråk som C är bitfält ett användbart sätt att skicka en uppsättning namngivna boolska argument till en funktion. I grafik-API:et OpenGL finns det till exempel ett kommando, glClear(), som rensar skärmen eller andra buffertar. Det kan rensa upp till fyra buffertar (färg-, djup-, ackumulations- och stencilbuffertar), så API-författarna kunde ha låtit det ta fyra argument. Men då skulle ett anrop till den se ut som
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
vilket inte är särskilt beskrivande. Istället finns det fyra definierade fältbitar, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT och GL_STENCIL_BUFFER_BIT och glClear() deklareras som
void glClear(GLbitfield bits);
Då ser ett anrop till funktionen ut så här
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Internt kan en funktion som tar ett bitfält av det här slaget använda binärt and för att extrahera de enskilda bitarna. Till exempel kan en implementering av glClear() se ut så här:
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. }}
Fördelen med det här tillvägagångssättet är att överskottet av funktionsargument minskar. Eftersom den minsta datumstorleken är en byte, skulle separering av alternativen i separata argument innebära att man slösar bort sju bitar per argument och att man upptar mer stapelutrymme. Istället accepterar funktioner vanligtvis ett eller flera 32-bitars heltal, med upp till 32 optionsbitar i varje. Den här lösningen är elegant, men i den enklaste implementeringen är den inte typsäker. En GLbitfield definieras helt enkelt som en unsigned int, så kompilatorn skulle tillåta ett meningslöst anrop till glClear(42) eller till och med glClear(GL_POINTS). I C++ skulle ett alternativ vara att skapa en klass för att kapsla in den uppsättning argument som glClear kan acceptera och som skulle kunna kapslas in rent i ett bibliotek.
Inversa maskerRedigera
Masker används tillsammans med IP-adresser i IP ACL:er (Access Control Lists) för att ange vad som ska tillåtas och nekas. För att konfigurera IP-adresser på gränssnitt börjar maskerna med 255 och har de stora värdena på vänster sida: till exempel IP-adress 209.165.202.129 med en mask 255.255.255.255.224. Maskerna för IP ACL:er är de omvända: till exempel mask 0.0.0.0.255. Detta kallas ibland för en omvänd mask eller en wildcard-mask. När maskens värde delas upp i binära värden (0:or och 1:or) avgör resultaten vilka adressbitar som ska beaktas vid behandlingen av trafiken. En 0 anger att adressbitarna måste beaktas (exakt matchning); en 1 i masken är en ”don’t care” (bryr sig inte). Denna tabell förklarar begreppet ytterligare.
Mask exempel:
nätverksadress (trafik som ska behandlas) 10.1.1.0
mask0.0.0.0.255
nätverksadress (binär)00001010.00000001.00000001.00000001.00000000
mask (binär)00000000.00000000.00000000.00000000.11111111
Med utgångspunkt i den binära masken kan man se att de tre första uppsättningarna (oktetter) måste matcha den givna binära nätverksadressen exakt (00001010.00000001.00000001). Den sista sifferuppsättningen består av ”don’t cares” (.1111111111). Därför matchar all trafik som börjar med 10.1.1. eftersom den sista oktetten är ”don’t care”. Med den här masken behandlas därför nätverksadresserna 10.1.1.1.1 till 10.1.1.255 (10.1.1.x).
Subtrahera den normala masken från 255.255.255.255.255 för att fastställa ACL:s omvända mask. I det här exemplet bestäms den omvända masken för nätverksadressen 172.16.1.0 med en normal mask på 255.255.255.255.0.
255.255.255.255.255 – 255.255.255.255.0 (normal mask) = 0.0.0.0.255 (omvänd mask)
ACL-ekvivalenter
Källan/källan-vildkortet 0.0.0.0.0/255.255.255.255.255 betyder ”vilken som helst”.
Källan/vildkortet 10.1.1.1.2/0.0.0.0.0 är detsamma som ”värd 10.1.1.1.2”
BildmaskerRedigera
I datorgrafik kan de genomskinliga områdena specificeras med hjälp av en binär mask när en viss bild är avsedd att placeras över en bakgrund. På så sätt finns det för varje avsedd bild egentligen två bitmappar: den faktiska bilden, där de oanvända områdena ges ett pixelvärde med alla bitar satta till 0, och en ytterligare mask, där motsvarande bildområden ges ett pixelvärde med alla bitar satta till 0 och de omgivande områdena ett värde med alla bitar satta till 1. I exemplet till höger har svarta pixlar alla nollbitar och vita pixlar alla ettbitar.
För att sätta bilden på skärmen över bakgrunden maskerar programmet först skärmpixelns bitar med bildmasken vid de önskade koordinaterna med hjälp av den bitvisa AND-operationen. Detta bevarar bakgrundspixlarna i de genomskinliga områdena och nollställer bitarna i de pixlar som kommer att skymmas av den överlappande bilden.
Därefter render programmet bildpixelns bitar genom att kombinera dem med bakgrundspixelns bitar med hjälp av den bitvisa OR-operationen. På så sätt placeras bildpixlarna på lämpligt sätt samtidigt som de omgivande bakgrundspixlarna bevaras. Resultatet är en perfekt sammansättning av bilden över bakgrunden.
Denna teknik används för att måla pekdonens markörer, i typiska tvådimensionella videospel för karaktärer, kulor och så vidare (sprites), för GUI-ikoner och för videobeteckningar och andra bildblandningsprogram.
Och även om de är besläktade (på grund av att de används för samma ändamål) är transparenta färger och alfakanaler tekniker som inte involverar bildpixelblandning genom binär maskering.
HashtabellerRedigera
För att skapa en hashfunktion för en hashtabell används ofta en funktion som har en stor domän. För att skapa ett index från utmatningen av funktionen kan en modulo användas för att minska domänens storlek så att den matchar storleken på matrisen; det är dock ofta snabbare på många processorer att begränsa hashtabellens storlek till potenser av två storlekar och använda en bitmask i stället.
Ett exempel på både modulo och maskering i 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;}