Masker (informatica)
Argumenten voor functiesEdit
In programmeertalen zoals C zijn bitvelden een handige manier om een reeks met name genoemde booleaanse argumenten aan een functie door te geven. Bijvoorbeeld, in de grafische API OpenGL, is er een commando, glClear() dat het scherm of andere buffers leegmaakt. Het kan tot vier buffers leegmaken (de kleur, diepte, accumulatie, en stencil buffers), dus de API auteurs hadden het vier argumenten kunnen laten nemen. Maar dan zou een aanroep eruit zien als
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
, wat niet erg beschrijvend is. In plaats daarvan zijn er vier gedefinieerde veldbits, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, en GL_STENCIL_BUFFER_BIT en glClear() wordt gedeclareerd als
void glClear(GLbitfield bits);
Dan ziet een aanroep van de functie er als volgt uit
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Intern kan een functie die een bitveld als dit neemt, binair and gebruiken om de individuele bits te extraheren. Een implementatie van glClear() zou er bijvoorbeeld als volgt uit kunnen zien:
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. }}
Het voordeel van deze benadering is dat de overhead van functie-argumenten wordt verminderd. Aangezien de minimumdatagrootte één byte is, zou het scheiden van de opties in afzonderlijke argumenten een verspilling van zeven bits per argument betekenen en meer stackruimte innemen. In plaats daarvan accepteren functies gewoonlijk een of meer 32-bits gehele getallen, met maximaal 32 optiebits in elk getal. Hoewel elegant, is deze oplossing in de eenvoudigste implementatie niet type-veilig. Een GLbitfield is eenvoudig gedefinieerd als een unsigned int, dus de compiler zou een zinloze aanroep naar glClear(42) of zelfs glClear(GL_POINTS) toestaan. In C++ zou een alternatief zijn om een klasse te maken om de set van argumenten die glClear zou kunnen accepteren in te kapselen en netjes in te kapselen in een library.
Inverse masksEdit
Maskers worden gebruikt met IP adressen in IP ACLs (Access Control Lists) om te specificeren wat toegestaan en geweigerd moet worden. Om IP adressen op interfaces te configureren, beginnen maskers met 255 en hebben de grote waarden aan de linkerkant: bijvoorbeeld, IP adres 209.165.202.129 met een 255.255.255.224 masker. Maskers voor IP ACLs zijn omgekeerd: bijvoorbeeld, masker 0.0.0.255. Dit wordt ook wel een invers masker of een wildcard masker genoemd. Wanneer de waarde van het masker wordt uitgesplitst in binaire (0s en 1s), bepaalt het resultaat welke adresbits in aanmerking moeten worden genomen bij het verwerken van het verkeer. Een 0 geeft aan dat de adresbits in aanmerking moeten worden genomen (exacte overeenkomst); een 1 in het masker is een “don’t care”. In deze tabel wordt het concept verder uitgelegd.
Mask voorbeeld:
netwerk adres (verkeer dat verwerkt moet worden) 10.1.1.0
mask0.0.0.255
netwerk adres (binair)00001010.00000001.00000001.00000001.00000000
mask (binair)00000000.00000000.00000000.111111
Gebaseerd op het binaire masker, kan worden gezien dat de eerste drie sets (octetten) precies moeten overeenkomen met het gegeven binaire netwerkadres (00001010.00000001.00000001). De laatste set getallen bestaat uit “don’t cares” (.11111111). Daarom komt al het verkeer dat begint met 10.1.1. overeen omdat het laatste octet “don’t care” is. Daarom worden met dit masker netwerk adressen 10.1.1.1 tot en met 10.1.1.255 (10.1.1.x) verwerkt.
Trek het normale masker af van 255.255.255.255 om het ACL inverse masker te bepalen. In dit voorbeeld, wordt het inverse masker bepaald voor netwerk adres 172.16.1.0 met een normaal masker van 255.255.255.0.
255.255.255.255 – 255.255.255.0 (normale masker) = 0.0.0.255 (invers masker)
ACL equivalenten
De source/wildcard van 0.0.0.0/255.255.255.255 betekent “any”.
De source/wildcard van 10.1.1.2/0.0.0.0 is hetzelfde als “host 10.1.1.2”
BeeldmaskersEdit
In computer graphics, wanneer een bepaalde afbeelding bedoeld is om over een achtergrond te worden geplaatst, kunnen de transparante gebieden worden gespecificeerd door middel van een binair masker. Op deze manier zijn er voor elke bedoelde afbeelding in feite twee bitmaps: de eigenlijke afbeelding, waarin de ongebruikte gebieden een pixelwaarde krijgen waarbij alle bits op 0s zijn gezet, en een aanvullend masker, waarin de corresponderende beeldgebieden een pixelwaarde krijgen waarbij alle bits op 0s zijn gezet en de omringende gebieden een waarde krijgen waarbij alle bits op 1s zijn gezet. In het voorbeeld rechts hebben zwarte pixels alle nullen bits en witte pixels alle één bits.
Om het beeld op het scherm over de achtergrond heen te zetten, maskeert het programma eerst de bits van de schermpixel met het beeldmasker op de gewenste coördinaten met behulp van de bitwise AND bewerking. Dit behoudt de achtergrondpixels van de transparante gebieden, terwijl de bits van de pixels die door de overlappende afbeelding zullen worden verborgen, met nullen worden gereset.
Daarna rendert het programma de bits van de beeldpixel door ze te combineren met de bits van de achtergrondpixel met behulp van de bitwise OR bewerking. Op deze manier worden de beeldpixels op de juiste plaats gezet terwijl de omliggende achtergrondpixels behouden blijven. Het resultaat is een perfecte samenstelling van het beeld over de achtergrond.
Deze techniek wordt gebruikt voor het schilderen van aanwijsapparaatcursors, in typische 2-D videogames voor karakters, kogels enzovoort (de sprites), voor GUI-pictogrammen, en voor videotiteling en andere beeldmengtoepassingen.
Hoewel verwant (omdat ze voor dezelfde doeleinden worden gebruikt), zijn transparante kleuren en alpha kanalen technieken die niet de beeldpixel menging door binaire maskering impliceren.
Hash tabellenEdit
Om een hashing functie voor een hash tabel te maken, wordt vaak een functie gebruikt die een groot domein heeft. Om een index te maken van de uitvoer van de functie, kan een modulo worden genomen om de grootte van het domein te verkleinen zodat het overeenkomt met de grootte van de matrix; op veel processoren is het echter vaak sneller om de grootte van de hashtabel te beperken tot machten van twee grootheden en in plaats daarvan een bitmask te gebruiken.
Een voorbeeld van zowel modulo als masking 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;}