To keep things simple, the program loader hangs all programs on the ready queue before running any of them. Because the program loader runs to completion and stops, there's no longer any need for the done() predicate and poke() procedure in the interface; only the init() procedure remains as the program loader's interface.

There is, however, another reason besides simplicity for delaying program execution until all programs have been loaded. Because the paging area follows the programs on disk, the page manager can't be initialized until the total size of the programs are known.

Keeping track of a program on disk involves recording its starting block and the number of blocks it occupies, something for which a pair of unsigneds is well suited. Keeping track of all such programs on the disk is easiest done with a vector of such pairs.

<program loader data structures>= (U->)

typedef std::pair<unsigned, unsigned> program_info;
static std::vector<program_info> program_list;

Defines program_info, program_list (links are to index).

<program loader macros>= (U->)

const address pl_buffer = usr_base;

#define do_disk_read() \
   disk_dvr::request(device::read, next_block_to_read, pl_buffer, get_block, 0)

Defines do_disk_read, pl_buffer (links are to index).

<program loader procedures>= (U->)

static void start_program(program_info pi) {
  process::add(pi.first, pi.second);
  }

static void get_block(status::responses r, void *) {

  if (r != status::ok)
    panic("disk read error %R in program_loader::get_block()", r);

  word psize;
  fetch_mem(pl_buffer, psize, handle_first_block);
  if (static_cast<unsigned>(psize) > disk_size)
    panic("invalid program size %d in handle_first_block()", psize);

  if (psize != 0) {
    program_list.push_back(std::make_pair(next_block_to_read, psize));
    next_block_to_read += psize;
    }

  if ((psize != 0) && (next_block_to_read < disk_size))
    do_disk_read();
  else {
   page_mgr::initialize(next_block_to_read);

   std::for_each(program_list.begin(), program_list.end(), start_program);

   if (process::done())
     process::halt();
    }
  }

Defines get_block, start_program (links are to index).

<program loader interface procedures>= (U->)

void init(void) {
  next_block_to_read = 0;
  do_disk_read();
  }

Defines program_loader::init (links are to index).

There are a couple of ways the disk manager can implement the physical-virtual address translation, but the easiest way is to assign a one-block disk buffer to the disk manager. The disk manager does all disk I-O to and from the its buffer, and does virtual-physical address translation when copying data between its (physical address) buffer and the process's (virtual) address space.

There's plenty of free device space available, so allocate a one-block buffer there.

<os buffer definitions>= (U->)

const address dm_buffer = dev_top - disk_block_size;

Defines dm_buffer (links are to index).

The disk manager also has to keep a queue of disk I-O requests because the buffer is a serially reusable resource available to only one process at a time (this is the source of the bottleneck). Also, the need to copy between the buffer and the process essentially doubles the I-O time.

The interface presented by the disk manager is unchanged; only the internals need to be changed to accommodate virtual memory.

The disk manager needs to be able to queue up requests and issue them one at a time when the buffer is available.

<disk manager data structures>= (U->)

struct req {

  req(device::operations d, address l, unsigned b, process::id p)
    : dop(d), loc(l), bno(b), pid(p) { 
    }

  const device::operations dop;
  const address loc;
  const unsigned bno;
  const process::id pid;
  };

static std::queue<req> pending;

Defines pending, req (links are to index).

<disk manager procedures>= (U->) [D->]

static void poke(void) {

  if (in_progress || pending.empty()) return;
  
  const req & r = pending.front();
  in_progress = true;

  if (r.dop == device::write)
    write_dm_buffer(0);
  else if (r.dop == device::read)
    disk_dvr::request(device::read, r.bno, dm_buffer, read_buffer_cb, 0);
  else
    panic("impossible occurrence in disk-mgr::poke()");
  }

Defines poke (links are to index).

<disk manager procedures>+= (U->) [<-D->]

static void next_disk_request(void) {
  pending.pop();
  in_progress = false;
  poke();
  }

Defines next_disk_request (links are to index).

1. Copy the data to write from the process to the buffer.

2. Write the buffer to the disk.

The second step is easy, involving a call to disk_dvr::request(). The first step is more complicated, because it may involving paging.

A disk block is the same size as a page (what a coincidence!), so the data block to write may be split across at most two pages, which means the copy to the buffer may require at most two page-ins. When copying the data, the disk manager has to first check each virtual address to make sure it's resident in primary store, and page it in if it's not.

The analysis given in the previous paragraph is a bit simple minded because it's only necessary to check at most two addresses: the address at the start of the data block and the address on the other side of the page boundary crossed by the data block (if it doesn't fit all in one page). However, exploiting this fact complicates the code, so it will be ignored in what follows.

