内存分配

Posted 2022-05-21 a1b3c7d9

内存分配

内存是计算机重要的资源之一，程序运行的过程中必须对内存进行分配。

经典的内存分配过程是这样进行的：

1、 内存以内存单元为基本单位，每个内存单元用一个固定的整数作为标识，称为地址。地址从0开始连续排列，地址相邻的内存单元被认为是逻辑上连续的。我们把从地址i开始的s个连续的内存单元称为首地址为i长度为s的地址片。

2、 运行过程中有若干进程需要占用内存，对于每个进程有一个申请时刻T，需要内存单元数M及运行时间P。在运行时间P内（即T时刻开始，T+P时刻结束），这M个被占用的内存单元不能再被其他进程使用。

3、假设在T时刻有一个进程申请M个单元，且运行时间为P，则：

若T时刻内存中存在长度为M的空闲地址片，则系统将这M个空闲单元分配给该进程。若存在多个长度为M个空闲地址片，则系统将首地址最小的那个空闲地址片分配给该进程。

如果T时刻不存在长度为M的空闲地址片，则该进程被放入一个等待队列。对于处于等待队列队头的进程，只要在任一时刻，存在长度为M的空闲地址片，系统马上将该进程取出队列，并为它分配内存单元。注意，在进行内存分配处理过程中，处于等待队列队头的进程的处理优先级最高，队列中的其它进程不能先于队头进程被处理。

现在给出一系列描述进程的数据，请编写一程序模拟系统分配内存的过程。

解

显然需要维护一个队列，处理不能被立即处理的进程，此外注意到数据范围只有10000,而有注意到我们需要查询每个进程能够使用的内存空间，（显然空间不能暴力存下来），我们可以考虑用三元组\((l,r,b)\)表示一段空间\([l,r]\)表示这段空间的位置,b表示这段内存是否被占用（１占用，０没占用）。

数据范围只有10000，于是可以暴力查询是否有空闲空间，而对于内存的合并和分离，我们就可以利用链表实现。

现在的问题是对于时间的处理，不可能取枚举时间，但是注意到整个题目，只有三个主体，队列中的等待元素，申请使用内存的程序，还有在占用内存的程序的结束，其中不难自我归纳出优先级为占用结束，等待元素，申请使用内存，而占用结束，显然不能一个数组保存下来，于是考虑优先队列，存储结束时间，每次能够知道哪个程序首先结束（注意一个细节，如果同时结束的话，需要特判，让它们先结束，再进行下一步）。

优先队列还要顺便维护它在链表中的位置，然后特判是否能够合并相邻的内存，再将其标记为０，然后再执行队列中的元素是否能够申请到内存，最后才是按正常顺序申请内存的程序，按照这个顺序，思维就不会乱了。（注意到结束的程序必然是在按正常顺序的程序申请开始时间之前）。

时间复杂度太玄学，不予分析。

参考代码：

#include <iostream>
#include <cstdio>
#include <queue>
#define il inline
#define ri register
#define Size 15000
using namespace std;
template<class free>
struct heap
    free a[Size];int n;
    il void push(free x)
        a[++n]=x;ri int p(n);
        while(p>1)
            if(a[p]<a[p>>1])
                swap(a[p],a[p>>1]),
                    p>>=1;
            else break;
    il void pop()
        a[1]=a[n--];ri int p(1),s(2);
        while(s<=n)
            if(s<n&&a[s+1]<a[s])++s;
            if(a[s]<a[p])
                swap(a[s],a[p]),
                    p=s,s<<=1;
            else break;
        
    
;
template<class free>
struct list
    struct iter
        iter*pre,*next;free v;
    *head,*tail,*lt;
    il void initialize()
        head=new iter(),tail=new iter();
        head->next=tail,tail->pre=head;
    
    il void insert(iter *p,free x)
        lt=new iterp->pre,p,x;
        p->pre->next=lt,p->pre=lt;
    
    il void erase(iter *p)
        p->next->pre=p->pre;
        p->pre->next=p->next;
        delete p;
    
    il void recycle()
        while(head!=tail)
            head=head->next,
                delete head->pre;
        delete tail;
    
;
struct Wait
    int m,p;
;
struct mem
    int l,r;bool used;
;
struct take
    int t;list<mem>::iter *p;
    il bool operator<(const take&x)const
        return t<x.t;
    
;
int tim;
queue<Wait>D;
list<mem>L;heap<take>H;
int t,m,p;
il bool give(int,int);
il void read(int&),release();
int main()L.initialize();
    int n,ans(0);read(n),L.insert(L.tail,0,n-1);
    while(read(t),read(m),read(p),t||m||p)
        while(H.a[1].t<t&&H.n)
            tim=H.a[1].t+1,release();if(H.n&&H.a[1].t+1==tim)continue;
            while(D.size())if(give(D.front().m,D.front().p))D.pop();
                else break;
        tim=t;if(!give(m,p))D.push(m,p),++ans;
    while(H.n)
        tim=H.a[1].t+1,release();if(H.n&&H.a[1].t+1==tim)continue;
        while(D.size())if(give(D.front().m,D.front().p))D.pop();
            else break;
    
    printf("%d\n%d",tim,ans),L.recycle();
    return 0;

il void release()
    if(!H.n)return;
    list<mem>::iter *i(H.a[1].p);
    if(i->pre!=L.head&&!i->pre->v.used)
        i->v.l=i->pre->v.l,L.erase(i->pre);
    if(i->next!=L.tail&&!i->next->v.used)
        i->v.r=i->next->v.r,L.erase(i->next);
    i->v.used=0,H.pop();

il bool give(int m,int p)list<mem>::iter *i;
    for(i=L.head->next;i!=L.tail;i=i->next)
        if(!i->v.used&&i->v.r-i->v.l+1>=m)
            int mid(i->v.l+m-1);
            if(mid<i->v.r)
                L.insert(i->next,mid+1,i->v.r,0),i->v.r=mid;
            i->v.used=1,H.push(tim+p-1,i);return true;
        return false;

il void read(int &x)
    x^=x;ri char c;while(c=getchar(),c<'0'||c>'9');
    while(c>='0'&&c<='9')x=(x<<1)+(x<<3)+(c^48),c=getchar();