数据库

最新推荐文章于 2020-04-24 02:20:32 发布
最新推荐文章于 2020-04-24 02:20:32 发布
阅读量648 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoumingsong123/article/details/52963507
版权 
#ifndef STRUCTURE_H_INCLUDED
#define STRUCTURE_H_INCLUDED
#define FRAMESIZE  4096
#define MAXPAGES   100000
#define DEFBUFSIZE  1024
#include <string>
#include <cstdio>
#include "structure.h"
using namespace std;
struct NewPage//buffer中空闲的frame的信息
    { int page_id;
      int frame_id;
    };
struct bFrame//frame
    {
     char field [FRAMESIZE];
    };
struct BCB//每个page进入buffer，将会产生BCB，frame的相关信息存储在其相应的BCB中
    {

      //BCB();
      int page_id;
      int frame_id;
      int latch;
      int count;
      int dirty;
      BCB * next;
      BCB * previous;
    };
struct BUFFER
    {bFrame bframe[DEFBUFSIZE];
     bool used[DEFBUFSIZE];
     int  freeFrames;
    };

class DSMgr//数据存储管理控制器
{
public:
  DSMgr();
  int OpenFile(string filename);
  int CloseFile();
  bFrame ReadPage(int page_id);
  int WritePage(int frame_id, bFrame frm);
  int Seek(int offset, int pos);
  FILE * GetFile();
  void IncNumPages();
  int GetNumPages();
  void SetUse(int index, int use_bit);
  int GetUse(int index);
  int WriteBackPage(int page_id, bFrame frm);//自创函数,写回函数
  int FileSeek(int offset);//移动文件指针
private:
  FILE *currFile;
  int numPages;
  int pages[MAXPAGES];
};
DSMgr::DSMgr()
{
int flag=OpenFile("data.dbf");
if(-1==flag)
    throw "没有找到数据库文件";

}

int DSMgr::OpenFile(string filename)//打开文件
{
currFile=fopen(filename.c_str(),"rb+");
if(currFile==NULL)
    return -1;
else
    return  0;
}

int DSMgr::CloseFile()
{
    return fclose(currFile);
}

bFrame DSMgr::ReadPage(int page_id)
{
FileSeek((page_id+1)*FRAMESIZE);
bFrame bframe;
int getByteCount=fread(bframe.field,1,FRAMESIZE,currFile);
if(getByteCount!=FRAMESIZE)
    throw "读页面失败";
return bframe;

}

int DSMgr::WritePage(int frame_id, bFrame frm)
{

return 0;
}
int DSMgr::WriteBackPage(int page_id, bFrame frm)
{FileSeek((page_id+1)*FRAMESIZE);
 int writeSuccessCount=fwrite(frm.field,1,FRAMESIZE,currFile);
 fflush(currFile);
 if(writeSuccessCount!=FRAMESIZE)
    throw "写回页面失败";

return 0;
}

int DSMgr::Seek(int offset, int pos)//三种模式
{if(1==pos)
fseek(currFile,offset,SEEK_SET);
if(2==pos)
fseek(currFile,offset,SEEK_CUR);
if(3==pos)
fseek(currFile,offset,SEEK_END);
return 0;
}
int DSMgr::FileSeek(int offset)
{fseek(currFile,offset,SEEK_SET);
return 0;
}

FILE* DSMgr::GetFile()
{
return currFile;
}

void DSMgr::IncNumPages()
{
numPages++;
}

int DSMgr::GetNumPages()
{
return numPages;
}

void DSMgr::SetUse(int index, int use_bit)
{

}

int DSMgr::GetUse(int index)
{
return 0;
}





#endif // STRUCTURE_H_INCLUDED

