├── SA13226226_杨扬_高级数据库实验二.docx
├── Storage_and_Buffer_Manager_v2
    ├── FullLRU.h
    ├── EmptyLRU.h
    ├── Console.h
    ├── Disk.h
    ├── Hash_P2F.h
    ├── LRU.h
    ├── FullLRU.cpp
    ├── EmptyLRU.cpp
    ├── Console.cpp
    ├── LRU.cpp
    ├── ClassDiagram.cd
    ├── Disk.cpp
    ├── Hash_P2F.cpp
    ├── Storage_and_Buffer_Manager_v2.vcxproj.filters
    ├── main.cpp
    └── Storage_and_Buffer_Manager_v2.vcxproj
├── README.md
├── .gitattributes
├── Storage_and_Buffer_Manager_v2.sln
└── .gitignore


/SA13226226_杨扬_高级数据库实验二.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/netbeen/StorageAndBufferManager/HEAD/SA13226226_杨扬_高级数据库实验二.docx


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/FullLRU.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "LRU.h"
 3 | 
 4 | class FullLRU :public LRU{
 5 | public:
 6 | 	FullLRU();
 7 | 	void adjustLRU(const int);
 8 | private:
 9 | 	void init();
10 | };


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/EmptyLRU.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "LRU.h"
 3 | 
 4 | class EmptyLRU :public LRU{
 5 | public:
 6 | 	EmptyLRU();
 7 | 	int getAvailableNodeCount() const;
 8 | 	void setAvailableNodeCountMinusOne();
 9 | private:
10 | 	void init();
11 | 	int availableNodeCount;
12 | };


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | Storage_and_Buffer_Manager_v2
2 | =============================
3 | 
4 | Advanced Database Technology Lab2 of University of Science and Technology of China (USTC), Directed by Jin Peiquan (~jpq).
5 | 
6 | Using double circular linked list and hash table, tackle 500,000 read and write request cost about 30 seconds.
7 | 


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/Console.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <fstream>
 3 | #include <iostream>
 4 | #include <string>
 5 | #include "Disk.h"
 6 | 
 7 | const int BUFFERSIZE = 1024;	//default BUFFERSIZE is 1024
 8 | const int FRAMESIZE = PAGESIZE;
 9 | const int TESTCOUNT = 500000;
10 | 
11 | struct dataRequest{
12 | 	bool isWrite;
13 | 	int pageID;
14 | };
15 | 
16 | class Console{
17 | public:
18 | 	Console();
19 | 	dataRequest arrayOfDataRequest[TESTCOUNT];
20 | private:
21 | 	void init();
22 | };
23 | 
24 | 


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/Disk.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <fstream>
 3 | #include <iostream>
 4 | #include <time.h>
 5 | 
 6 | using namespace std;
 7 | 
 8 | const int MAXPAGES = 50100;
 9 | const int PAGESIZE = 4096;
10 | 
11 | class Disk{
12 | public:
13 | 	Disk();
14 | 	~Disk();
15 | 	void inputProcess(const int pageID);
16 | 	void outputProcess(const int pageID);
17 | private:
18 | 	void writeLog(const int pageID);
19 | 	void searchIndex();
20 | 	void searchPageTable();
21 | 	void init();
22 | 	char * frame;
23 | 	ifstream input;
24 | 	ofstream output;
25 | 	ofstream log;
26 | };


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | *.sln    merge=union
 7 | *.csproj merge=union
 8 | *.vbproj merge=union
 9 | *.fsproj merge=union