write_dm_buffer() is responsible for performing a disk write; it also is the call-back for the page manager on page ins. The pass-along argument is the offset into the data block being written; the rest of the arguments are kept at the head of the pending queue. Once the data block has been copied to the buffer, the actual disk write can begin, and the disk write request is wrapped-up by write_buffer_cb().

<disk manager procedures>+= (U->) [<-D->]

static void write_dm_buffer(void * arg) {
  
  unsigned offset = reinterpret_cast<unsigned>(arg);
  const req & r = pending.front();

  while (offset < disk_block_size) {
    address pa;
    if (!(mass.memory->va2pa(r.pid, r.loc + offset, pa, 'r'))) {
      page_mgr::page_in(r.pid, (address) (r.loc + offset), write_dm_buffer, 
                        reinterpret_cast<void *>(offset));
      return;
      }

    word w;
    fetch_mem(pa, w, write_dm_buffer);
    store_mem(dm_buffer + offset, w, write_dm_buffer);

    offset++;
    }

  disk_dvr::request(device::write, r.bno, dm_buffer, write_buffer_cb, 0);
  }

Defines write_dm_buffer (links are to index).

<disk manager procedures>+= (U->) [<-D->]

static void write_buffer_cb(status::responses s, void *) {
  
  assert(!pending.empty());
  const process::id pid = pending.front().pid;

  process::put_register(pid, 0, s);
  process::ready(pid);

  next_disk_request();
  }

Defines write_buffer_cb (links are to index).

<disk manager procedures>+= (U->) [<-D->]

static void read_dm_buffer(void * arg) {
  
  unsigned offset = reinterpret_cast<unsigned>(arg);
  assert(!pending.empty());
  const req & r = pending.front();

  while (offset < disk_block_size) {
    address pa;
    if (!(mass.memory->va2pa(r.pid, r.loc + offset, pa, 'w'))) {
      page_mgr::page_in(r.pid, (address) (r.loc + offset), read_dm_buffer, 
                        reinterpret_cast<void *>(offset));
      return;
      }

    word w;
    fetch_mem(dm_buffer + offset, w, read_dm_buffer);
    store_mem(pa, w, read_dm_buffer);

    offset++;
    }

  process::ready(r.pid);
  process::put_register(r.pid, 1, r.bno);

  next_disk_request();
  }

Defines read_dm_buffer (links are to index).

<disk manager procedures>+= (U->) [<-D]

static void read_buffer_cb(status::responses s, void *) {

  assert(!pending.empty());
  const req & r = pending.front();

  process::put_register(r.pid, 0, s);
  if (s != status::ok) {
    process::ready(r.pid);
    next_disk_request();
    }
  else
    read_dm_buffer(0);

  }

Defines read_buffer_cb (links are to index).

<disk manager interface procedures>= (U->)

void operation(
  system_call::system_calls op, word dev_id, address loc, unsigned n) {

  assert(is_valid_id(dev_id));
  assert((op == system_call::read) || (op == system_call::write));

  if (!legal_range(loc, disk_block_size)) {
    store_mem(0, status::bad_address, disk_mgr::operation);
    return;
    }

  pending.push(req((op == system_call::read ? device::read : device::write),
                   loc, n, process::block()));
  poke();
  }

Defines disk_mgr::operation (links are to index).

Unlike the disk, from which a process can only read a fixed-sized data block, the terminal can supply a process with an arbitrarily long sequence of words. This complicates buffering. On the other hand, also unlike the disk, data come from the terminal a word at a time, which, assuming you're not interested in high performance, simplifies buffering.

The interface presented to by the terminal manager is unchanged.

The terminal manager now needs to deal with call-backs from the page manager in addition to interrupts from the terminal. It seems a wise design decision to devote a procedure to handle each. The write-interrupt handler, for example, look as it did before, except the actual character handling code has been moved to character_from_process(), which also handles the page-manager call-back.

<terminal manager procedures>= (U->) [D->]

static void write_terminal_ih(void) {

  check_tty(write_terminal_ih);

  if (request_chcnt > 0)
    character_from_process(0);
  else
    wake_up_process();
  }

Defines write_terminal_ih (links are to index).

<terminal manager procedures>+= (U->) [<-D->]

static void character_from_process(void *) {

  address pa;

  assert(request_chcnt > 0);

  if (!(mass.memory->va2pa(tty_proc, request_chaddr, pa, 'r')))
    page_mgr::page_in(tty_proc, request_chaddr, character_from_process, 0);
  else {
    word w;

    fetch_char(pa, w, character_from_process);
    store_mem(terminal_data_register, w, character_from_process);
    tty_op(write, character_from_process);

    request_chaddr++;
    request_result_cnt++;
    request_chcnt--;
    }
  }

