Esempio n. 1
0
/*
 * 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
}
Esempio n. 2
0
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);
}
Esempio n. 3
0
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);
}
Esempio n. 4
0
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;
	
}
Esempio n. 5
0
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);
}
Esempio n. 6
0
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
}
Esempio n. 7
0
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;
}
Esempio n. 8
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);
}
Esempio n. 9
0
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);
}
Esempio n. 10
0
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);
}
Esempio n. 11
0
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);
}