使用OpenMP并行化常见算法

OpenMP并行化常见算法

openmp是强大的并行编译库，可以动态地设置多线程，使用方便。
这里我将以搜索算法为例，介绍如何用OpenMP把常见算法并行化。

旅行商问题

旅行商问题已经老生常谈了。指在有向带权图内，寻找一条最短回路(指经过每个顶点仅一次，且权值总和最小)。事实上该问题是一个NPhard问题，想解决它只能花费指数级的时间复杂度。
我们尝试使用BFS和DFS去求解它。因为题目要求经过每个顶点仅一次，则不会出现环，即只要约定我们的搜索不走已经经过的顶点，搜索的状态就永远不会出现交叉，即我们是要在一个解空间树里求解。
先定义用于表示一个搜索状态的结构体，以及一个用于求下一状态的算法。

/*
记录搜索状态的状态结点
用经典数组保存路径，其中order[i]表示i顶点被造访的
时间顺序，起点的order[i]为0，后续每下溯一层则加1
front表示最新造访的顶点，以它为起点下溯一层。
order[i]==-1表示从未造访过，也是我们可以扩展的顶点。
*/
struct Node
{
	int order[N];
	int front = -1;
	int cost = 0;
	Node() { fill(order, order + N, -1); }
};

successors算法很简单，我们在结构体里已经定义了分辨顶点是否被遍历过的方法order[i]==-1，只需要遍历所有顶点，并把未遍历过的顶点作为后继顶点生成新的解状态结点即可。
考虑DFS算法，如果用非递归的形式，也就是用栈和循环模拟递归，自然可以实现循环形式的DFS算法。既然搜索的是解空间树，循环的各部分没有相关性，我们就能用parallel for语句直接把DFS并行化，这是相当简单的。
解空间树的分支因子在最上层为n-1，每向下一层，如果要简单地划分for循环来实现并行，则在最上层划分是最优解。
当n远大于线程数时自然可行，但是本问题是NPhard问题，n很大时是不可能求解的，一般n都在几十左右，而我们的线程数却有可能很多，这样就造成了极大的负载不均衡，会失去我们原有的并行优越性。
为此可能需要并行化的BFS，BFS借助队列进行。每次从队首取出结点，然后求successors，把新的结点放入队尾。很容易看出，每个successors操作之间是可以并行的，而一次successors操作只需要线性时间复杂度，这就把原有的大规模问题变得颗粒化。只要我们的多线程每次都从队列中请求元素，然后并行地执行successors，再把新结点入队，就实现了很好的负载均衡的并行搜索算法。
要注意的一点是，队列不允许并行的pop和push，因此操作队列的代码应该被设置线程锁；此外，修改全局变量，最优解solution时，也要设计线程锁。
另一个问题，单线程中，我们直接认为队列为空的时候就是搜索完毕的时候。但多线程中，即使搜索未进行完，仍然有可能让队列为空，这时某个线程去队列内请求元素就会造成报错。因此对搜索进行完毕就需要其他的逻辑，当所有的叶结点，也就是goalstate都被搜索完的时候，搜索就真正结束了。在此之前，某些线程即使无法从队列中得到元素，也不能退出循环，而需要一直等待。
bfs的cpp代码如下

#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

#define N 4

/*
问题：
开发能并行线程解决旅行商问题的程序。
旅行商问题是在一张n个顶点的全连通带权图中，寻找一条经过
每个顶点仅一次，并且能回到出发城市的“回路”，并让
这个回路的cost最小。我们能够证明的是，没有多项式
级别的算法能求解本问题，我们至少要花费指数级的时间
去计算。

分析：解决旅行商问题的基本算法就是朴素的搜索，一般使用
空间占用较小的DFS搜索。首先分析问题，问题中提到“不重复
结点”，即如果我们共有n个顶点，从第m个顶点出发，则总回路
数(搜索树叶结点数)就为(n-1)!种。分支因子在最上层为n-1，越向下
越小，如果要简单地划分for循环来实现并行，则在最上层划分
是最优。但是如果comm_sz和n可比拟，这样的划分方式就会造成极大的
负载不均衡，所以根据情况，我们也有必要选择广度优先搜索

BFS时，在任一节点，每次我们只需要下溯一层，即把successors的
状态结点推入队列。单次操作的运算复杂度O(n)，实际上m=b，当前
的分支数。这样就让计算的“粒度”更小，也就能更有效地实现负载
均衡。算法执行时，我们只需要设置共享的queue，然后每个线程独立
地向queue请求一个结点，然后在做下溯的过程中把新结点推入队列。
如果当前结点是叶结点(最终回路)，记录cost并更新我们的全局最小。

缺点也很明显，对n级别的顶点数，队列需要的空间是n的指数级，空间
复杂度高。

*/




