memset and (&, >>) symbols in C - c

Question

I found one project where I can't uderstand one piece of code.Virtual memory
#include <assert.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define TLB_SIZE 16
#define PAGE_SIZE 256
#define FRAME_SIZE 256
#define PHYSICAL_MEMORY_SIZE PAGE_SIZE *FRAME_SIZE
int logicalAddress = 0;
int offsetNumber = 0;
int pageNumber = 0;
int physicalAddress = 0;
int Frame = 0;
int Value = 0;
int Hit = 0;
int tlbIndex = 0;
int tlbSize = 0;
unsigned pageNumberMask = 65280; // 1111111100000000
unsigned offsetMask = 255; // 11111111
int tlbHitCount = 0;
float tlbHitRate = 0;
int addressCount = 0;
int pageFaultCount = 0;
float pageFaultRate = 0;
struct tlbTable {
unsigned int pageNum;
unsigned int frameNum;
};
int main(int argc, char *argv[]) {
// Check to see if user inputs addresses.txt
if (argc != 2) {
fprintf(stderr, "Usage ./VirtualMem_Manager <Filename.txt> \n");
exit(1);
}
// Open addresses.txt, BACKING_STORE.bin, and
// Create Output.txt to store program results
FILE *addresses = fopen(argv[1], "r");
FILE *BACKINGSTORE = fopen("BACKING_STORE.bin", "rb");
FILE *Output = fopen("addressOutput.txt", "w");
int physicalMemory[PHYSICAL_MEMORY_SIZE];
char Buffer[256];
int Index;
// Declare and initialize pageTable[] array to -1
int pageTable[PAGE_SIZE];
memset(pageTable, -1, 256 * sizeof(int));
// Declare and initialize tlb[] structure to -1
struct tlbTable tlb[TLB_SIZE];
memset(pageTable, -1, 16 * sizeof(char));
// Read each address from addresses.txt
while (fscanf(addresses, "%d", &logicalAddress) == 1) {
addressCount++;
// set the page number and offset for each logical address
pageNumber = logicalAddress & pageNumberMask;
pageNumber = pageNumber >> 8;
offsetNumber = logicalAddress & offsetMask;
Hit = -1;
// Check to see if the page number is already in the tlb
// If it is in tlb, then it is tlb hit
for (Index = 0; Index < tlbSize; Index++) {
if (tlb[Index].pageNum == pageNumber) {
Hit = tlb[Index].frameNum;
physicalAddress = Hit * 256 + offsetNumber;
}
}
if (!(Hit == -1)) {
tlbHitCount++;
}
// This "else if" loop is the tlb miss
// Gets the physical page number from page table
else if (pageTable[pageNumber] == -1) {
fseek(BACKINGSTORE, pageNumber * 256, SEEK_SET);
fread(Buffer, sizeof(char), 256, BACKINGSTORE);
pageTable[pageNumber] = Frame;
for (Index = 0; Index < 256; Index++) {
physicalMemory[Frame * 256 + Index] = Buffer[Index];
}
pageFaultCount++;
Frame++;
// FIFO algorithm for the tlb
if (tlbSize == 16) tlbSize--;
for (tlbIndex = tlbSize; tlbIndex > 0; tlbIndex--) {
tlb[tlbIndex].pageNum = tlb[tlbIndex - 1].pageNum;
tlb[tlbIndex].frameNum = tlb[tlbIndex - 1].frameNum;
}
if (tlbSize <= 15) tlbSize++;
tlb[0].pageNum = pageNumber;
tlb[0].frameNum = pageTable[pageNumber];
physicalAddress = pageTable[pageNumber] * 256 + offsetNumber;
} else {
physicalAddress = pageTable[pageNumber] * 256 + offsetNumber;
}
// Gets the value from the bin file provided
Value = physicalMemory[physicalAddress];
// print the addresses and value to Output.txt
fprintf(Output, "Virtual Address: %d Physical Address: %d Value: %d \n",
logicalAddress, physicalAddress, Value);
}
// The statistics of the program
pageFaultRate = pageFaultCount * 1.0f / addressCount;
tlbHitRate = tlbHitCount * 1.0f / addressCount;
// Close files provided for the project
fclose(addresses);
fclose(BACKINGSTORE);
// Print the statistics of the program to Output.txt
fprintf(Output, "Number of Addresses: %d\n", addressCount);
fprintf(Output, "Number of Page Faults: %d\n", pageFaultCount);
fprintf(Output, "Page Fault Rate: %f\n", pageFaultRate);
fprintf(Output, "TLB Hits: %d\n", tlbHitCount);
fprintf(Output, "TLB Hit Rate %f\n", tlbHitRate);
// Close Output.txt
fclose(Output);
return 0;
}
I can't understand these three lines.
pageNumber = logicalAddress & pageNumberMask;
pageNumber = pageNumber >> 8;
offsetNumber = logicalAddress & offsetMask;
As I understand papeNumber is value where logicalAddress and pageNuberMask a stored together. And this char & join them. Then we do offset on 8(>> 8).
And why is using memset dangerous.

