Máscara (informática) - Mask (computing)

El "enmascaramiento de señales" vuelve a dirigir aquí. Para otros usos, consulte Enmascaramiento (desambiguación) .

En informática , una máscara o máscara de bits son datos que se utilizan para operaciones bit a bit , particularmente en un campo de bits . Usando una máscara, múltiples bits en un byte , nibble , palabra , etc. pueden activarse, desactivarse o invertirse de activado a desactivado (o viceversa) en una sola operación bit a bit. Un uso y significado adicional de 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

Enmascaramiento de bits para 1

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

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

    10010101   10100101
 OR 11110000   11110000
  = 11110101   11110101

Enmascaramiento de bits para 0

Más a menudo en la práctica, los bits son "enmascarados off " (o enmascarados a 0) que "enmascarado en " (o enmascarados a 1). Cuando un bit se ANDedita con un 0, el resultado siempre es 0, es decir Y AND 0 = 0. Para dejar los otros bits a medida que eran originalmente, se pueden ANDEd con 1tanY AND 1 = Y

Ejemplo: Enmascaramiento de los más altos nibble (bits 4, 5, 6, 7) los más bajos nibble (bits 0, 1, 2, 3) sin cambios. 

    10010101   10100101
AND 00001111   00001111
  = 00000101   00000101

Consultando el estado de un bit

Es posible utilizar máscaras de bits para comprobar fácilmente el estado de los bits individuales independientemente de los otros bits. Para hacer esto, apagar todos los demás bits usando el bit a bit ANDse hace como se discutió 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, solo que no lo es 0.

Ejemplo: consultar el estado del cuarto bit 

    10011101   10010101
AND 00001000   00001000
  = 00001000   00000000

Alternar valores de bits

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, pero debe hacerse lo contrario de lo que es actualmente. Esto se puede lograr utilizando la operación XOR(exclusiva o) . XORdevuelve 1 si y solo si hay un número impar de bits 1. Por lo tanto, si dos bits correspondientes son 1, el resultado será a 0, pero si solo uno de ellos lo es 1, el resultado será 1. Por lo tanto, la inversión de los valores de los bits se hace XORingiriéndolos con a 1. Si el bit original era 1, regresa 1 XOR 1 = 0. Si el bit original era 0, vuelve 0 XOR 1 = 1. También tenga en cuenta que el XORenmascaramiento es seguro para bits, lo que significa que no afectará a los bits desenmascarados porque Y XOR 0 = Y, al igual que un archivo OR.

Ejemplo: alternar valores de bits 

    10011101   10010101
XOR 00001111   11111111
  = 10010010   01101010

Para escribir unos y ceros arbitrarios en un subconjunto de bits, primero escriba ceros en ese subconjunto y luego establezca los bits altos: 

  register = (register & ~bitmask) | value;

Usos de máscaras de bits

Un truco de fiesta para adivinar un número a partir de qué tarjetas está impreso utiliza los bits de la representación binaria del número. En el archivo SVG, haga clic en una tarjeta para alternarla

Argumentos para 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 búferes. Puede borrar hasta cuatro búferes (el color, la profundidad, la acumulación y los búferes de la plantilla ), por lo que los autores de la API podrían haber tenido cuatro argumentos. Pero luego una llamada se vería como 

 glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.

que no es muy descriptivo. En su lugar hay cuatro bits del campo definido, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, y GL_STENCIL_BUFFER_BITy glClear()es declarado 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 toma un campo de bits como este puede usar binario andpara extraer los bits individuales. Por ejemplo, una implementación de glClear()podría verse así: 

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.
  }
}

La ventaja de este enfoque es que se reduce la sobrecarga del argumento de función. Dado que el tamaño de referencia mínimo es de un byte, separar las opciones en argumentos separados desperdiciaría 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 los tipos . A GLbitfieldsimplemente se define como an 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.

Máscaras inversas

Las máscaras se utilizan con direcciones IP en IP ACL (listas de control de acceso) para especificar qué se debe permitir y denegar. Para configurar direcciones IP en interfaces, las máscaras comienzan con 255 y tienen valores grandes en el lado izquierdo: por ejemplo, dirección IP 203.0.113.129 con una máscara 255.255.255.224 . Las máscaras para las ACL IP son lo contrario: por ejemplo, máscara 0.0.0.255 . Esto a veces se denomina máscara inversa o máscara comodín . Cuando el valor de la máscara se divide en binarios (0 y 1), los resultados determinan qué bits de dirección se deben considerar 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 un "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

Según 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á formado por "no me importa" (.11111111). Por lo tanto, todo el tráfico que comienza con " 192.0.2. " Coincide , ya que el último octeto es "no importa". Por lo tanto, con esta máscara, se procesan las direcciones de red 192.0.2.0.1 a 192.0.2.0.255 ( 192.0.2.0.x ).

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

El código fuente / comodín de origen de 0.0.0.0 / 255.255.255.255 significa "cualquiera".

La fuente / comodín de 198.51.100.2 / 0.0.0.0 es la misma que "host 198.51.100.2 "

Máscaras de imágenes

Ver también: Bit blit y trazado de recorte
Sprites gráficos de trama (izquierda) y máscaras (derecha)

En los gráficos por ordenador , 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 deseada hay en realidad dos mapas de bits : la imagen real, en la que las áreas no utilizadas reciben un valor de píxel con todos los bits establecidos en 0, y una máscara adicional , en la que las áreas de la imagen correspondiente reciben un valor de píxel. de todos los bits establecidos en 0 y de las áreas circundantes un valor de todos los bits establecidos en 1. En la muestra de la derecha, los píxeles negros tienen todos los bits cero y los píxeles blancos tienen todos los bits uno.

En tiempo de ejecución , para poner 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 serán oscurecidos por la imagen superpuesta.

Luego, el programa procesa los bits del píxel de la imagen combinándolos con los bits del píxel de fondo usando la operación OR bit a bit . De esta forma, los píxeles de la imagen se colocan de forma adecuada mientras se conservan los píxeles circundantes de fondo. El resultado es una combinación perfecta de la imagen sobre el fondo.

Representación de Sprite por máscara de imagen binaria.png

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

Aunque 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 usa 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, a menudo es más rápido en muchos procesadores restringir el tamaño de la tabla hash a potencias de dos tamaños y usar una máscara de bits en su lugar.

Un ejemplo de módulo y enmascaramiento en 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;
}

Ver también

Referencias