Mask (beräkning) - Mask (computing)
Inom datavetenskap är en mask eller bitmask data som används för bitvisa operationer , särskilt i ett bitfält . Med hjälp av en mask kan flera bitar i en byte , nibble , word etc. sättas antingen på, av eller inverteras från på till av (eller vice versa) i en enda bitvis operation. En ytterligare användning och betydelse av maskering innebär predikation i vektorbehandling , där bitmask används för att välja vilka elementoperationer i vektorn som ska utföras (maskbit är aktiverad) och vilka som inte är (maskbit är tydlig)
Vanliga bitmaskfunktioner
Maskera bitar till 1
För att slå på vissa bitar kan den bitvisaOR operationen användas, enligt principen att Y OR 1 = 1och Y OR 0 = Y. Därför, för att se till att lite är på, ORkan användas med en 1. Att lämna lite oförändrat, ORanvänds med en 0.
Exempel: Maskering på den högre nibble (bit 4, 5, 6, 7) den nedre nibble (bit 0, 1, 2, 3) oförändrad.
10010101 10100101 OR 11110000 11110000 = 11110101 11110101
Maskera bitar till 0
Oftare i praktiken bitar "maskas off " (eller maskeras till 0) än "maskerad på " (eller maskeras för att 1). När en bit ANDed med en 0, är resultatet alltid 0, det vill säga Y AND 0 = 0. För att lämna de andra bitarna som de var ursprungligen kan de ANDredigeras med 1asY AND 1 = Y
Exempel: Maskering av den högre nibble (bit 4, 5, 6, 7) den nedre nibble (bit 0, 1, 2, 3) oförändrad.
10010101 10100101 AND 00001111 00001111 = 00000101 00000101
Frågar status för lite
Det är möjligt att använda bitmasker för att enkelt kontrollera tillståndet för enskilda bitar oavsett de andra bitarna. För att göra detta, stängs alla andra bitar av med bitvis ANDgörs som diskuterats ovan och värdet jämförs med 0. Om det är lika med 0, var biten avstängd, men om värdet är något annat värde, var biten på. Det som gör detta bekvämt är att det inte är nödvändigt att ta reda på vad värdet faktiskt är, bara att det inte är det 0.
Exempel: Fråga status för den 4: e biten
10011101 10010101 AND 00001000 00001000 = 00001000 00000000
Växla mellan bitvärden
Hittills har artikeln täckt hur man slår på och stänger av bitar, men inte båda samtidigt. Ibland spelar det egentligen ingen roll vad värdet är, utan det måste göras motsatsen till vad det är för närvarande. Detta kan uppnås med XOR(exklusiv eller) operation. XORreturnerar 1 om och bara om ett udda antal bitar är 1. Därför, om två motsvarande bitar är 1, blir resultatet a 0, men om bara en av dem är 1, blir resultatet 1. Därför görs inversion av bitarnas värden genom att XORange dem med a 1. Om den ursprungliga biten var 1, återgår den 1 XOR 1 = 0. Om den ursprungliga biten var 0återkommer den 0 XOR 1 = 1. Observera också att XORmaskering är bitsäker, vilket betyder att den inte kommer att påverka omaskerade bitar eftersom Y XOR 0 = Y, precis som en OR.
Exempel: Växla mellan bitvärden
10011101 10010101 XOR 00001111 11111111 = 10010010 01101010
För att skriva godtyckliga 1s och 0s till en delmängd av bitar, skriv först 0s till den delmängden och ställ sedan in de höga bitarna:
register = (register & ~bitmask) | value;
Användning av bitmasker
Argument till funktioner
I programmeringsspråk som C är bitfält ett användbart sätt att överföra en uppsättning namngivna booleska argument till en funktion. I grafik -API: et OpenGL finns till exempel ett kommando glClear()som rensar skärmen eller andra buffertar. Det kan rensa upp till fyra buffertar (färg, djup, ackumulering och stencilbuffertar ), så API -författarna kunde ha fått det att ta fyra argument. Men då skulle ett samtal till det se ut
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 fyra definierade fältbitar GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIToch GL_STENCIL_BUFFER_BIToch glClear()deklareras som
void glClear(GLbitfield bits);
Då ser ett samtal till funktionen ut så här
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Internt kan en funktion som tar ett bitfält som detta använda binärt för andatt 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 detta tillvägagångssätt är att funktionsargumentets omkostnader minskar. Eftersom den minsta datumstorleken är en byte skulle åtskillnad av alternativen i separata argument vara att slösa sju bitar per argument och skulle ta mer stack. Istället accepterar funktioner vanligtvis ett eller flera 32-bitars heltal, med upp till 32 alternativbitar i varje. Även om den är enkel, är den här lösningen i den enklaste implementeringen inte typsäker . A GLbitfielddefinieras helt enkelt som ett unsigned int, så kompilatorn skulle tillåta ett meningslöst samtal till glClear(42)eller till och med glClear(GL_POINTS). I C ++ skulle ett alternativ vara att skapa en klass för att inkapsla den uppsättning argument som glClear kunde acceptera och som skulle kunna inkapslas rent i ett bibliotek.
Omvända masker
Masker används med IP -adresser i IP ACL (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 masker med 255 och har de stora värdena på vänster sida: till exempel IP -adress 203.0.113.129 med en 255.255.255.224 mask. Masker för IP -ACL är omvända: till exempel mask 0.0.0.255 . Detta kallas ibland en omvänd mask eller en jokerteckenmask . När maskens värde bryts ner till binärt (0s och 1s), avgör resultaten vilka adressbitar som ska beaktas vid bearbetning av trafiken. En 0 -bit indikerar att adressbiten måste beaktas (exakt matchning); en 1 -bit i masken är en "don't care". Denna tabell förklarar vidare konceptet.
Mask exempel:
nätverksadress (trafik som ska bearbetas): 192.0.2.0
mask: 0.0.0.255
nätverksadress (binär): 11000000.00000000.00000010.00000000
mask (binär): 00000000.00000000.00000000.11111111
Baserat på den binära masken kan det ses att de tre första uppsättningarna ( oktetter ) måste matcha den angivna binära nätverksadressen exakt (11000000.00000000.00000010). Den sista uppsättningen nummer är gjord av "don't care" (.11111111). Därför matchar all trafik som börjar med " 192.0.2. " Eftersom den sista oktetten är "bryr sig inte". Därför bearbetas nätverksadresserna 192.0.2.0.1 till 192.0.2.0.255 ( 192.0.2.0.x ) med denna mask .
Subtrahera den normala masken från 255.255.255.255 för att bestämma ACL -inversmask. I detta exempel bestäms den inversa masken för nätverksadress 198.51.100.0 med en normal mask på 255.255.255.0 .
255.255.255.255 - 255.255.255.0 (normal mask) = 0.0.0.255 (invers mask)
ACL -ekvivalenter
Käll- / käll -jokertecken på 0.0.0.0 / 255.255.255.255 betyder "valfritt".
Källan / jokertecken för 198.51.100.2 / 0.0.0.0 är samma som "värd 198.51.100.2 "
Bildmasker
I datorgrafik , när en given bild är avsedd att placeras över en bakgrund, kan de transparenta områdena specificeras genom en binär mask. På så sätt finns det för varje avsedd bild faktiskt två bitmappar : den faktiska bilden, där de oanvända områdena får ett pixelvärde med alla bitar inställda på 0s, och en extra mask , där motsvarande bildområden ges ett pixelvärde av alla bitar inställda på 0s och de omgivande områdena ett värde på alla bitar som är 1s. I urvalet till höger har svarta pixlar alla noll-bitar och vita pixlar har all-one-bitarna.
Vid körning , för att lägga bilden på skärmen över bakgrunden, maskerar programmet först skärmpixelns bitar med bildmasken vid önskade koordinater med hjälp av bitvis OCH -operationen. Detta bevarar bakgrundspixlarna för de transparenta områdena medan nollställer bitarna i pixlarna som kommer att döljas av den överlappade bilden.
Därefter återger programmet bildpixelns bitar genom att kombinera dem med bakgrundspixelns bitar med hjälp av den bitvisa ELLER -operationen. På så sätt placeras bildpixlarna på lämpligt sätt samtidigt som bakgrundens omgivande pixlar bevaras. Resultatet är en perfekt sammansättning av bilden över bakgrunden.
Denna teknik används för att måla pekdonets markörer, i typiska 2-D-videospel för tecken, kulor och så vidare ( sprites ), för GUI- ikoner och för videotitling och andra bildblandningsapplikationer.
Även om de är relaterade (på grund av att de används för samma ändamål), är transparenta färger och alfakanaler tekniker som inte involverar bildpixelblandningen genom binär maskering.
Hashbord
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 funktionens utsignal kan en modul tas för att minska storleken på domänen för att matcha storleken på matrisen; dock är det ofta snabbare för många processorer att begränsa hashtabellens storlek till två storlekar och istället använda en bitmask.
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;
}
