Máscara (informática)

En informática, una máscara o una máscara de bits son datos que se utilizan para operaciones bit a bit, particularmente en un campo de bits. Utilizando una máscara, se pueden activar o desactivar varios bits de un byte, cuarteto, palabra, etc., o invertirlos de activado a desactivado (o viceversa) en una única operación bit a bit. Un uso adicional del enmascaramiento implica la predicación en el procesamiento de vectores, donde la máscara de bits se usa para seleccionar qué operaciones de elementos en el vector se ejecutarán (el bit de máscara está habilitado) y cuáles no (el bit de máscara está claro).

Funciones de máscara de bits comunes

Enmascarar bits a 1

Para activar ciertos bits, se puede utilizar la operación OR bit a bit, siguiendo el principio de que Y OR 1 = 1 y Y OR 0 = Y. Por lo tanto, para asegurarse de que un bit esté activado, se puede usar OR con un 1. Para dejar un poco sin cambios, OR se usa con un 0.

Ejemplo: enmascarar en el cuarteto superior (bits 4, 5, 6, 7) y dejar el cuarteto inferior (bits 0, 1, 2, 3) sin cambios.

 10010101 Graben 19, 10100101
O 11110000 11110000
= 11110101 11110101

Enmascarar bits a 0

En la práctica, es más frecuente que los bits estén "enmascarados apagados" (o enmascarado a 0) que "enmascarado on" (o enmascarado a 1). Cuando un bit se Yed con un 0, el resultado siempre es 0, es decir, Y AND 0 = 0. Para dejar los otros bits como estaban originalmente, pueden ser ANDed con 1 como Y AND 1 = Y

Ejemplo: enmascarar off el cuarteto superior (bits 4, 5, 6, 7) y dejar el cuarteto inferior (bits 0, 1, 2, 3) sin cambios.

 10010101 Graben 19, 10100101
Y 00001111 00001111
= 00000101 00000101

Consultar el estado de un bit

Es posible utilizar máscaras de bits para comprobar fácilmente el estado de bits individuales independientemente de los demás bits. Para hacer esto, se desactivan todos los demás bits usando AND bit a bit como 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 valor, entonces el bit estaba activado. Lo que hace que esto sea conveniente es que no es necesario averiguar cuál es realmente el valor, sólo que no es 0.

Ejemplo: Consultar el estado del 4º bit

 10011101 10010101
Y 000010001000
= 000010000000

Alternar valores de bits

Hasta ahora, el artículo ha cubierto cómo activar y desactivar bits, pero no ambas cosas a la vez. A veces realmente no importa cuál sea el valor, sino que hay que hacerlo lo contrario de lo que es actualmente. Esto se puede lograr utilizando la operación XOR (exclusiva o). XOR devuelve 1 si y sólo si un número impar de bits es 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 XORal aplicarles un 1. Si el bit original era 1, devuelve 1 XOR 1 = 0. Si el bit original era 0, devuelve 0 XOR 1 = 1. También tenga en cuenta que el enmascaramiento XOR es seguro para bits, lo que significa que no afectará a los bits desenmascarados porque Y XOR 0 = Y, al igual que un OR.

Ejemplo: alternar valores de bits

 10011101 10010101
XOR 0000111111 11111111= 10010010 01101010

Para escribir 1 y 0 arbitrarios en un subconjunto de bits, primero escriba 0 en ese subconjunto y luego configure los bits altos:

 registro = (registro & ~bitmask).

Usos de máscaras de bits

Argumentos a funciones

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 de gráficos OpenGL, hay un comando, glClear() que borra la pantalla u otros buffers. 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 tomado cuatro argumentos. Pero entonces una llamada sería así

 glClear()1,1,0,0); // No es así como el glClear realmente funciona y haría para código inestable.

que no es muy descriptivo. En su lugar, hay cuatro bits de campo definidos, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT y GL_STENCIL_BUFFER_BIT y glClear() se declara como

 vacío glClear()GLbitfield bits);

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

 glClear()GL_COLOR_BUFFER_BIT Silencio GL_DEPTH_BUFFER_BIT);

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

vacío glClear()GLbitfield bits) {} si ()bits " GL_COLOR_BUFFER_BIT) ! 0) {} // Buffer de color claro. } si ()bits " GL_DEPTH_BUFFER_BIT) ! 0) {} // Buffer de profundidad clara. } si ()bits " GL_ACCUM_BUFFER_BIT) ! 0) {} // Buffer de acumulación clara. } si ()bits " GL_STENCIL_BUFFER_BIT) ! 0) {} // Despejado buffer stencil. }}