10 | *.dbproj merge=union
11 | 
12 | # Standard to msysgit
13 | *.doc	 diff=astextplain
14 | *.DOC	 diff=astextplain
15 | *.docx diff=astextplain
16 | *.DOCX diff=astextplain
17 | *.dot  diff=astextplain
18 | *.DOT  diff=astextplain
19 | *.pdf  diff=astextplain
20 | *.PDF	 diff=astextplain
21 | *.rtf	 diff=astextplain
22 | *.RTF	 diff=astextplain
23 | 


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/Hash_P2F.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include "Console.h"
 3 | #include <iostream>
 4 | 
 5 | struct BCB{
 6 | 	bool isHead;
 7 | 	bool isTrail;
 8 | 	int frameID;
 9 | 	int pageID;
10 | 	bool isWrite;
11 | 	BCB * previous;
12 | 	BCB * next;
13 | };
14 | 
15 | class Hash_P2F{
16 | public:
17 | 	Hash_P2F();
18 | 	void dropBCB(BCB * const victim);
19 | 	bool findPage(const int);
20 | 	void insertBCB(const int frameID, const int pageID, const bool isWrite);
21 | 	BCB * locateNode(const int pageID);
22 | private:
23 | 	int hash(const int) const;
24 | 	void init();
25 | 	BCB * searchPtr;
26 | 	BCB * hashTable[BUFFERSIZE];
27 | };
28 | 
29 | 


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/LRU.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <iostream>
 4 | #include "Console.h"
 5 | 
 6 | struct LRUElement{
 7 | 	bool isHead;
 8 | 	bool isTrail;
 9 | 	int frameID;
10 | 	int pageID;
11 | 	LRUElement * moreRecent;
12 | 	LRUElement * lessRecent;
13 | };
14 | 
15 | class LRU{
16 | public:
17 | 	virtual void init() = 0;
18 | 	LRUElement * returnTheOneBeforeTrail();
19 | 	LRUElement * returnTheOneAfterHead();
20 | 	void insertNodeOnTrail(LRUElement * const);
21 | 	void dropNode(LRUElement * const);
22 | protected:
23 | 	void initHeadAndTrail();
24 | 	LRUElement head;
25 | 	LRUElement trail;
26 | 	LRUElement * current;
27 | };
28 | 
29 | 


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/FullLRU.cpp:
--------------------------------------------------------------------------------
 1 | #include "FullLRU.h"
 2 | 
 3 | using namespace std;
 4 | 
 5 | FullLRU::FullLRU(){
 6 | 	init();
 7 | }
 8 | 
 9 | void FullLRU::init(){
10 | 	initHeadAndTrail();
11 | 
12 | 	cout << "#   (4/5) Full LRU link list initialize cpmpeted.          #" << endl;
13 | }
14 | 
15 | //Search the specific node in LRU link list with the pageID, and adjust it into the trail.
16 | void FullLRU::adjustLRU(const int pageID){
17 | 	current = &trail;
18 | 	while(current ->lessRecent ->isHead == false){
19 | 		current = current ->lessRecent;
20 | 		if (current ->pageID == pageID){
21 | 			dropNode(current);
22 | 			insertNodeOnTrail(current);
23 | 			return;
24 | 		}
25 | 	}
26 | 	exit(1);
27 | }
28 | 


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/EmptyLRU.cpp:
--------------------------------------------------------------------------------
 1 | #include "EmptyLRU.h"
 2 | 
 3 | using namespace std;
 4 | 
 5 | EmptyLRU::EmptyLRU(){
 6 | 	availableNodeCount = 0;
 7 | 	init();
 8 | }
 9 | 
10 | //Initialize the LRU link list.
11 | void EmptyLRU::init(){
12 | 	initHeadAndTrail();
13 | 	
14 | 	for(int i = 0; i < BUFFERSIZE; i++){
15 | 		current = new LRUElement;
16 | 		current ->frameID = i;
17 | 		current ->isHead = false;
18 | 		current ->isTrail = false;
19 | 		insertNodeOnTrail(current);
20 | 	}
21 | 
22 | 	availableNodeCount = BUFFERSIZE;
23 | 
24 | 	cout << "#   (3/5) Empty LRU link list initialize cpmpeted.         #" << endl;
25 | }
26 | 
27 | int EmptyLRU::getAvailableNodeCount() const{
28 | 	return availableNodeCount;
29 | }	
30 | 
31 | void EmptyLRU::setAvailableNodeCountMinusOne(){
32 | 	availableNodeCount --;
33 | }


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/Console.cpp:
--------------------------------------------------------------------------------
 1 | #include "Console.h"
 2 | 
 3 | using namespace std;
 4 | 
 5 | //Construct function.
 6 | Console::Console(){
 7 | 	init();
 8 | }
 9 | 
10 | //Preread the data requests into memory.
11 | void Console::init(){
12 | 	ifstream inFile("data-5w-50w-zipf.txt");
13 | 	string tmp,tmpPre,tmpSuf;
14 | 	int commaIndex,dataRequestIndex = 0;
15 | 	while (dataRequestIndex < TESTCOUNT){
16 | 		getline(inFile,tmp);
17 | 		commaIndex = tmp.find(",");
18 | 		tmpPre = tmp.substr(0,commaIndex);
19 | 		tmpSuf = tmp.substr(commaIndex + 1);
20 | 		if (tmpPre == "1")
21 | 			arrayOfDataRequest[dataRequestIndex].isWrite = true;
22 | 		else
23 | 			arrayOfDataRequest[dataRequestIndex].isWrite = false;
24 | 		arrayOfDataRequest[dataRequestIndex].pageID = atoi(tmpSuf.c_str());
25 | 		dataRequestIndex ++;
26 | 	}
27 | 	cout << "#   (1/5) Console initialization competed.                 #" << endl;
28 | }


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 2012
 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Storage_and_Buffer_Manager_v2", "Storage_and_Buffer_Manager_v2\Storage_and_Buffer_Manager_v2.vcxproj", "{D33CD4B2-3D03-42A7-97AE-BA9E7C229481}"
 5 | EndProject
 6 | Global
 7 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 8 | 		Debug|Win32 = Debug|Win32
 9 | 		Release|Win32 = Release|Win32
