ejercicios.pdf

Ejercicio 1

Podemos usar un método int accept_connection() que acepta las conexiones del servidor.

Comencemos con el main del servidor:

enum {READ, WRITE};
int pipes[2];
int sc_array[5] = {-1};

void manejador_forward(int sig) {
	message_t msg;
	read(pipes[READ], &msg, sizeof(msg));
	for (int i = 0; i < s; i++) {
		if(sc_arr[i] != -1 && sc_arr[i] != msg.id) {
			write(sc_arr[i], msg, sizeof(msg));
		}
	}
}

int main () {
	signal(SIGURG, manejador_forward);
	pipe(pipes);
	int cant_cliente = 0;
	while(true) {
		int socket_connection = accept_connection();
		fill_sc_array(socket_connection);
		pid_t pid_or_zero = fork();
		if (pid_or_zero == 0) {
			handle_client(socket_connection, cant_cliente);
		}
		cant_cliente++;
	}
}

El proceso hijo:

typedef struct message {
	int id;
	char buffer[128];
} message_t; 

void handle_client(int fd) {
	char buffer[BUFFER_SIZE];
	while (true) {
		read(fd, buffer, sizeof(buffer));
		message_t msg = {id: id, buffer: buffer};
		write(pipes[WRITE], msg, sizeof(msg));
		kill(getppid(), SIGURG);
	}
	exit(0);
}

Ahora, programemos el cliente:

void handler_sigint() {
	kill(pidorzero, sigkill);
	wait(null);
	exit(0);
}

int main() {
	int sc = make_connection();
	char buffer[128];
	pid_t pid = fork();
	if (pid == 0) {
		signal(SIGINT, handler_sigint);
		while(true) {
			read(sc, buffer, sizeof(buffer));
			printf("%s", buffer);
		} 
		exit(0);
	else {
		while(true) {
			scanf(%s, buffer);
			write(sc, buffer, sizeof(buffer));
		}
	}
	wait(0);
	kill(pid, SIGKILL);
}

Ejercicio 2

Se asume que el sistema es planificable.

RT → [EDF | FCFS] Es más rápido FCFS ya que lo que quiero es resolver cada tarea lo ants posible.

Colas 1 a la K: Son interactivas en RR. Para evitar starvation y que haya fluidez de las tareas. El quantum es de k para la k cola.

Cuando ingresa una tarea nueva, comienzan en la cola 1. Vamos a implementar una Multilevel Feedback Queue. El feedback se refiere a que cada tarea va a quedar en la cola de quantum correspondiente: si se termina el quantum se la baja de prioridad, si no se la mantiene o se la sube según cuan cerca del final del quantum se bloqueó.

Podemos implementar aging: si pasó un segundo entero que no se corrieron ciertos procesos, se sube el tiempo del proceso. Garantiza que nadie se quede estancado.

Tiene que ser con desalojo (preemptive) para que, ante la llegada de un proceso de mayor prioridad, este no responda lentamente.

Puede haber starvation con las tareas real time ya que pueden llegar muchas bloqueando el sistema. Pero es el comportamiento esperado dado el sistema.

El tiempo de real time, si se puede acotar por t, es de k*t, siendo k la cantidad de tareas que llega antes.

Ejercicio 3

Es el mismo que el ejercicio 8 de la guía.