so-tp1/tasks.cpp

#include "tasks.h"
#include "stdlib.h"
#include <algorithm>

using namespace std;

void TaskCPU(int pid, vector<int> params) { // params: n
	uso_CPU(pid, params[0] - 1); // Uso el CPU n milisegundos.
}

void TaskIO(int pid, vector<int> params) { // params: ms_pid, ms_io,
	uso_CPU(pid, params[0]); // Uso el CPU ms_pid milisegundos.
	uso_IO(pid, params[1]); // Uso IO ms_io milisegundos.
}

void TaskAlterno(int pid, vector<int> params) { // params: ms_pid, ms_io, ms_pid, ...
	for(int i = 0; i < (int)params.size(); i++) {
		if (i % 2 == 0) uso_CPU(pid, params[i] - 1);
		else uso_IO(pid, params[i]);
	}
}

void TaskConsola(int pid, vector<int> params) {
	uint calls = params[0];
	uint bmin = params[1];
	uint bmax = params[2];

	for (uint i = 0; i < calls; i++) {
		uso_IO(pid, rand() %(bmax-bmin+1) + bmin);
		uso_CPU(pid, 1);
	}
}

void TaskBatch(int pid, vector<int> params ) {
	//Tengo que bloquear CPU total_cpu unidades; 
	//esto incluye 1 por cada vez que llamo a uso_IO
	//Entonces debo bloquear cpu total_cpu - cant_bloqueos
	//Y si cant_bloqueos > total_cpu ?
	uint total_cpu = params[0];
	uint cant_bloqueos = params[1];
	if (cant_bloqueos>total_cpu)// ???????
		return; 

	vector<int> arr;
	total_cpu = total_cpu - cant_bloqueos;
	uint i;

	for(i=0;i<total_cpu;i++)
		arr.insert(arr.end(),0);

	for(i=0;i<cant_bloqueos;i++)
		arr.insert(arr.end(),1);

	std::random_shuffle(arr.begin(),arr.end());
	
	for(i=0; i<arr.size();i++){
		if(arr[i]==1){
			uso_IO(pid, 2);
		} else {
			uso_CPU(pid, 1); //1 ciclo?
		}
	}
}


void tasks_init(void) {
	/* Todos los tipos de tareas se deben registrar acá para poder ser usadas.
	 * El segundo parámetro indica la cantidad de parámetros que recibe la tarea
	 * como un vector de enteros, o -1 para una cantidad de parámetros variable. */
	register_task(TaskCPU, 1);
	register_task(TaskIO, 2);
	register_task(TaskConsola, 3);
	register_task(TaskBatch, 2);
	register_task(TaskAlterno, -1);
}