109 lines
4.2 KiB
C
109 lines
4.2 KiB
C
|
/*
|
||
|
|
File: simple_frame_pool.H
|
||
|
|
|
||
|
|
Author: R. Bettati
|
||
|
|
Department of Computer Science
|
||
|
|
Texas A&M University
|
||
|
|
Date : 12/09/03
|
||
|
|
|
||
|
|
Description: Management of the non-contiguous Free-Frame Pool.
|
||
|
|
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef _FRAME_POOL_H_ // include file only once
|
||
|
|
#define _FRAME_POOL_H_
|
||
|
|
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
/* DEFINES */
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/* -- (none) -- */
|
||
|
|
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
/* INCLUDES */
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
#include "machine.H"
|
||
|
|
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
/* DATA STRUCTURES */
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
/* -- (none) -- */
|
||
|
|
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
/* S i m p l e F r a m e P o o l */
|
||
|
|
/*--------------------------------------------------------------------------*/
|
||
|
|
|
||
|
|
class SimpleFramePool {
|
||
|
|
|
||
|
|
private:
|
||
|
|
/* -- DEFINE YOUR FRAME POOL DATA STRUCTURE(s) HERE. */
|
||
|
|
|
||
|
|
|
||
|
|
unsigned char * bitmap; // We implement the simple frame pool with a bitmap
|
||
|
|
unsigned int nFreeFrames; //
|
||
|
|
unsigned long base_frame_no; // Where does the frame pool start in phys mem?
|
||
|
|
unsigned long nframes; // Size of the frame pool
|
||
|
|
unsigned long info_frame_no; // Where do we store the management information?
|
||
|
|
|
||
|
|
void mark_inaccessible(unsigned long _frame_no);
|
||
|
|
|
||
|
|
public:
|
||
|
|
|
||
|
|
static const unsigned int FRAME_SIZE = Machine::PAGE_SIZE;
|
||
|
|
|
||
|
|
SimpleFramePool(unsigned long _base_frame_no,
|
||
|
|
unsigned long _nframes,
|
||
|
|
unsigned long _info_frame_no);
|
||
|
|
/* Initializes the data structures needed for the management of this
|
||
|
|
frame pool. This function must be called before the paging system
|
||
|
|
is initialized.
|
||
|
|
_base_frame_no is the frame number at the start of the physical memory
|
||
|
|
region that this frame pool manages.
|
||
|
|
_nframes is the number of frames in the physical memory region that this
|
||
|
|
frame pool manages.
|
||
|
|
e.g. If _base_frame_no is 16 and _nframes is 4, this frame pool manages
|
||
|
|
physical frames numbered 16, 17, 18 and 19
|
||
|
|
_info_frame_no is the frame number (within the directly mapped region) of
|
||
|
|
the frame that should be used to store the management information of the
|
||
|
|
frame pool. However, if _info_frame_no is 0, the frame pool is free to
|
||
|
|
choose any frame from the pool to store management information.
|
||
|
|
*/
|
||
|
|
|
||
|
|
unsigned long get_frame();
|
||
|
|
/* Allocates a frame from the frame pool. If successful, returns the frame
|
||
|
|
* number of the frame. If fails, returns 0. */
|
||
|
|
|
||
|
|
void mark_inaccessible(unsigned long _base_frame_no,
|
||
|
|
unsigned long _nframes);
|
||
|
|
/* Mark the area of physical memory as inaccessible. The arguments have the
|
||
|
|
* same semanticas as in the constructor.
|
||
|
|
*/
|
||
|
|
|
||
|
|
static void release_frame(unsigned long _frame_no);
|
||
|
|
/* Releases frame back to the given frame pool.
|
||
|
|
The frame is identified by the frame number.
|
||
|
|
NOTE: This function is static because there may be more than one frame pool
|
||
|
|
defined in the system, and it is unclear which one this frame belongs to.
|
||
|
|
This function must first identify the correct frame pool and then call the frame
|
||
|
|
pool's release_frame function. */
|
||
|
|
|
||
|
|
static unsigned long needed_info_frames(unsigned long _n_frames);
|
||
|
|
/*
|
||
|
|
Returns the number of frames needed to manage a frame pool of size _n_frames.
|
||
|
|
The number returned here depends on the implementation of the frame pool and
|
||
|
|
on the frame size.
|
||
|
|
EXAMPLE: For FRAME_SIZE = 4096 and a bitmap with a single bit per frame
|
||
|
|
(not appropriate for contiguous allocation) one would need one frame to manage a
|
||
|
|
frame pool with up to 8 * 4096 = 32k frames = 128MB of memory!
|
||
|
|
This function would therefore return the following value:
|
||
|
|
_n_frames / 32k + (_n_frames % 32k > 0 ? 1 : 0) (always round up!)
|
||
|
|
Other implementations need a different number of info frames.
|
||
|
|
The exact number is computed in this function.
|
||
|
|
*/
|
||
|
|
|
||
|
|
};
|
||
|
|
#endif
|