Nachos内存管理实现
存储器管理包括两个层次的内容：分别是内存管理和文件系统管理。
每个用户进程都是自己的地址空间。当进程运行时它们都会被加载到内存中。
接下来我们仍使用Nachos源代码来讲述地址空间是怎样实现在Nachos模拟的物理内存上实现的。
为了运行一个程序，需要执行一下三步：
1：编译器将各个模块的源代码编译成对应的目标代码模块。
2：连接器将各个目标代码模块链接到一起，形成一个可执行文件。
3：加载器将可执行文件加载到内存中。
每一个目标模块都有自己的代码段，已初始化段，符号表和重定位信息。链接器的任务就是通过在各个模块中符号的交叉引用，将各个目标模块合并成一个模块。
可执行文件中存储的地址是逻辑地址。在程序运行前逻辑地址需要被转换成物理地址。这个转换操作是通过一个叫做MMU的硬件设备执行的。系统可以将模块加载到内存的不同的位置，这可以由重定位寄存器实现。
Nachos中使用machine类对象来模拟运行程序的机器环境。
// machine.h
// Data structures for simulating the execution of user programs
// running on top of Nachos.
//
// User programs are loaded into "mainMemory"; to Nachos,
// this looks just like an array of bytes. Of course, the Nachos
// kernel is in memory too -- but as in most machines these days,
// the kernel is loaded into a separate memory region from user
// programs, and accesses to kernel memory are not translated or paged.
//
// In Nachos, user programs are executed one instruction at a time,
// by the simulator. Each memory reference is translated, checked
// for errors, etc.
//
// DO NOT CHANGE EXCEPT AS NOTED BELOW -- part of the machine emulation
//
// Copyright (c) 1992-1996 The Regents of the University of California.
// All rights reserved. See copyright.h for copyright notice and limitation
// of liability and disclaimer of warranty provisions.
#ifndef MACHINE_H
#define MACHINE_H
#include "copyright.h"
#include "utility.h"
#include "translate.h"
// Definitions related to the size, and format of user memory
const int PageSize = 128; // set the page size equal to
// the disk sector size, for simplicity
//
// You are allowed to change this value.
// Doing so will change the number of pages of physical memory
// available on the simulated machine.
//
const int NumPhysPages = 128;
const int MemorySize = (NumPhysPages * PageSize);
const int TLBSize = 4; // if there is a TLB, make it small
enum ExceptionType { NoException, // Everything ok!
SyscallException, // A program executed a system call.
PageFaultException, // No valid translation found
ReadOnlyException, // Write attempted to page marked
// "read-only"
BusErrorException, // Translation resulted in an
// invalid physical address
AddressErrorException, // Unaligned reference or one that
// was beyond the end of the
// address space
OverflowException, // Integer overflow in add or sub.
IllegalInstrException, // Unimplemented or reserved instr.
NumExceptionTypes
};
// User program CPU state. The full set of MIPS registers, plus a few
// more because we need to be able to start/stop a user program between
// any two instructions (thus we need to keep track of things like load
// delay slots, etc.)
#define StackReg 29 // User's stack pointer
#define RetAddrReg 31 // Holds return address for procedure calls
#define NumGPRegs 32 // 32 general purpose registers on MIPS
#define HiReg 32 // Double register to hold multiply result
#define LoReg 33
#define PCReg 34 // Current program counter
#define NextPCReg 35 // Next program counter (for branch delay)
#define PrevPCReg 36 // Previous program counter (for debugging)
#define LoadReg 37 // The register target of a delayed load.
#define LoadValueReg 38 // The value to be loaded by a delayed load.
#define BadVAddrReg 39 // The failing virtual address on an exception
#define NumTotalRegs 40
// The following class defines the simulated host workstation hardware, as
// seen by user programs -- the CPU registers, main memory, etc.
// User programs shouldn't be able to tell that they are running on our
// simulator or on the real hardware, except
// we don't support floating point instructions
// the system call interface to Nachos is not the same as UNIX
// (10 system calls in Nachos vs. 200 in UNIX!)
// If we were to implement more of the UNIX system calls, we ought to be
// able to run Nachos on top of Nachos!
//
// The procedures in this class are defined in machine.cc, mipssim.cc, and
// translate.cc.
class Instruction;
class Interrupt;
class Machine {
public:
Machine(bool debug); // Initialize the simulation of the hardware
// for running user programs
~Machine(); // De-allocate the data structures
// Routines callable by the Nachos kernel
void Run(); // Run a user program
int ReadRegister(int num); // read the contents of a CPU register
void WriteRegister(int num, int value);
// store a value into a CPU register
// Data structures accessible to the Nachos kernel -- main memory and the
// page table/TLB.
//
// Note that *all* communication between the user program and the kernel
// are in terms of these data structures (plus the CPU registers).
char *mainMemory; // physical memory to store user program,
// code and data, while executing
// NOTE: the hardware translation of virtual addresses in the user program
// to physical addresses (relative to the beginning of "mainMemory")
// can be controlled by one of:
// a traditional linear page table
// a software-loaded translation lookaside buffer (tlb) -- a cache of
// mappings of virtual page #'s to physical page #'s
//
// If "tlb" is NULL, the linear page table is used
// If "tlb" is non-NULL, the Nachos kernel is responsible for managing
// the contents of the TLB. But the kernel can use any data structure
// it wants (eg, segmented paging) for handling TLB cache misses.
//
// For simplicity, both the page table pointer and the TLB pointer are
// public. However, while there can be multiple page tables (one per address
// space, stored in memory), there is only one TLB (implemented in hardware).
// Thus the TLB pointer should be considered as *read-only*, although
// the contents of the TLB are free to be modified by the kernel software.
TranslationEntry *tlb; // this pointer should be considered
// "read-only" to Nachos kernel code
TranslationEntry *pageTable;
unsigned int pageTableSize;
bool ReadMem(int addr, int size, int* value);
bool WriteMem(int addr, int size, int value);
// Read or write 1, 2, or 4 bytes of virtual
// memory (at addr). Return FALSE if a
// correct translation couldn't be found.
private:
// Routines internal to the machine simulation -- DO NOT call these directly
void DelayedLoad(int nextReg, int nextVal);
// Do a pending delayed load (modifying a reg)
void OneInstruction(Instruction *instr);
// Run one instruction of a user program.
ExceptionType Translate(int virtAddr, int* physAddr, int size,bool writing);
// Translate an address, and check for
// alignment. Set the use and dirty bits in
// the translation entry appropriately,
// and return an exception code if the
// translation couldn't be completed.
void RaiseException(ExceptionType which, int badVAddr);
// Trap to the Nachos kernel, because of a
// system call or other exception.
void Debugger(); // invoke the user program debugger
void DumpState(); // print the user CPU and memory state
// Internal data structures
int registers[NumTotalRegs]; // CPU registers, for executing user programs
bool singleStep; // drop back into the debugger after each
// simulated instruction
int runUntilTime; // drop back into the debugger when simulated
// time reaches this value
friend class Interrupt; // calls DelayedLoad()
};
extern void ExceptionHandler(ExceptionType which);
// Entry point into Nachos for handling
// user system calls and exceptions
// Defined in exception.cc
// Routines for converting Words and Short Words to and from the
// simulated machine's format of little endian. If the host machine
// is little endian (DEC and Intel), these end up being NOPs.
//
// What is stored in each format:
// host byte ordering:
// kernel data structures
// user registers
// simulated machine byte ordering:
// contents of main memory
unsigned int WordToHost(unsigned int word);
unsigned short ShortToHost(unsigned short shortword);
unsigned int WordToMachine(unsigned int word);
unsigned short ShortToMachine(unsigned short shortword);
#endif // MACHINE_H
machine类的主要的成员包括：
用户寄存器：intregisters[NumTotalRegs]
主存：char*MainMemory;
当前进程页表：TranslationEntry*pageTable;
tlb（快表）：TranslationEntry*tlb;
机器操作有以下函数模拟：
内存读写：
boolReadMem(intaddr,intsize,int*value);
boolWriteMem(intaddr,intsize,intvalue);
寄存器读写：
intReadRegister(intnum);//readthecontentsofaCPUregister
voidWriteRegister(intnum,intvalue);
指令解析：
voidRun();//Runauserprogram
voidOneInstruction(Instruction*instr);//Runoneinstructionofauserprogram.
异常处理：
ExceptionTypeTranslate(intvirtAddr,int*physAddr,intsize,boolwriting);
run（）函数将机器设置成用户模式，并开始一个循环，不停的模拟执行cpu的取指和执行指令的操作。
class Instruction {
public:
void Decode(); // decode the binary representation of the instruction
unsigned int value; // binary representation of the instruction
char opCode; // Type of instruction. This is NOT the same as the
// opcode field from the instruction: see defs in mips.h
char rs, rt, rd; // Three registers from instruction.
int extra; // Immediate or target or shamt field or offset.
// Immediates are sign-extended.
};
//----------------------------------------------------------------------
// Machine::Run
// Simulate the execution of a user-level program on Nachos.
// Called by the kernel when the program starts up; never returns.
//
// This routine is re-entrant, in that it can be called multiple
// times concurrently -- one for each thread executing user code.
//----------------------------------------------------------------------
void
Machine::Run()
{
Instruction *instr = new Instruction; // storage for decoded instruction
if (debug->IsEnabled('m')) {
cout << "Starting program in thread: " << kernel->currentThread->getName();
cout << ", at time: " << kernel->stats->totalTicks << "\n";
}
kernel->interrupt->setStatus(UserMode);
for (;;) {
OneInstruction(instr);
kernel->interrupt->OneTick();
if (singleStep && (runUntilTime <= kernel->stats->totalTicks))
Debugger();
}
}OneInstruction函数用于模拟一次取指和执行该指令的操作。
93 void
94 Machine::OneInstruction(Instruction *instr)
95 {
96 int raw;
97 int nextLoadReg = 0;
98 int nextLoadValue = 0; // record delayed load operation, to apply
99 // in the future
100
101 // Fetch instruction
102 if (!machine->ReadMem(registers[PCReg], 4, &raw))
103 return; // exception occurred
104 instr->value = raw;
105 instr->Decode();
106
...
122 // Execute the instruction (cf. Kane’s book)
123 switch (instr->opCode) {
124
125 case OP_ADD:
...
547 case OP_UNIMP:
548 RaiseException(IllegalInstrException, 0);
549 return;
550
551 default:
552 ASSERT(FALSE);
553 }
554
555 // Now we have successfully executed the instruction.
556
557 // Do any delayed load operation
558 DelayedLoad(nextLoadReg, nextLoadValue);
559
560 // Advance program counters.
561 registers[PrevPCReg] = registers[PCReg]; // for debugging, in case we
562 // are jumping into lala-land
563 registers[PCReg] = registers[NextPCReg];
564 registers[NextPCReg] = pcAfter;
565 }
用户进程的地址空间是以类AddrSpace对象的方式定义的。每个地址空间对象都有一个指向页表的pageTable指针成员。
Nachos的页表是TranslationEntry类型的数组。
TranslationEntry类型定义如下：
30 class TranslationEntry {
31 public:
32 int virtualPage; // The page number in virtual memory.
33 int physicalPage; // The page number in real memory (relative to the
34 // start of "mainMemory"
35 bool valid; // If this bit is set, the translation is ignored.
36 // (In other words, the entry hasn’t been initialized.)
37 bool readOnly; // If this bit is set, the user program is not allowed
38 // to modify the contents of the page.
39 bool use; // This bit is set by the hardware every time the
40 // page is referenced or modified.
41 bool dirty; // This bit is set by the hardware every time the
42 // page is modified.
43 };
AddrSpace类的构造函数负责创建地址空间。构造函数的参数一个可执行文件。
该函数首先判断文件是否是NOFF文件。接着计算地址空间大小。
// how big is address space?
72 size = noffH.code.size + noffH.initData.size + noffH.uninitData.size
73 + UserStackSize;
然后计算页面数。计算完之后分配页表，并初始化页表项。
page Table = new TranslationEntry[numPages];
87 for (i = 0; i < numPages; i++) {
88 pageTable[i].virtualPage = i; // for now, virtual page # = phys page #
89 pageTable[i].physicalPage = i;
90 pageTable[i].valid = TRUE;
91 pageTable[i].use = FALSE;
92 pageTable[i].dirty = FALSE;
93 pageTable[i].readOnly = FALSE; // if the code segment was entirely on
94 // a separate page, we could set its
95 // pages to be read-only
96 }
此处的初始化页面号等于页框号。
再往后就是将可执行文件的代码段和已初始化数据段复制到内存中。
// then, copy in the code and data segments into memory
103 if (noffH.code.size > 0) {
104 DEBUG(’a’, "Initializing code segment, at 0x%x, size %d\n",
105 noffH.code.virtualAddr, noffH.code.size);
106 executable->ReadAt(&(machine->mainMemory[noffH.code.virtualAddr]),
107 noffH.code.size, noffH.code.inFileAddr);
108 }
109 if (noffH.initData.size > 0) {
110 DEBUG(’a’, "Initializing data segment, at 0x%x, size %d\n",
111 noffH.initData.virtualAddr, noffH.initData.size);
112 executable->ReadAt(&(machine->mainMemory[noffH.initData.virtualAddr]),
113 noffH.initData.size, noffH.initData.inFileAddr);
59
114 }
115
前面介绍了用户程序是怎样加载到物理内存以及如何创建地址空间。但是地址空间中都是包含的逻辑地址。还涉及到将逻辑地址转换成物理地址。系统提供了两种转换方法的接口：线性页面地址转换方法和TLB页
面地址转换方法。在实际的系统中，线性页面地址转换和TLB页面地址转换只能二者取一，目前为简便起见，
Nachos选择了前者，读者可以自行完成TLB页面地址转换的实现。地址转换操作是通过Machine::Translate函数实现的。
该函数首先检查了逻辑地址是否已经对齐。
然后计算虚拟地址所在的页面以及页面偏移。
// calculate the virtual page number, and offset within the page,
207 // from the virtual address
208 vpn = (unsigned) virtAddr / PageSize;
209 offset = (unsigned) virtAddr % PageSize;
得到页面和页面偏移就需要在页表中查找它们所在的物理页框号。
如果采用的是TLB转换表，查找TLB表,搜索成功之后获得页表项的指针，取出对应的物理页框号。计算出物理地址：
*physAddr = pageFrame * PageSize + offset;
StartProcess是一个测试函数。它创建一个用户线程，展示了如何使用AddrSpace和Machine类：
23 void
24 StartProcess(char *filename)
25 {
26 OpenFile *executable = fileSystem->Open(filename);
27 AddrSpace *space;
28
29 if (executable == NULL) {
30 printf("Unable to open file %s\n", filename);
31 return;
32 }
33 space = new AddrSpace(executable);
34 currentThread->space = space;
35
36 delete executable; // close file
37
38 space->InitRegisters(); // set the initial register values
39 space->RestoreState(); // load page table register
40
41 machine->Run(); // jump to the user progam
42 ASSERT(FALSE); // machine->Run never returns;
43 // the address space exits
44 // by doing the syscall "exit"
45 }
其实在Nachos提供的源代码中包含了详细的注释，要弄懂Nachos需要不断查阅源代码才行！！
以上参考自《Nachos study book》如有纰漏，请不吝赐教！
2013.1.2于山西大同
扫一扫
1072
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
