Mask (computing)

To turn certain bits on, the bitwise OR operation can be used, following the principle that for an individual bit Y, Y OR 1 = 1 and Y OR 0 = Y. Therefore, to make sure a bit is on, OR can be used with a 1. To leave a bit unchanged, OR is used with a 0.

Example: Masking on the higher nibble (bits 4, 5, 6, 7) while leaving the lower nibble (bits 0, 1, 2, 3) unchanged.

10010101 10100101 OR 11110000 11110000 = 11110101 11110101

More often in practice, bits are "masked off" (or masked to 0) than "masked on" (or masked to 1). When a bit is ANDed with a 0, the result is always 0, i.e. Y AND 0 = 0. To leave the other bits as they were originally, they can be ANDed with 1 as Y AND 1 = Y

Example: Masking off the higher nibble (bits 4, 5, 6, 7) while leaving the lower nibble (bits 0, 1, 2, 3) unchanged.

10010101 10100101 AND 00001111 00001111 = 00000101 00000101

Es posible usar máscaras de bits para comprobar fácilmente el estado de bits individuales independientemente de los demás. Para ello, se desactivan todos los demás bits mediante la operación bit a bit, ANDcomo se explicó anteriormente, y el valor se compara con 0. Si es igual a 0, entonces el bit estaba desactivado; pero si el valor es cualquier otro, entonces el bit estaba activado. Lo que hace que esto sea conveniente es que no es necesario averiguar cuál es el valor real, solo que no es 0.

Ejemplo: Consultar el estado del cuarto bit

 1001 1 101 1001 0 101 Y 0000 1 000 0000 1 000 = 0000 1 000 0000 0 000

Hasta ahora, el artículo ha cubierto cómo activar y desactivar bits, pero no ambos a la vez. A veces, realmente no importa cuál sea el valor, sino que debe convertirse en el opuesto del que es actualmente. Esto se puede lograr utilizando la operación XOR(o exclusivo) . XORdevuelve 1si y solo si un número impar de bits son 1. Por lo tanto, si dos bits correspondientes son 1, el resultado será un 0, pero si solo uno de ellos es 1, el resultado será 1. Por lo tanto, la inversión de los valores de los bits se realiza combinándolos XORcon un 1. Si el bit original era 1, devuelve 1 XOR 1 = 0. Si el bit original era , 0devuelve 0 XOR 1 = 1. También tenga en cuenta que XORel enmascaramiento es seguro para los bits, lo que significa que no afectará a los bits no enmascarados porque Y XOR 0 = Y, al igual que un OR.

Ejemplo: Conmutación de valores de bits

 10011101 10010101 XOR 00001111 11111111 = 10010010 01101010

Para escribir 1s y 0s arbitrarios en un subconjunto de bits, primero escriba 0s en ese subconjunto y luego establezca los bits más altos:

 registro = (registro & ~máscara de bits) | valor;

A veces, es necesario copiar bits seleccionados sin alterar otros bits en un registro o almacenamiento. Esto se puede expresar, por ejemplo, como

${\displaystyle destino=(destino\land \lnot máscara)\lor (origen\land máscara)}$, o

 destino = (destino y ~máscara de bits) | (fuente y máscara de bits);

En este ejemplo, la máscara de bits tiene 0 donde los bits de destino permanecen y 1 donde son reemplazados por los bits de origen .

(Si la fuente solo contiene los bits que se van a insertar, se puede omitir la parte de la máscara de bits & ).

En lenguajes de programación como C , los campos de bits son una forma útil de pasar un conjunto de argumentos booleanos con nombre a una función. Por ejemplo, en la API gráfica OpenGL , hay un comando glClear()que borra la pantalla u otros búferes. Puede borrar hasta cuatro búferes (los búferes de color, profundidad, acumulación y plantilla ), por lo que los autores de la API podrían haber hecho que aceptara cuatro argumentos. Pero entonces una llamada a él se vería así:

glClear ( 1 , 1 , 0 , 0 ); // Así no es como realmente funciona glClear y daría lugar a un código inestable.

lo cual no es muy descriptivo. En cambio, hay cuatro bits de campo definidos, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, y GL_STENCIL_BUFFER_BITse glClear()declara como

void glClear ( GLbitfield bits );

Entonces, una llamada a la función se ve así:

glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );

Internamente, una función que recibe un campo de bits como este puede usar binario andpara extraer los bits individuales. Por ejemplo, una implementación glClear()podría verse así:

void glClear ( GLbitfield bits ) { if (( bits & GL_COLOR_BUFFER_BIT ) != 0 ) { // Borrar el búfer de color. } if (( bits & GL_DEPTH_BUFFER_BIT ) != 0 ) { // Borrar el búfer de profundidad. } if (( bits & GL_ACCUM_BUFFER_BIT ) != 0 ) { // Borrar el búfer de acumulación. } if (( bits & GL_STENCIL_BUFFER_BIT ) != 0 ) { // Borrar el búfer de plantilla. } }

La ventaja de este enfoque es que se reduce la sobrecarga de argumentos de función. Dado que el tamaño mínimo de dato es de un byte, separar las opciones en argumentos separados sería desperdiciar siete bits por argumento y ocuparía más espacio de pila. En cambio, las funciones suelen aceptar uno o más enteros de 32 bits, con hasta 32 bits de opción en cada uno. Si bien elegante, en la implementación más simple esta solución no es segura en cuanto a tipos . A GLbitfieldse define simplemente como un unsigned int, por lo que el compilador permitiría una llamada sin sentido a glClear(42)o incluso glClear(GL_POINTS). En C++ una alternativa sería crear una clase para encapsular el conjunto de argumentos que glClear podría aceptar y podría encapsularse limpiamente en una biblioteca.

Las máscaras se utilizan con direcciones IP en las ACL (Listas de Control de Acceso) de IP para especificar qué se debe permitir y qué se debe denegar. Para configurar direcciones IP en interfaces, las máscaras comienzan con 255 y tienen los valores grandes en el lado izquierdo: por ejemplo, la dirección IP 203.0.113.129 con una máscara 255.255.255.224 . Las máscaras para las ACL de IP son inversas: por ejemplo, la máscara 0.0.0.255 . A veces se la denomina máscara inversa o máscara comodín . Cuando el valor de la máscara se descompone en binario (0 y 1), los resultados determinan qué bits de la dirección se deben considerar al procesar el tráfico. Un bit 0 indica que el bit de la dirección debe considerarse (coincidencia exacta); un bit 1 en la máscara se ignora.

Por ejemplo: Una dirección de red (tráfico que se va a procesar): 192.0.2.0con máscara: 0.0.0.255. En binario, la dirección es 11000000.00000000.00000010.00000000y la máscara es 00000000.00000000.00000000.11111111.

Basándonos en la máscara binaria, se observa que los tres primeros conjuntos ( octetos ) deben coincidir exactamente con la dirección de red binaria dada ( 11000000.00000000.00000010). El último conjunto de números es ignorado por la máscara. Por lo tanto, todo el tráfico que comienza con " 192.0.2." coincide. En consecuencia, con esta máscara, se procesan las direcciones de red 192.0.2.1hasta 192.0.2.255( ).192.0.2.x

Al restar la máscara normal se 255.255.255.255determina la máscara inversa de la ACL. En este ejemplo, la máscara inversa se determina para la dirección de red 198.51.100.0con una máscara normal de 255.255.255.0:

255.255.255.255 − 255.255.255.0 = 0.0.0.255 (máscara normal) (máscara inversa) 

En gráficos por computadora , cuando se pretende colocar una imagen sobre un fondo, las áreas transparentes se pueden especificar mediante una máscara binaria. ^{[ 1 ]} De esta manera, para cada imagen deseada hay en realidad dos mapas de bits : la imagen propiamente dicha, en la que las áreas no utilizadas tienen un valor de píxel con todos los bits establecidos en 0, y una máscara adicional , en la que las áreas de imagen correspondientes tienen un valor de píxel con todos los bits establecidos en 0 y las áreas circundantes un valor con todos los bits establecidos en 1. En el ejemplo de la derecha, los píxeles negros tienen todos los bits en cero y los píxeles blancos tienen todos los bits en uno.

En tiempo de ejecución , para superponer la imagen sobre el fondo, el programa primero aplica una máscara a los bits de los píxeles de la pantalla con la máscara de la imagen en las coordenadas deseadas mediante la operación lógica AND . Esto preserva los píxeles de fondo de las áreas transparentes, mientras que restablece a cero los bits de los píxeles que quedarán ocultos por la imagen superpuesta.

A continuación, el programa procesa los bits de los píxeles de la imagen combinándolos con los bits de los píxeles del fondo mediante la operación OR bit a bit . De esta forma, los píxeles de la imagen se colocan correctamente, conservando los píxeles circundantes del fondo. El resultado es una superposición perfecta de la imagen sobre el fondo.

Esta técnica se utiliza para pintar cursores de dispositivos señaladores , en videojuegos típicos 2D para personajes, balas, etc. (los sprites ), para iconos de GUI y para títulos de vídeo y otras aplicaciones de mezcla de imágenes. Un método más rápido consiste simplemente en sobrescribir los píxeles de fondo con los píxeles de primer plano si su alfa=1

Aunque están relacionadas (porque se utilizan para los mismos fines), los colores transparentes y los canales alfa son técnicas que no implican la mezcla de píxeles de la imagen mediante enmascaramiento binario.

Para crear una función hash para una tabla hash , a menudo se utiliza una función con un dominio amplio. Para crear un índice a partir del resultado de la función, se puede aplicar el módulo para reducir el tamaño del dominio y ajustarlo al tamaño del array; sin embargo, en muchos procesadores suele ser más rápido restringir el tamaño de la tabla hash a potencias de dos y utilizar una máscara de bits.

Un ejemplo de módulo y enmascaramiento en C:

#include <stdint.h> #include <stdlib.h> #include <string.h>// una función hash uint32_t hashFunction ( char * token , size_t len ​​, uint32_t bucketCount );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 const size_t TOKEN_COUNT = 100 ; // tamaño de ejemplochar * tokens [] = ( char ** ) malloc ( sizeof ( char * ) * TOKEN_COUNT ); // Manejar la asignación de memoria para los tokens...char token [] = "algún valor hashable" ; uint32_t hashedToken = hashFunction ( token , strlen ( token ), NUM_BUCKETS );// Usando módulo: size_t index = hashedToken % MAX_RECORDS ;// O bien, usando una máscara de bits: size_t index = hashedToken & HASH_BITMASK ;tokens [ índice ] = token ;// Libera la memoria de los tokens... free ( tokens ); return 0 ; }