10 | 	EndGlobalSection
11 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
12 | 		{D33CD4B2-3D03-42A7-97AE-BA9E7C229481}.Debug|Win32.ActiveCfg = Debug|Win32
13 | 		{D33CD4B2-3D03-42A7-97AE-BA9E7C229481}.Debug|Win32.Build.0 = Debug|Win32
14 | 		{D33CD4B2-3D03-42A7-97AE-BA9E7C229481}.Release|Win32.ActiveCfg = Release|Win32
15 | 		{D33CD4B2-3D03-42A7-97AE-BA9E7C229481}.Release|Win32.Build.0 = Release|Win32
16 | 	EndGlobalSection
17 | 	GlobalSection(SolutionProperties) = preSolution
18 | 		HideSolutionNode = FALSE
19 | 	EndGlobalSection
20 | EndGlobal
21 | 


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/LRU.cpp:
--------------------------------------------------------------------------------
 1 | #include "LRU.h"
 2 | 
 3 | //Set the two pointer of each nodes.
 4 | void LRU::initHeadAndTrail(){
 5 | 	head.isHead = true;
 6 | 	head.isTrail = false;
 7 | 	head.lessRecent = nullptr;
 8 | 	head.moreRecent = &trail;
 9 | 
10 | 	trail.isTrail = true;
11 | 	trail.isHead = false;
12 | 	trail.lessRecent = &head;
13 | 	trail.moreRecent = nullptr;
14 | }
15 | 
16 | //Insert node.
17 | void LRU::insertNodeOnTrail(LRUElement * const newNode){
18 | 	newNode ->moreRecent = &trail;
19 | 	newNode ->lessRecent = trail.lessRecent;
20 | 
21 | 	newNode ->lessRecent ->moreRecent = newNode;
22 | 	trail.lessRecent = newNode;
23 | }
24 | 
25 | //Cut the two pointer of the node.
26 | void LRU::dropNode(LRUElement * const dropPtr){
27 | 	dropPtr ->lessRecent ->moreRecent = dropPtr ->moreRecent;
28 | 	dropPtr ->moreRecent ->lessRecent = dropPtr ->lessRecent;
29 | }
30 | 
31 | //Get an empty node.
32 | LRUElement * LRU::returnTheOneBeforeTrail(){
33 | 	LRUElement * returnPtr;
34 | 	returnPtr = trail.lessRecent;
35 | 	return returnPtr;
36 | }
37 | 
38 | //Decide the victim.
39 | LRUElement * LRU::returnTheOneAfterHead(){
40 | 	LRUElement * returnPtr;
41 | 	returnPtr = head.moreRecent;
42 | 	return returnPtr;
43 | }


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/ClassDiagram.cd:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <ClassDiagram MajorVersion="1" MinorVersion="1">
 3 |   <Class Name="LRU" Collapsed="true">
 4 |     <Position X="1.75" Y="0.5" Width="1.5" />
 5 |     <TypeIdentifier>
 6 |       <HashCode>AAAAAAAAgIAAIAAAAAAAIAAAgAAAAAJAAAAAAAAAAIQ=</HashCode>
 7 |       <FileName>LRU.h</FileName>
 8 |     </TypeIdentifier>
 9 |   </Class>
10 |   <Class Name="EmptyLRU" Collapsed="true">
11 |     <Position X="2.75" Y="1.75" Width="1.5" />
12 |     <TypeIdentifier>
13 |       <HashCode>AAgAAAAAAAAAAAAAAAAAAAAAAABAAAIEAAAAAAAAAAA=</HashCode>
14 |       <FileName>EmptyLRU.h</FileName>
15 |     </TypeIdentifier>
16 |   </Class>
17 |   <Class Name="FullLRU" Collapsed="true">
18 |     <Position X="0.5" Y="1.75" Width="1.5" />
19 |     <TypeIdentifier>
20 |       <HashCode>AAAABAAAAAAAAAAAAAAAAAAAACAAAAIAAAAAAAAAAAA=</HashCode>
21 |       <FileName>FullLRU.h</FileName>
22 |     </TypeIdentifier>
23 |   </Class>
24 |   <Class Name="Console" Collapsed="true">
25 |     <Position X="5.25" Y="0.5" Width="1.5" />
26 |     <TypeIdentifier>
27 |       <HashCode>AACAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAEAAAAAA=</HashCode>
28 |       <FileName>Console.h</FileName>
29 |     </TypeIdentifier>
30 |   </Class>
31 |   <Struct Name="LRUElement" Collapsed="true">
32 |     <Position X="5.25" Y="1.75" Width="1.5" />
33 |     <TypeIdentifier>
34 |       <HashCode>IAAAAAEAAgAAACAAAAAAAAAAABAAAAAAAAAAEAAAAAA=</HashCode>
35 |       <FileName>LRU.h</FileName>
36 |     </TypeIdentifier>
37 |   </Struct>
38 |   <Font Name="宋体" Size="9" />
39 | </ClassDiagram>


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/Disk.cpp:
--------------------------------------------------------------------------------
 1 | #include "Disk.h"
 2 | #include "Console.h"
 3 | 
 4 | using namespace std;
 5 | 
 6 | //
 7 | Disk::Disk(){
 8 | 	init();
 9 | }
