---

Basic_Consumer.cc

Go to the documentation of this file.

// ===================================================================
// Basic_Consumer.cc
// Scott F. H. Kaplan -- sfkaplan@cs.amherst.edu
// October 2002

// A subclass of Consumer that emits a basic page-level reference
// trace with no extra information about shared space or multiple
// processes.  Canonical page numbers are emitted, however, so that
// shared pages are not multiply counted.  The trace takes the
// following form:
//
//   R 14fe3
//
// The first field is the ``type tag'':  A single character, either
// 'R' or 'W', to indicate whether or not the reference is a read or a
// write.  Note that this trace format does not distinguish between
// kernel and user references.  Instruction references are considered
// read operations.
//
// The second field is the page number: A hexidecimal value giving the
// canonical page number being referenced.
// ===================================================================



// ===================================================================
// INCLUDES

#include "Basic_Consumer.hh"
// ===================================================================



// ===================================================================
Basic_Consumer::Basic_Consumer (Reference_Reader* const reference_reader,
        const char* const kernel_pathname,
        const char* const output_file_pathname) :
  Consumer(reference_reader, kernel_pathname) {

  // Open the output file, checking for success.
  output_stream = fopen(output_file_pathname, "w");
  if (output_stream == NULL) {
    perror("Failure opening output file");
    exit(1);
  }

} // Basic_Consumer::Basic_Consumer
// ===================================================================



// ===================================================================
Basic_Consumer::~Basic_Consumer () {

  // Close the output file, checking for success.
  int close_result = fclose(output_stream);
  if (close_result == EOF) {
    perror("Failure closing output file");
    exit(1);
  }

} // Basic_Consumer::~Basic_Consumer
// ===================================================================



// ===================================================================
void
Basic_Consumer::act_on_reference_record () {

  // Convert the input record's tag to a valid output tag.
  tag_t output_tag = 0;
  switch (reference_record->tag) {
    
  case TAG_USER_READ:
  case TAG_KERNEL_READ:
  case TAG_USER_INSTRUCTION_FETCH:
  case TAG_KERNEL_INSTRUCTION_FETCH:

    output_tag = TAG_KERNEL_READ;
    break;

  case TAG_USER_WRITE:
  case TAG_KERNEL_WRITE:

    output_tag = TAG_KERNEL_WRITE;
    break;

  default:
    fprintf(stderr,
      "act_on_reference_record(): Invalid tag %c(%d)\n",
      reference_record->tag,
      (int)reference_record->tag);
    exit(1);

  }

  // If the page referenced is in the kernel's address range, we need
  // to use the kernel's context.
  context_ID_t context_ID;
  if (reference_record->virtual_page.page_ID <
      KERNEL_VIRTUAL_PAGE_OFFSET) {

    context_ID = reference_record->virtual_page.context_ID;

  } else {

    context_ID = KERNEL_CONTEXT;

  }
  Process* process = safe_context_ID_to_process(context_ID);
  virtual_to_canonical_map_t* map = process->virtual_to_canonical_map;

  // Lookup the canonical page ID if one exists.
  bool V2C_mapping_exists;
  canonical_page_ID_t canonical_page_ID;
  lookup_canonical_page_ID(&V2C_mapping_exists,
       &canonical_page_ID,
       map,
       reference_record->virtual_page.page_ID);

  // Emit the new record only if a mapping was found (that is, if this
  // is not a reference to a buffer cache page).
  if (V2C_mapping_exists) {
    fprintf(output_stream, "%c %lx\n", output_tag, canonical_page_ID);
  }

} // act_on_reference_record
// ===================================================================

---