#include "structure.h"
#include<fstream>
#include<iostream>
#include<cstring>
#include<string>
#include <sstream>
#include <list>
using namespace std;
int count=0;
class BMgr//buffer控制管理器
    {
    public:
      BMgr();
      // Interface functions
      int FixPage(int page_id, int prot);
      NewPage FixNewPage();
      int UnfixPage(int page_id);
      int NumFreeFrames();

      // Internal Functions
      int SelectVictim();
      int Hash(int page_id);
      void RemoveBCB(BCB * ptr, int page_id);
      void UpdateLRUEle(int frid);
      void SetDirty(int frame_id);
      void UnsetDirty(int frame_id);
      void WriteDirtys();
      void  PrintFrame(int frame_id);
      void  getFrameData(char storage [],int frameID)
            {for(int i=0;i<FRAMESIZE;i++)
                {storage[i]=buffer.bframe[frameID].field[i];
                }

            }
      BUFFER getBuffer();
      int getIdleFrame()//找到第一个空闲的frame返回id
        {for(int i=0;i<DEFBUFSIZE;i++)//初始化标记frame数组
            {if(!buffer.used[i])
                return i;
            }
         return -1;
        }
     void decreaseLatch(int frameID)
        {BCBassemble[frameID]->latch--;
        }
      DSMgr getDSMgr()
        {return dsm;
        }


    private:
      // Hash Table
      int ftop[DEFBUFSIZE];//
      BCB* ptof[DEFBUFSIZE];//

      BCB * BCBassemble[DEFBUFSIZE];
      BUFFER buffer;
      list<int> lrulist;
      DSMgr dsm;

    };


    BMgr::BMgr()
    {
    for(int i=0;i<DEFBUFSIZE;i++)//初始化标记frame数组
        {buffer.used[i]=false;
         ptof[i]=0;
        }
    buffer.freeFrames=DEFBUFSIZE;//空闲的frame的数量


    }

    int BMgr::FixPage(int page_id, int prot)//it returns a frame_id.
    {
//    for(int i=0;i<DEFBUFSIZE;i++)//初始化标记frame数组
//        {if(buffer.used[i])//被使用了
//            {BCB * bcb=BCBassemble[i];//获得i对应的bcb
//             if(bcb->page_id==page_id)//在buffer中找到page
//                {
//                 UpdateLRUEle(bcb->frame_id);//命中，更新LRU表
//
//                 bcb->latch=bcb->latch+1;
//                 return bcb->frame_id;//返回
//                }
//
//            }
//
//        }
//*****************************new way******************************
        BCB *tempBCBPointer=ptof[page_id%DEFBUFSIZE];
        if(0!=tempBCBPointer)
            {while(tempBCBPointer->page_id!=page_id)
                {cout<<tempBCBPointer<<" ";
                tempBCBPointer=tempBCBPointer->next;

                if(0==tempBCBPointer)
                    break;
                }
            cout<<endl;
            if(0!=tempBCBPointer)
                {UpdateLRUEle(tempBCBPointer->frame_id);//命中，更新LRU表
                tempBCBPointer->latch=tempBCBPointer->latch+1;
                return tempBCBPointer->frame_id;
                }

            }
//*****************************new way******************************
    //页面不在缓存
        if(0==buffer.freeFrames)//没有空余frame,需要替换
            {int victimFrameID=SelectVictim();
             BCB *bcbVcitim =BCBassemble[victimFrameID];
             if(1==bcbVcitim->dirty)//需要写回
                {
                dsm.WriteBackPage(bcbVcitim->page_id,buffer.bframe[bcbVcitim->frame_id]);
                count++;
                }

             //hashtable更新
             if(0!=bcbVcitim->previous)
                {bcbVcitim->previous->next=bcbVcitim->next;
                if(0!=bcbVcitim->next)
                  bcbVcitim->next->previous=bcbVcitim->previous;
                }
             else //bcbVcitim是链上第一个元素
                {ptof[(bcbVcitim->page_id)%DEFBUFSIZE]=bcbVcitim->next;
                if(0!=bcbVcitim->next)
                   bcbVcitim->next->previous=0;

                }
             buffer.used[victimFrameID]=false;
             buffer.freeFrames++;

            //从文件中读数据到buffer frame victimPageID
            bFrame abframe=dsm.ReadPage(page_id);
             for(int i=0;i<FRAMESIZE;i++)
                {buffer.bframe[victimFrameID].field[i]=abframe.field[i];
                 //cout<<buffer.bframe[victimFrameID].field[i]<<"****************"<<endl;
                }

             count++;
             buffer.used[victimFrameID]=true;
             buffer.freeFrames--;

             delete bcbVcitim;
             BCB * bcb=new BCB;
             //bcb更新
             bcb->dirty=0;
             bcb->frame_id=victimFrameID;
             bcb->page_id=page_id;
             bcb->next=0;
             bcb->previous=0;

             BCB * tempBCBPointer=ptof[page_id%DEFBUFSIZE];

             if(0==tempBCBPointer)
                {ptof[page_id%DEFBUFSIZE]=bcb;
                 bcb->previous=0;//第一个父指针为空
                bcb->next=0;
                }
             else
                { bcb->next=tempBCBPointer->next;
                 if(0!=tempBCBPointer->next)
                    tempBCBPointer->next->previous=bcb;
                 tempBCBPointer->next=bcb;
                 bcb->previous=tempBCBPointer;

                }


           UpdateLRUEle(victimFrameID);//更新LRU表
           bcb->latch=bcb->latch+1;//数据即将要提交到主存，需要加锁
           BCBassemble[victimFrameID]=bcb;//增加bcb

             //返回ID
             return  victimFrameID;

            }
        else
            //有空闲，找到第一个一个空闲的frame读入
            {
            int idleFrameID=getIdleFrame();
             //从文件复制数据到这个frame  idleFrameID
             bFrame abframe=dsm.ReadPage(page_id);
             for(int i=0;i<FRAMESIZE;i++)
                buffer.bframe[idleFrameID].field[i]=abframe.field[i];
             count++;
             buffer.used[idleFrameID]=true;
             buffer.freeFrames--;

             //生成bcb;
             BCB * bcb=new BCB;
             bcb->dirty=0;
             bcb->frame_id=idleFrameID;
             bcb->page_id=page_id;
             bcb->next=0;
             bcb->previous=0;
             UpdateLRUEle(idleFrameID);//更新LRU表
             cout<<"LRU队首"<<lrulist.front()<<endl;
             BCBassemble[idleFrameID]=bcb;//增加bcb

             BCB * tempBCBPointer=ptof[page_id%DEFBUFSIZE];
             if(0==tempBCBPointer)
                {ptof[page_id%DEFBUFSIZE]=bcb;
                 bcb->previous=0;//第一个父指针为空
                }
             else
                {

                 bcb->next=tempBCBPointer->next;
                 if(0!=tempBCBPointer->next)
                    tempBCBPointer->next->previous=bcb;
                 tempBCBPointer->next=bcb;
                 bcb->previous=tempBCBPointer;

                }

             bcb->latch=bcb->latch+1;//加锁
             //返回ID
             return idleFrameID;

            }

    }

    NewPage BMgr::FixNewPage()//
    {for(int i=0;i<DEFBUFSIZE;i++)
        {if(!buffer.used[i])
            {NewPage newpage;
            newpage.frame_id=i;
            newpage.page_id=ftop[i];
            return newpage;
            }
        }
        NewPage newpage;
        newpage.frame_id=-1;
        newpage.page_id=-1;
        return newpage;

    }

    int BMgr::UnfixPage(int page_id)
    {

    }

    int BMgr::NumFreeFrames()
    {
       return buffer.freeFrames;
    }

    int BMgr::SelectVictim()
    {
        for(list<int> ::reverse_iterator riter=lrulist.rbegin();riter!=lrulist.rend();riter++)
            if(0==BCBassemble[*riter]->latch)
                {return  *riter;
                }
        return -1;
    }

    int BMgr::Hash(int page_id)
    {
     return  (page_id)%DEFBUFSIZE;

    }

    void BMgr::RemoveBCB(BCB* ptr, int page_id)
    {

    }

    void BMgr::UpdateLRUEle(int frid)
    { lrulist.remove(frid);//——————————————
      lrulist.push_front(frid);//放入开始头

    }

    void BMgr::SetDirty(int frame_id)
    {
        BCBassemble[frame_id]->dirty=1;
    }

    void BMgr::UnsetDirty(int frame_id)
    {

    }

    void BMgr::WriteDirtys()
    {

    }

    void BMgr::PrintFrame(int frame_id)
    { for(int i=0;i<FRAMESIZE;i++)
            {cout<<buffer.bframe[frame_id].field[i];
            }
      cout<<endl;

    }
    BUFFER BMgr::getBuffer()
        {return buffer;
        }
    int main()
        {int datacount=0;
        ifstream infileStream;
        string str;
        infileStream.open("data.txt",ios::in);
        char requestdata[30];
        BMgr bMgr;
        while(!infileStream.eof())
            {datacount++;
            cout<<"datacount:*************"<<datacount<<endl;

            infileStream.getline(requestdata,20,'\n');//字符数组中包含"\n"
                //cout<<"****"<<strlen(requestdata)<<"***"<<endl;
                str=string(requestdata);
                if(str[str.size()-1]=='\n')
                str=str.substr(0,str.size()-1);//去掉\n，最后一列没有\n
               // cout<<"**"<<str<<"**"<<endl;
                int pos=str.find(',',0);
                string  strRorW=str.substr(0,pos);
                string strPage=str.substr(pos+1,str.length());
                stringstream ss;
                int flagWorR=-1;
                int pageAccessID=-1;
        //      cout<<"**"<<strRorW<<"****"<<endl;
        //      cout<<"**"<<strPage<<"****"<<endl;
                ss<<strRorW;
                ss>>flagWorR;

                ss.clear();
                ss<<strPage;
                ss>>pageAccessID;
               cout<<flagWorR<<","<<pageAccessID<<endl;



                int frameID=bMgr.FixPage(pageAccessID,flagWorR);//获得frameid
                char contentPage[FRAMESIZE];
                //strncpy(contentPage,bMgr.getBuffer().bframe[frameID].field,FRAMESIZE);//读进内存
                 //bMgr.PrintFrame(frameID);
                 bMgr.getFrameData(contentPage,frameID);
                 cout<<"&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"<<strlen(contentPage)<<endl;
                 for(int i=0;i<FRAMESIZE;i++)
                    {cout<<contentPage[i];
                    }
                 cout<<endl;


                //数据操作处理
                //×××××××××××

                //如果是写操作
                //设置写标志
                if(flagWorR==1)
                    {bMgr.SetDirty(frameID);//设置frameID对的frame写污染
                    }

                //读操作不管


                //操作完成处理之后，然后将锁减一；
                bMgr.decreaseLatch(frameID);








            }
         infileStream.close();
         bMgr.getDSMgr().CloseFile();
         cout<<"buffer和磁盘之间的IO次数是"<<count<<endl;

        return 0;
        }