Defines character_from_process (links are to index).

<terminal manager procedures>+= (U->) [<-D->]

static void read_terminal_ih(void) {

  check_tty(read_terminal_ih);

  word w;
  fetch_mem(terminal_data_register, w, read_terminal_ih);

  if (w == device::eof_char)
    wake_up_process();
  else 
    character_to_process(reinterpret_cast<void *>(w));
  }

Defines read_terminal_ih (links are to index).

<terminal manager procedures>+= (U->) [<-D]

static void character_to_process(void * arg) {

  address pa;

  if (!(mass.memory->va2pa(tty_proc, request_chaddr, pa, 'w')))
    page_mgr::page_in(tty_proc, request_chaddr, character_to_process, arg);
  else {
    word w = reinterpret_cast<word>(arg);

    store_char(pa, w, character_to_process);
    request_chaddr++;
    request_chcnt--;
    request_result_cnt++;

    if (request_chcnt == 0)
      wake_up_process();
    else
      tty_op(read, character_to_process);
    }
  }

Defines character_to_process (links are to index).

When a process throws a bad (virtual) address, it could be because the address is outside the range of legal addresses for the process, or because the address isn't resident in physical storage. In the latter case, schedule a page in for the address; end the process in the former case.

<interrupt handlers>= (U->) [D->]

static void badaddr_ih(void) {

  word w;
  fetch_mem(ia_register, w, badaddr_ih);

  if (legal_range(w, 1)) {
    const process::id pid = process::block();
    page_mgr::page_in(pid, (address) w, 
                      page_fault_cb, 
                      reinterpret_cast<void *>(pid));
    }
  else 
    process::exit();
  }  

Defines badaddr_ih (links are to index).

<interrupt handlers>+= (U->) [<-D]

static void page_fault_cb(void * arg) {
  process::ready(reinterpret_cast<process::id>(arg));
  }

Defines page_fault_cb (links are to index).

A new process is defined by its starting location on the disk and the number of disk blocks it occupies.

<process manager interface declarations>= (U->) [D->]

void add(unsigned bno, unsigned size);

<process manager interface declarations>+= (U->) [<-D]

unsigned get_page_block(id pid, unsigned pno);
void put_page_block(id pid, unsigned pno, unsigned dbn);

<process manager data structures>= (U->)

struct process_table_entry {

  static process::id next_id;
  
  const process::id     id;
  process_status        status;
  word                  registers[next_register];
  std::vector<unsigned> page_map;

  process_table_entry(unsigned bno, unsigned size) 
   : id(next_id++), 
     page_map(std::vector<unsigned>(size)) 
   { 
    assert((size > 0) && (bno + size <= disk_size));

    for (unsigned i = 0; i < size; i++)
      page_map[i] = bno + i;
    }

  void save_state(void) {
    for (address a = 0; a < next_register; a++)
      fetch_mem(a, registers[a], save_state);
    }

  void restore_state(void) const {
    for (address a = 0; a < next_register; a++)
      store_mem(a, registers[a], restore_state);
    }
  };

Defines process_table_entry (links are to index).

<process manager interface procedures>= (U->) [D->]

unsigned get_page_block(id pid, unsigned pno) {
  ptab_iter pti = find_proc(pid);
  assert(pno < pti->page_map.size());
  return pti->page_map[pno];
  }

void put_page_block(id pid, unsigned pno, unsigned dbn) {
  ptab_iter pti = find_proc(pid);
  assert((pno < pti->page_map.size()) && (dbn < disk_size));
  pti->page_map[pno] = dbn;
  }

Defines process::get_page_block, process::put_page_block (links are to index).

<process manager interface procedures>+= (U->) [<-D->]

void add(unsigned bno, unsigned size) {

  process_table_entry new_pte(bno, size);

  new_pte.registers[base_register] = vmem_base;
  new_pte.registers[top_register] = 
    vmem_base + size*disk_block_size;
  new_pte.registers[pc_register] = vmem_base + 1;

  new_pte.registers[sw_register] = 0;
  put_swr_field(new_pte.registers[sw_register], vmem, 1);
  put_swr_field(new_pte.registers[sw_register], pid, new_pte.id);

  ptab.push_front(new_pte);

  debugp(dbp_execute, "At time %4d, process %d created.\n", 
         read_clock(), new_pte.id);

  ready(new_pte.id);
  }

Defines process::add (links are to index).

<process manager interface procedures>+= (U->) [<-D]

void exit(void) {

  debugp(dbp_execute, "At time %4d, process %d exits.\n", 
         read_clock(), running_process->id);

  page_mgr::clear_process(running_process->id);
  ptab.erase(running_process);

  poke();
  }

Defines process::exit (links are to index).