static int* SolvingIt(int* puzzle) {
int r, c;
for (r = 0; r < 9; r++)
for (c = 0; c < 9; c++)
if (puzzle[SUDOKU_INDEX(r,c)] == 0)
puzzle[SUDOKU_INDEX(r,c)] = 123456789;
int puzzleValue = GetValue(puzzle);
int oldValue = 9 * 81;
while (oldValue > puzzleValue && puzzleValue > 81) {
oldValue = puzzleValue;
//printf("1: %d\n", GetValue(puzzle));
Reduction(puzzle, GetValue(puzzle));
//printf("2: %d\n", GetValue(puzzle));
if (CheckSudoku(puzzle))
return puzzle;
//PrintSudoku(puzzle);
puzzleValue=GetValue(puzzle);
while(true){
LonelyNum(puzzle);
if (GetValue(puzzle)==puzzleValue)
break;
else
puzzleValue=GetValue(puzzle);
}
//printf("3: %d\n", GetValue(puzzle));
//PrintSudoku(puzzle);
//return NULL;
Reduction(puzzle, GetValue(puzzle));
if (CheckSudoku(puzzle))
return puzzle;
Twos(puzzle);
puzzleValue = GetValue(puzzle);
}
if (CheckSudoku(puzzle) || guess >= guesslimit)
return puzzle;
int s, i;
for (s = 2; s < 10; s++) {
for (i = 0; i < 81; i++) {
if (Length_int(puzzle[i]) != s)
continue;
int tmp = puzzle[i];
int* guessing = (int*) (malloc)(sizeof(int) * 81);
while (tmp) {
int n;
for (n = 0; n < 81; n++)
guessing[n] = puzzle[n];
guessing[i] = tmp % 10;
guess++;
guessing = SolvingIt(guessing);
guess--;
if (CheckSudoku(guessing)) {
puzzle = guessing;
return puzzle;
}
tmp /= 10;
}
free(guessing);
}
}
if (guess == 0 && !CheckSudoku(puzzle)) {
guesslimit++;
puzzle = SolvingIt(puzzle);
return puzzle;
}
if (!CheckSudoku(puzzle))
return NULL;
return puzzle;
}
/* -------------------------------------------------------------------------
O primeiro parametro a ser passado para esse agente e' o numero do proce-
ssador em que esta executando o 'ns' e o segundo parametro e' o nome do
arquivo que contem a instancia do SCP.
------------------------------------------------------------------------- */
main(int argc, char *argv[])
{
int flagConnect = 1;
char port[MPI_MAX_PORT_NAME];
MPI_Comm commServerMD;
MPI_Init(&argc, &argv);
MPI_Comm_get_parent(&interfaceComm);
/* Tetativa de conectar com o servidor */
flagConnect = MPI_Lookup_name("ServerMD", MPI_INFO_NULL, port);
if(flagConnect)
{
printf("\n\n* Termino do Agente Dual Greedy *");
printf("\n* ERRO : A memoria de solucoes duais nao foi iniciada. *");
fflush(stdout);
}
else
{
/*
TimeSleeping = (int) ReadAteamParam(1);
MaxLenDualMem = (int) ReadAteamParam(2);
CutsofSol = (int) ReadAteamParam(6);
MaxExeTime = (int) ReadAteamParam(11);
ReducPerc = (int) ReadAteamParam(12);
RandomDual = (char) ReadAteamParam(17);
*/
TimeSleeping = atoi(argv[2]);
MaxLenDualMem = atoi(argv[3]);
CutsofSol = atoi(argv[4]);
MaxExeTime = atoi(argv[5]);
ReducPerc = atoi(argv[6]);
RandomDual = (char) atoi(argv[7]);
if (!(finput = fopen(argv[1],"r")))
{ printf("\n\n* Erro na abertura do arquivo %s. *\n",argv[1]);
exit(1);
}
ReadSource();
fclose(finput);
Reduction(NULL,NULL);
srand48(time(NULL));
MPI_Comm_connect(port, MPI_INFO_NULL, 0, MPI_COMM_SELF, &commServerMD);
ExecAgDual(commServerMD);
printf("\n\n* Agente Dual Greedy finalizado *");
printf("\n* Servidor finalizou processamento. *\n");
}
/* Finaliza comunicacao com o servidor */
int message = 1224;
MPI_Send(&message, 1, MPI_INT, 0, 1, commServerMD);
/* Envia mensagem de Finalizacao para interface */
//message = 1;
//MPI_Send(&message, 1, MPI_INT, 0, 1, interfaceComm);
MPI_Comm_disconnect(&commServerMD);
MPI_Finalize();
printf("\n ==== ag_dual FINALIZADO \n", message);
}
/* -------------------------------------------------------------------------
O primeiro parametro a ser passado para esse agente e' o numero do proce-
ssador em que esta executando o 'ns', o segundo parametro e' o nome do
arquivo que contem a instancia do SCP e o terceiro e' o nome do diretorio
em que serao gerados os arquivos de estatisticas.
------------------------------------------------------------------------- */
main(int argc,char *argv[])
{
int numSpawns = 1, /* Qtd de processos de serverMD */
errcodes[numSpawns], /* Array de erros para o spawn. Um */
/* código por processo */
/* Variáveis de controle de um grupo de processos da MPI*/
size,
rank;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &size);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm interComSpawn;
char *look = NULL,
path[200];
unsigned long NbServerMD = 0;
/*
MaxLenDualMem = (int) ReadAteamParam(2);
ReducPerc = (int) ReadAteamParam(12);
RandomInitMD = (char) ReadAteamParam(16);
*/
MaxLenDualMem = atoi(argv[3]);
ReducPerc = atoi(argv[4]);
RandomInitMD = (char) atoi(argv[5]);
/* OBS: Esse arquivo de ser passado por argv[2] */
if (!(finput = fopen(argv[1],"r")))
{ printf("\n\n* Erro na abertura do arquivo %s. *",argv[1]);
exit(1);
}
ReadSource(); /* Localizada em readsc.c */
fclose(finput);
Reduction(NULL,NULL); /* Localizada em reduction.c */
srand48(time(NULL));
if (argc == 10)
strcpy(path,argv[2]);
else
strcpy(path,"./");
look = argv[1];
while (look)
if (look = (char *) strstr(argv[1],"/"))
argv[1] = (look + 1);
strcat(path,argv[1]);
// char *param = malloc(200 * sizeof(char));
// strcpy(param, path);
char *param[7];
param[0] = (char *) malloc (512 * sizeof(char));
param[1] = (char *) malloc (16 * sizeof(char));
param[2] = (char *) malloc (16 * sizeof(char));
param[3] = (char *) malloc (16 * sizeof(char));
param[4] = (char *) malloc (16 * sizeof(char));
param[5] = (char *) malloc (16 * sizeof(char));
param[6] = NULL;
strcpy(param[0], path);
strcpy(param[1], argv[3]);
strcpy(param[2], argv[6]);
strcpy(param[3], argv[7]);
strcpy(param[4], argv[8]);
strcpy(param[5], argv[9]);
/* ------------------------------------------------------------------------- */
/* Iniciando o serverMD */
MPI_Comm_spawn("../../AteamMPI/bin/serverMD",
param, 1, MPI_INFO_NULL, 0, MPI_COMM_SELF, &interComSpawn, errcodes);
/* ------------------------------------------------------------------------- */
/* Espera bloqueante necessária para não dar crash */
char messageBlock[1];
MPI_Status status;
MPI_Recv(messageBlock, 1, MPI_CHAR, 0, MPI_ANY_TAG, interComSpawn, &status);
/* ------------------------------------------------------------------------- */
int method = INIT_GLOBAL_VARS, /* Primeira função a ser chamada pelo */
/* serverMD (INIT_GLOBAL_VARS) */
position = 0, /* Marca as posicoes de cada dado
empacotado */
flagConnect = 1; /* Flag para verificar se conectou com o
servidor */
char * buffer, /* Buffer contendo a mensagem a ser enviada*/
port[MPI_MAX_PORT_NAME]; /* Porta para conectar com o serverMD */
MPI_Comm commServerMD; /* Comunicador retornado apos a conexao com
serverMD */
/* Verificando a existencia do serverMD - se sim recebe a porta */
/* para conectar */
flagConnect = MPI_Lookup_name("ServerMD", MPI_INFO_NULL, port);
if(flagConnect)
{
printf("\n\n Erro: Porta não concebida \n\n");fflush(stdout);
}else{
/* Conecta como serverMD */
MPI_Comm_connect(port, MPI_INFO_NULL, 0, MPI_COMM_SELF, &commServerMD);
buffer = malloc(3 * sizeof(int) + sizeof(float) + sizeof(unsigned long));
/* Sequência de empacotamento da primeira mensagem */
MPI_Pack(&method, 1, MPI_INT, buffer, 3 * sizeof(int) + sizeof(float) +
sizeof(unsigned long), &position, commServerMD);
/*
* Position foi incrementada: passa a referenciar a primeira
* posição livre no buffer e assim sucessivamente.
*/
MPI_Pack(&nb_lin, 1, MPI_INT, buffer, 3 * sizeof(int) + sizeof(float) +
sizeof(unsigned long), &position, commServerMD);
MPI_Pack(&nb_col, 1, MPI_INT, buffer, 3 * sizeof(int) + sizeof(float) +
sizeof(unsigned long), &position, commServerMD);
MPI_Pack(&density, 1, MPI_FLOAT, buffer, 3 * sizeof(int) + sizeof(float) +
sizeof(unsigned long), &position, commServerMD);
MPI_Pack(&NbServerMD, 1, MPI_UNSIGNED_LONG, buffer, 3 * sizeof(int) +
sizeof(float) + sizeof(unsigned long), &position, commServerMD);
/*
* Envia a mensagem empacotada para o serverMD, fazendo uso do comu-
* nicador interComSpawn resultante da chamada a rotina spawn
*/
MPI_Send(buffer, position, MPI_PACKED, 0, 1, commServerMD);
free(buffer);
}
/* A heuristica dual gulosa sera chamada <MaxLenDualMem> vezes para gerar
solucoes que permitam preencher total ou parcialmente a memoria de solu-
coes duais. */
ExecAgInitMD(commServerMD);
FreeSource();
int i = 0;
int message = 1224;
//printf("\n \n Messagen 1224 %d: \n", message);
MPI_Send(&message, 1, MPI_INT, 0, 1, commServerMD);
MPI_Comm_disconnect(&commServerMD);
//printf("\n\n* Termino do Agente InitMD *");
//printf("\n* A memoria de solucoes duais foi inicializada. *\n");
MPI_Finalize();
}
