int main(int argc, char ** argv)
{
int dimension = 5;
int ** array = array2d(dimension);
for(int i = 0; i < dimension; i++){
for(int j = 0; j < dimension; j++){
array[i][j] = i * dimension + j;
}
}
// Initial array
display(array, dimension);
// Rotate 90 degrees clockwise
rotate(array, dimension);
// Array after rotation
display(array, dimension);
free(array);
return 0;
}
int main(int argc, char **argv) {
double **locdens;
double ***locvel;
rundata_t rundata;
int ierr;
int rank, size;
ierr = MPI_Init(&argc, &argv);
ierr = MPI_Comm_size(MPI_COMM_WORLD,&size);
ierr = MPI_Comm_rank(MPI_COMM_WORLD,&rank);
/*
* set default values for parameters, then check what the user says
* with the options
*/
/* choose sensible defaults */
nearsquare(size,&(rundata.npx),&(rundata.npy));
rundata.globalnx = 100;
rundata.globalny = 100;
rundata.nprocs = size;
rundata.rank = rank;
rundata.localnx = (rundata.globalnx / rundata.npx);
rundata.localny = (rundata.globalny / rundata.npy);
strcpy(rundata.filename,"paralleldata.h5");
/* get options */
get_options(argc,argv,&rundata);
printf("[%d]: (%d,%d) \n", rank, rundata.myx, rundata.myy);
/*
* allocate our local arrays
*/
locdens = array2d(rundata.localnx, rundata.localny);
locvel = array3d(2, rundata.localnx, rundata.localny);
printf("[%d]: Allocated arrays\n", rank);
fillarray2d(locdens, &rundata);
fillarray3d(locvel, &rundata);
printf("[%d]: Filled arrays\n", rank);
if (rundata.localnx*rundata.localny < 200)
printarray2d(locdens, rundata.localnx, rundata.localny);
writehdf5file(rundata, locdens, locvel);
printf("[%d]: Wrote file\n", rank);
freearray2d(locdens);
freearray3d(locvel);
ierr = MPI_Finalize();
return 0;
}
int main(int argc, char *argv[]) {
// Manipulacao de Arquivop
FILE *arquivo;
arquivo = fopen("info.dat","w");
/*------------------- Declaracao das variaveis------------------------------*/
array2d(pop, TAM_POP, TAM_IND); //populacao de individuos
array2d(popAux, TAM_POP, TAM_IND); //populacao de individuos
array2d(popIntermed, TAM_POP, TAM_IND); //populacao gerada pelos torneio
array1d(pesos, TAM_IND); //peso de cada objeto
array1d(beneficios, TAM_IND); //benf. de cada objeto
int capacidade; //capacidade da mochila
array1d(pesoIndividuo, TAM_POP); //soma dos pesos de cada individuo
array1d(excessoIndividuo, TAM_POP); //excesso de cada individuo
array1d(benefIndividuo, TAM_POP); //beneficio de cada individuo
array1d(penalidadeIndividuo, TAM_POP); //penalidade de cada individuo por exceder.
array1d(melhorIndividuo, TAM_IND); //melhor individuo
array2d(torneio, TAM_POP, TAM_TORNEIO); //matriz das competicoes
/*Variaveis para paralelização*/
int x;
/*Variaveis MPI*/
int CPU, ret, size;
/*Inicialização MPI*/
MPI_Status status;
ret = MPI_Init(&argc, &argv);
ret = MPI_Comm_rank(MPI_COMM_WORLD, &CPU);
ret = MPI_Comm_size(MPI_COMM_WORLD, &size);
/*Feedback para inicialização da CPU*/
printf("Executando CPU=%d...\n",CPU);
if (CPU == 0) {// CPU 0 INI
/* ---------------Construcao do Problema--------------- */
// Gerar Pesos
srand((unsigned)time(NULL));
for (i = 0; i < TAM_IND; i++)
pesos[i] = rand() % 40;
// Imprimir Pesos
fprintf(arquivo, "Pesos: ");
for(i = 0; i < TAM_IND; i++) {
fprintf(arquivo, " %d ", pesos[i]);
}
fprintf(arquivo, "\n");
// Gerar Beneficios
srand((unsigned)time(NULL));
for (i = 0; i < TAM_IND; i++) {
beneficios[i] = rand() % 200;
}
// Imprimir Beneficios
fprintf(arquivo, "Valores: ");
for(i = 0; i < TAM_IND; i++) {
fprintf(arquivo, " %d ", beneficios[i]);
}
fprintf(arquivo, "\n");
// Calcular a capacidade da mochila
int peso = 0;
for (i = 0; i < TAM_IND; i++)
peso += pesos[i];
capacidade = peso * CAPACIDADE;
fprintf(arquivo, "Capacidade da mochila: %d\n", capacidade);
fprintf(arquivo, "\n");
}// FIM CPU 0
/*----------------------- Gerar Populacao --------------------*/
int auxZero = 0;
int auxUm = 0;
int auxxZero = 0;
int auxxUm = 0;
if (CPU == 0) {//CPU 0 INI
srand((unsigned)time(NULL));
for (i = 0; i < TAM_POP/2; i++) {
for (j = 0; j < TAM_IND/2; j++) {
pop[i][j] = rand() % 2;
if (pop[i][j] == 0) // Conta o numero de 0s e 1s do individuo
auxZero++;
else
auxUm++;
}
// Caso o individuo seja formado totalmente por 0s ou 1s, renicia-se o laço externo.
if (auxZero == TAM_IND || auxUm == TAM_IND)
i--;
auxZero = 0;
auxUm = 0;
}
} // FIM DO IF CPU 0
if (CPU == 1) {//CPU 1 INI
srand((unsigned)time(NULL));
for (i = TAM_POP - 1; i > TAM_POP/2; i--) {
for (j = TAM_IND - 1; j > TAM_IND/2; j--) {
popAux[i][j] = rand() % 2;
if (popAux[i][j] == 0) // Conta o numero de 0s e 1s do individuo
auxxZero++;
else
auxxUm++;
}
// Caso o individuo seja formado totalmente por 0s ou 1s, renicia-se o laço externo.
if (auxxZero == TAM_IND || auxxUm == TAM_IND)
i--;
auxxZero = 0;
auxxUm = 0;
}
}// FIM DO IF CPU 1
// UNIAO
for (i = TAM_POP - 1; i > TAM_POP/2; i--) {
for (j = TAM_IND - 1; j > TAM_IND/2; j--) {
if (CPU != 0)
MPI_Send(&popAux[i][j], 1, MPI_INT, (0), 0, MPI_COMM_WORLD);
else {
MPI_Recv(&x, 1, MPI_INT, (1), 0, MPI_COMM_WORLD, &status);
pop[i][j] = x;
}
}
}
if (CPU == 0) {// CPU 0 INI
// Imprimir populacao
fprintf(arquivo, "Solucao inicial aleatoria:\n");
for (i = 0 ; i < TAM_POP; i++) {
fprintf(arquivo, "Individuo%d: ", i);
for(j = 0; j < TAM_IND; j++) {
fprintf(arquivo, " %d ", pop[i][j]);
}
fprintf(arquivo, "\n");
}
fprintf(arquivo, "\n");
/*----------------------- Fim Gerar Populacao --------------------*/
/*----------------------Termino Construcao do Problema-------------*/
/*---------------- Medir qualidade da Solucao Aleatoria-----------------------*/
// Calcular Peso do Individuo
int aux = 0;
for(i = 0; i < TAM_POP; i++) {
for(j = 0; j < TAM_IND; j++) {
if (pop[i][j])
aux += pesos[j];
}
pesoIndividuo[i] = aux;
aux = 0;
}
// Calcular Excesso do Individuo
for(i = 0; i < TAM_POP; i++) {
if (pesoIndividuo[i] - capacidade < 0)
excessoIndividuo[i] = 0;
else
excessoIndividuo[i] = pesoIndividuo[i] - capacidade;
}
// Calcular a Penalidade do Individuo
aux = 0;
for(i = 0; i<TAM_POP; i++) {
for(j = 0 ; j < TAM_IND; j++) {
if (pop[i][j])
aux++;
}
penalidadeIndividuo[i] = PENALIDADE * aux;
aux = 0;
}
// Calcular Beneficios dos Individuos
aux = 0;
for(i = 0; i < TAM_POP; i++) {
for(j = 0; j < TAM_IND; j++)
if (pop[i][j])
aux += beneficios[j] - penalidadeIndividuo[i] * excessoIndividuo[i];
benefIndividuo[i] = aux;
aux = 0;
}
// Imprime os Dados dos Individuos
fprintf(arquivo, "Dados de Cada Individuo: \n");
for(i = 0; i < TAM_POP; i++) {
fprintf(arquivo, "Individuo%d: ", i);
fprintf(arquivo, "Peso: %d \t", pesoIndividuo[i]);
fprintf(arquivo, "Excesso: %d \t", excessoIndividuo[i]);
fprintf(arquivo, "Fitness: %d ", benefIndividuo[i]);
fprintf(arquivo, "\n");
}
/*---------------- Fim Medir qualidade da Solucao Aleatoria-----------------------*/
/*----------------------- Torneio (Selecao dos melhores individuos)----------------*/
int vet[TAM_POP]; //indices populacao intermediaria
int maior = 0;
fprintf(arquivo, "\n\nTorneio: \n");
srand((unsigned)time(NULL));
for(i = 0; i < TAM_POP; i++) {
for(j = 0; j < TAM_TORNEIO; j++) {
torneio[i][j] = rand() % TAM_POP; // Preencher a matriz de torneio com individuos
fprintf(arquivo, " %d ", torneio[i][j]);
if (benefIndividuo[torneio[i][j]] > benefIndividuo[maior]) // Analisa qual individuo tem a > fitness
maior = torneio[i][j];
}
fprintf(arquivo, "\n");
vet[i] = maior;
maior = 0;
}
fprintf(arquivo, "\n");
//Preencher populacaoIntermediaria
for(i = 0; i < TAM_POP; i++)
for(j = 0; j < TAM_IND; j++)
popIntermed[i][j] = pop[vet[i]][j];
// Imprimir populacao intermediaria
fprintf(arquivo, "População Intermediaria - Torneio\n");
for (i = 0 ; i < TAM_POP; i++) {
fprintf(arquivo, "Individuo%d: ", i);
for(j = 0; j < TAM_IND; j++) {
fprintf(arquivo, " %d ", popIntermed[i][j]);
}
fprintf(arquivo, "\n");
}
fprintf(arquivo, "\n");
/*---------------------FIM do Torneio (Selecao dos melhores individuos)-------------*/
/*------------- Fim Medir qualidade dos Individuos Selecionados ------------------*/
// Calcular Peso do Individuo
aux = 0;
for(i = 0; i < TAM_POP; i++) {
for(j = 0; j < TAM_IND; j++) {
if (popIntermed[i][j])
aux += pesos[j];
}
pesoIndividuo[i] = aux;
aux = 0;
}
// Calcular Excesso do Individuo
for(i = 0; i < TAM_POP; i++) {
if (pesoIndividuo[i] - capacidade < 0)
excessoIndividuo[i] = 0;
else
excessoIndividuo[i] = pesoIndividuo[i] - capacidade;
}
// Calcular a Penalidade do Individuo
aux = 0;
for(i = 0; i<TAM_POP; i++) {
for(j = 0 ; j < TAM_IND; j++) {
if (popIntermed[i][j])
aux++;
}
penalidadeIndividuo[i] = PENALIDADE * aux;
aux = 0;
}
// Calcular Beneficios dos Individuos
aux = 0;
for(i = 0; i < TAM_POP; i++) {
for(j = 0; j < TAM_IND; j++)
if (popIntermed[i][j])
aux += beneficios[j] - penalidadeIndividuo[i] * excessoIndividuo[i];
benefIndividuo[i] = aux;
aux = 0;
}
// Imprime os Dados dos Individuos
fprintf(arquivo, "Dados de Cada Individuo: \n");
for(i = 0; i < TAM_POP; i++) {
fprintf(arquivo, "Individuo%d: ", i);
fprintf(arquivo, "Peso: %d \t", pesoIndividuo[i]);
fprintf(arquivo, "Excesso: %d \t", excessoIndividuo[i]);
fprintf(arquivo, "Fitness: %d ", benefIndividuo[i]);
fprintf(arquivo, "\n");
}
/*------------- Fim Medir qualidade dos Individuos Selecionados ------------------*/
/*------------------------------ Cruzamento-------------------------------- */
fprintf(arquivo, "\n---- Inicio Cruzamento ---\n");
int indiceMaiorBenef = 0, indiceMenorBenef = 0, indiceSegundoMaiorBenef = 0;
int maiorBenef = benefIndividuo[0], menorBenef = benefIndividuo[0];
int segundoMaiorBenef = benefIndividuo[0];
int mutacao;
for(k = 0; k < GERACOES; k++) {
fprintf(arquivo, "\n---- GERACAO: %d -----\n", k);
for(j = 1; j < TAM_POP; j++) {
if (benefIndividuo[j] > maiorBenef) {
maiorBenef = benefIndividuo[j];
indiceMaiorBenef = j;
}
if (benefIndividuo[j] < menorBenef) {
menorBenef = benefIndividuo[j];
indiceMenorBenef = j;
}
}
for (j = 1; j < TAM_POP; j++) {
if (benefIndividuo[j] > segundoMaiorBenef && j != indiceMaiorBenef) {
segundoMaiorBenef = benefIndividuo[j];
indiceSegundoMaiorBenef = j;
}
}
fprintf(arquivo, "Maior Beneficio: %d\n", maiorBenef);
fprintf(arquivo, "Indice Maior Benef: %d\n", indiceMaiorBenef);
fprintf(arquivo, "Segundo Maior Beneficio: %d\n", segundoMaiorBenef);
fprintf(arquivo, "Indice Segundo Maior Benef: %d\n", indiceSegundoMaiorBenef);
fprintf(arquivo, "Menor Beneficio: %d\n", menorBenef);
fprintf(arquivo, "Indice Menor Benef: %d\n", indiceMenorBenef);
mutacao = rand() % 101;
for(j = 0; j < TAM_IND / 2; j++)
if (mutacao > 99) {
if (popIntermed[indiceMaiorBenef][j] == 0)
popIntermed[indiceMenorBenef][j] = 1;
else
popIntermed[indiceMenorBenef][j] = 0;
}
else
popIntermed[indiceMenorBenef][j] = popIntermed[indiceMaiorBenef][j];
for(j = TAM_IND / 2; j < TAM_IND; j++)
if (mutacao > 99) {
if (popIntermed[indiceSegundoMaiorBenef][j] == 0)
popIntermed[indiceMenorBenef][j] = 1;
else
popIntermed[indiceMenorBenef][j] = 0;
}
else
popIntermed[indiceMenorBenef][j] = popIntermed[indiceSegundoMaiorBenef][j];
for (i = 0; i < TAM_POP; i++){
for(j = 0; j < TAM_IND; j++) {
fprintf(arquivo, " %d ", popIntermed[i][j]);
}
fprintf(arquivo, "\n");
}
maiorBenef = benefIndividuo[0];
segundoMaiorBenef = benefIndividuo[0];
menorBenef = benefIndividuo[0];
indiceMaiorBenef = 0;
indiceMenorBenef = 0;
indiceSegundoMaiorBenef = 0;
fprintf(arquivo, "\n");
/*------------------- Medir Qualidade da Geracao-----------------*/
aux = 0;
for(i = 0; i < TAM_POP; i++) {
for(j = 0; j < TAM_IND; j++) {
if (popIntermed[i][j])
aux += pesos[j];
}
pesoIndividuo[i] = aux;
aux = 0;
}
// Calcular Excesso do Individuo
for(i = 0; i < TAM_POP; i++) {
if (pesoIndividuo[i] - capacidade < 0)
excessoIndividuo[i] = 0;
else
excessoIndividuo[i] = pesoIndividuo[i] - capacidade;
}
// Calcular a Penalidade do Individuo
aux = 0;
for(i = 0; i<TAM_POP; i++) {
for(j = 0 ; j < TAM_IND; j++) {
if (popIntermed[i][j])
aux++;
}
penalidadeIndividuo[i] = PENALIDADE * aux;
aux = 0;
}
// Calcular Beneficios dos Individuos
aux = 0;
for(i = 0; i < TAM_POP; i++) {
for(j = 0; j < TAM_IND; j++)
if (popIntermed[i][j])
aux += beneficios[j] - penalidadeIndividuo[i] * excessoIndividuo[i];
benefIndividuo[i] = aux;
aux = 0;
}
// Imprime os Dados dos Individuos
fprintf(arquivo, "Dados de Cada Individuo: \n");
for(i = 0; i < TAM_POP; i++) {
fprintf(arquivo, "Individuo%d: ", i);
fprintf(arquivo, "Peso: %d \t", pesoIndividuo[i]);
fprintf(arquivo, "Excesso: %d \t", excessoIndividuo[i]);
fprintf(arquivo, "Fitness: %d ", benefIndividuo[i]);
fprintf(arquivo, "\n");
}
/*----------------FIM Medir Qualidade da Geracao-----------------*/
}
fprintf(arquivo, "\n");
/*----------Medir Qualidade apos o cruzamento---------------- */
// Verificar o Melhor Individuo
indiceMaiorBenef = 0;
maiorBenef = benefIndividuo[0];
for(i = 1; i < TAM_POP; i++)
if (maiorBenef < benefIndividuo[i]) {
maiorBenef = benefIndividuo[i];
indiceMaiorBenef = i;
}
for (i = 0; i < TAM_IND; i++)
melhorIndividuo[i] = popIntermed[indiceMaiorBenef][i];
// Imprimir o Melhor Individuo
fprintf(arquivo, "\nMelhor Individuo: \n");
for(i = 0; i < TAM_IND; i++)
fprintf(arquivo, "%d ", melhorIndividuo[i]);
/*----------FIM Medir Qualidade apos o cruzamento--------------*/
fprintf(arquivo, "\n");
fclose(arquivo);
/*---------------------------FIM Cruzamento-------------------------------- */
} //FIM CPU 0
return 0;
}
int main( int argc, char *argv[] ){
//Leitura da imagem
IplImage *input_file = cvLoadImage("image.jpg", CV_LOAD_IMAGE_COLOR);
int height = input_file->height;
int width = input_file->width;
//Criacao da imagem de saida
IplImage *output_file = cvCreateImage( cvSize( width, height), IPL_DEPTH_8U, 1 );
array2d(x, height, width);
array2d(y, height, width);
int h, w, r, g, b, pixel, tmp, a;
//Variaveis MPI
int CPU, ret, size;
//Inicializacao MPI
MPI_Status status;
ret = MPI_Init(&argc, &argv);
ret = MPI_Comm_rank(MPI_COMM_WORLD, &CPU);
ret = MPI_Comm_size(MPI_COMM_WORLD, &size);
/*
Variavel da divisao
A imagem sera dividida e metade dela sera executada na CPU0 e a outra metade na CPU1
*/
if (CPU == 0) {
tmp = 0;
}
if (CPU == 1) {
tmp = width/2;
}
//Processamento da imagem
for( h = 0; h < height; ++h ){
for( w = 0 + tmp; w <= ((width/2)+tmp); ++w ){
b = CV_IMAGE_ELEM( input_file, uchar, h, w * 3 );
g = CV_IMAGE_ELEM( input_file, uchar, h, w * 3 + 1 );
r = CV_IMAGE_ELEM( input_file, uchar, h, w * 3 + 2 );
pixel = 0.299 * r + 0.587 * g + 0.114 * b;
y[h][w] = pixel;
}
}
//Liberando a imagem da memoria
cvReleaseImage( &input_file );
//Troca de menssagem
if (CPU != 0) {
//Envio da CPU1 para a CPU0
cvReleaseImage( &output_file );
MPI_Send(&(y[0][0]), height*width, MPI_INT, (0), 0, MPI_COMM_WORLD);
}else{ //(CPU == 0)
//Recebimento da menssagem (imagem)
//Uma boa forma de visualizar a troca de mensasgens ocorre quando se comenta a recepcao da menssagem
//Quando isso ocorre a imagem final gerada e metade preta pois a outra metade nao foi recebida
MPI_Recv(&(x[0][0]), height*width, MPI_INT, (1), 0, MPI_COMM_WORLD, &status);
//Juncao das imagens
for(h = 0; h < height; ++h) {
for(w = 0; w < width; ++w){
if(w <= width/2){
CV_IMAGE_ELEM(output_file, uchar, h, w) = y[h][w];
}else{
CV_IMAGE_ELEM(output_file, uchar, h, w) = x[h][w];
}
}
}
}
if(CPU==0){
cvSaveImage("image-gray", output_file, NULL);
}
//Fim
MPI_Finalize();
}
