多线程运行时-C ++

Question

I am working on a CPU router which finds the shortest path between source and target on a 2D mesh. I am using BFS expansion in combination with the 'greedy' cost algorithm to find the shortest path. I am also implementing this whole function by multi-threading. I am expecting to see a decrease in function run time with increase in number of threads. But until I have 5 threads running, the time trend is not followed (ie time for 2 threads should be less than time for 5 threads). However with 6 threads running, upto 16 threads running, this time trend is seen. What could be the possible reason?

I am also using a concurrent queue.

void *bfs(void* threadArg)
{
int i, numOfElements;
struct threadData *data;
element* currentNode;

data = (struct threadData *)threadArg;
currentNode = NULL;

for (i = 0; i < data->numElements; i++)
{

    if (!adjacencyQ.empty())
    {
        currentNode = *(adjacencyQ.unsafe_begin());
        adjacencyQ.try_pop(*(adjacencyQ.unsafe_begin()));
    }

    //if (!adjacencyQ.empty())
    {
        if ((currentNode->north != NULL))// && (currentNode->north->visited == false))
        {
            nodeMutex[currentNode->north->i][currentNode->north->j].lock();
            if (currentNode->north->visited == false)
            {
                adjacencyQ.push(currentNode->north);
            }

            if (currentNode->north->cost > (currentNode->cost + currentNode->northCost))
            {
                currentNode->north->cost = currentNode->cost + currentNode->northCost;
                currentNode->north->visited = true;
                currentNode->north->visitedBy = currentNode;
            }
            nodeMutex[currentNode->north->i][currentNode->north->j].unlock();
        }

        if ((currentNode->south != NULL))// && (currentNode->south->visited == false))
        {
            nodeMutex[currentNode->south->i][currentNode->south->j].lock();
            if (currentNode->south->visited == false)
            {
                adjacencyQ.push(currentNode->south);
            }

            if (currentNode->south->cost > (currentNode->cost + currentNode->southCost))
            {
                currentNode->south->cost = currentNode->cost + currentNode->southCost;
                currentNode->south->visited = true;
                currentNode->south->visitedBy = currentNode;
            }
            nodeMutex[currentNode->south->i][currentNode->south->j].unlock();
        }

        if ((currentNode->east != NULL))// && (currentNode->east->visited == false))
        {
            nodeMutex[currentNode->east->i][currentNode->east->j].lock();
            if (currentNode->east->visited == false)
            {
                adjacencyQ.push(currentNode->east);
            }

            if (currentNode->east->cost > (currentNode->cost + currentNode->eastCost))
            {
                currentNode->east->cost = currentNode->cost + currentNode->eastCost;
                currentNode->east->visited = true;
                currentNode->east->visitedBy = currentNode;
            }
            nodeMutex[currentNode->east->i][currentNode->east->j].unlock();
        }

        if ((currentNode->west != NULL))// && (currentNode->west->visited == false))
        {
            nodeMutex[currentNode->west->i][currentNode->west->j].lock();
            if (currentNode->west->visited == false)
            {
                adjacencyQ.push(currentNode->west);
            }

            if (currentNode->west->cost > (currentNode->cost + currentNode->westCost))
            {
                currentNode->west->cost = currentNode->cost + currentNode->westCost;
                currentNode->west->visited = true;
                currentNode->west->visitedBy = currentNode;
            }
            nodeMutex[currentNode->west->i][currentNode->west->j].unlock();
        }

        if (!adjacencyQ.empty())
        {
            currentNode = *(adjacencyQ.unsafe_begin());
        }
    }
}

pthread_exit(NULL);
return NULL;

}

Answer 1

There are three possible reasons:

1. Contention
2. CPU starvation
3. Bugs in the implementation - peer-review the code, fix the bug

With all of them a "poor man profiler" would be a reasonable tool to start from (unless you have VTune installed, which does the same but automatically): run gstack multiple times while running the app and look at stack traces, they may point towards where the time is spent.