Masque (informatique)
Arguments aux fonctionsEdit
Dans les langages de programmation comme le C, les champs de bits sont un moyen utile de passer un ensemble d’arguments booléens nommés à une fonction. Par exemple, dans l’API graphique OpenGL, il existe une commande, glClear() qui efface l’écran ou d’autres tampons. Elle peut effacer jusqu’à quatre tampons (les tampons de couleur, de profondeur, d’accumulation et de pochoir), les auteurs de l’API auraient donc pu lui faire prendre quatre arguments. Mais alors un appel à cette fonction ressemblerait à
glClear(1,1,0,0); // This is not how glClear actually works and would make for unstable code.
, ce qui n’est pas très descriptif. Au lieu de cela, il y a quatre bits de champ définis, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, et GL_STENCIL_BUFFER_BIT et glClear() est déclaré comme
void glClear(GLbitfield bits);
Alors un appel à la fonction ressemble à ceci
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Internellement, une fonction prenant un champ de bits comme celui-ci peut utiliser le binaire and pour extraire les bits individuels. Par exemple, une implémentation de glClear() pourrait ressembler à :
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. }}
L’avantage de cette approche est que l’overhead des arguments de fonction est diminué. Comme la taille minimale des données est d’un octet, séparer les options en arguments distincts reviendrait à gaspiller sept bits par argument et occuperait plus d’espace sur la pile. Au lieu de cela, les fonctions acceptent généralement un ou plusieurs entiers de 32 bits, avec jusqu’à 32 bits d’option dans chacun. Bien qu’élégante, dans l’implémentation la plus simple, cette solution n’est pas sûre du point de vue du type. Un GLbitfield est simplement défini comme étant un unsigned int, le compilateur autoriserait donc un appel sans signification à glClear(42) ou même glClear(GL_POINTS). En C++, une alternative serait de créer une classe pour encapsuler l’ensemble des arguments que glClear pourrait accepter et pourrait être proprement encapsulé dans une bibliothèque.
Masques inversesEdit
Les masques sont utilisés avec les adresses IP dans les ACL (Access Control Lists) IP pour spécifier ce qui doit être autorisé et refusé. Pour configurer les adresses IP sur les interfaces, les masques commencent par 255 et ont les grandes valeurs sur le côté gauche : par exemple, l’adresse IP 209.165.202.129 avec un masque 255.255.255.224. Les masques pour les ACL IP sont inversés : par exemple, le masque 0.0.0.255. C’est ce qu’on appelle parfois un masque inverse ou un masque joker. Lorsque la valeur du masque est décomposée en binaire (0 et 1), les résultats déterminent quels bits d’adresse doivent être pris en compte dans le traitement du trafic. Un 0 indique que les bits d’adresse doivent être pris en compte (correspondance exacte) ; un 1 dans le masque correspond à un » je m’en fous « . Ce tableau explique davantage le concept.
Exemple de masque:
adresse réseau (trafic qui doit être traité) 10.1.1.0
masque0.0.0.255
adresse réseau (binaire)00001010.00000001.00000001.00000000
mask (binaire)00000000.00000000.00000000.11111111
Sur la base du masque binaire, on peut voir que les trois premiers ensembles (octets) doivent correspondre exactement à l’adresse réseau binaire donnée (00001010.00000001.00000001). Le dernier ensemble de chiffres est constitué de « je m’en fous » (.11111111). Par conséquent, tout le trafic qui commence par 10.1.1. correspond puisque le dernier octet est « don’t care ». Par conséquent, avec ce masque, les adresses réseau 10.1.1.1 à 10.1.1.255 (10.1.1.x) sont traitées.
Soustraire le masque normal de 255.255.255.255 afin de déterminer le masque inverse de l’ACL. Dans cet exemple, le masque inverse est déterminé pour l’adresse réseau 172.16.1.0 avec un masque normal de 255.255.255.0.
255.255.255.255 – 255.255.255.0 (masque normal) = 0.0.0.255 (masque inverse)
Equivalents ACL
Le caractère générique de source de 0.0.0.0/255.255.255.255 signifie « tout ».
Le caractère générique de source de 10.1.1.2/0.0.0.0 est le même que « hôte 10.1.1.2 »
Masques d’imageEdit
En infographie, lorsqu’une image donnée est destinée à être placée sur un fond, les zones transparentes peuvent être spécifiées par un masque binaire. De cette façon, pour chaque image prévue, il existe en fait deux bitmaps : l’image réelle, dans laquelle les zones inutilisées reçoivent une valeur de pixel dont tous les bits sont à 0s, et un masque supplémentaire, dans lequel les zones d’image correspondantes reçoivent une valeur de pixel de tous les bits à 0s et les zones environnantes une valeur de tous les bits à 1s. Dans l’échantillon de droite, les pixels noirs ont les bits tout à zéro et les pixels blancs ont les bits tout à un.
Au moment de l’exécution, pour mettre l’image à l’écran par-dessus le fond, le programme masque d’abord les bits du pixel de l’écran avec le masque de l’image aux coordonnées souhaitées en utilisant l’opération ET au sens du bit. Cela préserve les pixels d’arrière-plan des zones transparentes tout en réinitialisant avec des zéros les bits des pixels qui seront obscurcis par l’image superposée.
Puis, le programme effectue le rendu des bits des pixels de l’image en les combinant avec les bits des pixels d’arrière-plan à l’aide de l’opération OU par bit. De cette façon, les pixels de l’image sont placés de manière appropriée tout en conservant les pixels environnants de l’arrière-plan. Le résultat est un composé parfait de l’image sur le fond.
Cette technique est utilisée pour peindre les curseurs des dispositifs de pointage, dans les jeux vidéo 2-D typiques pour les personnages, les balles et ainsi de suite (les sprites), pour les icônes des interfaces graphiques, et pour le titrage vidéo et d’autres applications de mélange d’images.
Bien que liés (du fait qu’ils sont utilisés aux mêmes fins), les couleurs transparentes et les canaux alpha sont des techniques qui n’impliquent pas le mélange des pixels de l’image par un masquage binaire.
Tables de hachageEdit
Pour créer une fonction de hachage pour une table de hachage, on utilise souvent une fonction qui a un grand domaine. Pour créer un index à partir de la sortie de la fonction, on peut prendre un modulo pour réduire la taille du domaine afin qu’elle corresponde à la taille du tableau ; cependant, il est souvent plus rapide sur de nombreux processeurs de restreindre la taille de la table de hachage aux puissances de deux tailles et d’utiliser un masque de bits à la place.
Un exemple de modulo et de masquage 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;}
.