Incomputer science, amask orbitmask is data that is used forbitwise operations, particularly in abit field. Using a mask, multiple bits in abyte,nibble,word, etc. can be set either on or off, or inverted from on to off (or vice versa) in a single bitwise operation. An additional use of masking involvespredication invector processing, where the bitmask is used to select which element operations in the vector are to be executed (mask bit is enabled) and which are not (mask bit is clear).

To turn certain bits on, thebitwiseOR operation can be used, followingthe principle that for an individual bitY,Y OR 1 = 1 andY OR 0 = Y. Therefore, to make sure a bit is on,OR can be used with a1. To leave a bit unchanged,OR is used with a0.

Example: Maskingon the highernibble (bits 4, 5, 6, 7) while leaving the lower nibble (bits 0, 1, 2, 3) unchanged.

1001010110100101 OR1111000011110000  =1111010111110101

More often in practice, bits are "maskedoff" (or masked to0) than "maskedon" (or masked to1). When a bit isANDed with a 0, the result is always 0, i.e.Y AND 0 = 0. To leave the other bits as they were originally, they can beANDed with1 asY AND 1 = Y

Example: Maskingoff the highernibble (bits 4, 5, 6, 7) while leaving the lower nibble (bits 0, 1, 2, 3) unchanged.

1001010110100101AND0000111100001111  =0000010100000101

It is possible to use bitmasks to easily check the state of individual bits regardless of the other bits. To do this, turning off all the other bits using the bitwiseAND is done as discussed above and the value is compared with0. If it is equal to0, then the bit was off, but if the value is any other value, then the bit was on. What makes this convenient is that it is not necessary to figure out what the value actually is, just that it is not0.

Example: Querying the status of the 4th bit

    10011101   10010101AND 00001000   00001000  = 00001000   00000000

So far the article has covered how to turn bits on and turn bits off, but not both at once. Sometimes it does not really matter what the value is, but it must be made the opposite of what it currently is. This can be achieved using theXOR (exclusive or) operation.XOR returns1if and only if anodd number of bits are1. Therefore, if two corresponding bits are1, the result will be a0, but if only one of them is1, the result will be1. Therefore inversion of the values of bits is done byXORing them with a1. If the original bit was1, it returns1 XOR 1 = 0. If the original bit was0 it returns0 XOR 1 = 1. Also note thatXOR masking is bit-safe, meaning that it will not affect unmasked bits becauseY XOR 0 = Y, just like anOR.

Example: Toggling bit values

    10011101   10010101XOR00001111   11111111  = 10010010   01101010

To write arbitrary 1s and 0s to a subset of bits, first write 0s to that subset, then set the high bits:

  register = (register & ~bitmask) | value;

In programming languages such asC, bit fields are a useful way to pass a set of named Boolean arguments to a function. For example, in the graphics APIOpenGL, there is a command,glClear() which clears the screen or other buffers. It can clear up to four buffers (the color, depth, accumulation, andstencil buffers), so the API authors could have had it take four arguments. But then a call to it would look like

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

which is not very descriptive. Instead there are four defined field bits,GL_COLOR_BUFFER_BIT,GL_DEPTH_BUFFER_BIT,GL_ACCUM_BUFFER_BIT, andGL_STENCIL_BUFFER_BIT andglClear() is declared as

voidglClear(GLbitfieldbits);

Then a call to the function looks like this

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

Internally, a function taking a bitfield like this can use binaryand to extract the individual bits. For example, an implementation ofglClear() might look like:

voidglClear(GLbitfieldbits){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.}}

The advantage to this approach is that function argument overhead is decreased. Since the minimum datum size is one byte, separating the options into separate arguments would be wasting seven bits per argument and would occupy more stack space. Instead, functions typically accept one or more 32-bit integers, with up to 32 option bits in each. While elegant, in the simplest implementation this solution is nottype-safe. AGLbitfield is simply defined to be anunsigned int, so the compiler would allow a meaningless call toglClear(42) or evenglClear(GL_POINTS). InC++ an alternative would be to create a class to encapsulate the set of arguments that glClear could accept and could be cleanly encapsulated in a library.

