Реализация страничного распределения памяти

#include <iostream>
#include "classes.h"
 
int main(){
    freopen("input.txt", "rt", stdin);
    int pageCount;
    cin >> pageCount;
    MemoryManager myMemory(pageCount);
    int n;
    vector < Request > requests;
    vector < Process > procs;
    cin >> n;
    forn(i, n){
        int pid = i;
        int segmentCount;
        cin >> segmentCount;
        vector<int> segments;
        segments.resize(segmentCount);
        forn(j, segmentCount){
            cin >> segments[j];
        }
        int requestCount;
        cin >> requestCount;
        forn(j, requestCount){
            int rTime, rAdress;
            cin >> rTime >> rAdress;
            requests.push_back(Request(rTime, pid, rAdress));
        }
        procs.push_back(Process(pid, segments, requestCount, &myMemory));
    }
    sort(all(requests));
    forn(i, sz(requests)){
        sysTime = requests[i].requestTime;
        procs[requests[i].PID].requestData(requests[i].virtAdress);
    }
    return 0;
}

#include <vector>
#include <queue>
#include <set>
#include <map>
#include <algorithm>
#include <cassert>
 
using namespace std;
 
#define forn(i, n) for(int i = 0; i < int(n); ++i)
#define sz(v) (int((v).size()))
#define mp(p, q) (make_pair((p), (q)))
#define all(v) (v).begin(), (v).end()
 
const int INF = 1e9;
const int MEMORY_SIZE = 512;
 
int sysTime = 0;
 
class MemoryManager;
class ProcessMemory;
 
struct Request{
    int requestTime, PID, virtAdress;
    Request(int cRequestTime = 0, int cPID = 0, int cVirtAdress = 0){
        requestTime = cRequestTime;
        PID = cPID;
        virtAdress = cVirtAdress;
    }
    bool operator < (const Request& c){
        return requestTime < c.requestTime;
    }
};
 
class Process{
    private:
        int PID, requestCounter, requestCount;
        vector<int> segmentSizes;
        MemoryManager* manager;
        void load();
        void die();
    public:    
        Process(int cPID, const vector<int>& cSegmentSizes, int cRequestCount, MemoryManager* cManager);
        void requestData(int virtAdress);
};
 
class MemoryManager{
    friend ProcessMemory;
    private:
        int pageSize, pageCount;
        set<int> freePages;
        map<int, ProcessMemory> processes;
        int getFreePage();
    public:
        MemoryManager(const int cPageCount = 16);
        int getPageSize();
        int newProcess(int PID, const vector<int>& segmentSizes);
        bool hasProcess(int PID);
        void killProcess(int PID);
        void getAccess(int PID, int virtAdress);
};
 
class ProcessMemory{
    friend MemoryManager;
    private:
        MemoryManager* manager;
        vector<int> sumAdress;
        vector< vector< pair<int, int> > > pages;
        pair<int, int> getLessPage();
        void freeLessPage();
        void getAccess(int virtAdress);
        void getPageList(vector<int>& result);
    public:
        ProcessMemory(const vector<int>& segmentSizes = vector<int>(1, 1), MemoryManager* cManager = 0);        
};
 
MemoryManager::MemoryManager(const int cPageCount){
    pageCount = cPageCount;
    pageSize = MEMORY_SIZE / pageCount;
    forn(i, pageCount){
        freePages.insert(i);
    }
}
 
int MemoryManager::getPageSize(){
    return pageSize;
}
 
int MemoryManager::getFreePage(){
    if (!freePages.empty()){
        int v = *freePages.begin();
        freePages.erase(v);
        return v;
    }else{
        pair<int, int> minP(-1, INF);
        int process;
        for(map<int, ProcessMemory>::iterator it = processes.begin(); it != processes.end(); it++){
            pair<int, int> curP = it->second.getLessPage();
            if (minP.second > curP.second){
                process = it->first;
                minP = curP;
            }
        }
        assert(minP.first != -1);
        processes[process].freeLessPage();
        return minP.first;
    }
}
 