10 | 
11 | //Initialize the HDD.
12 | void Disk::init(){
13 | 	ofstream diskFileInit("data.dbf");
14 | 	char initBuffer[MAXPAGES * PAGESIZE];
15 | 	memset(initBuffer,0,sizeof(initBuffer));
16 | 	diskFileInit.write(initBuffer,sizeof(initBuffer));
17 | 	diskFileInit.close();
18 | 
19 | 	frame = new char[FRAMESIZE];
20 | 	
21 | 	diskFileInit.open("data.log");
22 | 	diskFileInit.close();
23 | 
24 | 	input.open("data.dbf",ios::binary);
25 | 	output.open("data.dbf",ios::binary);
26 | 	log.open("data.log",ios::binary);
27 | 
28 | 	cout << "#   (2/5) HDD initialize competed.                         #" << endl;
29 | }
30 | 
31 | //Close the file streams open in my program.
32 | Disk::~Disk(){
33 | 	log.close();
34 | 	input.close();
35 | 	output.close();
36 | }
37 | 
38 | //Startup the read process, read 4KB data from "data.dbf".
39 | void Disk::inputProcess(const int pageID){
40 | 
41 | 	//Read the file.
42 | 	input.seekg((pageID * PAGESIZE), ios::beg);
43 | 	input.read(frame, FRAMESIZE);
44 | }
45 | 
46 | //Startup the write process, write 4KB data into "data.dbf".
47 | void Disk::outputProcess(const int pageID){
48 | 
49 | 	writeLog(pageID);
50 | 
51 | 	//Write into the file.
52 | 	output.seekp((pageID * PAGESIZE), ios::beg);
53 | 	output.write(frame, FRAMESIZE);
54 | }
55 | 
56 | //Write system log into "data.log".
57 | void Disk::writeLog(const int pageID){
58 | 	log << static_cast<double>(clock())/CLOCKS_PER_SEC*1000 << "ms\t<Write," << pageID <<">\r\n";
59 | }


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/Hash_P2F.cpp:
--------------------------------------------------------------------------------
 1 | #include "Hash_P2F.h"
 2 | 
 3 | using namespace std;
 4 | 
 5 | Hash_P2F::Hash_P2F(){
 6 | 	init();
 7 | }
 8 | 
 9 | void Hash_P2F::init(){
10 | 	for(int i = 0; i < BUFFERSIZE; i ++){
11 | 		BCB * newHead = new BCB;
12 | 		BCB * newTrail = new BCB;
13 | 		newHead ->isHead = true;
14 | 		newHead ->isTrail =false;
15 | 		newHead ->previous = nullptr;
16 | 		newHead ->next = newTrail;
17 | 
18 | 		newTrail ->isHead = false;
19 | 		newTrail ->isTrail = true;
20 | 		newTrail ->previous = newHead;
21 | 		newTrail ->next = nullptr;
22 | 
23 | 		hashTable[i] = newHead;
24 | 	}
25 | 	cout << "#   (5/5) Hash table of page to frame initialize competed. #" << endl;
26 | }
27 | 
28 | //Return whether the specific page with the pageID exist in the buffer.
29 | bool Hash_P2F::findPage(const int pageID){
30 | 	int hashResult = hash(pageID);
31 | 	searchPtr = hashTable[hashResult];
32 | 	while(searchPtr ->next ->isTrail != true){
33 | 		searchPtr = searchPtr ->next;
34 | 		if (searchPtr ->pageID == pageID)
35 | 			return true;
36 | 	}
37 | 	return false;
38 | }
39 | 
40 | //Calculate the hash.
41 | int Hash_P2F::hash(const int pageID) const{
42 | 	return (pageID % BUFFERSIZE);
43 | }
44 | 
45 | void Hash_P2F::insertBCB(const int frameID, const int pageID, const bool isWrite){
46 | 	int hashResult = hash(pageID);
47 | 	BCB * inserting = new BCB;
48 | 	inserting ->frameID = frameID;
49 | 	inserting ->pageID = pageID;
50 | 	inserting ->isWrite = isWrite;
51 | 	inserting ->isHead = false;
52 | 	inserting ->isTrail =false;
53 | 	
54 | 	inserting ->previous = hashTable[hashResult];
55 | 	inserting ->next = hashTable[hashResult] ->next;
56 | 	inserting ->next ->previous = inserting;
57 | 	hashTable[hashResult] ->next = inserting;
58 | }
59 | 
60 | //Find where the node with the pageID is.
61 | BCB * Hash_P2F::locateNode(const int pageID){
62 | 	int hashResult = hash(pageID);
63 | 	BCB * searchPtr = hashTable[hashResult];
64 | 	while(searchPtr ->next ->isTrail != true){
65 | 		searchPtr = searchPtr ->next;
66 | 		if(searchPtr ->pageID == pageID){
67 | 			return searchPtr;
68 | 		}
69 | 	}
70 | }
71 | 
72 | //Cut the two pointer of the node.
73 | void Hash_P2F::dropBCB(BCB * const victim){
74 | 	victim ->previous ->next = victim ->next;
75 | 	victim ->next ->previous = victim ->previous;
76 | }


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/Storage_and_Buffer_Manager_v2.vcxproj.filters:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <ItemGroup>
 4 |     <Filter Include="源文件">
 5 |       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
 6 |       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
 7 |     </Filter>
 8 |     <Filter Include="头文件">
 9 |       <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
