Bonsoir je développe une application sur l'algorithme génétique appliquer au TSP sous l'environnement CUDA avec le langage C mon problème c'est que lorsque je veux augmenter le nombre de ville de 100 jusqu'à 500 je ne peux mon application plante. voila mon code
#include <stdio.h>
#include <stdlib.h>
#include <cuda_runtime.h>
#include <string.h>
#include <time.h>
#include <math.h>
#include <math_functions.h>
#include <gtk/gtk.h>
#include <GL/glut.h>
#define BLOCK_SIZE 16
typedef struct
{ char nomville[20];
long x;
long y;
}ville;
typedef struct
{ int *a;
float b;
int maxiteration;
}individu;
__global__ void initialisation_population(int nombreville, int indicevilledepart, int *population_d)
{ int k = blockIdx.x * blockDim.x + threadIdx.x;
int l = blockIdx.y * blockDim.y + threadIdx.y;
int index = k * nombreville + l;
if(index%nombreville==0)
{ population_d[index] = indicevilledepart;
}
else { population_d[index] = -1;
}
}
__global__ void initialisation_verification(int nombreville, int indicevilledepart, int *verification_d)
{ int k = blockIdx.x * blockDim.x + threadIdx.x;
int l = blockIdx.y * blockDim.y + threadIdx.y;
int index = k * nombreville + l;
if(((index-indicevilledepart)%nombreville)==0)
{ verification_d[index] = 1;
}
else { verification_d[index] = 0;
}
}
__global__ void somme(long *p_d, long *distance_d, int nombreville, float *resultat_d, int nombreindividu)
{ float Cvalue=0;
long difference=0;
long carre=0;
int row = blockIdx.x * blockDim.x + threadIdx.x;
int col = blockIdx.y * blockDim.y + threadIdx.y;
for (int e = 0 ; e < 2 ; e++)
{ difference = abs(distance_d[row * 2 + e] - p_d[e * (nombreville*nombreindividu) + col]);
carre = difference * difference;
Cvalue+= carre;
}
resultat_d[row * (nombreville*nombreindividu) + col] = sqrt(Cvalue);
}
int grainerandom=0;
int tirage(long valeurmax)
{ int resultat;
srand(grainerandom+=time(NULL));
resultat=((rand()+1)%(valeurmax--));
return resultat;
}
GtkWidget *MainWindow;
GtkWidget *Window_Iteration;
GtkWidget *Window_Final;
GtkWidget *Window_Final2;
GtkWidget *Window_Temps;
GtkWidget *HBox1;
GtkWidget *VBox1;
GtkWidget *VBox2;
GtkWidget *VBox3;
GtkWidget *VBox5;
GtkWidget *Label1;
GtkWidget *Label2;
GtkWidget *Label3;
GtkWidget *Button[8];
GtkWidget *Entry1;
GtkWidget *Entry2;
GtkWidget *Entry3;
GtkWidget *Entry4;
GtkWidget *Entry6;
GtkWidget *Entry7;
individu meilleurindividu;
ville *v;
int nombreville;
int nombreindividu;
int *population_h;
int moitiepopulation;
int i;
size_t size;
dim3 dimBlock(BLOCK_SIZE, BLOCK_SIZE);
FILE *sauvegarde;
int *verification_h;
int j;
float tauxmutationuser;
int tauxmutation;
int indicevilledepart=-1;
void annuler (GtkWidget *pButton, gpointer data);
void annuler_nombre_iteration (GtkWidget *pButton, gpointer data);
void annuler_final_nombre_iteration (GtkWidget *pButton, gpointer data);
void annuler_temps (GtkWidget *pButton, gpointer data);
void annuler_final_temps (GtkWidget *pButton, gpointer data);
void executer (void);
void executer_nombre_iteration (void);
void executer_temps (void);
void clavier(unsigned char touche,int x, int y)
{
switch (touche)
{
/*case 'p':
glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
glutPostRedisplay(); break;
case 'f':
glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
glutPostRedisplay(); break;
case 's':
glPloygonMode(GL_FRONT_AND_BACK,GL_POINT);
glutPostRedisplay(); break;*/
case 'q':
exit(0);
}
}
void affichage(void)
{
GLint iso;
GLint izo;
GLint izo2;
GLfloat pp1;
GLfloat pp2;
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_LINE_LOOP);
for(iso=0 ; iso<nombreindividu ; iso++)
{ for(izo=0 ; izo<nombreville ; izo++)
{ pp1=((v[ population_h[iso * nombreville + izo] ].x)/1000.0);
pp2=((v[ population_h[iso * nombreville + izo] ].y)/1000.0);
glColor3f(0.0,0.0,1.0);
glVertex2f(pp1,pp2);
}
}
for(izo2=0 ; izo2<nombreville ; izo2++)
{ pp1=((v[ meilleurindividu.a[izo2] ].x)/1000.0);
pp2=((v[ meilleurindividu.a[izo2] ].y)/1000.0);
glColor3f(1.0,0.0,0.0);
glVertex2f(pp1,pp2);
}
glEnd();
glFlush();
}
int main(int argc, char **argv)
{ glutInit(&argc,argv);
gtk_init(&argc, &argv);
MainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
HBox1 = gtk_hbox_new(FALSE, 0);
VBox1 = gtk_vbox_new(FALSE, 1);
VBox2 = gtk_vbox_new(FALSE, 1);
VBox3 = gtk_vbox_new(FALSE, 1);
Label1 = gtk_label_new("Donnez la taille de la population : ");
Label2 = gtk_label_new("Donnez le nombre de ville : ");
Button[0] = gtk_button_new_with_label("Executer");
Button[1] = gtk_button_new_with_label("Exit");
Entry1 = gtk_entry_new();
Entry2 = gtk_entry_new();
gtk_window_set_position(GTK_WINDOW(MainWindow), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(MainWindow), 600, 100);
gtk_window_set_title(GTK_WINDOW(MainWindow), "Algorithme Genetique : Probleme du Voyageur de Commerce");
gtk_container_add(GTK_CONTAINER(MainWindow), HBox1);
gtk_box_pack_start(GTK_BOX(HBox1), VBox1, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(HBox1), VBox2, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(HBox1), VBox3, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(VBox1), Label1, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(VBox1), Label2, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(VBox2), Entry1, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(VBox2), Entry2, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(VBox3), Button[0], TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(VBox3), Button[1], TRUE, FALSE, 0);
g_signal_connect(G_OBJECT(MainWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(Button[0]), "clicked", G_CALLBACK(executer), (GtkWidget*) VBox3);
g_signal_connect(G_OBJECT(Button[1]), "clicked", G_CALLBACK(annuler), (GtkWidget*) VBox3);
gtk_widget_show_all(MainWindow);
gtk_main();
return EXIT_SUCCESS;
}
//DEBUT DE FERMETURE DE LA PREMIERE INTERFACE
void annuler (GtkWidget *pButton, gpointer data)
{
gtk_widget_destroy(MainWindow);
}
//FIN DE FERMETURE DE LA PREMIERE INTERFACE
//DEBUT DE FERMETURE DE L'INTERFACE NOMBRE ITERATION
void annuler_nombre_iteration (GtkWidget *pButton, gpointer data)
{
gtk_widget_destroy(Window_Iteration);
}
//FIN DE FERMETURE DE L'INTERFACE NOMBRE ITERATION
//DEBUT DE FERMETURE DE L'INTERFACE FINAL DANS LE MODE NOMBRE ITERATION
void annuler_final_nombre_iteration (GtkWidget *pButton, gpointer data)
{
gtk_widget_destroy(Window_Final);
}
//FIN DE FERMETURE DE L'INTERFACE FINAL DANS LE MODE NOMBRE ITERATION
//DEBUT DE FERMETURE DE L'INTERFACE TEMPS D'EXECUTION
void annuler_temps (GtkWidget *pButton, gpointer data)
{
gtk_widget_destroy(Window_Temps);
}
//FIN DE FERMETURE DE L'INTERFACE TEMPS D'EXECUTION
//DEBUT DE FERMETURE DE L'INTERFACE FINAL DANS LE MODE TEMPS
void annuler_final_temps (GtkWidget *pButton, gpointer data)
{
gtk_widget_destroy(Window_Final2);
}
//FIN DE FERMETURE DE L'INTERFACE FINAL DANS LE MODE TEMPS
//DEBUT DE LA FONCTION NOMBRE INDIVIDU ET NOMBRE VILLE
void executer (void)
{ //Récupération de la valeur nombreindividu
gint temporary;
temporary = atoi(gtk_entry_get_text(GTK_ENTRY(Entry1)));
nombreindividu=temporary;
//Récupération de la valeur nombreville
gint temporary2;
temporary2 = atoi(gtk_entry_get_text(GTK_ENTRY(Entry2)));
nombreville=temporary2;
if((temporary <= 0) || (temporary2 <= 0))
{ GtkWidget *Window_Attention;
//Création de boite de dialogue ATTENTION avec le bouton CLOSE
Window_Attention = gtk_dialog_new_with_buttons("Attention !", GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
//Création du label
Label3 = gtk_label_new(" \n\t\t\tDonnees incorrectes !!!\t\t\t\n ");
//Ajout du label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Window_Attention)->vbox), Label3, TRUE, FALSE, 0);
//Affichage des elements de la boite de dialogue
gtk_widget_show_all(GTK_DIALOG(Window_Attention)->vbox);
//Lancement de la boite de dialogue
switch(gtk_dialog_run(GTK_DIALOG(Window_Attention)))
{ case GTK_RESPONSE_CLOSE:
{ exit(-1);
gtk_widget_destroy(MainWindow);
gtk_widget_destroy(Window_Attention);
}
break;
default:
break;
}
}
//DEBUT DE RECUPERATION DES DONNEES A PARTIR DU FICHIER
FILE *fichier;
fichier=fopen("villes2.txt", "r");
if (fichier==NULL)
{ printf("\n\nError lors de l'ouverture du fichier ");
printf("\n\nFin du programme...");
exit(-1);
}
else
{ v=(ville*)malloc(sizeof(ville)*nombreville);
for(i=0 ; i<nombreville ; i++)
fscanf(fichier, "%s""%ld""%ld", &v[i].nomville, &v[i].x, &v[i].y);
/*printf("\n\n");
for(i=0 ; i<nombreville ; i++)
printf("%s\t%ld\t%ld\n", v[i].nomville, v[i].x, v[i].y);*/
}
fclose(fichier);
//FIN DE RECUPERATION DES DONNEES A PARTIR DU FICHIER
//DEBUT DU CALACUL DE LA MOITIE DE LA POPULATION
moitiepopulation=nombreindividu/2;
if(nombreindividu%2!=0)
{ moitiepopulation++;
}
/*printf("\n\nLa valeur de la moitie de la population est de : %d individus\n", moitiepopulation);
fprintf(sauvegarde,"\n\nLa valeur de la moitie de la population est de : %d individus\n", moitiepopulation);*/
//FIN DU CALACUL DE LA MOITIE DE LA POPULATION
//DEBUT DE CHOIX DE LA VILLE DE DEPART PAR L'UTILISATEUR
sauvegarde=fopen("Resultat_Algorihme.txt", "w");
GtkWidget *Window_City;
GtkWidget *Label4;
GtkWidget *Label5;
GtkWidget *Label10;
GtkWidget *pComboBox;
GtkWidget *ComboBox2;
GtkWidget *ComboBox3;
const char *sText;
const char *sText2;
const char *sText3;
//Creation de boite de dialogue VILLE DE DEPART avec Les boutons OK, CLOSE et Annuler
Window_City = gtk_dialog_new_with_buttons("Choix ", GTK_WINDOW(MainWindow), GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_widget_destroy(MainWindow);
//Création du label
Label4 = gtk_label_new("Choisissez votre ville de depart : ");
//Ajout du label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Window_City)->vbox), Label4, TRUE, FALSE, 0);
//Création de de la ComboBox
pComboBox = gtk_combo_box_new_text();
//Ajout de la ComboBox
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Window_City)->vbox), pComboBox, TRUE, FALSE, 0);
//Ajout des éléments
for(i=0 ; i<nombreville ; i++)
{ gtk_combo_box_append_text(GTK_COMBO_BOX(pComboBox), v[i].nomville);
}
//Activer le premier element
gtk_combo_box_set_active(GTK_COMBO_BOX(pComboBox), 0);
//Création du label
Label5 = gtk_label_new("\nChoisissez le mode d'execution : ");
//Ajout du label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Window_City)->vbox), Label5, TRUE, FALSE, 0);
//Création de de la ComboBox
ComboBox2 = gtk_combo_box_new_text();
//Ajout de la ComboBox
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Window_City)->vbox), ComboBox2, TRUE, FALSE, 0);
//Ajout des éléments
gtk_combo_box_append_text(GTK_COMBO_BOX(ComboBox2), "Iterations");
gtk_combo_box_append_text(GTK_COMBO_BOX(ComboBox2), "Temps");
gtk_combo_box_append_text(GTK_COMBO_BOX(ComboBox2), "Milou");
//Activer le premier element
gtk_combo_box_set_active(GTK_COMBO_BOX(ComboBox2), 0);
//Création du label
Label10 = gtk_label_new("\nChoisissez le taux de mutation (en pourcentage) : ");
//Ajout du label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Window_City)->vbox), Label10, TRUE, FALSE, 0);
//Création de de la ComboBox
ComboBox3 = gtk_combo_box_new_text();
//Ajout de la ComboBox
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(Window_City)->vbox), ComboBox3, TRUE, FALSE, 0);
//Ajout des éléments
gtk_combo_box_append_text(GTK_COMBO_BOX(ComboBox3), "30");
gtk_combo_box_append_text(GTK_COMBO_BOX(ComboBox3), "50");
gtk_combo_box_append_text(GTK_COMBO_BOX(ComboBox3), "70");
//Activer le premier element
gtk_combo_box_set_active(GTK_COMBO_BOX(ComboBox3), 0);
//Affichage des elements de la boite de dialogue
gtk_widget_show_all(GTK_DIALOG(Window_City)->vbox);
switch(gtk_dialog_run(GTK_DIALOG(Window_City)))
{ case GTK_RESPONSE_OK:
{ //Récupération de la valeur ville de départ
sText = gtk_combo_box_get_active_text(GTK_COMBO_BOX(pComboBox));
//Récupération de la valeur mode d'execution
sText2 = gtk_combo_box_get_active_text(GTK_COMBO_BOX(ComboBox2));
//Récupération de la valeur taux mutation
sText3 = gtk_combo_box_get_active_text(GTK_COMBO_BOX(ComboBox3));
i=0;
for(i=0 ; i<nombreville ; i++)
{ if(strcmp(v[i].nomville,sText)==0)
{ indicevilledepart=i;
}
}
//FIN DE CHOIX DE LA VILLE DE DEPART PAR L'UTILISATEUR
gtk_widget_destroy(Window_City);
//DEBUT DE CREATION DES INDIVIDUS DE LA POPULATION 1
j=0;
population_h = (int*) malloc(sizeof(int) * nombreville * nombreindividu);
int *population_d;
size=sizeof(int) * nombreville * nombreindividu;
cudaMalloc(&population_d, size);
dim3 dimension(((nombreville/dimBlock.x)+20), ((nombreindividu/dimBlock.y)+20));
initialisation_population<<<dimension,dimBlock>>>(nombreville,indicevilledepart,population_d);
cudaMemcpy(population_h, population_d, size, cudaMemcpyDeviceToHost);
printf("\n\nLes valeurs de population_h sont :\n");
//fprintf(sauvegarde, "\n\nLes valeurs de population_h sont :\n");
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%ld\t", population_h[i*nombreville+j]);
//fprintf(sauvegarde, "%ld\t", population_h[i*nombreville+j]);
}
printf("\n");
//fprintf(sauvegarde, "\n");
}
verification_h = (int*) malloc(sizeof(int) * nombreville * nombreindividu);
int *verification_d;
size=sizeof(int) * nombreville * nombreindividu;
cudaMalloc(&verification_d, size);
initialisation_verification<<<dimension,dimBlock>>>(nombreville,indicevilledepart,verification_d);
cudaMemcpy(verification_h, verification_d, size, cudaMemcpyDeviceToHost);
/*printf("\n\nLes valeurs de verification_h sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de verification_h sont :\n");
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%ld\t", verification_h[i*nombreville+j]);
fprintf(sauvegarde, "%ld\t", verification_h[i*nombreville+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
int resultat;
srand(time(NULL));
for(i=0; i<nombreindividu; i++)
{ for(j=1 ; j<nombreville; j++)
{ do { resultat=((rand()+1)%(nombreville));
}
while(verification_h[i*nombreville+resultat]!=0);
population_h[i*nombreville+j]=resultat;
verification_h[i*nombreville+resultat]=1;
}
}
printf("\n\nLa matrice population est : \n\n");
fprintf(sauvegarde, "\n\nLa matrice population est : \n\n");
/*printf("\n\nLes valeurs de verification_h sont :\n");
//fprintf(sauvegarde, "\n\nLes valeurs de verfication_h sont :\n");
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%ld\t", verification_h[i*2+j]);
//fprintf(sauvegarde, "%ld\t", verification_h[i*2+j]);
}
printf("\n");
//fprintf(sauvegarde, "\n");
}*/
cudaFree(population_d);
cudaFree(verification_d);
free(verification_h);
//FIN DE CREATION DES INDIVIDUS DE LA POPULATION 1
if(strcmp(sText3, "30")==0)
{ tauxmutationuser = 0.3 * nombreindividu;
tauxmutation = floor(tauxmutationuser);
}
else if(strcmp(sText3, "50")==0)
{ tauxmutationuser = 0.5 * nombreindividu;
tauxmutation = floor(tauxmutationuser);
}
else if(strcmp(sText3, "70")==0)
{ tauxmutationuser = 0.7 * nombreindividu;
tauxmutation = floor(tauxmutationuser);
}
if(strcmp(sText2, "Iterations")==0)
{ GtkWidget *Label6;
GtkWidget *VBox4;
GtkWidget *HBox2;
//Création de boite de dialogue NOMBRE D'ITERATIONS avec les boutons EXECUTER et EXIT
Window_Iteration = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(Window_Iteration), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(Window_Iteration), 300, 100);
gtk_window_set_title(GTK_WINDOW(Window_Iteration), "Nombre d'iteration");
//Création d'un VBOX
VBox4 = gtk_vbox_new(FALSE, 1);
//Ajout du VBOX dans la boite de dialogue
gtk_container_add(GTK_CONTAINER(Window_Iteration), VBox4);
//Création d'une zone label
Label6 = gtk_label_new("Donnez le nombre d'iterations : ");
//Ajout de la zone label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox4), Label6, TRUE, FALSE, 0);
//Création d'une zone de saisie
Entry4 = gtk_entry_new();
//Ajout de la zone de saisie dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox4), Entry4, TRUE, FALSE, 0);
//Création d'un HBOX
HBox2 = gtk_hbox_new(FALSE, 1);
//Ajout du HBOX dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox4), HBox2, TRUE, FALSE, 0);
//Création des BOUTTONS
Button[2] = gtk_button_new_with_label("Executer");
Button[3] = gtk_button_new_with_label("Exit");
//Ajout des BOUTTONS dans la HBOX
gtk_box_pack_start(GTK_BOX(HBox2), Button[2], TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(HBox2), Button[3], TRUE, FALSE, 0);
g_signal_connect(G_OBJECT(Window_Iteration), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(Button[2]), "clicked", G_CALLBACK(executer_nombre_iteration), (GtkWidget*) HBox2);
g_signal_connect(G_OBJECT(Button[3]), "clicked", G_CALLBACK(annuler_nombre_iteration), (GtkWidget*) HBox2);
gtk_widget_show_all(Window_Iteration);
gtk_main();
}
else
{ if(strcmp(sText2, "Temps")==0)
{ GtkWidget *Label8;
GtkWidget *VBox6;
GtkWidget *HBox3;
//Création de boite de dialogue TEMPS D'EXECUTION avec les boutons EXECUTER et EXIT
Window_Temps = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(Window_Temps), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(Window_Temps), 300, 100);
gtk_window_set_title(GTK_WINDOW(Window_Temps), "Temps d'execution");
//Création d'un VBOX
VBox6 = gtk_vbox_new(FALSE, 1);
//Ajout du VBOX dans la boite de dialogue
gtk_container_add(GTK_CONTAINER(Window_Temps), VBox6);
//Création d'une zone label
Label8 = gtk_label_new("Donnez le temps d'execution : (en secondes)");
//Ajout de la zone label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox6), Label8, TRUE, FALSE, 0);
//Création d'une zone de saisie
Entry6 = gtk_entry_new();
//Ajout de la zone de saisie dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox6), Entry6, TRUE, FALSE, 0);
//Création d'un HBOX
HBox3 = gtk_hbox_new(FALSE, 1);
//Ajout du HBOX dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox6), HBox3, TRUE, FALSE, 0);
//Création des BOUTTONS
Button[5] = gtk_button_new_with_label("Executer");
Button[6] = gtk_button_new_with_label("Exit");
//Ajout des BOUTTONS dans la HBOX
gtk_box_pack_start(GTK_BOX(HBox3), Button[5], TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(HBox3), Button[6], TRUE, FALSE, 0);
g_signal_connect(G_OBJECT(Window_Temps), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(Button[5]), "clicked", G_CALLBACK(executer_temps), (GtkWidget*) HBox3);
g_signal_connect(G_OBJECT(Button[6]), "clicked", G_CALLBACK(annuler_temps), (GtkWidget*) HBox3);
gtk_widget_show_all(Window_Temps);
gtk_main();
}
else
{ //milou
//exit(-1);
}
}
}
break;
case GTK_RESPONSE_CLOSE:
{
}
break;
default:
break;
}
}
//FIN DE LA FONCTION NOMBRE INDIVIDU ET NOMBRE VILLE
//DEBUT DE LA FONCTION MODE D'EXECUTION = NOMBRE ITERATION
void executer_nombre_iteration (void)
{
//Récupération de la valeur nombre iteration
gint temporary3;
temporary3 = atoi(gtk_entry_get_text(GTK_ENTRY(Entry4)));
gtk_widget_destroy(Window_Iteration);
int iterationreelle=temporary3;
int croisementmutation=1;
int iteration=iterationreelle * 2;
meilleurindividu.a=(int *)malloc(sizeof(int) * nombreville);
for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=-1;
meilleurindividu.b=0;
int ecriture=1;
double debut, fin;
debut = clock();
while(iteration!=0)
{
//DEBUT DE CREATION STRUCTURE POUR FAIRE LE CALCUL DES DISTANCES
long *distance_h;
distance_h=(long *)malloc(sizeof(long)*2*nombreville*nombreindividu);
int k=0; int l=0;
j=0;
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ distance_h[i*2+j]=v[population_h[k*nombreville+l]].x;
distance_h[i*2+(j+1)]=v[population_h[k*nombreville+l]].y;
l++;
if(l==nombreville)
{ l=0;
k++;
}
}
/*printf("\n\n");
fprintf(sauvegarde, "\n\n");
printf("\n\nLes valeurs de distance_h sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de distance_h sont :\n");
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ for(j=0 ; j<2 ; j++)
{ printf("%ld\t", distance_h[i*2+j]);
fprintf(sauvegarde, "%ld\t", distance_h[i*2+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
long *distance_d;
size=sizeof(long)*2*nombreville*nombreindividu;
cudaMalloc(&distance_d, size);
cudaMemcpy(distance_d, distance_h, size, cudaMemcpyHostToDevice);
long *p;
p=(long *)malloc(sizeof(long)*2*nombreville*nombreindividu);
//COPIE DE distance_h vers p avec décalage
i=0; k=0; l=1;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+l]].x;
l++;
if(l==nombreville)
{ l=1;
j++;
k++;
}
}
l=0;k=0;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ l++;
if(l==nombreville)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+0]].x;
k++;
l=0;
}
}
i=1; k=0; l=1;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+l]].y;
l++;
if(l==nombreville)
{ l=1;
j++;
k++;
}
}
l=0;k=0;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ l++;
if(l==nombreville)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+0]].y;
k++;
l=0;
}
}
/*printf("\n\n");
fprintf(sauvegarde, "\n\n");
printf("\n\nLes valeurs de p sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de p sont :\n");
for(i=0 ; i<2 ; i++)
{ for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ printf("%ld\t", p[i*(nombreville*nombreindividu)+j]);
fprintf(sauvegarde, "%ld\t", p[i*(nombreville*nombreindividu)+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
long *p_d;
size=sizeof(long)*2*nombreville*nombreindividu;
cudaMalloc(&p_d, size);
cudaMemcpy(p_d, p, size, cudaMemcpyHostToDevice);
float *resultat_h;
resultat_h=(float *)malloc(sizeof(float)*nombreville*nombreindividu*nombreville*nombreindividu);
float *resultat_d;
size = ((((nombreville*nombreindividu)*nombreville)*nombreindividu)*sizeof(float));
cudaMalloc(&resultat_d, size);
if(((nombreville*nombreindividu)%dimBlock.x)==0)
{ dim3 dimGrid(((nombreville*nombreindividu)/dimBlock.x), ((nombreville*nombreindividu)/dimBlock.y));
somme<<<dimGrid, dimBlock>>>(p_d, distance_d, nombreville, resultat_d, nombreindividu);
cudaMemcpy(resultat_h, resultat_d, size, cudaMemcpyDeviceToHost);
}
else
{ dim3 dimGrid2(((nombreville*nombreindividu)/dimBlock.x)+1, ((nombreville*nombreindividu)/dimBlock.y)+1);
somme<<<dimGrid2, dimBlock>>>(p_d, distance_d, nombreville, resultat_d, nombreindividu);
cudaMemcpy(resultat_h, resultat_d, size, cudaMemcpyDeviceToHost);
}
/*printf("\n\nLe resultat est : \n");
fprintf(sauvegarde, "\n\nLe resultat est : \n");
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ printf("\n\nLigne numero %d : \n", i);
fprintf(sauvegarde, "\n\nLigne numero %d : \n", i);
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ printf("%f\t", resultat_h[i*(nombreville*nombreindividu)+j]);
fprintf(sauvegarde, "%f\t", resultat_h[i*(nombreville*nombreindividu)+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
float *distanceindividu;
distanceindividu=(float *)malloc(sizeof(float)*nombreindividu);
k=0;
for(j=0 ; j<nombreindividu ; j++)
{ for(i=0 ; i<nombreville ; i++)
{ distanceindividu[j]+=resultat_h[k*(nombreville*nombreindividu)+k];
k++;
}
i=0;
}
/* printf("\n\nLes distances des individus sont : \n\n");
fprintf(sauvegarde, "\n\nLes distances des individus sont : \n\n");
for(i=0 ; i<nombreindividu ; i++)
{ printf("Distance Individu %d : %f\n", i, distanceindividu[i]);
fprintf(sauvegarde, "Distance Individu %d : %f\n", i, distanceindividu[i]);
}*/
cudaFree(p_d);
cudaFree(distance_d);
cudaFree(resultat_d);
free(p);
free(distance_h);
free(resultat_h);
//FIN DE CREATION STRUCTURE POUR FAIRE LE CALCUL DES DISTANCES
//DEBUT DU CLASSEMENT DES DISTANCES
float distance_temporaire=0;
int indice_temporaire=0;
int *classementdistance;
classementdistance = (int *) malloc (sizeof(int)*nombreindividu);
for(i=0 ; i<nombreindividu ; i++)
classementdistance[i]=-1;
verification_h = (int *) malloc(sizeof(int)*nombreindividu);
for(i=0 ; i<nombreindividu ; i++)
verification_h[i]=0;
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreindividu ; j++)
{ if((distanceindividu[j]>=distance_temporaire)&&(verification_h[j]==0))
{ distance_temporaire=distanceindividu[j];
indice_temporaire=j;
}
}
classementdistance[i]=indice_temporaire;
verification_h[indice_temporaire]=1;
distance_temporaire=0;
indice_temporaire=0;
}
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%d\t",population_h[classementdistance[i]*nombreville+j]);
fprintf(sauvegarde, "%d\t",population_h[i*nombreville+j]);
}
printf("\t%f\n", distanceindividu[classementdistance[i]]);
fprintf(sauvegarde,"\t%f\n", distanceindividu[classementdistance[i]]);
//fprintf(sauvegarde, "\n");
}
/* printf("\n\nDistance classees par ordre decroissant :\n");
//fprintf(sauvegarde,"\n\nDistance classees par ordre decroissant :\n");
for(i=0 ; i<nombreindividu ; i++)
{ printf("Individu %d : %f\n", classementdistance[i], distanceindividu[classementdistance[i]] );
//fprintf(sauvegarde, "Individu %d : %f\n", classementdistance[i], distanceindividu[classementdistance[i]] );
}*/
free(verification_h);
//FIN DU CLASSEMENT DES DISTANCES
//DEBUT DU MEILLEUR INDIVIDU
if((distanceindividu[classementdistance[nombreindividu-1]]>meilleurindividu.b)&&(ecriture==1))
{ for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=population_h[(classementdistance[nombreindividu-1]*nombreville)+i];
meilleurindividu.b=distanceindividu[classementdistance[nombreindividu-1]];
ecriture=0;
}
if((distanceindividu[classementdistance[nombreindividu-1]]<meilleurindividu.b))
{ for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=population_h[(classementdistance[nombreindividu-1]*nombreville)+i];
meilleurindividu.b=distanceindividu[classementdistance[nombreindividu-1]];
}
printf("\n\nLe meilleur chemin est : ");
//fprintf(sauvegarde, "\n\nLe meilleur chemin est :");
for(i=0 ; i<nombreville ; i++)
{ printf("\t%d", meilleurindividu.a[i]);
//fprintf(sauvegarde, "\t%d", meilleurindividu.a[i]);
}
printf(", sa distance est de : %f", meilleurindividu.b);
//fprintf(sauvegarde, ", sa distance est de : %f", meilleurindividu.b);
//FIN DU MEILLEUR INDIVIDU
if(croisementmutation==1)
{
//DEBUT DE SELECTION PAR LA METHODE ELITISTE
l=moitiepopulation;
int *population2_h;
population2_h = (int*) malloc(sizeof(int) * nombreville * nombreindividu);
if(nombreindividu%2==0)
{ for(i=0 ; i<moitiepopulation ; i++)
{ for(j=0 ; j<nombreville ;j++)
{ k=classementdistance[l];
population2_h[i*nombreville+j]=population_h[k*nombreville+j];
}
l++;
}
//On remplit les individus suivants avec -1.
for(i=moitiepopulation ; i<nombreindividu ; i++)
{ for(j=0 ;j<nombreville ;j++)
{ population2_h[i*nombreville+j]=-1;
}
}
}
else
{ for(i=0 ; i<moitiepopulation ; i++)
{ for(j=0 ; j<nombreville ;j++)
{ k=classementdistance[l-1];
population2_h[i*nombreville+j]=population_h[k*nombreville+j];
}
l++;
}
}
//FIN DE SELECTION PAR LA METHODE ELITISTE
//ACCOUPLEMENT
int debutcroisement=-1;
int largeurcroisement=-1;
int maman;
int papa;
int fille=moitiepopulation;
int fils=moitiepopulation+1;
int individuacreer=nombreindividu-moitiepopulation;
int villeDouble;
int m;
srand(time(NULL));
//printf("\n\nLe nombre d'individus A creer est de : %d", individuacreer);
//fprintf(sauvegarde, "\n\nLe nombre d'individus A creer est de : %d", individuacreer);
for(m=0 ; m<individuacreer/2 ; m++)
{ debutcroisement=tirage(nombreville-3)+1;
largeurcroisement=tirage(nombreville-debutcroisement)+1;
do { maman=tirage(moitiepopulation-1);
papa=tirage(moitiepopulation-1);
}
while(maman==papa);
printf("\n\n\nLancement de l'operateur de croisement : Maman : %d ; Papa : %d ; Fille : %d ; Fils : %d ; Debut croisement : %d ; Largeur du croisement : %d", maman, papa, fille, fils, debutcroisement, largeurcroisement);
//fprintf(sauvegarde,"\n\n\nLancement de l'operateur de croisement : Maman : %d ; Papa : %d ; Fille : %d ; Fils : %d ; Debut croisement : %d ; Largeur du croisement : %d", maman, papa, fille, fils, debutcroisement, largeurcroisement);
//DEBUT DU CROISEMENT
for(i=0 ; i<nombreville ; i++)
{ population2_h[fille*nombreville+i]=population2_h[maman*nombreville+i];
population2_h[fils*nombreville+i]=population2_h[papa*nombreville+i];
}
for(i=debutcroisement ; i<(debutcroisement+largeurcroisement) ; i++)
{ population2_h[fille*nombreville+i]=population2_h[papa*nombreville+i];
population2_h[fils*nombreville+i]=population2_h[maman*nombreville+i];
}
//On recherche les villes en double et on les remplace par celles manquantes.
for(i=debutcroisement ; i<(debutcroisement+largeurcroisement) ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ if( (*(population2_h+fils*nombreville+i)==*(population2_h+fils*nombreville+j)) && ( (j<debutcroisement) || (j>=(debutcroisement+largeurcroisement)) ) )
{ for(k=debutcroisement ; k<(debutcroisement+largeurcroisement) ; k++)
{ for(l=0 ; l<nombreville ; l++)
{ if( ( (*(population2_h+fille*nombreville+k))==(*(population2_h+fille*nombreville+l)) ) && ( (l<debutcroisement) || (l>=(debutcroisement+largeurcroisement)) ) )
{ villeDouble=population2_h[fille*nombreville+l];
population2_h[fille*nombreville+l]=population2_h[fils*nombreville+j];
population2_h[fils*nombreville+j]=villeDouble;
}
}
}
}
}
}
fille=fille+2;
fils=fils+2;
}
//FIN DU CROISEMENT
if(((individuacreer/2)*2)!=individuacreer)
{ for(i=0 ; i<nombreville ; i++)
{ population2_h[(nombreindividu-1)*nombreville+i]=meilleurindividu.a[i];
}
}
printf("\n\nLa population apres croisement :\n");
fprintf(sauvegarde,"\n\nLa population apres croisement :\n");
//FIN DE ACCOUPLEMENT
croisementmutation=2;
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ population_h[i*nombreville+j]=population2_h[i*nombreville+j];
}
}
free(population2_h);
/*printf("\n\nLa population apres croisement :\n");
fprintf(sauvegarde,"\n\nLa population apres croisement :\n");
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%ld\t", population_h[i*nombreville+j]);
fprintf(sauvegarde,"%ld\t", population_h[i*nombreville+j]);
}
printf("\n");
fprintf(sauvegarde,"\n");
}*/
}
else
{ //DEBUT DE MUTATION
for(l=0 ; l<tauxmutation ; l++)
{ /*do
{ i = (tirage (nombreville-2))+1;
j = (tirage (nombreville-2))+1;
}
while((i==j)||(i==indicevilledepart)||(j==indicevilledepart)) ;
*/
do
{ i = tirage (nombreville-1);
j = tirage (nombreville-1);
}
while((i==j)||(i==0)||(j==0)) ;
k = population_h[classementdistance[l] * nombreville + i];
population_h[classementdistance[l] * nombreville + i] = population_h[classementdistance[l] * nombreville + j];
population_h[classementdistance[l] * nombreville + j] = k;
}
printf("\n\nLa population apres mutation :\n");
fprintf(sauvegarde,"\n\nLa population apres mutation :\n");
/*for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%ld\t", population_h[i*nombreville+j]);
fprintf(sauvegarde,"%ld\t", population_h[i*nombreville+j]);
}
printf("\n");
fprintf(sauvegarde,"\n");
}*/
croisementmutation=1;
}
//FIN DE MUTATION
iteration--;
//CONTROLE INDIVIDU DOUBLE
int tt; int ttt=0;
/* k=0; i=0; j=0; l=0;
for(i=0;i<nombreindividu-1; i++)
{ for(j=i+1; j<nombreindividu; j++)
{ for(k=0 ; k<nombreville ; k++)
{etiq: if(population_h[i*nombreville+k]==population_h[j*nombreville+k])
{ l++;
if(l==nombreville)
{ tt=population_h[j*nombreville+1];
population_h[j*nombreville+1]=population_h[j*nombreville+(nombreville-1)];
population_h[j*nombreville+(nombreville-1)]=tt;
ttt++;
}
}
}
l=0;
}
}*/
int aze,rty;
etiq: k=0; i=0; j=0; l=0;
for(i=0;i<nombreindividu-1; i++)
{ for(j=i+1; j<nombreindividu; j++)
{ for(k=0 ; k<nombreville ; k++)
{ if(population_h[i*nombreville+k]==population_h[j*nombreville+k])
{ l++;
if(l==nombreville)
{ do
{ aze = tirage (nombreville-1);
rty = tirage (nombreville-1);
}
while((aze==rty) || (aze==0) || (rty==0));
tt=population_h[j*nombreville+aze];
population_h[j*nombreville+aze]=population_h[j*nombreville+rty];
population_h[j*nombreville+rty]=tt;
ttt++;
}
}
}
l=0;
}
}
if(ttt!=0)
{ ttt--;
goto etiq;
}
//FIN CONTROLE INDIVIDU DOUBLE
}
//DEBUT DE CREATION STRUCTURE POUR FAIRE LE CALCUL DES DISTANCES
long *distance_h;
distance_h=(long *)malloc(sizeof(long)*2*nombreville*nombreindividu);
int k=0; int l=0;
j=0;
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ distance_h[i*2+j]=v[population_h[k*nombreville+l]].x;
distance_h[i*2+(j+1)]=v[population_h[k*nombreville+l]].y;
l++;
if(l==nombreville)
{ l=0;
k++;
}
}
printf("\n\n");
/*fprintf(sauvegarde, "\n\n");
printf("\n\nLes valeurs de distance_h sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de distance_h sont :\n");
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ for(j=0 ; j<2 ; j++)
{ printf("%ld\t", distance_h[i*2+j]);
fprintf(sauvegarde, "%ld\t", distance_h[i*2+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
long *distance_d;
size=sizeof(long)*2*nombreville*nombreindividu;
cudaMalloc(&distance_d, size);
cudaMemcpy(distance_d, distance_h, size, cudaMemcpyHostToDevice);
long *p;
p=(long *)malloc(sizeof(long)*2*nombreville*nombreindividu);
//COPIE DE distance_h vers p avec décalage
i=0; k=0; l=1;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+l]].x;
l++;
if(l==nombreville)
{ l=1;
j++;
k++;
}
}
l=0;k=0;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ l++;
if(l==nombreville)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+0]].x;
k++;
l=0;
}
}
i=1; k=0; l=1;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+l]].y;
l++;
if(l==nombreville)
{ l=1;
j++;
k++;
}
}
l=0;k=0;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ l++;
if(l==nombreville)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+0]].y;
k++;
l=0;
}
}
/*printf("\n\n");
fprintf(sauvegarde, "\n\n");
printf("\n\nLes valeurs de p sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de p sont :\n");
for(i=0 ; i<2 ; i++)
{ for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ printf("%ld\t", p[i*(nombreville*nombreindividu)+j]);
fprintf(sauvegarde, "%ld\t", p[i*(nombreville*nombreindividu)+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
long *p_d;
size=sizeof(long)*2*nombreville*nombreindividu;
cudaMalloc(&p_d, size);
cudaMemcpy(p_d, p, size, cudaMemcpyHostToDevice);
float *resultat_h;
resultat_h=(float *)malloc(sizeof(float)*nombreville*nombreindividu*nombreville*nombreindividu);
float *resultat_d;
size = ((((nombreville*nombreindividu)*nombreville)*nombreindividu)*sizeof(float));
cudaMalloc(&resultat_d, size);
dim3 dimGrid(((nombreville*nombreindividu)/dimBlock.x)+1, ((nombreville*nombreindividu)/dimBlock.y)+1);
somme<<<dimGrid, dimBlock>>>(p_d, distance_d, nombreville, resultat_d, nombreindividu);
cudaMemcpy(resultat_h, resultat_d, size, cudaMemcpyDeviceToHost);
/*printf("\n\nLe resultat est : \n");
fprintf(sauvegarde, "\n\nLe resultat est : \n");
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ printf("\n\nLigne numero %d : \n", i);
fprintf(sauvegarde, "\n\nLigne numero %d : \n", i);
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ printf("%f\t", resultat_h[i*(nombreville*nombreindividu)+j]);
fprintf(sauvegarde, "%f\t", resultat_h[i*(nombreville*nombreindividu)+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
float *distanceindividu;
distanceindividu=(float *)malloc(sizeof(float)*nombreindividu);
k=0;
for(j=0 ; j<nombreindividu ; j++)
{ for(i=0 ; i<nombreville ; i++)
{ distanceindividu[j]+=resultat_h[k*(nombreville*nombreindividu)+k];
k++;
}
i=0;
}
/* printf("\n\nLes distances des individus sont : \n\n");
fprintf(sauvegarde, "\n\nLes distances des individus sont : \n\n");
for(i=0 ; i<nombreindividu ; i++)
{ printf("Distance Individu %d : %f\n", i, distanceindividu[i]);
fprintf(sauvegarde, "Distance Individu %d : %f\n", i, distanceindividu[i]);
}*/
cudaFree(p_d);
cudaFree(distance_d);
cudaFree(resultat_d);
free(p);
free(distance_h);
free(resultat_h);
//FIN DE CREATION STRUCTURE POUR FAIRE LE CALCUL DES DISTANCE
//DEBUT DU CLASSEMENT DES DISTANCES
float distance_temporaire=0;
int indice_temporaire=0;
int *classementdistance;
classementdistance = (int *) malloc (sizeof(int)*nombreindividu);
for(i=0 ; i<nombreindividu ; i++)
classementdistance[i]=0;
verification_h = (int *) malloc(sizeof(int)*nombreindividu);
for(i=0 ; i<nombreindividu ; i++)
verification_h[i]=0;
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreindividu ; j++)
{ if((distanceindividu[j]>=distance_temporaire)&&(verification_h[j]!=1))
{ distance_temporaire=distanceindividu[j];
indice_temporaire=j;
}
}
classementdistance[i]=indice_temporaire;
verification_h[indice_temporaire]=1;
distance_temporaire=0;
indice_temporaire=0;
}
/* printf("\n\nDistance classees par ordre decroissant :\n");
fprintf(sauvegarde,"\n\nDistance classees par ordre decroissant :\n");
for(i=0 ; i<nombreindividu ; i++)
{ printf("Individu %d : %f\n", classementdistance[i], distanceindividu[classementdistance[i]] );
fprintf(sauvegarde, "Individu %d : %f\n", classementdistance[i], distanceindividu[classementdistance[i]] );
}*/
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%d\t",population_h[classementdistance[i]*nombreville+j]);
fprintf(sauvegarde, "%d\t",population_h[i*nombreville+j]);
}
printf("\t%f\n", distanceindividu[classementdistance[i]]);
fprintf(sauvegarde, "\n");
}
free(verification_h);
//FIN DU CLASSEMENT DES DISTANCES
//DEBUT DU MEILLEUR INDIVIDU
if((distanceindividu[classementdistance[nombreindividu-1]]>meilleurindividu.b)&&(ecriture==1))
{ for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=population_h[(classementdistance[nombreindividu-1]*nombreville)+i];
meilleurindividu.b=distanceindividu[classementdistance[nombreindividu-1]];
ecriture=0;
}
if((distanceindividu[classementdistance[nombreindividu-1]]<meilleurindividu.b))
{ for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=population_h[(classementdistance[nombreindividu-1]*nombreville)+i];
meilleurindividu.b=distanceindividu[classementdistance[nombreindividu-1]];
}
printf("\n\nLe meilleur chemin est : ");
//fprintf(sauvegarde, "\n\nLe meilleur chemin est :");
for(i=0 ; i<nombreville ; i++)
{ printf("\t%d", meilleurindividu.a[i]);
//fprintf(sauvegarde, "\t%d", meilleurindividu.a[i]);
}
printf(", sa distance est de : %f", meilleurindividu.b);
//fprintf(sauvegarde, ", sa distance est de : %f", meilleurindividu.b);
fin=clock();
printf("\n\nLe temps d'execution est de : %f", (double)(fin-debut)/(double)CLOCKS_PER_SEC);
fclose(sauvegarde);
//FIN DU MEILLEUR INDIVIDU
const char *sText4;
GtkWidget *Label7;
GtkWidget *Label11;
GtkWidget *VBox5;
// GtkWidget *Entry5;
//Création de boite de dialogue NOMBRE D'ITERATIONS avec les boutons EXECUTER et EXIT
Window_Final = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(Window_Final), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(Window_Final), 300, 100);
gtk_window_set_title(GTK_WINDOW(Window_Final), "Resultat");
//Création d'un VBOX
VBox5 = gtk_vbox_new(FALSE, 1);
//Ajout du VBOX dans la boite de dialogue
gtk_container_add(GTK_CONTAINER(Window_Final), VBox5);
//Création d'une zone label
Label7 = gtk_label_new("Le meilleur chemin est : ");
//Ajout de la zone label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox5), Label7, TRUE, FALSE, 0);
//Création d'une zone label
Label11 = gtk_label_new(" ");
//Ajout de la zone label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox5), Label11, TRUE, FALSE, 0);
/* //Création d'une zone de saisie
Entry5 = gtk_entry_new();
//Ajout de la zone de saisie dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox5), Entry5, TRUE, FALSE, 0);*/
gtk_label_set_text(GTK_LABEL(Label11), sText4);
/* char KERNEL_VERSION = system("uname -r");
GString *chaine = g_string_new(NULL);
g_string_sprintf(chaine, "%s", KERNEL_VERSION);
Label11 = gtk_label_new(chaine->str);
g_string_free(chaine, TRUE);
*/
//Création des BOUTTONS
Button[4] = gtk_button_new_with_label("Exit");
//Ajout du BOUTTON dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox5), Button[4], TRUE, FALSE, 0);
g_signal_connect(G_OBJECT(Window_Final), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(Button[4]), "clicked", G_CALLBACK(annuler_final_nombre_iteration), (GtkWidget*) VBox5);
gtk_widget_show_all(Window_Final);
gtk_main();
glutInitWindowPosition(200,200);
glutInitWindowSize(850,850);
glutInitDisplayMode(GLUT_RGB);
glutCreateWindow("Execution");
glClearColor(0.0,0.0,0.0,0.0);
glPointSize(4.0);
glutDisplayFunc(&affichage);
glutKeyboardFunc(&clavier);
glutMainLoop();
}
//FIN DE LA FONCTION MODE D'EXECUTION = NOMBRE ITERATION
//DEBUT DE LA FONCTION MODE D'EXECUTION = TEMPS D'EXECUTION
void executer_temps (void)
{ //Récupération de la valeur temps d'execution
gint temporary4;
temporary4 = atoi(gtk_entry_get_text(GTK_ENTRY(Entry6)));
gtk_widget_destroy(Window_Temps);
double duree, user;
time_t debut, fin;
user=temporary4;
int croisementmutation=1;
meilleurindividu.a=(int *)malloc(sizeof(int) * nombreville);
for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=-1;
meilleurindividu.b=0;
int ecriture=1;
int iteration=0;
debut=time(NULL);
fin=time(NULL);
duree=difftime(fin,debut);
while(duree<user)
{ iteration=2;
fin=time(NULL);
while(iteration!=0)
{ fin=time(NULL);
//DEBUT DE CREATION STRUCTURE POUR FAIRE LE CALCUL DES DISTANCES
long *distance_h;
distance_h=(long *)malloc(sizeof(long)*2*nombreville*nombreindividu);
int k=0; int l=0;
j=0;
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ distance_h[i*2+j]=v[population_h[k*nombreville+l]].x;
distance_h[i*2+(j+1)]=v[population_h[k*nombreville+l]].y;
l++;
if(i==(nombreville-1))
{ l=0;
k++;
}
}
printf("\n\n");
fprintf(sauvegarde, "\n\n");
/*printf("\n\nLes valeurs de distance_h sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de distance_h sont :\n");
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ for(j=0 ; j<2 ; j++)
{ printf("%ld\t", distance_h[i*2+j]);
fprintf(sauvegarde, "%ld\t", distance_h[i*2+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
long *distance_d;
size=sizeof(long)*2*nombreville*nombreindividu;
cudaMalloc(&distance_d, size);
cudaMemcpy(distance_d, distance_h, size, cudaMemcpyHostToDevice);
long *p;
p=(long *)malloc(sizeof(long)*2*nombreville*nombreindividu);
//COPIE DE distance_h vers p avec décalage
i=0; k=0; l=1;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+l]].x;
l++;
if(l==nombreville)
{ l=1;
j++;
k++;
}
}
l=0;k=0;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ l++;
if(l==nombreville)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+0]].x;
k++;
l=0;
}
}
i=1; k=0; l=1;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+l]].y;
l++;
if(l==nombreville)
{ l=1;
j++;
k++;
}
}
l=0;k=0;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ l++;
if(l==nombreville)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+0]].y;
k++;
l=0;
}
}
/*printf("\n\n");
fprintf(sauvegarde, "\n\n");
printf("\n\nLes valeurs de p sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de p sont :\n");
for(i=0 ; i<2 ; i++)
{ for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ printf("%ld\t", p[i*(nombreville*nombreindividu)+j]);
fprintf(sauvegarde, "%ld\t", p[i*(nombreville*nombreindividu)+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
long *p_d;
size=sizeof(long)*2*nombreville*nombreindividu;
cudaMalloc(&p_d, size);
cudaMemcpy(p_d, p, size, cudaMemcpyHostToDevice);
float *resultat_h;
resultat_h=(float *)malloc(sizeof(float)*nombreville*nombreindividu*nombreville*nombreindividu);
float *resultat_d;
size = ((((nombreville*nombreindividu)*nombreville)*nombreindividu)*sizeof(float));
cudaMalloc(&resultat_d, size);
dim3 dimGrid(((nombreville*nombreindividu)/dimBlock.x)+1, ((nombreville*nombreindividu)/dimBlock.y)+1);
somme<<<dimGrid, dimBlock>>>(p_d, distance_d, nombreville, resultat_d, nombreindividu);
cudaMemcpy(resultat_h, resultat_d, size, cudaMemcpyDeviceToHost);
/*printf("\n\nLe resultat est : \n");
fprintf(sauvegarde, "\n\nLe resultat est : \n");
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ printf("\n\nLigne numero %d : \n", i);
fprintf(sauvegarde, "\n\nLigne numero %d : \n", i);
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ printf("%f\t", resultat_h[i*(nombreville*nombreindividu)+j]);
fprintf(sauvegarde, "%f\t", resultat_h[i*(nombreville*nombreindividu)+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
float *distanceindividu;
distanceindividu=(float *)malloc(sizeof(float)*nombreindividu);
k=0;
for(j=0 ; j<nombreindividu ; j++)
{ for(i=0 ; i<nombreville ; i++)
{ distanceindividu[j]+=resultat_h[k*(nombreville*nombreindividu)+k];
k++;
}
i=0;
}
/*printf("\n\nLes distances des individus sont : \n\n");
fprintf(sauvegarde, "\n\nLes distances des individus sont : \n\n");
for(i=0 ; i<nombreindividu ; i++)
{ printf("Distance Individu %d : %f\n", i, distanceindividu[i]);
fprintf(sauvegarde, "Distance Individu %d : %f\n", i, distanceindividu[i]);
}*/
cudaFree(p_d);
cudaFree(distance_d);
cudaFree(resultat_d);
free(p);
free(distance_h);
free(resultat_h);
//FIN DE CREATION STRUCTURE POUR FAIRE LE CALCUL DES DISTANCES
//DEBUT DU CLASSEMENT DES DISTANCES
float distance_temporaire=0;
int indice_temporaire=0;
int *classementdistance;
classementdistance = (int *) malloc (sizeof(int)*nombreindividu);
for(i=0 ; i<nombreindividu ; i++)
classementdistance[i]=0;
verification_h = (int *) malloc(sizeof(int)*nombreindividu);
for(i=0 ; i<nombreindividu ; i++)
verification_h[i]=0;
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreindividu ; j++)
{ if((distanceindividu[j]>=distance_temporaire)&&(verification_h[j]!=1))
{ distance_temporaire=distanceindividu[j];
indice_temporaire=j;
}
}
classementdistance[i]=indice_temporaire;
verification_h[indice_temporaire]=1;
distance_temporaire=0;
indice_temporaire=0;
}
/* printf("\n\nDistance classees par ordre decroissant :\n");
fprintf(sauvegarde,"\n\nDistance classees par ordre decroissant :\n");
for(i=0 ; i<nombreindividu ; i++)
{ printf("Individu %d : %f\n", classementdistance[i], distanceindividu[classementdistance[i]] );
fprintf(sauvegarde, "Individu %d : %f\n", classementdistance[i], distanceindividu[classementdistance[i]] );
}*/
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%d\t",population_h[classementdistance[i]*nombreville+j]);
// fprintf(sauvegarde, "%d\t",population_h[i*nombreville+j]);
}
printf("\t%f\n", distanceindividu[classementdistance[i]]);
// fprintf(sauvegarde, "\n");
}
free(verification_h);
//FIN DU CLASSEMENT DES DISTANCES
//DEBUT DU MEILLEUR INDIVIDU
if((distanceindividu[classementdistance[nombreindividu-1]]>meilleurindividu.b)&&(ecriture==1))
{ for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=population_h[(classementdistance[nombreindividu-1]*nombreville)+i];
meilleurindividu.b=distanceindividu[classementdistance[nombreindividu-1]];
ecriture=0;
}
if((distanceindividu[classementdistance[nombreindividu-1]]<meilleurindividu.b))
{ for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=population_h[(classementdistance[nombreindividu-1]*nombreville)+i];
meilleurindividu.b=distanceindividu[classementdistance[nombreindividu-1]];
}
printf("\n\nLe meilleur chemin est : ");
fprintf(sauvegarde, "\n\nLe meilleur chemin est :");
for(i=0 ; i<nombreville ; i++)
{ printf("\t%d", meilleurindividu.a[i]);
fprintf(sauvegarde, "\t%d", meilleurindividu.a[i]);
}
printf(", sa distance est de : %f", meilleurindividu.b);
fprintf(sauvegarde, ", sa distance est de : %f", meilleurindividu.b);
//FIN DU MEILLEUR INDIVIDU
if(croisementmutation==1)
{
//DEBUT DE SELECTION PAR LA METHODE ELITISTE
l=moitiepopulation;
int *population2_h;
population2_h = (int*) malloc(sizeof(int) * nombreville * nombreindividu);
if(nombreindividu%2==0)
{ for(i=0 ; i<moitiepopulation ; i++)
{ for(j=0 ; j<nombreville ;j++)
{ k=classementdistance[l];
population2_h[i*nombreville+j]=population_h[k*nombreville+j];
}
l++;
}
//On remplit les individus suivants avec -1.
for(i=moitiepopulation ; i<nombreindividu ; i++)
{ for(j=0 ;j<nombreville ;j++)
{ population2_h[i*nombreville+j]=-1;
}
}
}
else
{ for(i=0 ; i<moitiepopulation ; i++)
{ for(j=0 ; j<nombreville ;j++)
{ k=classementdistance[l-1];
population2_h[i*nombreville+j]=population_h[k*nombreville+j];
}
l++;
}
}
//FIN DE SELECTION PAR LA METHODE ELITISTE
//ACCOUPLEMENT
int debutcroisement=-1;
int largeurcroisement=-1;
int maman;
int papa;
int fille=moitiepopulation;
int fils=moitiepopulation+1;
int individuacreer=nombreindividu-moitiepopulation;
int villeDouble;
int m;
srand(time(NULL));
//printf("\n\nLe nombre d'individus A creer est de : %d", individuacreer);
//fprintf(sauvegarde, "\n\nLe nombre d'individus A creer est de : %d", individuacreer);
for(m=0 ; m<individuacreer/2 ; m++)
{ debutcroisement=tirage(nombreville-3)+1;
largeurcroisement=tirage(nombreville-debutcroisement)+1;
do { maman=tirage(moitiepopulation-1);
papa=tirage(moitiepopulation-1);
}
while(maman==papa);
printf("\n\n\nLancement de l'operateur de croisement : Maman : %d ; Papa : %d ; Fille : %d ; Fils : %d ; Debut croisement : %d ; Largeur du croisement : %d", maman, papa, fille, fils, debutcroisement, largeurcroisement);
fprintf(sauvegarde,"\n\n\nLancement de l'operateur de croisement : Maman : %d ; Papa : %d ; Fille : %d ; Fils : %d ; Debut croisement : %d ; Largeur du croisement : %d", maman, papa, fille, fils, debutcroisement, largeurcroisement);
//DEBUT DU CROISEMENT
for(i=0 ; i<nombreville ; i++)
{ population2_h[fille*nombreville+i]=population2_h[maman*nombreville+i];
population2_h[fils*nombreville+i]=population2_h[papa*nombreville+i];
}
for(i=debutcroisement ; i<(debutcroisement+largeurcroisement) ; i++)
{ population2_h[fille*nombreville+i]=population2_h[papa*nombreville+i];
population2_h[fils*nombreville+i]=population2_h[maman*nombreville+i];
}
//On recherche les villes en double et on les remplace par celles manquantes.
for(i=debutcroisement ; i<(debutcroisement+largeurcroisement) ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ if( (*(population2_h+fils*nombreville+i)==*(population2_h+fils*nombreville+j)) && ( (j<debutcroisement) || (j>=(debutcroisement+largeurcroisement)) ) )
{ for(k=debutcroisement ; k<(debutcroisement+largeurcroisement) ; k++)
{ for(l=0 ; l<nombreville ; l++)
{ if( ( (*(population2_h+fille*nombreville+k))==(*(population2_h+fille*nombreville+l)) ) && ( (l<debutcroisement) || (l>=(debutcroisement+largeurcroisement)) ) )
{ villeDouble=population2_h[fille*nombreville+l];
population2_h[fille*nombreville+l]=population2_h[fils*nombreville+j];
population2_h[fils*nombreville+j]=villeDouble;
}
}
}
}
}
}
fille=fille+2;
fils=fils+2;
}
//FIN DU CROISEMENT
if(((individuacreer/2)*2)!=individuacreer)
{ for(i=0 ; i<nombreville ; i++)
{ population2_h[(nombreindividu-1)*nombreville+i]=meilleurindividu.a[i];
}
}
printf("\n\nLa population apres croisement :\n");
fprintf(sauvegarde,"\n\nLa population apres croisement :\n");
//FIN DE ACCOUPLEMENT
croisementmutation=2;
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ population_h[i*nombreville+j]=population2_h[i*nombreville+j];
}
}
free(population2_h);
/*printf("\n\nLa population apres mutation :\n");
fprintf(sauvegarde,"\n\nLa population apres mutation :\n");
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%ld\t", population_h[i*nombreville+j]);
fprintf(sauvegarde,"%ld\t", population_h[i*nombreville+j]);
}
printf("\n");
fprintf(sauvegarde,"\n");
}*/
}
else
{ //DEBUT DE MUTATION
for(l=0 ; l<tauxmutation ; l++)
{ do
{ i = tirage (nombreville-1);
j = tirage (nombreville-1);
}
while((i==j) || (i==0) || (j==0));
k = population_h[classementdistance[l] * nombreville + i];
population_h[classementdistance[l] * nombreville + i] = population_h[classementdistance[l] * nombreville + j];
population_h[classementdistance[l] * nombreville + j] = k;
}
printf("\n\nLa population apres mutation :\n");
fprintf(sauvegarde,"\n\nLa population apres mutation :\n");
/*for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%ld\t", population_h[i*nombreville+j]);
fprintf(sauvegarde,"%ld\t", population_h[i*nombreville+j]);
}
printf("\n");
fprintf(sauvegarde,"\n");
}*/
croisementmutation=1;
}
//FIN DE MUTATION
iteration--;
//CONTROLE INDIVIDU DOUBLE
int tt; int ttt=0;
/* k=0; i=0; j=0; l=0;
for(i=0;i<nombreindividu-1; i++)
{ for(j=i+1; j<nombreindividu; j++)
{ for(k=0 ; k<nombreville ; k++)
{etiq2: if(population_h[i*nombreville+k]==population_h[j*nombreville+k])
{ l++;
if(l==nombreville)
{ tt=population_h[j*nombreville+1];
population_h[j*nombreville+1]=population_h[j*nombreville+(nombreville-1)];
population_h[j*nombreville+(nombreville-1)]=tt;
ttt++;
}
}
}
l=0;
}
}*/
int aze,rty;
etiq2: k=0; i=0; j=0; l=0;
for(i=0;i<nombreindividu-1; i++)
{ for(j=i+1; j<nombreindividu; j++)
{ for(k=0 ; k<nombreville ; k++)
{ if(population_h[i*nombreville+k]==population_h[j*nombreville+k])
{ l++;
if(l==nombreville)
{ do
{ aze = tirage (nombreville-1);
rty = tirage (nombreville-1);
}
while((aze==rty) || (aze==0) || (rty==0));
tt=population_h[j*nombreville+aze];
population_h[j*nombreville+aze]=population_h[j*nombreville+rty];
population_h[j*nombreville+rty]=tt;
ttt++;
}
}
}
l=0;
}
}
if(ttt!=0)
{ ttt--;
goto etiq2;
}
//FIN CONTROLE INDIVIDU DOUBLE
}
//DEBUT DE CREATION STRUCTURE POUR FAIRE LE CALCUL DES DISTANCES
long *distance_h;
distance_h=(long *)malloc(sizeof(long)*2*nombreville*nombreindividu);
int k=0; int l=0;
j=0;
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ distance_h[i*2+j]=v[population_h[k*nombreville+l]].x;
distance_h[i*2+(j+1)]=v[population_h[k*nombreville+l]].y;
l++;
if(i==(nombreville-1))
{ l=0;
k++;
}
}
printf("\n\n");
fprintf(sauvegarde, "\n\n");
/*printf("\n\nLes valeurs de distance_h sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de distance_h sont :\n");
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ for(j=0 ; j<2 ; j++)
{ printf("%ld\t", distance_h[i*2+j]);
fprintf(sauvegarde, "%ld\t", distance_h[i*2+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
long *distance_d;
size=sizeof(long)*2*nombreville*nombreindividu;
cudaMalloc(&distance_d, size);
cudaMemcpy(distance_d, distance_h, size, cudaMemcpyHostToDevice);
long *p;
p=(long *)malloc(sizeof(long)*2*nombreville*nombreindividu);
//COPIE DE distance_h vers p avec décalage
i=0; k=0; l=1;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+l]].x;
l++;
if(l==nombreville)
{ l=1;
j++;
k++;
}
}
l=0;k=0;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ l++;
if(l==nombreville)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+0]].x;
k++;
l=0;
}
}
i=1; k=0; l=1;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+l]].y;
l++;
if(l==nombreville)
{ l=1;
j++;
k++;
}
}
l=0;k=0;
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ l++;
if(l==nombreville)
{ p[i*(nombreville*nombreindividu)+j]=v[population_h[k*nombreville+0]].y;
k++;
l=0;
}
}
/*printf("\n\n");
fprintf(sauvegarde, "\n\n");
printf("\n\nLes valeurs de p sont :\n");
fprintf(sauvegarde, "\n\nLes valeurs de p sont :\n");
for(i=0 ; i<2 ; i++)
{ for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ printf("%ld\t", p[i*(nombreville*nombreindividu)+j]);
fprintf(sauvegarde, "%ld\t", p[i*(nombreville*nombreindividu)+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
long *p_d;
size=sizeof(long)*2*nombreville*nombreindividu;
cudaMalloc(&p_d, size);
cudaMemcpy(p_d, p, size, cudaMemcpyHostToDevice);
float *resultat_h;
resultat_h=(float *)malloc(sizeof(float)*nombreville*nombreindividu*nombreville*nombreindividu);
float *resultat_d;
size = ((((nombreville*nombreindividu)*nombreville)*nombreindividu)*sizeof(float));
cudaMalloc(&resultat_d, size);
dim3 dimGrid(((nombreville*nombreindividu)/dimBlock.x)+1, ((nombreville*nombreindividu)/dimBlock.y)+1);
somme<<<dimGrid, dimBlock>>>(p_d, distance_d, nombreville, resultat_d, nombreindividu);
cudaMemcpy(resultat_h, resultat_d, size, cudaMemcpyDeviceToHost);
/*printf("\n\nLe resultat est : \n");
fprintf(sauvegarde, "\n\nLe resultat est : \n");
for(i=0 ; i<(nombreville*nombreindividu) ; i++)
{ printf("\n\nLigne numero %d : \n", i);
fprintf(sauvegarde, "\n\nLigne numero %d : \n", i);
for(j=0 ; j<(nombreville*nombreindividu) ; j++)
{ printf("%f\t", resultat_h[i*(nombreville*nombreindividu)+j]);
fprintf(sauvegarde, "%f\t", resultat_h[i*(nombreville*nombreindividu)+j]);
}
printf("\n");
fprintf(sauvegarde, "\n");
}*/
float *distanceindividu;
distanceindividu=(float *)malloc(sizeof(float)*nombreindividu);
k=0;
for(j=0 ; j<nombreindividu ; j++)
{ for(i=0 ; i<nombreville ; i++)
{ distanceindividu[j]+=resultat_h[k*(nombreville*nombreindividu)+k];
k++;
}
i=0;
}
/*printf("\n\nLes distances des individus sont : \n\n");
fprintf(sauvegarde, "\n\nLes distances des individus sont : \n\n");
for(i=0 ; i<nombreindividu ; i++)
{ printf("Distance Individu %d : %f\n", i, distanceindividu[i]);
fprintf(sauvegarde, "Distance Individu %d : %f\n", i, distanceindividu[i]);
}*/
//printf("\n\nla valeur de k est : %d", k);
cudaFree(p_d);
cudaFree(distance_d);
cudaFree(resultat_d);
free(p);
free(distance_h);
free(resultat_h);
//FIN DE CREATION STRUCTURE POUR FAIRE LE CALCUL DES DISTANCES
//DEBUT DU CLASSEMENT DES DISTANCES
float distance_temporaire=0;
int indice_temporaire=0;
int *classementdistance;
classementdistance = (int *) malloc (sizeof(int)*nombreindividu);
for(i=0 ; i<nombreindividu ; i++)
classementdistance[i]=0;
verification_h = (int *) malloc(sizeof(int)*nombreindividu);
for(i=0 ; i<nombreindividu ; i++)
verification_h[i]=0;
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreindividu ; j++)
{ if((distanceindividu[j]>=distance_temporaire)&&(verification_h[j]!=1))
{ distance_temporaire=distanceindividu[j];
indice_temporaire=j;
}
}
classementdistance[i]=indice_temporaire;
verification_h[indice_temporaire]=1;
distance_temporaire=0;
indice_temporaire=0;
}
/*printf("\n\nDistance classees par ordre decroissant :\n");
fprintf(sauvegarde,"\n\nDistance classees par ordre decroissant :\n");
for(i=0 ; i<nombreindividu ; i++)
{ printf("Individu %d : %f\n", classementdistance[i], distanceindividu[classementdistance[i]] );
fprintf(sauvegarde, "Individu %d : %f\n", classementdistance[i], distanceindividu[classementdistance[i]] );
}*/
for(i=0 ; i<nombreindividu ; i++)
{ for(j=0 ; j<nombreville ; j++)
{ printf("%d\t",population_h[classementdistance[i]*nombreville+j]);
// fprintf(sauvegarde, "%d\t",population_h[i*nombreville+j]);
}
printf("\t%f\n", distanceindividu[classementdistance[i]]);
// fprintf(sauvegarde, "\n");
}
free(verification_h);
//FIN DU CLASSEMENT DES DISTANCES
//DEBUT DU MEILLEUR INDIVIDU
if((distanceindividu[classementdistance[nombreindividu-1]]>meilleurindividu.b)&&(ecriture==1))
{ for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=population_h[(classementdistance[nombreindividu-1]*nombreville)+i];
meilleurindividu.b=distanceindividu[classementdistance[nombreindividu-1]];
ecriture=0;
}
if((distanceindividu[classementdistance[nombreindividu-1]]<meilleurindividu.b))
{ for(i=0 ; i<nombreville ; i++)
meilleurindividu.a[i]=population_h[(classementdistance[nombreindividu-1]*nombreville)+i];
meilleurindividu.b=distanceindividu[classementdistance[nombreindividu-1]];
}
printf("\n\nLe meilleur chemin est : ");
fprintf(sauvegarde, "\n\nLe meilleur chemin est :");
for(i=0 ; i<nombreville ; i++)
{ printf("\t%d", meilleurindividu.a[i]);
fprintf(sauvegarde, "\t%d", meilleurindividu.a[i]);
}
printf(", sa distance est de : %f", meilleurindividu.b);
fprintf(sauvegarde, ", sa distance est de : %f", meilleurindividu.b);
//FIN DU MEILLEUR INDIVIDU
fin=time(NULL);
duree=difftime(fin,debut);
}
duree=difftime(fin,debut);
GtkWidget *Label9;
GtkWidget *VBox7;
GtkWidget *Entry7;
//Création de boite de dialogue NOMBRE D'ITERATIONS avec les boutons EXECUTER et EXIT
Window_Final2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(Window_Final2), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(Window_Final2), 300, 100);
gtk_window_set_title(GTK_WINDOW(Window_Final2), "Resultat");
//Création d'un VBOX
VBox7 = gtk_vbox_new(FALSE, 1);
//Ajout du VBOX dans la boite de dialogue
gtk_container_add(GTK_CONTAINER(Window_Final2), VBox7);
//Création d'une zone label
Label9 = gtk_label_new("Le meilleur chemin est : ");
//Ajout de la zone label dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox7), Label9, TRUE, FALSE, 0);
//Création d'une zone de saisie
Entry7 = gtk_entry_new();
//Ajout de la zone de saisie dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox7), Entry7, TRUE, FALSE, 0);
//Création des BOUTTONS
Button[7] = gtk_button_new_with_label("Exit");
//Ajout du BOUTTON dans la boite de dialogue
gtk_box_pack_start(GTK_BOX(VBox7), Button[7], TRUE, FALSE, 0);
g_signal_connect(G_OBJECT(Window_Final2), "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(Button[7]), "clicked", G_CALLBACK(annuler_final_temps), (GtkWidget*) VBox7);
gtk_widget_show_all(Window_Final2);
gtk_main();
glutInitWindowPosition(200,200);
glutInitWindowSize(850,850);
glutInitDisplayMode(GLUT_RGB);
glutCreateWindow("Execution");
glClearColor(0.0,0.0,0.0,0.0);
glPointSize(4.0);
glutDisplayFunc(&affichage);
glutKeyboardFunc(&clavier);
glutMainLoop();
}
//FIN DE LA FONCTION MODE D'EXECUTION = TEMPS D'EXECUTION