Máscara (informática)
Argumentos às funçõesEditar
Em linguagens de programação como C, os campos de bits são uma forma útil de passar um conjunto de argumentos booleanos nomeados para uma função. Por exemplo, na API gráfica OpenGL, há um comando, glClear() que limpa a tela ou outros buffers. Ele pode limpar até quatro buffers (os buffers de cor, profundidade, acumulação e stencil), então os autores da API poderiam ter tido quatro argumentos. Mas então uma chamada a ele pareceria
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
o que não é muito descritivo. Em vez disso há quatro bits de campo definidos, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, e GL_STENCIL_BUFFER_BIT, e glClear() é declarado como
void glClear(GLbitfield bits);
Então uma chamada para a função parece assim
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Internamente, uma função que toma um campo de bits como este pode usar o binário and para extrair os bits individuais. Por exemplo, uma implementação de glClear() pode parecer:
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. }}
A vantagem desta abordagem é que a sobrecarga de argumentos de função é reduzida. Como o tamanho mínimo dos dados é de um byte, separar as opções em argumentos separados seria desperdiçar sete bits por argumento e ocuparia mais espaço na pilha. Em vez disso, as funções tipicamente aceitam um ou mais inteiros de 32 bits, com até 32 bits de opção em cada um. Embora elegante, na implementação mais simples, esta solução não é segura para o tipo. Um GLbitfield é simplesmente definido para ser um unsigned int, então o compilador permitiria uma chamada sem sentido para glClear(42) ou mesmo glClear(GL_POINTS). Em C++, uma alternativa seria criar uma classe para encapsular o conjunto de argumentos que o glClear poderia aceitar e poderia ser limpo encapsulado em uma biblioteca.
Máscaras InvertidasEditar
Máscaras são usadas com endereços IP em ACLs IP (Listas de Controle de Acesso) para especificar o que deve ser permitido e negado. Para configurar endereços IP nas interfaces, as máscaras começam com 255 e têm os grandes valores do lado esquerdo: por exemplo, o endereço IP 209.165.202.129 com uma máscara 255.255.255.224. As máscaras para ACLs IP são o inverso: por exemplo, máscara 0.0.0.255. Isto é às vezes chamado de máscara inversa ou máscara wildcard. Quando o valor da máscara é decomposto em binário (0s e 1s), os resultados determinam quais bits de endereço devem ser considerados no processamento do tráfego. Um 0 indica que os bits de endereço devem ser considerados (correspondência exata); um 1 na máscara é um “não importa”. Esta tabela explica melhor o conceito.
Máscara exemplo:
Endereço de rede (tráfego que deve ser processado) 10.1.1.0
mask0.0.0.255
Endereço de rede (binário)00001010.00000001.00000001.00000000
mask (binário)00000000.00000000.00000000.11111111
Baseado na máscara binária, pode-se ver que os três primeiros conjuntos (octetos) devem corresponder exatamente ao endereço de rede binário dado (00001010.00000001.00000001). O último conjunto de números é feito de “não importa” (.11111111). Portanto, todo o tráfego que começa com 10.1.1. coincide desde o último octeto é “don’t care”. Portanto, com esta máscara, os endereços de rede 10.1.1.1.1 até 10.1.1.255 (10.1.1.x) são processados.
Subtrair a máscara normal de 255.255.255.255 a fim de determinar a máscara inversa do ACL. Neste exemplo, a máscara inversa é determinada para o endereço de rede 172.16.1.0 com uma máscara normal de 255.255.255.0.
255.255.255.255.255 – 255.255.255.0 (máscara normal) = 0.0.0.255 (máscara inversa)
Equivalentes aACL
O source/source-wildcard de 0.0.0.0/255.255.255.255 significa “qualquer”.
O source/wildcard de 10.1.1.2/0.0.0.0 é o mesmo que “host 10.1.1.2”
Máscaras de imagemEditar
>
Em computação gráfica, quando uma determinada imagem se destina a ser colocada sobre um fundo, as áreas transparentes podem ser especificadas através de uma máscara binária. Desta forma, para cada imagem pretendida existem na realidade dois bitmaps: a imagem real, na qual as áreas não utilizadas recebem um valor de pixel com todos os bits definidos para 0s, e uma máscara adicional, na qual as áreas da imagem correspondente recebem um valor de pixel com todos os bits definidos para 0s e as áreas circundantes um valor de todos os bits definidos para 1s. Na amostra à direita, os pixels pretos têm os bits tudo-zero e os pixels brancos têm os bits tudo-um.
Em tempo de execução, para colocar a imagem na tela sobre o fundo, o programa primeiro mascara os bits do pixel da tela com a máscara da imagem nas coordenadas desejadas usando a operação bitwise AND. Isto preserva os pixels de fundo das áreas transparentes enquanto restabelece com zeros os bits dos pixels que serão obscurecidos pela imagem sobreposta.
Então, o programa renderiza os bits do pixel da imagem combinando-os com os bits do pixel de fundo usando a operação bitwise OR. Desta forma, os pixels da imagem são colocados apropriadamente, mantendo os pixels de fundo ao redor dos pixels preservados. O resultado é um composto perfeito da imagem sobre o fundo.
Esta técnica é usada para pintar cursores de dispositivos apontadores, em típicos videojogos 2-D para personagens, balas e assim por diante (os sprites), para ícones GUI, e para títulos de vídeo e outras aplicações de mistura de imagens.
Embora relacionadas (devido a serem usadas para os mesmos fins), cores transparentes e canais alfa são técnicas que não envolvem a mistura de pixels de imagem por máscara binária.
Tabelas de hashEditar
Para criar uma função de hash para uma tabela de hash, muitas vezes é usada uma função que tem um grande domínio. Para criar um índice a partir da saída da função, um módulo pode ser tomado para reduzir o tamanho do domínio para corresponder ao tamanho do array; no entanto, muitas vezes é mais rápido em muitos processadores restringir o tamanho da tabela hash a potências de dois tamanhos e usar uma máscara de bits em vez disso.
Um exemplo de ambos modulo e máscara em 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;}