C 中的 memset 和 (&, >>) 符号

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 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.

Answer 2

(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.