Maszk (számítástechnika)
Függvények argumentumaiSzerkesztés
A programozási nyelvekben, például a C-ben a bitmezők egy hasznos módja annak, hogy egy sor megnevezett bólusú argumentumot adjunk át egy függvénynek. Például az OpenGL grafikus API-ban van egy glClear() parancs, amely törli a képernyőt vagy más puffereket. Legfeljebb négy puffert (a szín-, a mélység-, a felhalmozási és a sablonpuffert) képes törölni, így az API szerzői négy argumentumot is megadhattak volna neki. De akkor a meghívása így nézne ki:
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
ami nem túl szemléletes. Ehelyett négy meghatározott mezőbit van, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT és GL_STENCIL_BUFFER_BIT, és a glClear() így van deklarálva:
void glClear(GLbitfield bits);
Ezután a függvény hívása így néz ki:
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Egy ilyen bitmezőt vevő függvény a bináris and-t használhatja az egyes bitek kivonására. A glClear() megvalósítása például így nézhet ki:
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. }}
Az előnye ennek a megközelítésnek, hogy a függvény argumentumterhelése csökken. Mivel a minimális adatméret egy bájt, az opciók külön argumentumokra való szétválasztása argumentumonként hét bitet pazarolna, és több helyet foglalna a veremben. Ehelyett a függvények általában egy vagy több 32 bites egész számot fogadnak el, mindegyikben legfeljebb 32 opciós bitet. Bár elegáns, a legegyszerűbb megvalósításban ez a megoldás nem típusvédett. Egy GLbitfield egyszerűen unsigned int-nek van definiálva, így a fordító lehetővé tenné az glClear(42) vagy akár a glClear(GL_POINTS) értelmetlen hívását. C++-ban egy alternatíva az lenne, ha létrehoznánk egy osztályt, amely a glClear által elfogadható argumentumkészletet kapszulázná, és tisztán egy könyvtárba lehetne kapszulázni.
Inverz maszkokSzerkesztés
A maszkokat IP-címekkel együtt használják az IP ACL-ekben (Access Control Lists) annak meghatározására, hogy mit kell engedélyezni és megtagadni. Az IP-címek konfigurálásához az interfészeken a maszkok 255-tel kezdődnek, és a bal oldalon vannak a nagy értékek: például a 209.165.202.129 IP-cím 255.255.255.255.224 maszkkal. Az IP ACL-ek esetében a maszkok fordítottak: például 0.0.0.0.255 maszk. Ezt néha fordított maszknak vagy wildcard maszknak is nevezik. Amikor a maszk értékét binárisra (0-ra és 1-re) bontjuk, az eredmény meghatározza, hogy mely címbiteket kell figyelembe venni a forgalom feldolgozása során. A 0 azt jelzi, hogy a címbiteket figyelembe kell venni (pontos egyezés); az 1 a maszkban a “nem érdekel” jelzést jelenti. Ez a táblázat tovább magyarázza a koncepciót.
Maszk példa:
hálózati cím (feldolgozandó forgalom) 10.1.1.0
maszk0.0.0.0.255
hálózati cím (bináris)00001010.00000001.00000001.00000000
maszk (bináris)00000000.00000000.00000000.00000000.11111111
A bináris maszk alapján látható, hogy az első három sorozatnak (oktettnek) pontosan meg kell egyeznie a megadott bináris hálózati címmel (00001010.00000001.00000001). Az utolsó számhalmaz a “don’t cares” (.1111111111). Ezért minden olyan forgalom, amely 10.1.1.-vel kezdődik, megfelel, mivel az utolsó oktett “don’t care”. Ezért ezzel a maszkkal a 10.1.1.1.1-től 10.1.1.1.255-ig (10.1.1.1.x) terjedő hálózati címek kerülnek feldolgozásra.
A normál maszkot kivonjuk a 255.255.255.255.255-ből, hogy meghatározzuk az ACL inverz maszkját. Ebben a példában az inverz maszkot a 172.16.1.0 hálózati címhez határozzuk meg, amelynek normál maszkja 255.255.255.255.0.
255.255.255.255.255 – 255.255.255.255.0 (normál maszk) = 0.0.0.0.255 (inverz maszk)
ACL ekvivalensek
A 0.0.0.0.0/255.255.255.255.255.255 forrás/forrás-vadkártya jelentése “bármilyen”.
A 10.1.1.2/0.0.0.0.0 forrás/vadkártya a “host 10.1.1.2”
Image masksEdit
A számítógépes grafikában, amikor egy adott képet háttér fölé kívánunk helyezni, az átlátszó területek bináris maszkkal adhatók meg. Ily módon minden egyes tervezett képhez tulajdonképpen két bittérkép tartozik: a tényleges kép, amelyben a nem használt területek olyan pixelértéket kapnak, amelyben minden bit 0-ra van állítva, és egy további maszk, amelyben a megfelelő képi területek olyan pixelértéket kapnak, amelyben minden bit 0-ra van állítva, a környező területek pedig olyan értéket kapnak, amelyben minden bit 1-re van állítva. A jobb oldali mintában a fekete pixelek minden bitje nulla, a fehér pixelek pedig minden bitje egy.
Futtatáskor, hogy a képet a háttér fölé helyezzük a képernyőn, a program először a képernyő pixel bitjeit a kívánt koordinátáknál a képmaszkkal maszkolja a bitenkénti ÉS művelet segítségével. Ez megőrzi az átlátszó területek háttérpixeleit, míg az átfedő kép által eltakarásra kerülő pixelek bitjeit nullára állítja.
Ezután a program a képpixel bitjeit a háttérpixel bitjeivel kombinálva a bitenkénti VAGY művelet segítségével rendereli a képpixel bitjeit. Így a képpixelek megfelelően kerülnek elhelyezésre, miközben a hátteret körülvevő pixelek megmaradnak. Az eredmény a kép tökéletes összetétele a háttér felett.
Ezt a technikát használják a mutatóeszköz kurzorainak festésére, a tipikus 2D-s videojátékokban a karakterek, golyók és hasonlók (a sprite-ok), a GUI ikonok, valamint a videócímek és más képkeverő alkalmazások esetében.
A transzparens színek és az alfacsatornák, bár rokonok (mivel ugyanazokra a célokra használják őket), olyan technikák, amelyek nem tartalmazzák a kép képpontjainak bináris maszkolással történő keverését.
HashtáblákSzerkesztés
A hashtáblához való hash-függvény létrehozásához gyakran olyan függvényt használnak, amelynek nagy tartománya van. Ahhoz, hogy a függvény kimenetéből indexet hozzunk létre, modulo segítségével csökkenthetjük a tartomány méretét, hogy az megfeleljen a tömb méretének; sok processzoron azonban gyakran gyorsabb, ha a hash-tábla méretét két méret hatványaira korlátozzuk, és helyette bitmaszkot használunk.
Egy példa a modulo és a maszkolásra is C-ben:
#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;}