//     list<int>::iterator  contain (list<int> listTemp,int elem)
//            {for(list<int>::iterator iter=listTemp.begin();iter!=listTemp.end();iter++)
//                {if(*iter==elem)
//                    return iter;
//                }
//             return listTemp.end();
//
//
//
//            }
//
//       list<int> getLRUList()
//            {return lrulist;
//            }
楼边斜月为明
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据库作业要求
qq_37184374的博客
11-21 273
存储和缓冲管理 实验目的 实现一个简易的存储和缓冲管理器 缓冲区和页面 缓冲区Buffer代表了在主存中的空间 缓冲区由frame组成 frame由下面的数据结构表示 #define FRAMESIZE 4096 struct bFrame{ Char field[FRAMESIZE]; }; 缓冲区buffer数组(array)会存储一系列frame(存储已装...
在单向链表中插入节点——C语言基础
Lanyan9的博客
07-21 5353
向单向链表插入节点 前言：链表的插入过程就是把新建的节点插入到已有的链表中，鉴于此种理解，也可以把链表的创建看做是一种特殊的插入节点过程，但是具体来说，链表的插入较于链表的创建来说稍复杂一些。 一、问题描述     编写函数，将一个节点插入到一个已有学生链表中，设已有链表按学号有小到大顺序已经排列。 二、算法描述 （1） 输入数据 （2） 生成新节点 （3） 将数据存入新节点 （4） 在链表中寻找第一个大于新节点的学号 注意：该算法的难点是第四步——在链表中寻找第一个
C语言：程序填空：填写两个函数，使代码连接structure.h和CreateStruct.c后利用结构体计算每个学生的平均分并输出分数与其对应学生姓名
Caleb Sung的博客
05-26 1640
题目来源：大工慕课 链接 作者：Caleb Sung 题目要求 本题中要用到的结构体类型的定义放在31.structure.h文件中，31.CreateStruct.c文件里放的是函数crtstruct的定义，这个函数用来为结构体数组赋值，每个学生的8门成绩通过随机数得到并放在结构体的score成员数组里。本题需要完成如下任务： （1）写一个函数ave()来求每个学生的平均分,并把...
【H.266/VVC】VTM-4.0中CodingStructure.h代码阅读
allensu374125056的博客
04-24 427
像是H.266中的CU，PU，TU都一起集合到了编码结构CS里面，我太困了脑子不清楚了。 class CodingStructure { public: UnitArea area;//各个分量的面积 Picture *picture;//指针类型 图片 CodingStructure *parent;//类似链表的结构 父类编码结构 #if JV...
关于线性表的线性表的实现(顺序结构)
weixin_30596023的博客
03-01 263
学习了数据结构后对线性表有了更好的了解，所谓线性表有两种实现方法，一种是用顺序结构，一种是用链式结构。具体说来就是用动态数组与链表的方式来实现。 这便是数据结构的两种储存方式，顺序存储结构与链式存储结构，同时也是数据结构研究的存储结构的具体体现，因此线性表的实现对于初步学习数据结构的我们有着重要的意义。 这篇博客用的是动态数组实现线性表。 利用了c++里面的关键词new 进行内存动态分配 ...
实时数据库openPlant
09-02
实时数据库openPlant驱动 com.magus.jdbc.jar
神通数据库驱动jar，Java 连接神通数据库驱动包
03-25
神通数据库驱动jar，Java 连接神通数据库驱动包
数据库课程设计：长途汽车信息管理数据库设计
最新发布
06-12
数据库课程设计：长途汽车信息管理数据库设计 数据库课程设计：长途汽车信息管理数据库设计 数据库课程设计：长途汽车信息管理数据库设计 数据库课程设计：长途汽车信息管理数据库设计 数据库课程设计：长途汽车信息...
数据库系统原理
03-15
数据库系统原理
ces 数据库 ces 数据库
07-20
ces 数据库 ces 数据库
单配送物流算法（简化为旅行商问题）
最爱山间那朵云
10-18 2488
1.     物流企业为N个客户配送产品，企业有一台卡车，客户的包裹均为小件，一车可以全部装载。请设计配送路径，使得配送所通过的总路程最短。 2.     分别做三次实验，每次试验中客户数分别为N = 10, 100, 1000 3.     每次实验按下述步骤进行： (1) 客户分别为1, 2, …, N，随机产生每两个客户之间的距离 (2) 卡车从物流企业出发，遍历所有客户，每个客户只
printf( )的格式字符
最爱山间那朵云
10-27 1158
printf( )的格式字符： ① d格式符　用来输出十进制整数 %d 按整型数据的实际长度输出 %md 使输出长度为m，如果数据长度小于m，则左补空格，如果大于m，则输出实际长度 %ld 输出长整型数据 ② o格式符　以八进制形式输出整数 ③ x格式符　以十六进制形式输出整数 ④ u格式符　用来输出unsigned型数据，以十进制形式输出 ⑤ c格式符　用来输出一个字符 ⑥ s
fstream 默认以字符方式读取和写文件，除非设置ios::binary
最爱山间那朵云
10-21 955
#include <fstream> #include <cstring> #include <iostream> using namespace std; void test(char name []) { ofstream fout; fout.open("2.jpg",ios::out|ios::binary); ifstream fin; fin.open("1.jpg",
AES算法加密文件
最爱山间那朵云
10-21 882
// cryptoDemo.cpp : Defines the entry point for the console application. // Windows: cl cryptoDemo.cpp // Linux: gcc -o cryptoDemo cryptoDemo.cpp -lcrypto#include <memory.h> #include <stdio.h> #include
为什么需要堆？
最爱山间那朵云
08-20 726
#reason 1 动态分配： int size = file.length(); char *mem = malloc(size); file.read(mem); 只要执行完int size = file.length();才能知道size多大，才好分配内存存储 #reason2 如果设想只用栈，如何在多个函数只能共享东西了？变量都是函数帧内私有。 又比如说，多个线程如何有效通信。共享内存。...
sizeof
最爱山间那朵云
09-13 718
#include &amp;amp;lt;iostream&amp;amp;gt; struct Empty {}; struct Base { int a; }; struct Derived : Base { int b; }; struct Bit { unsigned bit: 1; }; int main() { Empty e; Derived d; Base&amp;amp;amp; b = d;//b...
C++对象两种方法的声明
最爱山间那朵云
03-26 653
//正确的姿势： PointToPointHelper * ptrP2P[2]; for (int iAggNode=0;iAggNode<2;iAggNode++) { PointToPointHelper * pointToPoint=new PointToPointHelper() ; ptrP2P[iAggNode]=pointToPoint; } p
MySQL数据库介绍
03.MySQL数据库-new.pptx是一份关于MySQL数据库系统的文件，展示了数据库的基本概念和结构。数据库是用来存储和管理数据的仓库，具有存储大量数据、方便检索、保持数据一致性和完整性、安全可共享以及通过组合分析...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值