Answer 1

(For purposes of illustration, this answer assumes the addresses are 32 bits, which appears to be consistent with the code in the question.)
pageNumber = logicalAddress & pageNumberMask;
pageNumber = pageNumber >> 8;
offsetNumber = logicalAddress & offsetMask;
The logical address is partitioned into three sets of bits: 16 upper bits that are ignored in this code, 8 bits used for a page number, and 8 lower bits that are used for an offset within a page.
pageNumberMask is a value that has been prepared to have 1s in the page number bits and 0s elsewhere. Then the operation logicalAddress & pageNumberMask performs a bitwise AND, which produces a value in which the only bits set are those that were set in the page number bits of logicalAddress. In other words, it produces a value in which the upper bits and the offset bits are cleared, effectively isolating the page number bits.
Then pageNumber >> 8 shifts those page number bits down to the low bits, so the result is a page number. That page number can then be used to index arrays.
Similarly, offsetMask is a prepared value with 1s in the offset bits and 0s elsewhere, and logicalAddress & offsetMask extracts just the offset bits.
Note that logicalAddress & pageNumberMask serves a purpose only if bits above the page number bits might be set. This is because pageNumber >> 8 removes the lower bits anyway, so there is no point in clearing them with an & operation. So this code separates the page number bits from the upper bits but makes no use of those upper bits. This might be because it is a simplified example for teaching, and actual code for deployment would make use of the upper bits.
And why is using memset dangerous.
memset is a powerful routine that is easy to use incorrectly. Given incorrect arguments, it will modify any accessible memory, and the compiler often cannot detect that it has been used incorrectly, so it cannot provide a warning or error message.
Defects in the Code
The code in the question has a number of defects, so it is not a great example for teaching:
struct tlbTable tlb[TLB_SIZE]; followed by memset(pageTable, -1, 16*sizeof(char)); looks like a bug. pageTable was initialized previously, and this was probably intended to initialize tlb. And the size is wrong; tlb has 16 elements (TLB_SIZE is 16), and each is several bytes. That line should probably be memset(tlb, -1, sizeof tlb);, and the previous memset should be memset(pageTable, -1, sizeof pageTable);.
Preprocessor macros are defined for various parameters, such as 256 for PAGE_SIZE, but then parts of the code ignore these and use hard-coded constants, as in Frame*256 + Index. This is a recipe for bugs.

Answer 2

For performance and memory reasons pageNumber and offset in the page are stored in single unsigned value.
I will use c++14 bit representation with 0b prefix in comments to explain.
unsigned logicalAddress = someValue; // <- 0bPPPPPPPPFFFFFFFF
where P denotes bits for pageNumber and F bits for offsetNumber;
pageNumber = logicalAddress & pageNumberMask; // <- 0bPPPPPPPP00000000
pageNumber = pageNumber >> 8; // <- 0bPPPPPPPP
offsetNumber = logicalAddress & offsetMask; // <- 0bFFFFFFFF
About memset using it is not dangerous if used correctly.