Máscara (informática)
Argumentos a funcionesEditar
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 buffers (el de color, el de profundidad, el de acumulación y el del stencil), por lo que los autores de la API podrían haber hecho que tomara cuatro argumentos. Pero entonces una llamada a esta función se vería como
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
lo cual 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
void glClear(GLbitfield bits);
Entonces una llamada a la función se parece a esto
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Internamente, una función que toma un campo de bits como este puede usar el binario and para extraer los bits individuales. Por ejemplo, una implementación de glClear() podría ser como:
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 la sobrecarga de argumentos de la función se reduce. Dado que el tamaño mínimo de los datos es de 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 su lugar, las funciones suelen aceptar uno o más enteros de 32 bits, con hasta 32 bits de opción en cada uno. Aunque es elegante, en la implementación más sencilla esta solución no es segura para el tipo. 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 podría ser limpiamente encapsulado en una biblioteca.
Máscaras inversasEditar
Las máscaras se utilizan con las direcciones IP en las ACLs (Listas de Control de Acceso) IP para especificar lo que debe ser permitido y denegado. Para configurar las direcciones IP en las interfaces, las máscaras empiezan por 255 y tienen los valores grandes a la izquierda: por ejemplo, la dirección IP 209.165.202.129 con una máscara 255.255.255.224. Las máscaras para las ACLs IP son lo contrario: por ejemplo, la máscara 0.0.0.255. Esto se denomina a veces máscara inversa o máscara comodín. Cuando el valor de la máscara se descompone en binario (0s y 1s), los resultados determinan qué bits de dirección deben ser considerados en el procesamiento del tráfico. Un 0 indica que los bits de dirección deben ser considerados (coincidencia exacta); un 1 en la máscara es un «no me importa». Esta tabla explica mejor el concepto.
Ejemplo de máscara:
dirección de red (tráfico que se va a procesar) 10.1.1.0
máscara0.0.0.255
dirección de red (binaria)00001010.00000001.00000001.00000000
máscara (binaria)00000000.00000000.00000000.11111111
En base a la máscara binaria, se puede ver que los tres primeros conjuntos (octetos) deben coincidir exactamente con la dirección de red binaria dada (00001010.00000001.00000001). El último conjunto de números está formado por «don’t cares» (.11111111). Por lo tanto, todo el tráfico que comienza con 10.1.1. coincide ya que el último octeto es «don’t care». Por lo tanto, con esta máscara, se procesan las direcciones de red 10.1.1.1 a 10.1.1.255 (10.1.1.x).
Reste la máscara normal de 255.255.255.255 para determinar la máscara inversa de la ACL. En este ejemplo, la máscara inversa se determina para la dirección de red 172.16.1.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/tarjeta salvaje de 0.0.0.0/255.255.255.255 significa «cualquiera».
La fuente/tarjeta salvaje de 10.1.1.2/0.0.0.0 es la misma que «host 10.1.1.2»
Máscaras de imagenEditar
En los gráficos por ordenador, cuando se pretende colocar una determinada imagen sobre un fondo, se pueden especificar las zonas transparentes mediante una máscara binaria. De este modo, para cada imagen prevista 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 puestos a 0s, y una máscara adicional, en la que las áreas correspondientes de la imagen reciben un valor de píxel con todos los bits puestos a 0s y las áreas circundantes un valor con todos los bits puestos a 1s. En el ejemplo de la derecha, los píxeles negros tienen los bits a cero y los blancos los bits a 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 la imagen en las coordenadas deseadas utilizando la operación AND a nivel de bits. Esto preserva los píxeles del fondo de las áreas transparentes mientras que restablece con ceros los bits de los píxeles que serán oscurecidos por la imagen superpuesta.
A continuación, el programa renderiza los bits del píxel de la imagen combinándolos con los bits del píxel del fondo utilizando la operación O a nivel de bits. De este modo, los píxeles de la imagen se colocan de forma adecuada mientras se conservan los píxeles del fondo. El resultado es un compuesto perfecto de la imagen sobre el fondo.
Esta técnica se utiliza para pintar los cursores de los dispositivos señaladores, en los típicos videojuegos 2D para los personajes, balas y demás (los sprites), para los iconos de la interfaz gráfica de usuario, y para la titulación de vídeos y otras aplicaciones de mezcla de imágenes.
Aunque relacionadas (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 hashEditar
Para crear una función hash para una tabla hash, a menudo se utiliza una función que tiene un gran dominio. 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 utilizar una máscara de bits en su lugar.
Un ejemplo tanto de módulo como de 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;}