10 |       <Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
11 |     </Filter>
12 |     <Filter Include="资源文件">
13 |       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
14 |       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
15 |     </Filter>
16 |   </ItemGroup>
17 |   <ItemGroup>
18 |     <ClInclude Include="LRU.h">
19 |       <Filter>头文件</Filter>
20 |     </ClInclude>
21 |     <ClInclude Include="EmptyLRU.h">
22 |       <Filter>头文件</Filter>
23 |     </ClInclude>
24 |     <ClInclude Include="FullLRU.h">
25 |       <Filter>头文件</Filter>
26 |     </ClInclude>
27 |     <ClInclude Include="Console.h">
28 |       <Filter>头文件</Filter>
29 |     </ClInclude>
30 |     <ClInclude Include="Hash_P2F.h">
31 |       <Filter>头文件</Filter>
32 |     </ClInclude>
33 |     <ClInclude Include="Disk.h">
34 |       <Filter>头文件</Filter>
35 |     </ClInclude>
36 |   </ItemGroup>
37 |   <ItemGroup>
38 |     <ClCompile Include="LRU.cpp">
39 |       <Filter>源文件</Filter>
40 |     </ClCompile>
41 |     <ClCompile Include="EmptyLRU.cpp">
42 |       <Filter>源文件</Filter>
43 |     </ClCompile>
44 |     <ClCompile Include="main.cpp">
45 |       <Filter>源文件</Filter>
46 |     </ClCompile>
47 |     <ClCompile Include="FullLRU.cpp">
48 |       <Filter>源文件</Filter>
49 |     </ClCompile>
50 |     <ClCompile Include="Console.cpp">
51 |       <Filter>源文件</Filter>
52 |     </ClCompile>
53 |     <ClCompile Include="Hash_P2F.cpp">
54 |       <Filter>源文件</Filter>
55 |     </ClCompile>
56 |     <ClCompile Include="Disk.cpp">
57 |       <Filter>源文件</Filter>
58 |     </ClCompile>
59 |   </ItemGroup>
60 |   <ItemGroup>
61 |     <None Include="ClassDiagram.cd">
62 |       <Filter>资源文件</Filter>
63 |     </None>
64 |   </ItemGroup>
65 |   <ItemGroup>
66 |     <Text Include="data-5w-50w-zipf.txt">
67 |       <Filter>资源文件</Filter>
68 |     </Text>
69 |   </ItemGroup>
70 | </Project>


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <time.h>
 2 | #include <iomanip>
 3 | #include "Console.h"
 4 | #include "EmptyLRU.h"
 5 | #include "FullLRU.h"
 6 | #include "Hash_P2F.h"
 7 | 
 8 | using namespace std;
 9 | 
