Question

我正在研究一种CPU路由器，它在2D网格上找到源和目标之间的最短路径。我正在使用BFS扩展与'贪婪＆＃39;成本算法找到最短路径。我也通过多线程实现这整个功能。我希望随着线程数量的增加，功能运行时间会减少。但是在我运行5个线程之前，没有遵循时间趋势（即2个线程的时间应该小于5个线程的时间）。但是，如果运行6个线程，最多运行16个线程，则可以看到此时间趋势。可能的原因是什么？

我也在使用并发队列。

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

有三个可能的原因：

争用
CPU饥饿
实施中的错误 - 同行评审代码，修复错误

他们都是一个可怜的男人探员＆＃34;将是一个合理的工具开始（除非你安装了VTune，它自动执行相同操作）：运行应用程序时多次运行gstack并查看堆栈跟踪，它们可能指向花费时间的地方

多线程运行时 - c ++

1 个答案: