so-tp1/sched_mfq.cpp

#include <map>
#include <iostream>
#include <vector>
#include <queue>
#include "sched_mfq.h"
#include "basesched.h"

using namespace std;

SchedMFQ::SchedMFQ(vector<int> argn) {
	// MFQ recibe los quantums por parámetro
	n_colas = argn[1];
	q_cola = new uint[n_colas];

	for( uint i = 0; i < n_colas ;i++ ){
		q_cola[i] = argn[2+i];
		v_cola.push_back(std::map<int,process>());
	}
}

SchedMFQ::~SchedMFQ() {
	delete[] q_cola;
}

void SchedMFQ::load(int pid) {
	v_cola[0][pid].state=READY; //Cargo PID en la cola de mayor prioridad
}

void SchedMFQ::unblock(int pid) {
	uint p_q=pid_queue(pid);
	v_cola[p_q][pid].state = READY;
	v_cola[p_q][pid].quantum_count = 0;

	if(p_q > 0) { //Hay una cola "mejor" para ir; lo llevo
		v_cola[p_q-1][pid]=v_cola[p_q][pid];
		v_cola[p_q].erase(pid);
	}
}

uint SchedMFQ::pid_queue(uint pid){
	for( uint i = 0; i < n_colas; i++ )
		if ( v_cola[i].count(pid) == 1) //Solo hay 0/1 key en un map
			return i;

	return 65535; // ??
}

int SchedMFQ::ready_at(uint qn){
	if (v_cola[qn].size() == 0)
		return -1;
	for (it_type it = v_cola[qn].begin(); it != v_cola[qn].end(); it++) {
		if (it->second.state == READY)
			return it->first;
	}
	return -1;
}
uint SchedMFQ::next_pid(){
	for( uint q = 0; q < n_colas; q++ ){
		int p = ready_at(q);
		if (p!=-1){
			return p; //Algun proceso listo
		}
	}

	return IDLE_TASK;
	//return 65535;
}

int SchedMFQ::tick(int core, const enum Motivo m) {
	uint switch_process = 0;
	uint cur_pid = current_pid(core);
	if (cur_pid == IDLE_TASK)
		return next_pid();

	uint p_q = pid_queue(cur_pid);
	//cout << "curpid " << cur_pid << endl; //-1
	//cout << "p_q " << p_q << endl; //65535, segfault

	process cur_process=v_cola[p_q][cur_pid];
	//cout << "asd4" << endl;
	switch (m) {
	case TICK:
		cur_process.quantum_count++;
		if (cur_process.quantum_count >= q_cola[p_q]) {
			switch_process = 1;
			cur_process.state = READY;
			cur_process.quantum_count = 0;
			if(p_q < n_colas) { //Hay una cola "peor" para ir; lo llevo
				v_cola[p_q+1][cur_pid]=cur_process;
				v_cola[p_q].erase(cur_pid);
			}
		}
		break;
	case BLOCK:
		switch_process = 1;
		cur_process.state = BLOCKED;
		break;
	case EXIT:
		switch_process = 1;
		v_cola[p_q].erase(cur_pid);
		break;
	}
	if (switch_process)
		return next_pid();

	return cur_pid;
}