/*
* Fonction auxilière à producer
* Crée une fractale depuis un string
*
* @str: description d'une fractale
* @return: la fractale créée
*/
struct fractal* compute(char* str) {
const char *delim = " ";
char* name = strtok(str, delim);
if (name == NULL) { //Il n'y a pas de nom
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
char* token = strtok(NULL, delim);
if (token == NULL) { //Il n'y a pas de longueur
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
int width = atoi(token);
if (width <= 0) { //la longueur est invalide
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
token = strtok(NULL, delim);
if (token == NULL) { //Il n'y a pas de hauteur
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
int height = atoi(token);
if (height <= 0) { //la hauteur est invalide
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
token = strtok(NULL, delim);
if (token == NULL) { //Il n'y a pas de valeur a
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
double a = strtod(token, NULL);
if (a > 1.0 || a < -1.0) { //a n'est pas dans les bonnes bornes
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
token = strtok(NULL, delim);
if (token == NULL) { //Il n'y a pas de valeur b
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
double b = strtod(token, NULL);
if (b > 1.0 || b <- 1.0) { //b n'est pas dans les bonnes bornes
fprintf(stderr, "Erreur, la fractale : %s n'est pas formatée correctement. Elle a été ignorée", str);
return NULL;
}
struct fractal *result = fractal_new(name, width, height, a, b); //crée la fractale
pthread_mutex_lock(&newfract);
readFract++; //Une fractale supplémentaire a été créée
pthread_mutex_unlock(&newfract);
return result; //Renvoie la fracale
}
void *reader(void *param)
{
int err = 0;
fractal_t *new_fract = NULL;
FILE *input = NULL;
const char *file_name = (char *) param;
if (strcmp(file_name, "stdin") == 0) {
log_info("Reading on standard input. %s", param);
input = stdin;
} else {
log_info("Reading file %s.", file_name);
input = fopen(file_name, "r");
}
check(input, "Failed to open %s.", file_name);
log_info("Succesfully opened file.");
char line[SIZE_MAX] = "";
char *n = (char *) malloc (NAME_LEN * sizeof(char));
int w = 0;
int h = 0;
double a = 0.0;
double b = 0.0;
while (fgets(line, SIZE_MAX, input)) {
if (sscanf(line, "%s %d %d %lf %lf", n, &w, &h, &a, &b) == 5
&& line[0] != '#') {
new_fract = fractal_new(n, w, h, a, b);
check(new_fract, "Failed to mallocate %s.", n);
sem_wait(&empty);
pthread_mutex_lock(&mutex_buffer);
check(!enqueue(new_fract), "erreur avec enqueue/");
sem_wait(&full);
pthread_mutex_lock(&mutex_buffer);
}
}
check(fclose(input) != 0, "", (char *) param);
log_info("Succesfully closed file.");
print_buffer();
pthread_mutex_lock(&mutex_closing);
is_reading--;
pthread_mutex_unlock(&mutex_closing);
log_info("Reader ends for an input");
return NULL;
error:
fclose(input);
exit(EXIT_FAILURE);
}
void *reader(void* in){
struct argsRead* inS = (struct argsRead*)in;
char* input = inS->input;
buffer* out = inS->out;
if(strcmp("-",input)){
freopen("/tmp/thefractal", "r", stdin);
}
FILE* f = fopen(input, "r");
if(f == NULL && errno != 0){
//handle the error here
}
char *buff = (char*)malloc(sizeof(char)*128), *lect= buff;
char *nom = (char*)malloc(sizeof(char)*64);
int x, y;
double a, b;
fractal* result;
while(lect != NULL){
lect=buff;
lect = fgets(lect, 128, f);
if(lect != NULL){
if(lect[0]!='#' && lect[0]!='\0'){
result = (fractal*)malloc(sizeof(fractal));
sscanf(lect, "%s %d %d %lf %lf", nom, &x, &y, &a, &b);
result = fractal_new(nom, x, y, a, b);
if(DEBUG){
printf("Lu: %s\n",result->nom);
fflush(stdout);
}
unload(out, result);
}
}
}
//saying that this thread has finished
pthread_mutex_lock(&(out->mutexEnd));
out->endProduct = out->endProduct+1;
pthread_mutex_unlock(&(out->mutexEnd));
free(buff);
fclose(f);
int returnValue = 1;
pthread_exit((void*)&returnValue);
}
void producer(){
int currentLine = 1;
int currentFile = 0;
while(currentFile<FILEAMOUNT)
{
char* fractalResult=getFractal(files[currentFile], currentLine);
currentLine++;
printf("after get fractal: %s",fractalResult);
if(eof==true){
currentFile++;
eof=false;
}
if(fractalResult[0]!="#"){
printf("just before sem wait \n");
sem_wait(&empty);
pthread_mutex_lock(&mutexFractal);
int index;
for(int i =0;i<10;i++){
if(fractal_get_height(slots[i])<0){
index=i;
}
}
char * name= strtok(fractalResult," ");
char * width = strtok(NULL," ");
char * height = strtok(NULL," ");
char * a = strtok(NULL," ");
char * b = strtok(NULL," ");
slots[index]= fractal_new(atoi(width), atoi(height), atof(a), atof(b), name);
pthread_mutex_unlock(&mutexFractal);
sem_post(&full);
}
}
printf("After while");
noMoreFiles=true;
}
void test_libfractal_get_set_value() {
fractal_t *ptr = fractal_new(name, 10, 10, a, b);
int w = fractal_get_width(ptr);
int h = fractal_get_height(ptr);
int x = 0;
int y = 0;
for ( y = 0; y < h ; y++) {
for( x = 0; x < w ; x++) {
fractal_set_value(ptr, x, y, x+y*10);
}
}
for ( y = 0; y < h ; y++) {
for( x = 0; x < w ; x++) {
CU_ASSERT_EQUAL(fractal_get_value(ptr, x, y), x+y*10);
}
}
fractal_free(ptr);
}
void * average() {
/* Récupération des variables pour la condition de fin */
pthread_mutex_lock(&files);
pthread_mutex_lock(&newfract);
pthread_mutex_lock(&finished);
int flag = flagFiles;
int nread = readFract;
int nfinished = finishedFract;
pthread_mutex_unlock(&files);
pthread_mutex_unlock(&newfract);
pthread_mutex_unlock(&finished);
struct fractal *bestAv = fractal_new("empty", 1, 1, 0.0, 0.0); //Variable où stocker la meilleure fractale
while (!flag || nread != nfinished) { //Tant qu'il y a des fichiers à lire ou que le nombre de fractales créées est différent du nombre de fracales terminées
sem_wait(&full2); //On attend qu'il y ait quelque chose dans le buffer
pthread_mutex_lock(&mutex2); //On lock
struct fractal *test = stack_pop(&buffer2); //On prend la fractale;
if (fractal_get_av(test) > fractal_get_av(bestAv)) { //Si la fractale est meilleure que celle précédement en mémoire
fractal_free(bestAv);
bestAv = test;
} else {
fractal_free(test);
}
pthread_mutex_unlock(&mutex2);
sem_post(&empty2);
/* Update des variables pour la condition de fin */
pthread_mutex_lock(&files);
pthread_mutex_lock(&newfract);
pthread_mutex_lock(&finished);
finishedFract++; //Une fracatle supplémentaire est terminée
flag = flagFiles;
nread = readFract;
nfinished = finishedFract;
pthread_mutex_unlock(&files);
pthread_mutex_unlock(&newfract);
pthread_mutex_unlock(&finished);
}
pthread_exit((void *) bestAv); //Renvoie la meilleure fractale
}
int main(int argc, char *argv[])
{
///////LECTURE PARAMETRES/////////////
int printAll = 0;
//entier dans lequel on va stocker la position du "-" dans le tableau d'argument
//et qui nous indiquera si il faut gerer l'entree standard
int pos = 0;
//Commence a 1 car 0 est le nom du file
int i = 1;
int comp_maxthread1 = strcmp("--maxthreads", argv[i]);
int comp_d1 = strcmp("-d", argv[i]);
if(comp_maxthread1 == 0){
i++;
MAXTHREADS = atoi(argv[i]);
i++;
}
else if(comp_d1 == 0){
printAll = 1;
i++;
}
//on regarde quel est le deuxieme argument
int comp_maxthread2 = strcmp("--maxthreads", argv[i]);
int comp_d2 = strcmp("-d", argv[i]);
if(comp_maxthread2==0){
i++;
MAXTHREADS = atoi(argv[i]);
i++;
}
if(comp_d2==0){
printAll = 1;
i++;
}
while(i<argc-1){
int comp2 = strcmp("-",argv[i]);
if(comp2==0){
pos = i;
}
else{
strcpy(files[FILEAMOUNT],argv[i]);
FILEAMOUNT++;
}
i++;
}
char* fichierout = argv[argc-1];
//////////FIN LECTURE PARAMETRES////////:
printf("maxThreads : %d \n",MAXTHREADS);
printf("file amount : %d \n",FILEAMOUNT);
for(i=0;i<100;i++){
if(files[i] !=NULL){
printf("file: %s \n",files[i]);
}
}
emptyFract=fractal_new(-1,-1,-1.0,-1.0,"empty");
for(int i =0;i<10;i++){
slots[i]=emptyFract;
}
int err=pthread_mutex_init( &mutexFractal, NULL);
if(err!=0)
error(err,"pthread_mutex_init");
sem_init(&empty, 0 , 10); // buffer vide
sem_init(&full, 0 , 0); // buffer vide
printf("Before producer call");
producer();
return 0;
}
void test_libfractal_get_b() {
fractal_t *ptr = fractal_new(name, width, height, a, 42.0);
CU_ASSERT_EQUAL(fractal_get_b(ptr), 42.0);
fractal_free(ptr);
}
void test_libfractal_get_height() {
fractal_t *ptr = fractal_new(name, width, 42, a, b);
CU_ASSERT_EQUAL(fractal_get_height(ptr), 42);
fractal_free(ptr);
}
void test_libfractal_get_name() {
fractal_t *ptr = fractal_new("CUnit", width, height, a, b);
CU_ASSERT_EQUAL(fractal_get_name(ptr), "CUnit");
fractal_free(ptr);
}
void test_libfractal_ptr_value_not_null() {
fractal_t *ptr = fractal_new(name, width, height, a, b);
CU_ASSERT_PTR_NOT_NULL(ptr->value);
fractal_free(ptr);
}