struct Node
/*
记录搜索状态的状态结点
用经典数组保存路径，其中order[i]表示i顶点被造访的
时间顺序，起点的order[i]为0，后续每下溯一层则加1
front表示最新造访的顶点，以它为起点下溯一层。
order[i]==-1表示从未造访过，也是我们可以扩展的顶点。
*/
{
	int order[N];
	int front = -1;
	int cost = 0;
	Node() { fill(order, order + N, -1); }
};

queue<Node> Q;//存储状态的队列
int bestPath[N];//最优解
int bestCost = 9999999;
int graph[N][N];//邻接矩阵


void showpath(int order[N]) {
	int path[N];
	for (int i = 0;i < N;i++) {
		path[order[i]] = i;
	}
	for (int i = 0;i < N;i++) {
		cout << path[i] << "->";
	}
	cout << 0 << endl;
}


/*
input.txt:
0 1 3 8
5 0 2 6
1 18 0 10
7 4 12 0
*/


int main()
{
	freopen("input.txt", "r", stdin);
	for (int i = 0;i < N;i++)
		for (int j = 0;j < N;j++)
			cin >> graph[i][j];
	Node start;
	start.order[0] = 0;
	start.front = 0;//从0号顶点开始
	Q.push(start);
	omp_lock_t changeQ, changeSolu;
	omp_init_lock(&changeQ);
	omp_init_lock(&changeSolu);
	int goal_cnt = 0;
	/*已经访问的goal的计数器
	这个计数器的设置是为了一个特殊的问题
	单线程中，我们直接认为队列为空的时候就是搜索完毕的时候
	但多线程中，即使搜索未进行完，仍然有可能让队列为空，这
	时某个线程去队列内请求元素就会造成报错。因此对搜索进行
	完毕就需要其他的逻辑，当所有的叶结点，也就是goalstate
	都被搜索完的时候，搜索就真正结束了。在此之前，某些线程即使
	无法从队列中得到元素，也不能退出循环，而需要一直等待*/
	int MAX_CNT = 1;
	for (int i = 1;i < N;i++) MAX_CNT *= i;
#	pragma omp parallel num_threads(4)
	{
		while (goal_cnt<MAX_CNT) 
		{
			Node n;
			omp_set_lock(&changeQ);
			if (!Q.empty()) {
				n = Q.front();
				Q.pop();
			}
			omp_unset_lock(&changeQ);
			if (n.front==-1) //无效的结点
				continue;
			bool goal = 1;
			for (int i = 0;i < N;i++) {
				if (n.order[i] != -1)
					continue;
				else {
					Node newNode;
					copy(n.order, n.order + N, newNode.order);
					newNode.order[i] = n.order[n.front] + 1;
					newNode.cost = n.cost + graph[n.front][i];
					newNode.front = i;
					omp_set_lock(&changeQ);
					cout << "Process " << omp_get_thread_num() << " push" << endl;
					for (int x : newNode.order)
						cout << x << " ";
					cout << endl;
					Q.push(newNode);
					omp_unset_lock(&changeQ);
					goal = 0;
				}
			}
			if (goal) {//更新最优解
				omp_set_lock(&changeSolu);
				int final_cost = n.cost + graph[n.front][0];
				goal_cnt++;
				if (final_cost < bestCost) {
					bestCost = final_cost;
					copy(n.order, n.order + N, bestPath);
				}
				omp_unset_lock(&changeSolu);
			}
		}
	}
	cout << "Best path is: ";
	showpath(bestPath);
	cout << "Cost: " << bestCost << endl;
}