Maske (Computing)
Argumente für FunktionenBearbeiten
In Programmiersprachen wie C sind Bit-Felder eine nützliche Möglichkeit, eine Reihe von benannten booleschen Argumenten an eine Funktion zu übergeben. In der Grafik-API OpenGL gibt es zum Beispiel einen Befehl glClear(), der den Bildschirm oder andere Puffer löscht. Es können bis zu vier Puffer gelöscht werden (Farb-, Tiefen-, Akkumulations- und Schablonenpuffer), so dass die API-Autoren auch vier Argumente hätten angeben können. Aber dann würde ein Aufruf wie
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
aussehen, was nicht sehr anschaulich ist. Stattdessen gibt es vier definierte Feldbits, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT und GL_STENCIL_BUFFER_BIT, und glClear() wird deklariert als
void glClear(GLbitfield bits);
Dann sieht ein Aufruf der Funktion so aus
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Intern kann eine Funktion, die ein Bitfeld wie dieses nimmt, die Binärzahl and verwenden, um die einzelnen Bits zu extrahieren. Eine Implementierung von glClear() könnte zum Beispiel so aussehen:
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. }}
Der Vorteil dieses Ansatzes ist, dass der Overhead der Funktionsargumente verringert wird. Da die minimale Datengröße ein Byte beträgt, würde die Aufteilung der Optionen in separate Argumente sieben Bits pro Argument verschwenden und mehr Stapelplatz belegen. Stattdessen akzeptieren Funktionen normalerweise eine oder mehrere 32-Bit-Ganzzahlen mit jeweils bis zu 32 Optionsbits. Obwohl diese Lösung elegant ist, ist sie in der einfachsten Implementierung nicht typsicher. Ein GLbitfield ist einfach als unsigned int definiert, so dass der Compiler einen sinnlosen Aufruf an glClear(42) oder sogar glClear(GL_POINTS) zulassen würde. In C++ wäre eine Alternative, eine Klasse zu erstellen, um den Satz von Argumenten zu kapseln, die glClear akzeptieren könnte und die sauber in einer Bibliothek gekapselt werden könnten.
Inverse masksEdit
Masken werden zusammen mit IP-Adressen in IP ACLs (Access Control Lists) verwendet, um festzulegen, was erlaubt und verweigert werden soll. Um IP-Adressen auf Schnittstellen zu konfigurieren, beginnen Masken mit 255 und haben die großen Werte auf der linken Seite: z. B. die IP-Adresse 209.165.202.129 mit einer Maske 255.255.255.224. Masken für IP-ACLs sind umgekehrt: zum Beispiel die Maske 0.0.0.255. Dies wird manchmal als inverse Maske oder Wildcard-Maske bezeichnet. Wenn der Wert der Maske in Binärwerte (0 und 1) zerlegt wird, bestimmen die Ergebnisse, welche Adressbits bei der Verarbeitung des Datenverkehrs zu berücksichtigen sind. Eine 0 bedeutet, dass die Adressbits berücksichtigt werden müssen (exakte Übereinstimmung); eine 1 in der Maske ist ein „egal“. Diese Tabelle erläutert das Konzept näher.
Maskenbeispiel:
Netzwerkadresse (zu verarbeitender Verkehr) 10.1.1.0
Maske0.0.0.255
Netzwerkadresse (binär)00001010.00000001.00000001.00000000
Maske (binär)00000000.00000000.00000000.11111111
Aus der binären Maske geht hervor, dass die ersten drei Gruppen (Oktette) genau mit der angegebenen binären Netzwerkadresse (00001010.00000001.00000001) übereinstimmen müssen. Der letzte Satz von Zahlen besteht aus „don’t cares“ (.11111111). Daher passt der gesamte Verkehr, der mit 10.1.1. beginnt, da das letzte Oktett „don’t care“ ist. Mit dieser Maske werden also die Netzwerkadressen 10.1.1.1 bis 10.1.1.255 (10.1.1.x) verarbeitet.
Subtrahieren Sie die normale Maske von 255.255.255.255, um die inverse Maske der ACL zu ermitteln. In diesem Beispiel wird die inverse Maske für die Netzwerkadresse 172.16.1.0 mit einer normalen Maske von 255.255.255.0 ermittelt.
255.255.255.255.255 – 255.255.255.0 (normale Maske) = 0.0.0.255 (inverse Maske)
ACL-Äquivalente
Die source/source-wildcard von 0.0.0.0/255.255.255.255.255 bedeutet „beliebig“.
Die source/wildcard von 10.1.1.2/0.0.0.0 ist dasselbe wie „host 10.1.1.2“
BildmaskenBearbeiten
In der Computergrafik können, wenn ein bestimmtes Bild über einen Hintergrund gelegt werden soll, die transparenten Bereiche durch eine binäre Maske festgelegt werden. Auf diese Weise gibt es für jedes beabsichtigte Bild eigentlich zwei Bitmaps: das eigentliche Bild, in dem die nicht verwendeten Bereiche einen Pixelwert erhalten, bei dem alle Bits auf 0s gesetzt sind, und eine zusätzliche Maske, in der die entsprechenden Bildbereiche einen Pixelwert erhalten, bei dem alle Bits auf 0s gesetzt sind, und die umgebenden Bereiche einen Wert, bei dem alle Bits auf 1s gesetzt sind. Im Beispiel rechts haben schwarze Pixel alle Null-Bits und weiße Pixel alle 1-Bits.
Zur Laufzeit, um das Bild auf dem Bildschirm über den Hintergrund zu legen, maskiert das Programm zunächst die Bits der Bildschirmpixel mit der Bildmaske an den gewünschten Koordinaten mit der bitweisen UND-Operation. Dadurch bleiben die Hintergrundpixel der transparenten Bereiche erhalten, während die Bits der Pixel, die durch das überlagerte Bild verdeckt werden, mit Nullen zurückgesetzt werden.
Dann rendert das Programm die Bits der Bildpixel, indem es sie mit den Bits der Hintergrundpixel mittels der bitweisen ODER-Operation kombiniert. Auf diese Weise werden die Bildpixel angemessen platziert, während die umgebenden Hintergrundpixel erhalten bleiben. Das Ergebnis ist eine perfekte Verbindung des Bildes mit dem Hintergrund.
Diese Technik wird zum Malen von Cursorn für Zeigegeräte, in typischen 2D-Videospielen für Charaktere, Kugeln usw. (die Sprites), für GUI-Symbole und für Videotitel und andere Bildmischanwendungen verwendet.
Transparente Farben und Alphakanäle sind zwar verwandt (da sie für dieselben Zwecke verwendet werden), aber es handelt sich um Techniken, bei denen die Bildpixel nicht durch binäre Maskierung gemischt werden.
Hash-TabellenBearbeiten
Um eine Hash-Funktion für eine Hash-Tabelle zu erstellen, wird häufig eine Funktion mit einem großen Bereich verwendet. Um einen Index aus der Ausgabe der Funktion zu erstellen, kann ein Modulo genommen werden, um die Größe der Domäne zu reduzieren, damit sie mit der Größe des Arrays übereinstimmt; allerdings ist es auf vielen Prozessoren oft schneller, die Größe der Hash-Tabelle auf Potenzen von zwei Größen zu beschränken und stattdessen eine Bitmaske zu verwenden.
Ein Beispiel für sowohl Modulo als auch Maskierung 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;}