10 | /*************************************************
11 | Author: Yang Yang
12 | Date&Time: 2013-10-28 15:29
13 | Version: 2.2
14 | *************************************************/
15 | int main(){
16 | 	cout << "=================Storage and Buffer Manager=================" << endl;
17 | 	Console console = Console();
18 | 	Disk disk = Disk();
19 | 	EmptyLRU emptyLRU = EmptyLRU();
20 | 	FullLRU fullLRU = FullLRU();
21 | 	Hash_P2F hash_p2f = Hash_P2F();
22 | 
23 | 	int hitCount = 0;
24 | 	int IOCount = 0;
25 | 
26 | 	cout << "====================Now Start Simulating====================" << endl;
27 | 	clock_t startTime = clock();
28 | 
29 | 	for (int requestIndex = 0; requestIndex < TESTCOUNT; requestIndex ++){		
30 | 		int pageID = console.arrayOfDataRequest[requestIndex].pageID;
31 | 		bool isWrite = console.arrayOfDataRequest[requestIndex].isWrite;
32 | 		//Buffer hitted.
33 | 		if (hash_p2f.findPage(pageID)){
34 | 			hitCount ++;
35 | 			fullLRU.adjustLRU(pageID);
36 | 		}
37 | 		//Buffer missed.
38 | 		else{
39 | 			IOCount ++;
40 | 			disk.inputProcess(pageID);
41 | 			//EmptyLRU still available.
42 | 			if(emptyLRU.getAvailableNodeCount() > 0){
43 | 				//Add to LRU link list.
44 | 				emptyLRU.setAvailableNodeCountMinusOne();
45 | 				LRUElement * emptyNode = emptyLRU.returnTheOneBeforeTrail();
46 | 				emptyNode ->pageID =pageID;
47 | 				emptyLRU.dropNode(emptyNode);
48 | 				fullLRU.insertNodeOnTrail(emptyNode);
49 | 				//Add to Hash table.
50 | 				int frameID = emptyNode ->frameID;
51 | 				hash_p2f.insertBCB(frameID,pageID,isWrite);
52 | 			}
53 | 			//EmptyLRU does't available.
54 | 			else{
55 | 				LRUElement * replacing = fullLRU.returnTheOneAfterHead();
56 | 				int victimFrameID = replacing ->frameID;
57 | 				int victimPageID = replacing ->pageID;
58 | 				//Update the Hash Table.
59 | 				BCB * victim = hash_p2f.locateNode(victimPageID);
60 | 				if(victim ->isWrite == true){
61 | 					disk.outputProcess(victimPageID);
62 | 				}
63 | 				int frameID = victim ->frameID;
64 | 				hash_p2f.dropBCB(victim);
65 | 				hash_p2f.insertBCB(frameID,pageID,isWrite);
66 | 				delete victim;
67 | 				//Update the LRU link list.
68 | 				replacing ->pageID = pageID;
69 | 				fullLRU.dropNode(replacing);
70 | 				fullLRU.insertNodeOnTrail(replacing);
71 | 			}
72 | 		}
73 | 	}
74 | 	//write the changed data back to the disk before exit.
75 | 	disk.outputProcess(0);
76 | 	clock_t endTime = clock();
77 | 	cout << "#   Buffer Size: " << BUFFERSIZE  << "\t\tHit Rate: " << setprecision(4) <<(static_cast<float>(hitCount)/TESTCOUNT) * 100 <<"%\t   #" <<endl;
78 | 	cout << "#   I/O Count: " << IOCount << "\t\tRunning Time: "<< setprecision(0) << fixed << static_cast<double>(endTime - startTime)/CLOCKS_PER_SEC*1000 << " ms.\t   #" << endl;
79 | 	cout << "============================================================" << endl;
80 | 	system("pause");
81 | 	return 0;
82 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | data.dbf
  2 | data.log
  3 | #################
  4 | ## Eclipse
  5 | #################
  6 | 
  7 | *.pydevproject
  8 | .project
  9 | .metadata
 10 | bin/
 11 | tmp/
 12 | *.tmp
 13 | *.bak
 14 | *.swp
 15 | *~.nib
 16 | local.properties
 17 | .classpath
 18 | .settings/
 19 | .loadpath
 20 | 
 21 | # External tool builders
 22 | .externalToolBuilders/
 23 | 
 24 | # Locally stored "Eclipse launch configurations"
 25 | *.launch
 26 | 
 27 | # CDT-specific
 28 | .cproject
 29 | 
 30 | # PDT-specific
 31 | .buildpath
 32 | 
 33 | 
 34 | #################
 35 | ## Visual Studio
 36 | #################
 37 | 
 38 | ## Ignore Visual Studio temporary files, build results, and
 39 | ## files generated by popular Visual Studio add-ons.
 40 | 
 41 | # User-specific files
 42 | *.suo
 43 | *.user
 44 | *.sln.docstates
 45 | 
 46 | # Build results
 47 | 
 48 | [Dd]ebug/
 49 | [Rr]elease/
 50 | x64/
 51 | build/
 52 | [Bb]in/
 53 | [Oo]bj/
 54 | 
 55 | # MSTest test Results
 56 | [Tt]est[Rr]esult*/
 57 | [Bb]uild[Ll]og.*
 58 | 
 59 | *_i.c
 60 | *_p.c
 61 | *.ilk
 62 | *.meta
 63 | *.obj
 64 | *.pch
 65 | *.pdb
 66 | *.pgc
 67 | *.pgd
 68 | *.rsp
 69 | *.sbr
 70 | *.tlb
 71 | *.tli
 72 | *.tlh
 73 | *.tmp
 74 | *.tmp_proj
 75 | *.log
 76 | *.vspscc
 77 | *.vssscc
 78 | .builds
 79 | *.pidb
 80 | *.log
 81 | *.scc
 82 | 
 83 | # Visual C++ cache files
 84 | ipch/
 85 | *.aps
 86 | *.ncb
 87 | *.opensdf
 88 | *.sdf
 89 | *.cachefile
 90 | 
 91 | # Visual Studio profiler
 92 | *.psess
 93 | *.vsp
 94 | *.vspx
 95 | 
 96 | # Guidance Automation Toolkit
 97 | *.gpState
 98 | 
 99 | # ReSharper is a .NET coding add-in
100 | _ReSharper*/
101 | *.[Rr]e[Ss]harper
102 | 
103 | # TeamCity is a build add-in
104 | _TeamCity*
105 | 
106 | # DotCover is a Code Coverage Tool
107 | *.dotCover
108 | 
109 | # NCrunch
110 | *.ncrunch*
111 | .*crunch*.local.xml
112 | 
113 | # Installshield output folder
114 | [Ee]xpress/
115 | 
116 | # DocProject is a documentation generator add-in
117 | DocProject/buildhelp/
118 | DocProject/Help/*.HxT
119 | DocProject/Help/*.HxC
120 | DocProject/Help/*.hhc
121 | DocProject/Help/*.hhk
122 | DocProject/Help/*.hhp
123 | DocProject/Help/Html2
124 | DocProject/Help/html
125 | 
126 | # Click-Once directory
127 | publish/
128 | 
129 | # Publish Web Output
130 | *.Publish.xml
131 | *.pubxml
132 | 
133 | # NuGet Packages Directory
134 | ## TODO: If you have NuGet Package Restore enabled, uncomment the next line
135 | #packages/
136 | 
137 | # Windows Azure Build Output
138 | csx
139 | *.build.csdef
140 | 
141 | # Windows Store app package directory
142 | AppPackages/
143 | 
144 | # Others
145 | sql/
146 | *.Cache
147 | ClientBin/
148 | [Ss]tyle[Cc]op.*
149 | ~$*
150 | *~
151 | *.dbmdl
152 | *.[Pp]ublish.xml
153 | *.pfx
154 | *.publishsettings
155 | 
156 | # RIA/Silverlight projects
157 | Generated_Code/
158 | 
159 | # Backup & report files from converting an old project file to a newer
160 | # Visual Studio version. Backup files are not needed, because we have git ;-)
161 | _UpgradeReport_Files/
162 | Backup*/
163 | UpgradeLog*.XML
164 | UpgradeLog*.htm
165 | 
166 | # SQL Server files
167 | App_Data/*.mdf
168 | App_Data/*.ldf
169 | 
170 | #############
171 | ## Windows detritus
172 | #############
173 | 
174 | # Windows image file caches
175 | Thumbs.db
176 | ehthumbs.db
177 | 
178 | # Folder config file
179 | Desktop.ini
180 | 
181 | # Recycle Bin used on file shares
182 | $RECYCLE.BIN/
183 | 
184 | # Mac crap
185 | .DS_Store
186 | 
187 | 
188 | #############
189 | ## Python
190 | #############
191 | 
192 | *.py[co]
193 | 
194 | # Packages
195 | *.egg
196 | *.egg-info
197 | dist/
198 | build/
199 | eggs/
200 | parts/
201 | var/
202 | sdist/
203 | develop-eggs/
204 | .installed.cfg
205 | 
206 | # Installer logs
207 | pip-log.txt
208 | 
209 | # Unit test / coverage reports
210 | .coverage
211 | .tox
212 | 
213 | #Translations
214 | *.mo
215 | 
216 | #Mr Developer
217 | .mr.developer.cfg
218 | 


--------------------------------------------------------------------------------
/Storage_and_Buffer_Manager_v2/Storage_and_Buffer_Manager_v2.vcxproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <ItemGroup Label="ProjectConfigurations">
  4 |     <ProjectConfiguration Include="Debug|Win32">
  5 |       <Configuration>Debug</Configuration>
  6 |       <Platform>Win32</Platform>
  7 |     </ProjectConfiguration>
  8 |     <ProjectConfiguration Include="Release|Win32">
  9 |       <Configuration>Release</Configuration>
 10 |       <Platform>Win32</Platform>
 11 |     </ProjectConfiguration>
 12 |   </ItemGroup>
 13 |   <PropertyGroup Label="Globals">
 14 |     <ProjectGuid>{D33CD4B2-3D03-42A7-97AE-BA9E7C229481}</ProjectGuid>
 15 |     <Keyword>Win32Proj</Keyword>
 16 |     <RootNamespace>Storage_and_Buffer_Manager_v2</RootNamespace>
 17 |   </PropertyGroup>
 18 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
 19 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
 20 |     <ConfigurationType>Application</ConfigurationType>
 21 |     <UseDebugLibraries>true</UseDebugLibraries>
 22 |     <PlatformToolset>v110</PlatformToolset>
 23 |     <CharacterSet>Unicode</CharacterSet>
 24 |   </PropertyGroup>
 25 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
 26 |     <ConfigurationType>Application</ConfigurationType>
 27 |     <UseDebugLibraries>false</UseDebugLibraries>
 28 |     <PlatformToolset>v110</PlatformToolset>
 29 |     <WholeProgramOptimization>true</WholeProgramOptimization>
 30 |     <CharacterSet>Unicode</CharacterSet>
 31 |   </PropertyGroup>
 32 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
 33 |   <ImportGroup Label="ExtensionSettings">
 34 |   </ImportGroup>
 35 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 36 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 37 |   </ImportGroup>
 38 |   <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 39 |     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
 40 |   </ImportGroup>
 41 |   <PropertyGroup Label="UserMacros" />
 42 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 43 |     <LinkIncremental>true</LinkIncremental>
 44 |   </PropertyGroup>
 45 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 46 |     <LinkIncremental>false</LinkIncremental>
 47 |   </PropertyGroup>
 48 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
 49 |     <ClCompile>
 50 |       <PrecompiledHeader>
 51 |       </PrecompiledHeader>
 52 |       <WarningLevel>Level3</WarningLevel>
 53 |       <Optimization>Disabled</Optimization>
 54 |       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 55 |     </ClCompile>
 56 |     <Link>
 57 |       <SubSystem>Console</SubSystem>
 58 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 59 |       <StackReserveSize>1024000000</StackReserveSize>
 60 |       <StackCommitSize>1024000000</StackCommitSize>
 61 |     </Link>
 62 |   </ItemDefinitionGroup>
 63 |   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
 64 |     <ClCompile>
 65 |       <WarningLevel>Level3</WarningLevel>
 66 |       <PrecompiledHeader>
 67 |       </PrecompiledHeader>
 68 |       <Optimization>MaxSpeed</Optimization>
 69 |       <FunctionLevelLinking>true</FunctionLevelLinking>
 70 |       <IntrinsicFunctions>true</IntrinsicFunctions>
 71 |       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
 72 |     </ClCompile>
 73 |     <Link>
 74 |       <SubSystem>Console</SubSystem>
 75 |       <GenerateDebugInformation>true</GenerateDebugInformation>
 76 |       <EnableCOMDATFolding>true</EnableCOMDATFolding>
 77 |       <OptimizeReferences>true</OptimizeReferences>
 78 |       <StackReserveSize>1024000000</StackReserveSize>
 79 |       <StackCommitSize>1024000000</StackCommitSize>
 80 |     </Link>
 81 |   </ItemDefinitionGroup>
 82 |   <ItemGroup>
 83 |     <ClInclude Include="Console.h" />
 84 |     <ClInclude Include="Disk.h" />
 85 |     <ClInclude Include="EmptyLRU.h" />
 86 |     <ClInclude Include="FullLRU.h" />
 87 |     <ClInclude Include="Hash_P2F.h" />
 88 |     <ClInclude Include="LRU.h" />
 89 |   </ItemGroup>
 90 |   <ItemGroup>
 91 |     <ClCompile Include="Console.cpp" />
 92 |     <ClCompile Include="Disk.cpp" />
 93 |     <ClCompile Include="EmptyLRU.cpp" />
 94 |     <ClCompile Include="FullLRU.cpp" />
 95 |     <ClCompile Include="Hash_P2F.cpp" />
 96 |     <ClCompile Include="LRU.cpp" />
 97 |     <ClCompile Include="main.cpp" />
 98 |   </ItemGroup>
 99 |   <ItemGroup>
100 |     <None Include="ClassDiagram.cd" />
101 |   </ItemGroup>
102 |   <ItemGroup>
103 |     <Text Include="data-5w-50w-zipf.txt" />
104 |   </ItemGroup>
105 |   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
106 |   <ImportGroup Label="ExtensionTargets">
107 |   </ImportGroup>
108 | </Project>


--------------------------------------------------------------------------------