Пример #1
0
void MemoryManager::showAllocatedMemory() {
    unsigned int beginAllocatedAddress, endAllocatedAddress, totalAllocated, processId, internalFragmentation, externalFragmentation;
    // INSERT YOUR CODE TO SHOW EACH ONE OF THE ALLOCATED MEMORY PARTITIONS, INCLUDING INTERNAL AND EXTERNAL (THE FOLLOWING) FRAGMENTATION
    // ...

    // for ... {  // for each partition...  
    // ...
    externalFragmentation = 0;
    for (int i=0; i<NUMBER_PARTITIONS; i++) {
        
        beginAllocatedAddress = _partitions[i]->getBeginAddress();
        endAllocatedAddress = _partitions[i]->getEndAddress();
        if (_partitions[i]->hasProcess()) {
            totalAllocated = getProcessSize(_partitions[i]->getProcess());
            processId = _partitions[i]->getProcess()->getId();
            internalFragmentation = _partitions[i]->getLength() - getProcessSize(_partitions[i]->getProcess());
        } else {
            totalAllocated = 0;
            processId = 0;
            internalFragmentation = _partitions[i]->getLength();
        }
        std::cout << "\tAllocd: " << "B=" << (beginAllocatedAddress) << ", \tE=" << (endAllocatedAddress) << ", \tT=" << (totalAllocated) << ", \tPID=" << (processId)
            << ", \tIF=" << (internalFragmentation) << ", \tEF=" << (externalFragmentation) << "\n";
    }
    // no not change the next line (the way information are shown)

    // }
}
void MemoryManager::allocateMemoryForProcess(Process* process) {
    unsigned int process_size = getProcessSize(process);

    // Alg. Best-fit descrito no livro [4]
    unsigned int initial_memory_waste = this->_size;
    unsigned int memory_waste = 0;
    Partition *best = nullptr;
    auto itBest = _freeList.end();

    for(auto it = _freeList.begin(); it != _freeList.end(); it++){
        if(process_size <= (*it)->getLength())
            memory_waste = (*it)->getLength() - process_size;
        else
            continue;

        if(initial_memory_waste > memory_waste){
            best = (*it);
            itBest = it;
            initial_memory_waste = memory_waste;
        }
    }

    if(best != nullptr){// Achou uma partição livre que caiba o processo
        unsigned int begin = best->getBeginAddress();
        unsigned int end = begin + process_size - 1;

        // Atualiza os limites de memória do processo
        process->setBeginMemory(begin);
        process->setEndMemory(end);

        // Atualiza a _freeList
        if(initial_memory_waste != 0){
            // Caso o processo não caiba perfeitamente na partição,
            //  então deve-se atualizar o endereço inicial da partição
            best->setBeginAddress(end+1);
        }else{
            // Caso o processo caiba perfeitamente na partição,
            //  então deleta ela da _freeList
            delete best;
            _freeList.erase(itBest);
        }

        // Adiciona a nova partição na _busyList
        addPartitionInOrder(new Partition(process, begin, end), true);

        //Simulator::getInstance()->getModel()->getProcessManager()->scheduler_choose(process);
    }else{// Processo entrou na fila de espera
        _queue.push_back(process);
    }
}
Пример #3
0
void MemoryManager::allocateMemoryForProcess(Process* process) {
    // INSERT YOUR CODE TO ALLOCATE MEMOTY FOR THE PROCESS
    // ...
    unsigned int processSize = getProcessSize(process);
    std::cout << "Process size :" << processSize << "\n" << "  Process id : " << process->getId() << "\n";
    for (int i=0; i<NUMBER_PARTITIONS; i++) {
        std::cout << "Size Partition :" << _partitions[i]->getLength() << "\n";
        if (_partitions[i]->getLength() > processSize) {
            if(!(_partitions[i]->hasProcess())) {
                _partitions[i]->setProcess(process);
                std::cout << "I was allocated\n";
                return;
            } else {
                _partitions[i]->addQueue(process);
                std::cout << "Entrei para fila" << process->getId() << "\n";
                return;
            }
        }
    }
    throw "não foi possível alocar";
}
Пример #4
0
bool functions::fits(Process *process, Partition *partition) {
    unsigned int processSize = getProcessSize(process);
    unsigned int partitionSize = partition->getLength();
    return (processSize <= partitionSize);
}
void MemoryManager::deallocateMemoryOfProcess(Process* process) {

    // Pequena proteção...
    if(process->getBeginMemory() == 0 &&
        process->getEndMemory() == 0)
        return;

    // Verifica se tem partições adjacentes
    auto itUp = _freeList.end();// Iterador da partição acima
    auto itDown = _freeList.end();// Iterador da partição abaixo
    for(auto it = _freeList.begin(); it != _freeList.end(); it++){
        auto tmp = (*it);
        if(tmp->getEndAddress()+1 == process->getBeginMemory()){
            itUp = it;
        }else if(tmp->getBeginAddress()-1 == process->getEndMemory()){
            itDown = it;
        }

        if(tmp->getBeginAddress() > process->getEndMemory())
            break;
    }

    auto pUp = (*itUp);// Partição acima
    auto pDown = (*itDown);// Partição abaixo

    // Espaço que ficará livre após este desalocamento
    unsigned int freeSize = 0;

    if(itUp != _freeList.end() && itDown != _freeList.end()){// Acima e abaixo
        // Existem partições livres acima e abaixo da partição que será desalocado

        pUp->setEndAddress(pDown->getEndAddress());// Atualiza o endereço final da partição acima
                                                   //  com o endereço final da partição abaixo [junta elas]
        freeSize = pUp->getLength();
        delete pDown;
        _freeList.erase(itDown);// Remove a partição abaixo
    }else if(itUp != _freeList.end() && itDown == _freeList.end()){// Só acima
        // Existe uma partição livre acima da que será desalocada

        pUp->setEndAddress(process->getEndMemory());// Atualiza o endereço final da partição acima
                                                    //  com o endereço final da partição que será desalocada
        freeSize = pUp->getLength();
    }else if(itUp == _freeList.end() && itDown != _freeList.end()){// Só abaixo
        // Existe uma partição livre abaixo da que será desalocada

        pDown->setBeginAddress(process->getBeginMemory());// Atualiza o endereço inicial da partição abaixo
                                                          //  com o endereço inicial da partição que será
                                                          //  desalocada
        freeSize = pDown->getLength();
    }else{// Isolada
        // A partição esta isolada, então simplesmente adicione
        //  ela na _freeList.
        auto tmp = new Partition(process->getBeginMemory(),
                                    process->getEndMemory());
        addPartitionInOrder(tmp, false);
        freeSize = tmp->getLength();
    }

    // Remove a partição do processo da _busyList
    for(auto it = _busyList.begin(); it != _busyList.end(); it++){
        auto tmp = (*it);
        if(tmp->getProcess() == process){
            delete (*it);
            _busyList.erase(it);
            break;
        }
    }

    // Zera a memória do processo
    process->setBeginMemory(0);
    process->setEndMemory(0);

    // Verifica se tem algum processo na fila que
    //  caiba no espaço gerado por esta desalocação
    unsigned int pSize = 0;
    for(auto it = _queue.begin(); it != _queue.end(); it++){
        auto tmp = (*it);
        pSize = getProcessSize(tmp);
        if(freeSize >= pSize){
            allocateMemoryForProcess(tmp);
            _queue.erase(it);
            break;
        }
    }
}