MPI skips communications on larger data - c

Question

I want to parallelize a Backtracking algorithm to solve a sudoku game. My program skips some grids sometimes which is more likely to happen on larger sudoku files e.g. computation on 9x9 sudokus gives mostlikely a solution but on 16x16 almost never. It might return very quick meaning it does not compute all cached grids or they are not cached at all and thrown away(commenting continue statement in solveSudoku or not caching sudokus at all always returns a solution).
My idea is to have one process to collect a queue of sudoku grids on runtime from other processes which are solving a current sudoku grid. A sudoku grid is orginated from the sudoku root grid.
A computation process asks the manager process (in every node when there is at least more than one following node. Probably not very performance efficient.) if it needs more grids when its sudoku queue is not full.
When a computation process finishes its branch it asks the manager for a cached grid to solve.
solveSudoku is the method used for the backtracking algorithm and to cache branches/nodes from the sudoku graph.
I thought that maybe some MPI_Sends are thrown away because there are just too many happening at once but a synchronized MPI_Ssend does not change anything.
int solveSudoku(struct grid* grid, int row, int col, grids_queue** gridQueue, int* gridCount, int cacheGrids)
{
int index = row * grid->size + col;
// Solution found!
if (row == grid->size - 1 && col == grid->size)
return 1;
if (col == grid->size)
{
row++;
col = 0;
}
if (grid->sudoku[index] > 0)
return solveSudoku(grid, row, col + 1, gridQueue, gridCount, cacheGrids);
int multiplePaths = 0;
// First for loop to check for multiple next possiblities to attempt to cache one for manager process
if (cacheGrids == 1)
{
int count = 0;
for (int num = 1; num <= grid->size; num++)
{
if (isSafe(*grid, row, col, num) == 1)
{
count++;
if (count > 1)
{
multiplePaths = 1;
break;
}
}
}
}
int cachedGrid = 0;
for (int num = 1; num <= grid->size; num++)
{
if (isSafe(*grid, row, col, num) == 1)
{
grid->sudoku[index] = num;
// cache grid
if (multiplePaths == 1 && cachedGrid == 0)
{
if (attemptGridCache(*grid) == 1)
{
// Skip this node
cachedGrid = 1;
continue;
}
}
if (solveSudoku(grid, row, col + 1, NULL, gridCount, cacheGrids) == 1)
return 1;
}
grid->sudoku[index] = 0;
}
// No Solution return 0;
return 0;
}
#define MANAGER_RECV_GRIDS 11
#define COMPUT_RECV_GRIDS 12
#define COMPUT_STATUS 13
#define MANAGER_STATUS 14
#define SOLUTION_TIME 15
double solutionFindTime = 0;
double start_time;
int pid;
int gridWidth;
int gridSize;
int attemptGridCache(struct grid sudokuGrid) {
// Send Compute Status
int computeStatus = 1;
MPI_Ssend(&computeStatus, 1, MPI_INT, 0, COMPUT_STATUS, MPI_COMM_WORLD);
// Get Manager Status
int managerStatus;
MPI_Recv(&managerStatus, 1, MPI_INT, 0, MANAGER_STATUS, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
//printBoard(grid);
// Send grids to cache in manager process
if (managerStatus != GRIDS_FULL)
{
MPI_Send(sudokuGrid.sudoku, gridSize, MPI_INT, 0, MANAGER_RECV_GRIDS, MPI_COMM_WORLD);
return 1;
}
return 0;
}
struct grid recvGrid(int srcpid, int tag)
{
size_t size = gridSize * sizeof(int);
int* recvGrid = malloc(size);
MPI_Recv(recvGrid, gridSize, MPI_INT, srcpid, tag, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
struct grid g;
g.sudoku = recvGrid;
g.size = gridWidth;
return g;
}
void computeGrid(struct grid grid, int cacheGrids)
{
//printBoard(&grid);
if (solveSudoku(&grid, 0, 0, NULL, NULL, cacheGrids) == 1)
{
printf("<<<<<<<<<<<<<<<<<Solution found on pid %d >>>>>>>>>>>>>>>>>>>>>\n", pid);
double end_time = MPI_Wtime();
solutionFindTime = end_time - start_time;
//if (pid != 0)
//MPI_Send(&solutionFindTime, 1, MPI_DOUBLE, 0, SOLUTION_TIME, MPI_COMM_WORLD);
}
}
int main(int argc, char** argv) {
int process_count;
double end_time;
double duration;
double initDuration;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &process_count);
MPI_Comm_rank(MPI_COMM_WORLD, &pid);
char* file = argv[1];
start_time = MPI_Wtime();
if (process_count == 0 || process_count == 2)
return 0;
// For process 0
grids_queue* manager_gridQueue = NULL;
int sudokuListSize = 0;
// Manager Process Initialization
if (pid == 0)
{
double startInit_time = MPI_Wtime();
manager_gridQueue = initParallel(process_count - 1, &sudokuListSize, file);
initDuration = MPI_Wtime() - startInit_time;
gridWidth = manager_gridQueue->item.size;
}
// Broadcast grid size
MPI_Bcast(&gridWidth, 1, MPI_INT, 0, MPI_COMM_WORLD);
gridSize = gridWidth * gridWidth;
if(pid == 0 && process_count != 1)
{
for (int i = 1; i < process_count; i++)
{
//Sending grids to other processes...
MPI_Send(dequeue(&manager_gridQueue).sudoku, gridSize, MPI_INT, i, COMPUT_RECV_GRIDS, MPI_COMM_WORLD);
sudokuListSize--;
}
int msg;
int idlingProcessesCount = 0;
int computationFinished = 0;
do {
// receive status from other processes
MPI_Status status;
MPI_Recv(&msg, 1, MPI_INT, MPI_ANY_SOURCE, COMPUT_STATUS, MPI_COMM_WORLD, &status);
// send manager status
int reply;
if (sudokuListSize <= 0)
reply = GRIDS_EMPTY;
else if (sudokuListSize < process_count - 1)
reply = GRIDS_AVAILABLE;
else
reply = GRIDS_FULL;
MPI_Send(&reply, 1, MPI_INT, status.MPI_SOURCE, MANAGER_STATUS, MPI_COMM_WORLD);
// cache grid from other process
if (msg == 1 && reply != GRIDS_FULL) {
enqueue(&manager_gridQueue, recvGrid(status.MPI_SOURCE, MANAGER_RECV_GRIDS));
sudokuListSize++;
}
// process finished. Idling.. get work from queue
else if (msg == 0) {
if (reply != GRIDS_EMPTY) {
MPI_Send(dequeue(&manager_gridQueue).sudoku, gridSize, MPI_INT, status.MPI_SOURCE, COMPUT_RECV_GRIDS, MPI_COMM_WORLD);
sudokuListSize--;
}
// No Grids Available wait for more processes to check for completion
else {
idlingProcessesCount++;
// All processes are idling and no more work left.
// end mpi program
if (idlingProcessesCount == process_count - 1) {
computationFinished = 1;
}
}
}
} while (computationFinished == 0);
//if (solutionFindTime == 0)
//MPI_Recv(&solutionFindTime, 1, MPI_DOUBLE, MPI_ANY_SOURCE, SOLUTION_TIME, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
}
else if(pid != 0)
{
// compute init sudokus
computeGrid(recvGrid(0, COMPUT_RECV_GRIDS), 1);
// sudokus from dynamic queue
if (pid == 0)
return;
int managerStatus;
do {
// ask for new work
int computeStatus = 0;
MPI_Ssend(&computeStatus, 1, MPI_INT, 0, COMPUT_STATUS, MPI_COMM_WORLD);
// Get Manager Status
MPI_Recv(&managerStatus, 1, MPI_INT, 0, MANAGER_STATUS, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
if (managerStatus != GRIDS_EMPTY)
computeGrid(recvGrid(0, COMPUT_RECV_GRIDS), 1);
} while (managerStatus != GRIDS_EMPTY);
}
else if (pid == 0 && process_count == 1) {
computeGrid(dequeue(&manager_gridQueue), 0);
}
// CODE END
if (pid == 0) {
end_time = MPI_Wtime();
duration = end_time - start_time;
D(printf("\\\\ //\n"));
D(printf(" \\\\ //\n"));
D(printf(" \\\\_// Duration: %f\n", duration));
printf("%f\n", duration);
printf("%f\n", solutionFindTime);
printf("%f\n", initDuration);
}
MPI_Finalize();
return 0;
}

Answer 1

It was the continue keyword in the for loop in the backtracking function solveSudoku which made it skip some computations recursively.