La ventaja de este enfoque es que se reduce la sobrecarga de argumentos de la función. Dado que el tamaño mínimo de datos es un byte, separar las opciones en argumentos separados sería desperdiciar siete bits por argumento y ocuparía más espacio en la 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 es elegante, en la implementación más simple esta solución no es segura para tipos. Un GLbitfield se define simplemente como un unsigned int, por lo que el compilador permitiría una llamada sin sentido a glClear(42) o incluso a glClear(GL_POINTS). En C++, una alternativa sería crear una clase para encapsular el conjunto de argumentos que glClear podría aceptar y que podría encapsularse limpiamente en una biblioteca.

Máscaras inversas

Las máscaras se utilizan con direcciones IP en ACL (listas de control de acceso) de IP para especificar qué se debe permitir y denegar. Para configurar direcciones IP en interfaces, las máscaras comienzan con 255 y tienen los valores grandes en el lado izquierdo: por ejemplo, dirección IP 203.0.113.129 con un 255.255.255.224 máscara. Las máscaras para las ACL de IP son al revés: por ejemplo, máscara 0.0.0.255. A esto a veces se le llama 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 dirección se considerarán al procesar el tráfico. Un bit 0 indica que se debe considerar el bit de dirección (coincidencia exacta); un 1 bit en la máscara es "no importa". Esta tabla explica con más detalle el concepto.

Ejemplo de máscara:

dirección de red (tráfico que se va a procesar): 192.0.2.0

máscara: 0.0.0.255

dirección de red (binaria): 11000000.00000000.00000010.00000000

máscara (binaria): 00000000.00000000.00000000.11111111

Basado en la máscara binaria, se puede ver que los primeros tres conjuntos (octetos) deben coincidir exactamente con la dirección de red binaria dada (11000000.00000000.00000010). El último conjunto de números está compuesto por "no me importa"; (.11111111). Por lo tanto, todo el tráfico que comience con "192.0.2." coincidencias, ya que el último octeto es "no importa". Por lo tanto, con esta máscara, las direcciones de red 192.0.2.1 hasta 192.0.2.255 (192.0.2.x) se procesan.

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

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

Equivalentes de ACL

La fuente/fuente-comodín de 0.0.0.0/255.255.255.255 significa "cualquier".

La fuente/comodín de 198.51.100.2/0.0.0.0 es lo mismo que "host 198.51.100.2"

Máscaras de imagen

En gráficos por computadora, cuando se pretende colocar una imagen determinada sobre un fondo, las áreas transparentes se pueden especificar mediante una máscara binaria. De esta manera, para cada imagen prevista hay en realidad dos mapas de bits: la imagen real, en la que a las áreas no utilizadas se les asigna un valor de píxel con todos los bits establecidos en 0, y una máscara adicional, en la que la imagen correspondiente a las áreas de la imagen se les asigna un valor de píxel de todos los bits establecidos en 0 y a las áreas circundantes un valor de todos los bits establecidos en 1. En el ejemplo de la derecha, los píxeles negros tienen bits totalmente cero y los píxeles blancos tienen bits totalmente uno.

En tiempo de ejecución, para colocar la imagen en la pantalla sobre el fondo, el programa primero enmascara los bits del píxel de la pantalla con la máscara de imagen en las coordenadas deseadas usando la operación AND bit a bit. Esto preserva los píxeles de fondo de las áreas transparentes mientras restablece con ceros los bits de los píxeles que quedarán oscurecidos por la imagen superpuesta.

Luego, el programa representa los bits del píxel de la imagen combinándolos con los bits del píxel de fondo mediante la operación OR bit a bit. De esta manera, los píxeles de la imagen se colocan adecuadamente manteniendo el fondo que rodea a los píxeles. El resultado es una combinación perfecta de la imagen sobre el fondo.

Esta técnica se utiliza para pintar cursores de dispositivos señaladores, en videojuegos 2-D típicos para personajes, viñetas y demás (los sprites), para íconos GUI y para títulos de videos y otras aplicaciones de mezcla de imágenes.

Aunque están relacionados (debido a que 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.

Tablas hash

Para crear una función hash para una tabla hash, a menudo se utiliza una función que tiene un dominio grande. Para crear un índice a partir de la salida de la función, se puede tomar un módulo para reducir el tamaño del dominio para que coincida con el tamaño de la matriz; sin embargo, en muchos procesadores suele ser más rápido restringir el tamaño de la tabla hash a potencias de dos tamaños y utilizar una máscara de bits en su lugar.

Un ejemplo de módulo y enmascaramiento en C:

#include - No.#include Identificando.hint principal()vacío) {} const uint32_t NUM_BUCKETS = ¿Qué?; // 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; // Asignación de memoria manual para token_array... char token[] = "alguno valor razonable"; uint32_t hashed_token = hash_function()token, strlen()token), NUM_BUCKETS); // Uso de modulo size_t índice = hashed_token % MAX_RECORDS; / O // Usando bitmask size_t índice = hashed_token " HASH_BITMASK; *()token_array+índice) = token; // Libera la memoria de token_array... retorno 0;}