Masks are used with IP addresses in IP ACLs (Access Control Lists) to specify what should be permitted and denied. To configure IP addresses on interfaces, masks start with 255 and have the large values on the left side: for example, IP address203.0.113.129 with a255.255.255.224 mask. Masks for IP ACLs are the reverse: for example, mask0.0.0.255. This is sometimes called an inverse mask or awildcard mask. When the value of the mask is broken down into binary (0s and 1s), the results determine which address bits are to be considered in processing the traffic. A0-bit indicates that the address bit must be considered (exact match); a1-bit in the mask is a "don't care". This table further explains the concept.

Mask example:

network address (traffic that is to be processed):192.0.2.0

mask:0.0.0.255

network address (binary): 11000000.00000000.00000010.00000000

mask (binary): 00000000.00000000.00000000.11111111

Based on the binary mask, it can be seen that the first three sets (octets) must match the given binary network address exactly (11000000.00000000.00000010). The last set of numbers is made of "don't cares" (.11111111). Therefore, all traffic that begins with "192.0.2." matches, since the last octet is "don't care". Therefore, with this mask, network addresses192.0.2.1 through192.0.2.255 (192.0.2.x) are processed.

Subtract the normal mask from255.255.255.255 in order to determine the ACL inverse mask. In this example, the inverse mask is determined for network address198.51.100.0 with a normal mask of255.255.255.0.

255.255.255.255 −255.255.255.0 (normal mask) =0.0.0.255 (inverse mask)

ACL equivalents

The source/source-wildcard of0.0.0.0/255.255.255.255 means "any".

The source/wildcard of198.51.100.2/0.0.0.0 is the same as "host198.51.100.2"

Incomputer graphics, when a given image is intended to be placed over a background, the transparent areas can be specified through a binary mask.^[1] This way, for each intended image there are actually twobitmaps: the actual image, in which the unused areas are given apixel value with allbits set to 0s, and an additionalmask, in which the correspondent image areas are given a pixel value of all bits set to 0s and the surrounding areas a value of all bits set to 1s. In the sample at right, black pixels have the all-zero bits and white pixels have the all-one bits.

Atrun time, to put the image on the screen over the background, the program first masks the screen pixel's bits with the image mask at the desired coordinates using thebitwise AND operation. This preserves the background pixels of the transparent areas while resets with zeros the bits of the pixels which will be obscured by the overlapped image.

Then, the program renders the image pixel's bits by combining them with the background pixel's bits using thebitwise OR operation. This way, the image pixels are appropriately placed while keeping the background surrounding pixels preserved. The result is a perfect compound of the image over the background.

This technique is used for painting pointing device cursors, in typical 2-D videogames for characters, bullets and so on (thesprites), forGUIicons, and for video titling and other image mixing applications. A faster method is to simply overwrite the background pixels with the foreground pixels if their alpha=1

Although related (due to being used for the same purposes),transparent colors andalpha channels are techniques which do not involve the image pixel mixage by binary masking.

To create a hashing function for ahash table, often a function is used that has a large domain. To create an index from the output of the function, a modulo can be taken to reduce the size of the domain to match the size of the array; however, it is often faster on many processors to restrict the size of the hash table to powers of two sizes and use a bitmask instead.

An example of both modulo and masking in C:

#include<stdint.h>#include<string.h>intmain(void){constuint32_tNUM_BUCKETS=0xFFFFFFFF;// 2^32 - 1constuint32_tMAX_RECORDS=1<<10;// 2^10constuint32_tHASH_BITMASK=0x3FF;// (2^10)-1char**token_array=NULL;// Handle memory allocation for token_array…chartoken[]="some hashable value";uint32_thashed_token=hash_function(token,strlen(token),NUM_BUCKETS);// Using modulosize_tindex=hashed_token%MAX_RECORDS;// OR// Using bitmasksize_tindex=hashed_token&HASH_BITMASK;*(token_array+index)=token;// Free the memory from token_array …return0;}

• Affinity mask
• Binary-coded decimal
• Bit field
• Bit manipulation
• Bitwise operation
• Subnet
• Tagged pointer
• umask