Maske (computer)
Argumenter til funktionerRediger
I programmeringssprog som C er bitfelter en nyttig måde at videregive et sæt navngivne boolske argumenter til en funktion på. I grafik-API’en OpenGL findes der f.eks. en kommando, glClear(), som rydder skærmen eller andre buffere. Den kan rydde op til fire buffere (farve-, dybde-, akkumulerings- og stencilbuffere), så API-forfatterne kunne have ladet den tage fire argumenter. Men så ville et kald til den se ud som
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
, hvilket ikke er særlig beskrivende. I stedet er der fire definerede feltbits, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT og GL_STENCIL_BUFFER_BIT, og glClear() er deklareret som
void glClear(GLbitfield bits);
Så ser et kald til funktionen ud som følger
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Internt kan en funktion, der tager et bitfelt som dette, bruge binært and til at udtrække de enkelte bits. En implementering af glClear() kan f.eks. se således ud:
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 ved denne fremgangsmåde er, at overhead af funktionsargumenter mindskes. Da den mindste datumstørrelse er en byte, ville en opdeling af indstillingerne i separate argumenter være spild af syv bits pr. argument og ville optage mere stackplads. I stedet accepterer funktioner typisk et eller flere 32-bit-integriteter med op til 32 optionsbits i hver. Selv om denne løsning er elegant, er den i den enkleste implementering ikke type-sikker. En GLbitfield er simpelthen defineret til at være en unsigned int, så compileren ville tillade et meningsløst kald til glClear(42) eller endog glClear(GL_POINTS). I C++ ville et alternativ være at oprette en klasse til indkapsling af det sæt af argumenter, som glClear kunne acceptere, og som kunne indkapsles rent i et bibliotek.
Inverse masksRediger
Masker bruges sammen med IP-adresser i IP ACL’er (Access Control Lists) for at angive, hvad der skal tillades og nægtes. For at konfigurere IP-adresser på grænseflader starter masker med 255 og har de store værdier på venstre side: f.eks. IP-adresse 209.165.202.129 med en maske på 255.255.255.255.224. Masker til IP-ACL’er er omvendt: f.eks. maske 0.0.0.0.255. Dette kaldes undertiden en omvendt maske eller en wildcard-maske. Når værdien af masken opdeles i binære værdier (0’er og 1’er), bestemmer resultaterne, hvilke adressebits der skal tages i betragtning ved behandlingen af trafikken. Et 0 angiver, at adressebitsene skal tages i betragtning (nøjagtigt match); et 1 i masken er et “ligegyldigt”. Denne tabel forklarer begrebet yderligere:
Maske eksempel:
netværksadresse (trafik, der skal behandles) 10.1.1.1.0
maske0.0.0.0.255
netværksadresse (binær)00001010.00000001.00000001.00000001.00000000
maske (binær)00000000.00000000.00000000.00000000.1111111111
Med udgangspunkt i den binære maske kan det ses, at de første tre sæt (oktetter) skal stemme nøjagtigt overens med den givne binære netværksadresse (00001010.00000001.00000001.00000001). Det sidste sæt tal består af “don’t cares” (.1111111111). Derfor passer al trafik, der begynder med 10.1.1., da det sidste oktet er “don’t care”. Med denne maske behandles derfor netværksadresser 10.1.1.1.1.1 til 10.1.1.1.255 (10.1.1.1.x).
Subtraher den normale maske fra 255.255.255.255.255 for at bestemme den omvendte ACL-maske. I dette eksempel bestemmes den omvendte maske for netværksadresse 172.16.1.0 med en normal maske på 255.255.255.255.0.
255.255.255.255.255.255 – 255.255.255.255.0 (normal maske) = 0.0.0.0.255 (omvendt maske)
ACL-ækvivalenter
Kilde/kilde-wildcard for 0.0.0.0.0/255.255.255.255.255.255 betyder “enhver”.
Kilde/wildcard for 10.1.1.1.2/0.0.0.0.0.0 er det samme som “vært 10.1.1.1.2”
BilledmaskerRediger
I computergrafik kan de gennemsigtige områder, når et givet billede skal placeres over en baggrund, specificeres ved hjælp af en binær maske. På denne måde er der for hvert tilsigtet billede faktisk to bitmaps: det egentlige billede, hvor de ubrugte områder får en pixelværdi med alle bits sat til 0, og en ekstra maske, hvor de tilsvarende billedområder får en pixelværdi med alle bits sat til 0 og de omkringliggende områder en værdi med alle bits sat til 1. I eksemplet til højre har sorte pixels alle nul-bits og hvide pixels alle 1-bits.
For at placere billedet på skærmen over baggrunden maskerer programmet først skærmpixelens bits med billedmasken ved de ønskede koordinater ved hjælp af bitvis AND-operationen for at sætte billedet på skærmen over baggrunden. Herved bevares baggrundspixelerne i de gennemsigtige områder, mens bitsene i de pixels, der vil blive skjult af det overlappende billede, nulstilles.
Dernæst gengiver programmet billedpixelens bits ved at kombinere dem med baggrundspixelens bits ved hjælp af den bitvise OR-operation. På denne måde placeres billedpixlerne korrekt, samtidig med at de omgivende baggrundspixler bevares. Resultatet er en perfekt sammensætning af billedet over baggrunden.
Denne teknik bruges til at male pegeapparatets markører, i typiske 2D-videospil til figurer, kugler osv. (sprites), til GUI-ikoner og til video-titling og andre billedblandingsprogrammer.
Selv om de er beslægtede (fordi de bruges til de samme formål), er transparente farver og alfakanaler teknikker, som ikke involverer billedpixelblanding ved binær maskering.
HashtabellerRediger
For at skabe en hashfunktion til en hashtabel anvendes ofte en funktion, der har et stort domæne. For at oprette et indeks fra funktionens output kan der tages en modulo for at reducere domænets størrelse til at matche arrayets størrelse; det er dog ofte hurtigere på mange processorer at begrænse hashtabellens størrelse til potenser af to størrelser og bruge en bitmaske i stedet.
Et eksempel på både modulo og 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;}