schedule.c

#include "schedule.h"

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "util.h"
#include "list.h"
#include "instance.h"

/********************************************************************
 * schedule_node_t
 ********************************************************************/

/**
 * @brief Construire et initialiser un nouveau nœud d'un ordonnancement.
 * 
 * @param[in] task 
 * @param[in] bt 
 * @param[in] et 
 * @return struct schedule_node_t* 
 */
static struct schedule_node_t * new_schedule_node(struct task_t * task, unsigned long bt, unsigned long et) {
	assert(bt < et);
	struct schedule_node_t* sched = (struct schedule_node_t*)malloc(sizeof(struct schedule_node_t));
	sched->task = task;
	sched->begin_time = bt;
	sched->end_time = et;
	return sched; //here
}

struct task_t * get_schedule_node_task(const struct schedule_node_t * snode) {
	// A FAIRE
	assert(snode);
	return snode->task;
}

unsigned long get_schedule_node_begin_time(const struct schedule_node_t * snode) {
	// A FAIRE
	assert(snode);
	return snode->begin_time;
}

unsigned long get_schedule_node_end_time(const struct schedule_node_t * snode) {
	// A FAIRE
	assert(snode);
	return snode->end_time;
}

void set_schedule_node_begin_time(struct schedule_node_t * snode, unsigned long new_bt) {
	// A FAIRE
	assert(snode);
	snode->begin_time = new_bt;
}

void set_schedule_node_end_time(struct schedule_node_t * snode, unsigned long new_et) {
	// A FAIRE
	assert(snode);
	snode->end_time = new_et;
}

void view_schedule_node(const void * snode) {
	// A FAIRE
	assert(snode);
	struct schedule_node_t *node = (struct schedule_node_t*)snode;
	view_task(node->task);
	printf("beginTime : %lu endTime : %lu \n", node->begin_time, node->end_time);
}

void delete_schedule_node(void * snode) {
	assert(snode);
	struct schedule_node_t* sched = (struct schedule_node_t*)snode;
	free(sched);
}

/********************************************************************
 * schedule_t
 ********************************************************************/

struct schedule_t * new_schedule(int num_m) {
	assert(num_m >= 1);
	struct schedule_t* sched = (struct schedule_t*)malloc(sizeof(struct schedule_t));
	assert(sched);
	sched->schedule = (struct list_t**)calloc(num_m, sizeof(struct list_t*));	// init à zero automatiquement
	for (int i = 0; i < num_m; ++i)
		sched->schedule[i] = new_list(view_schedule_node, delete_schedule_node);
	sched->num_machines = num_m;
	return sched;
}

struct list_t * get_schedule_of_machine(const struct schedule_t * S, const int machine) {
	// A FAIRE
	assert(S);
	return S->schedule[machine];
}

int get_num_machines(const struct schedule_t * S) {
	// A FAIRE
	assert(S);
	return S->num_machines;
}

void view_schedule(const struct schedule_t * S) {
	// A FAIRE
	assert(S);
	for(int i = 0; i < S->num_machines; i++){
		view_list(S->schedule[i]);
	}
}

void delete_schedule(struct schedule_t * S) {
	// A FAIRE
	assert(S);
	for(int i = 0; i < S->num_machines; i++){
		delete_list(S->schedule[i], 1);
	}
	delete_list(S->num_machines, 1);
	delete_list(S, 1);
}

// Pour le format du fichier à créer, regardez dans la présentation du cours.
void save_schedule(struct schedule_t * S, char * filename) {
	assert(S);
	FILE* fp = fopen(filename, "wt");
	if (fp == NULL) 
	{
		printf("Erreur lors de l'ouverture pour écriture du fichier %s\n", filename);
		return NULL;
	}
	int num = get_num_machines(S);
	fprintf(fp, "%d\n", num);
	for (int i = 0; i < num; ++i)
	{
		fprintf(fp, "M%d\n", i);
		struct list_t* list = get_schedule_of_machine(S, i);
		struct schedule_node_t* walk = get_list_head(list);
		while (walk)
		{
			fprintf(fp, "%d %d %s", 
				get_schedule_node_begin_time(walk), 
				get_schedule_node_end_time(walk), 
				get_task_id(get_schedule_node_task(walk))
			);
			walk = get_successor(walk);
		}
	}

	fclose(fp);
}


int find_empty_machine(struct schedule_t * S, unsigned long time) {
	// A FAIRE
	assert(S);
	for(int i = 0; i < get_num_machines(S); i++)
	{
		struct list_t* machine =  get_schedule_of_machine(S, i);
		struct schedule_node_t* task = (struct schedule_node_t*) get_list_node_data(get_list_tail(machine));
		if(time > get_schedule_node_end_time(task)) {
			return i;
		}
	}
	return -1;
}

int find_machine_to_interrupt(struct schedule_t * S, unsigned long time, unsigned long processing_time) {
	// A FAIRE
	assert(S);
		for(int i = 0; i < get_num_machines(S); i++)
	{
		struct list_t* machine =  get_schedule_of_machine(S, i);
		struct schedule_node_t* task = (struct schedule_node_t*) get_list_node_data(get_list_tail(machine));
		if( (time - get_schedule_node_begin_time(task)) < processing_time){
			return i;
		}
	}
	return -1;
}

void add_task_to_schedule(struct schedule_t * S, struct task_t * task, int machine, unsigned long bt, unsigned long et) {
	// A FAIRE
	assert(S);
	assert(task);
	assert(machine >= 0 && machine < get_num_machines(S));

	struct schedule_node_t* sched = new_schedule_node(task, bt, et);
	struct list_t* list = get_schedule_of_machine(S, machine);
	assert(get_schedule_node_end_time(sched) < bt);
	list_insert_last(list, sched);
}

unsigned long preempt_task(struct schedule_t * S, int machine, unsigned long new_et) {
	// A FAIRE int machine
	assert(S);
	assert(machine >= 0 && machine < get_num_machines(S));
	struct list_t* M = get_schedule_of_machine(S, machine);
	assert(get_list_tail(M));
	struct schedule_node_t* task = (struct schedule_node_t*) get_list_node_data(get_list_tail(M));
	unsigned long ret = get_schedule_node_end_time(task) - new_et;
	set_schedule_node_end_time(task, new_et);
	
	return ret; //temps restant de la tache prempté 
	
}

unsigned long get_makespan(struct schedule_t * S) {
    assert(S);

    unsigned long makespan = 0;

    for(int i = 0; i < get_num_machines(S); i++) {
        struct list_t* machine = get_schedule_of_machine(S, i);
        struct schedule_node_t* last_task = (struct schedule_node_t*) get_list_node_data(get_list_tail(machine));
        unsigned long end_time = get_schedule_node_end_time(last_task);
        if(end_time > makespan) {
            makespan = end_time;
        }
    }

    return makespan;
}