int MemoryManager::newProcess(int PID, const vector<int>& segmentSizes){
    /*if (PID == -1){
        PID = 0;
        while(processes.count(PID) != 0){
            ++PID;
            //PID = rand() % (sz(processes) + 1);
        }
    }*/
    assert(processes.count(PID) == 0);
    ProcessMemory newProc(segmentSizes, this);
    processes.insert(mp(PID, newProc));
    return PID;
}
 
bool MemoryManager::hasProcess(int PID){
    return processes.count(PID);
}
 
void MemoryManager::killProcess(int PID){
    assert(processes.count(PID));
    vector<int> processPages;
    processes[PID].getPageList(processPages);
    processes.erase(PID);
    forn(i, sz(processPages)){
        freePages.insert(processPages[i]);
    }
}
 
void MemoryManager::getAccess(int PID, int virtAdress){
    assert(processes.count(PID));
    processes[PID].getAccess(virtAdress);
}
ProcessMemory::ProcessMemory(const vector<int>& segmentSizes, MemoryManager* cManager){
    manager = cManager;
    int s = 0;
    sumAdress.resize(sz(segmentSizes));
    pages.resize(sz(segmentSizes));
    forn(i, sz(segmentSizes)){
        int curSegment = segmentSizes[i];
        sumAdress[i] = s;
        s += curSegment;
        pages[i].resize(curSegment / (manager->getPageSize()));
        forn(j, sz(pages[i])){
            pages[i][j].first = -1;
        }
    }
}
 
pair<int, int> ProcessMemory::getLessPage(){
    pair<int, int> minP(-1, INF);
    forn(i, sz(pages))
        forn(j, sz(pages[i]))
            if (pages[i][j].first != -1 && pages[i][j].second < minP.second){
                minP = pages[i][j];
            }
    return minP;
}
 
void ProcessMemory::freeLessPage(){
    pair<int, int> minP(-1, INF), cords;
    forn(i, sz(pages))
        forn(j, sz(pages[i]))
            if (pages[i][j].first != -1 && pages[i][j].second < minP.second){
                minP = pages[i][j];
                cords = mp(i, j);
            }
    if (minP.first != -1){
        pages[cords.first][cords.second].first = -1;
    }
}
 
void ProcessMemory::getAccess(int virtAdress){
    int lf = 0, rg = sz(sumAdress);
    while(rg - lf > 3){
        int mid = lf + (rg - lf) /.2;
        if (sumAdress[mid] < virtAdress)
            lf = mid;
        else
            rg = mid;
    }
    int segmentNum = lf;
    while(segmentNum < sz(sumAdress) - 1 && sumAdress[segmentNum + 1] <= virtAdress)
        segmentNum++;
    virtAdress -= sumAdress[segmentNum];
    int pageNum = virtAdress / (manager->getPageSize()),
        pageMove = virtAdress % (manager->getPageSize());
    if (pages[segmentNum][pageNum].first == -1){
        pages[segmentNum][pageNum].first = (manager->getFreePage());
    }
    pages[segmentNum][pageNum].second = sysTime;
}
 
void ProcessMemory::getPageList(vector<int>& result){
    forn(i, sz(pages))
        forn(j, sz(pages[i]))
            if (pages[i][j].first != -1)
                result.push_back(pages[i][j].first);
}
 
Process::Process(int cPID, const vector<int>& cSegmentSizes, int cRequestCount, MemoryManager* cManager){
    PID = cPID;
    manager = cManager;
    segmentSizes = cSegmentSizes;
    forn(i, sz(segmentSizes)){
       if (segmentSizes[i] % (manager->getPageSize()) != 0){
           segmentSizes[i] -= (segmentSizes[i] % (manager->getPageSize()));
           segmentSizes[i] += manager->getPageSize();
       }
    }
    requestCounter = 0;
    requestCount = cRequestCount;
}
void Process::load(){
    manager->newProcess(PID, segmentSizes);
}
 
void Process::die(){
    manager->killProcess(PID);
}
 
void Process::requestData(int virtAdress){
    if (!manager->hasProcess(PID))
        load();
    manager->getAccess(PID, virtAdress);
    requestCounter++;
    if (requestCounter == requestCount){
        die();
    }
}