void trataSearch(int sockfd, Header& h, char * nomeArquivo)
{
Header resposta;
char dados[1];
FILE *arquivo;
char sNomeArquivo[MAX_NOME_ARQ];
strncpy(sNomeArquivo, nomeArquivo, h.tamDados);
sNomeArquivo[h.tamDados] = '\0';
#ifdef DEBUG_SEARCH
char tmp[TAM_STR_IP + 1];
IdPeer2StrIp(tmp, h.remetente);
printf("\n********** RECEBIMENTO DE SEARCH *************\n");
printf("Remetente: %s\n", tmp);
printf("NumSeq: %d\n", h.numSeq);
printf("********************************************\n\n");
printf("\n\n\n\n********** VOU CHECAR SE TENHO O ARQUIVO !!!! *************\n");
printf("\n\n\n\n********** NOME DO ARQUIVO: (%s)", sNomeArquivo);
#endif
arquivo = fopen(sNomeArquivo, "r");
if(arquivo) {
printf("\n\n\n\n********** ARQUIVO ENCONTRADO !!!! *************\n");
createHeader(&resposta, SEARCHR, h.remetente);
resposta.numSeq = h.numSeq;
dados[0] = calcDistancia(&DadosAplicacao.meuIp, &h.remetente );
resposta.tamDados = sizeof(unsigned char);
if(!escrevePacote(sockfd, resposta, dados))
puts("Erro ao enviar SEARCHR MSG");
#ifdef DEBUG_SEARCH
printf("\n********** RESPONDEU SEARCH *************\n");
#endif
fclose(arquivo);
}
//***********************************************************
distribui(h, nomeArquivo);
//***********************************************************
#ifdef DEBUG_SEARCH
printf("\n********** DISTRIBUIU SEARCH *************\n");
#endif
}
void trataJoin(int sockfd, Header& h, char * dadosP){
Header resposta;
char dados[1];
// #ifdef DEBUG
char tmp[TAM_STR_IP + 1];
IdPeer2StrIp(tmp, h.remetente);
printf("\n********** RECEBIMENTO DE JOIN *************\n");
printf("Remetente: %s\n", tmp);
printf("NumSeq: %d\n", h.numSeq);
printf("********************************************\n\n");
// #endif
puts("Inseriu na tabela de roteamento");
// Se ha espaco na tabela de vizinhos, adiciona o vizinho e envia JOINR com distancia
//if( insereVizinho(origem, sockfd) ){
if(contaVizinhos() < MAX_VIZINHOS){
createHeader( &resposta, JOINR, h.remetente );
resposta.numSeq = h.numSeq;
dados[0] = calcDistancia( &DadosAplicacao.meuIp, &h.remetente );
printf("\n\n\n**************\nDISTANCIA JOINR: %d\n*****************\n\n\n", dados[0]);
resposta.tamDados = sizeof( unsigned char );
printf("Tamanho dos Dados da JOINR: %d\n\n", resposta.tamDados);
if(!escrevePacote(sockfd, resposta, dados))
puts("Erro ao enviar JOINR MSG");
// if ( ( posicao = buscaPosicaoVizinho(h.remetente) ) != -1)
// SetTimer(DadosAplicacao.intervaloHelloR, TIMER_HELLOR, posicao);
}
//***********************************************************
distribui(h, NULL);
//***********************************************************
}
int main(int argc, char* argv[]){
int *cidadeX, *cidadeY, *cidadeD, *rotas, *novasRotas, demandaTotal = 0, capacidade, quantCidades, depositoCentral;
int tamLinha = 100, iLinha = 0, i;
float **distancia;
char arq[50];
char linha[tamLinha];
char *token;
FILE *arquivo;
struct timeval tpI, tpF;
int sec, usec;
/*
* INICIO LEITURA DO ARQUIVO
*/
printf("Arquivos disponiveis: \n");
system("ls A-VRP/");
printf("\nEx.: A-VRP/A-n32-k5.vrp\n\n");
printf("Arquivo: ");
scanf("%s", arq);
arquivo = fopen(arq, "r");
/*
* Pode-se utilizar a entrada de dados estática.
* arquivo = fopen("A-VRP/A-n32-k5.vrp", "r");
* arquivo = fopen("A-VRP/A-n44-k7.vrp", "r");
* arquivo = fopen("A-VRP/A-n53-k7.vrp", "r");
* arquivo = fopen("A-VRP/A-n63-k9.vrp", "r");
* arquivo = fopen("A-VRP/A-n80-k10.vrp", "r");
* arquivo = fopen("A-VRP/X-n1001-k43.vrp", "r");
*/
/*
* Tempo Inicial
*/
gettimeofday(&tpI,NULL);
if(arquivo == NULL){
printf("Erro, nao foi possivel abrir o arquivo. \n");
}else{
while(!feof(arquivo)){
fgets(linha, tamLinha , arquivo);
if (iLinha == 3){
/*
* Encontrado a quantidade de cidades/instancias no arquivo
*/
token = strtok(linha," ");
token = strtok (NULL, " ");
token = strtok (NULL, " ");
quantCidades = atoi(token);
printf("Quantidade de Cidades: %d \n", quantCidades);
/*
* Alocação do vetor que irá conter o ponto x de cada cidade.
*/
cidadeX = malloc((quantCidades) * sizeof(int));
if (cidadeX == NULL) {
printf( "Erro Malloc Cidade X!\n");
exit(-1);
}
/*
* Alocação do vetor que irá conter o ponto y de cada cidade.
*/
cidadeY = malloc((quantCidades) * sizeof(int));
if (cidadeY == NULL) {
printf( "Erro Malloc Cidade Y!\n");
exit(-1);
}
/*
* Alocação do vetor que irá conter a demanda de cada cidade.
*/
cidadeD = malloc((quantCidades) * sizeof(int));
if (cidadeD == NULL) {
printf( "Erro Malloc Demanda!\n");
exit(-1);
}
/*
* Alocação da matriz triangular inferior de distancias.
*/
distancia = malloc((quantCidades) * sizeof(float *));
#pragma acc kernels
for (i = 0; i < quantCidades; ++i){
distancia[i] = malloc((i) * sizeof(float *));
}
if (distancia == NULL) {
printf( "Erro Malloc distancia!\n");
exit(-1);
}
}else if (iLinha == 5){
/*
* Encontrado a capacidade de cada veículo no arquivo
*/
token = strtok(linha," ");
token = strtok (NULL, " ");
token = strtok (NULL, " ");
capacidade = atoi(token);
printf("Capacidade: %d \n", capacidade);
}else if (iLinha > 6 && iLinha <= 6+quantCidades){
/*
* Encontrado a cidade com seu respectivo ponto x e y no plano.
*/
int cidade;
/*
* Encontrada a cidade.
*/
token = strtok(linha," ");
cidade = atoi(token);
/*
* Encontrado o ponto x.
*/
token = strtok (NULL, " ");
cidadeX[cidade - 1] = atoi(token);
/*
* Encontrado o ponto y.
*/
token = strtok (NULL, " ");
cidadeY[cidade - 1] = atoi(token);
}else if (iLinha > (7+quantCidades) && iLinha <= (7+quantCidades*2)){
/*
* Encontrado a cidade com a sua respectiva demanda.
*/
int cidade;
/*
* Encontrada a cidade.
*/
token = strtok(linha," ");
cidade = atoi(token);
/*
* Encontrada a demanda.
*/
token = strtok (NULL, " ");
cidadeD[cidade - 1] = atoi(token);
/*
* Soma-se essa demanda na demanta total do problema.
*/
demandaTotal += atoi(token);
}else if ( iLinha == (7+quantCidades*2+2)){
/*
* Encontrado a cidade que é o depósito central do problema.
*/
token = strtok(linha," ");
depositoCentral = atoi(token)-1;
printf("Deposito Central: %d\n",depositoCentral);
break;
}
iLinha++;
}
}
fclose(arquivo);
/*
* FIM LEITURA DO ARQUIVO
*/
printf("Demanda Total: %d \n",demandaTotal);
/*
* Cálculo que irá definir o mínimo de rotas necessárias para resolver o problema.
*/
int minimo = ceil((float)demandaTotal/(float)capacidade);
printf("Minimo de Veículos: %d \n", minimo);
/*
* Cálculo que irá definir o tamanho do vetor que irá armazenar a resposta (rotas)
*/
int quantRotas = quantCidades+minimo;
double valor, inteiro, fracionario;
valor = (double)demandaTotal/(double)capacidade;
fracionario = modf(valor , &inteiro);
if(fracionario > 0.80){
quantRotas +=1;
}
/*
* Alocação do vetor que irá conter a resposta (rotas) do problema.
*/
rotas = malloc((quantRotas) * sizeof(int));
if (rotas == NULL) {
printf( "Erro Malloc Rotas!\n");
exit(-1);
}
/*
* Chamada ao cálculo que irá preencher a matris triangular inferior.
*/
calcDistancia(quantCidades, cidadeX, cidadeY, distancia);
/*
* Alocação do vetor que irá conter a resposta (novasRotas) do problema.
*/
novasRotas = malloc((quantRotas) * sizeof(int));
if (novasRotas == NULL) {
printf( "Erro Malloc novasRotas!\n");
exit(-1);
}
float newCost = 0, oldCoast = 0;
/*
* Geração da solução inicial.
*/
solucaoInicial(distancia, quantCidades, capacidade, cidadeD, rotas, depositoCentral);
/*
* Se quiser visualizar a solução incial encontrada é só descomentar as próximas duas linhas de código.
* imprime(rotas, quantRotas, cidadeD);
* printf("\nCost %f \n", calcCusto(rotas, distancia, quantRotas));
*/
/*
* Cálculo do custo da solução encontrada e armazenada na variável rotas.
*/
newCost = calcCusto(rotas, distancia, quantRotas);
/*
* Aplica-se a busca local na variável rotas.
*/
rotas = buscaLocal(distancia, quantCidades, capacidade, cidadeD, rotas, quantRotas, depositoCentral);
while(newCost != oldCoast){
/*
* Atualizando variável para critério de parada.
*/
oldCoast = newCost;
/*
* Aplica-se a perturbação na variável rotas.
*/
novasRotas = perturbacao(distancia, quantCidades, capacidade, cidadeD, rotas, quantRotas, depositoCentral);
/*
* Aplica-se a busca local na variável novasRotas.
*/
novasRotas = buscaLocal(distancia, quantCidades, capacidade, cidadeD, novasRotas, quantRotas, depositoCentral);
/*
* Aplica-se o critério de aceitação nas variáveis rotas e novasRotas.
*/
rotas = criterioDeAceitacao(rotas, novasRotas, distancia, quantRotas);
/*
* Cálculo do custo da solução encontrada e armazenada na variável rotas.
*/
newCost = calcCusto(rotas, distancia, quantRotas);
}
/*
* Imprime resultado final, suas rotas e seu custo total.
*/
printf("\nResultado Final\n");
imprime(rotas, quantRotas, cidadeD);
printf("\nCost %f \n", calcCusto(rotas, distancia, quantRotas));
/*
* Tempo Final
*/
gettimeofday(&tpF, NULL);
sec = tpF.tv_sec - tpI.tv_sec;
usec = tpF.tv_usec - tpI.tv_usec;
if (usec<0){
usec += 1000000L;
sec -= 1;
}
printf("Tempo de execucao: %d s %d us\n", sec, usec);
free(cidadeX);
free(cidadeY);
free(cidadeD);
free(distancia);
return 0;
}
