Parallel Processing did not increase the efficiency?

Question

I am learning about AI and read about Parallel Processing. Here is the code I copied the code solving Knight Tour Problem to test:

# Python3 program to solve Knight Tour problem using Backtracking

# Chessboard Size
# starting time
start = time.time()
n = 8


def isSafe(x, y, board):
    '''
        A utility function to check if i,j are valid indexes
        for N*N chessboard
    '''
    if(x >= 0 and y >= 0 and x < n and y < n and board[x][y] == -1):
        return True
    return False


def printSolution(n, board):
    '''
        A utility function to print Chessboard matrix
    '''
    for i in range(n):
        for j in range(n):
            print(board[i][j], end=' ')
        print()


def solveKT(n):
    '''
        This function solves the Knight Tour problem using
        Backtracking. This function mainly uses solveKTUtil()
        to solve the problem. It returns false if no complete
        tour is possible, otherwise return true and prints the
        tour.
        Please note that there may be more than one solutions,
        this function prints one of the feasible solutions.
    '''

    # Initialization of Board matrix
    board = [[-1 for i in range(n)]for i in range(n)]

    # move_x and move_y define next move of Knight.
    # move_x is for next value of x coordinate
    # move_y is for next value of y coordinate
    move_x = [2, 1, -1, -2, -2, -1, 1, 2]
    move_y = [1, 2, 2, 1, -1, -2, -2, -1]

    # Since the Knight is initially at the first block
    board[0][0] = 0

    # Step counter for knight's position
    pos = 1

    # Checking if solution exists or not
    if(not solveKTUtil(n, board, 0, 0, move_x, move_y, pos)):
        print("Solution does not exist")
    else:
        printSolution(n, board)


def solveKTUtil(n, board, curr_x, curr_y, move_x, move_y, pos):
    '''
        A recursive utility function to solve Knight Tour
        problem
    '''

    if(pos == n**2):
        return True

    # Try all next moves from the current coordinate x, y
    for i in range(8):
        new_x = curr_x + move_x[i]
        new_y = curr_y + move_y[i]
        if(isSafe(new_x, new_y, board)):
            board[new_x][new_y] = pos
            if(solveKTUtil(n, board, new_x, new_y, move_x, move_y, pos+1)):
                return True

            # Backtracking
            board[new_x][new_y] = -1
    return False


# Driver Code
#if __name__ == "__main__":
    
    # Function Call
    #solveKT(n)
    # printing main program process id

    # creating processes

p1 = multiprocessing.Process(target=solveKT(n))
p2 = multiprocessing.Process(target=solveKT(n))

# starting processes
p1.start()
p2.start()

# wait until processes are finished
p1.join()
p2.join()
# end time
end = time.time()
# total time taken
print(f"Runtime of the program is {end - start}")
# This code is contributed by AAKASH PAL

And it printed out the time is 61.015116691589355 seconds. And it seemed like it do the first problem (p1) and then to the second. When I tried to solve without multiprocessing, the time it took is just 25.836514472961426 seconds. So, does multiprocessing really work multi tasks independently?

score 2 · Answer 1 · answered Jun 19 '21 at 07:32

The issue is here

p1 = multiprocessing.Process(target=solveKT(n))
p2 = multiprocessing.Process(target=solveKT(n))

Arguments to a function are always eagerly evaluated. solveKT(n) is evaluted before the multiprocessing process even starts.

You need to tell multiprocessing that you want to invoke solveKT(n) without actually invoking solveKT(n). You can do that by passing the name & arguments separately:

p1 = multiprocessing.Process(target=solveKT, args=(n,))
p2 = multiprocessing.Process(target=solveKT, args=(n,))

Docs: https://docs.python.org/3/library/multiprocessing.html#multiprocessing.Process

Parallel Processing did not increase the efficiency?

1 Answers1