C++多线程矩阵相乘

问题

全连接层矩阵矩阵相乘的C++实现.
输入矩阵尺寸为(N,M),隐含层尺寸为(M,C),求输出矩阵.

解答

解法1: 循环嵌套

#include<iostream>
#include<vector>

using namespace std;

#define INPUT 3
#define HIDDEN 4
#define OUTPUT 2

vector<vector<int>> matmul(vector<vector<int>> A, vector<vector<int>> B)
{
	vector<vector<int>> ret;
	ret.resize(A.size());
	for (size_t n = 0; n < ret.size(); ++n)
		ret[n].resize(B[0].size());

	for (size_t i = 0; i < A.size(); ++i)
	{
		for (size_t j = 0; j < B[0].size(); ++j)
		{
			for (size_t k = 0; k < B.size(); ++k)
				ret[i][j] += A[i][k] * B[k][j];
		}
	}
	
	return ret;
}

int main()
{
	vector<vector<int >> A(INPUT, vector<int>(HIDDEN));
	for (size_t i = 0; i < INPUT; ++i)
	{
		for (size_t j = 0; j < HIDDEN; ++j)
		{
			A[i][j] = i + j;
		}
	}
	vector<vector<int >> B(HIDDEN, vector<int>(OUTPUT));
	for (size_t i = 0; i < HIDDEN; ++i)
	{
		for (size_t j = 0; j < OUTPUT; ++j)
		{
			B[i][j] = i + j;
		}
	}

	vector<vector<int>> ret = matmul(A, B);
	for (int i = 0; i < INPUT; ++i)
	{
		for (int j = 0; j < OUTPUT; ++j)
		{
			cout << ret[i][j] << "  ";
		}
		cout << endl;
	}
	return 0;
}

解法2: 多线程

多线程编程特别适合这种伪并发程序。假装并行执行多个计算。

编写多线程程序要做的两件事：

1. 拆分
2. 创建线程函数

int pthread_create(pthread_t *tidp,const pthread_attr_t *attr, (void*)(*start_rtn)(void*),void *arg);

pthread_create是类Unix操作系统（Unix、Linux、Mac OS X等）的创建线程的函数。它的功能是创建线程（实际上就是确定调用该线程函数的入口点），在线程创建以后，就开始运行相关的线程函数。

本例中，进行矩阵运算，假设输入矩阵是(3,4)，参数矩阵是(4,2)，其输出为(3,2)。
一种方案是将输出的3x2个数字分成两个线程去计算。一个线程算第一列的三个数，一个线程算第二列的三个数。
唯一要关心的只是矩阵元素的索引和线程的关系即可，下面直接上代码

// CPP Program to multiply two matrix using pthreads 
#include <bits/stdc++.h> 
using namespace std; 

// maximum size of matrix 
#define INPUT 3
#define HIDDEN 4
#define OUTPUT 2 
#define MAX 4
// maximum number of threads 
#define MAX_THREAD 2

int matA[INPUT][HIDDEN]; 
int matB[HIDDEN][OUTPUT]; 
int matC[INPUT][OUTPUT]; 
int step_i = 0; 


void* multi(void* arg) 
{ 
	int core = step_i++; 

	// Each thread computes 1/4th of matrix multiplication 
	for (int i = 0; i < INPUT; ++i) 
			for (int k = 0; k < HIDDEN; ++k) 
				matC[i][core] += matA[i][k] * matB[k][core]; 
} 

// Driver Code 
int main() 
{ 
	// Generating random values in matA and matB 
	for (int i = 0; i < INPUT; i++) { 
		for (int j = 0; j < HIDDEN; j++) { 
			matA[i][j] = i+j; 
		} 
	} 

	for (int i = 0; i < HIDDEN; i++) { 
		for (int j = 0; j < OUTPUT; j++) { 
			matB[i][j] = i+j; 
		} 
	} 

	// Displaying matA 
	cout << endl 
		<< "Matrix A" << endl; 
	for (int i = 0; i < INPUT; i++) { 
		for (int j = 0; j < HIDDEN; j++) 
			cout << matA[i][j] << " "; 
		cout << endl; 
	} 

	// Displaying matB 
	cout << endl 
		<< "Matrix B" << endl; 
	for (int i = 0; i < HIDDEN; i++) { 
		for (int j = 0; j < OUTPUT; j++) 
			cout << matB[i][j] << " ";		 
		cout << endl; 
	} 

	// declaring four threads 
	pthread_t threads[MAX_THREAD]; 

	// Creating four threads, each evaluating its own part 
	for (int i = 0; i < MAX_THREAD; i++) { 
		int* p; 
		pthread_create(&threads[i], NULL, multi, (void*)(p)); 
	} 

	// joining and waiting for all threads to complete 
	for (int i = 0; i < MAX_THREAD; i++) 
		pthread_join(threads[i], NULL);	 

	// Displaying the result matrix 
	cout << endl 
		<< "Multiplication of A and B" << endl; 
	for (int i = 0; i < INPUT; i++) { 
		for (int j = 0; j < OUTPUT; j++) 
			cout << matC[i][j] << " ";		 
		cout << endl; 
	} 
	return 0; 
} 

代码解析

1. #include <bits/stdc++.h>
   这是个万能头文件,包含了目前c++所包含的所有头文件.

2. 本例中仅仅分了两个线程,固定了B矩阵的列索引,比较low的说. 个人认为线程数需要考虑到CPU的核数,不确定.

# 总核数 = 物理CPU个数 X 每颗物理CPU的核数 
# 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU的核数 X 超线程数

# 查看物理CPU个数
cat /proc/cpuinfo| grep "physical id"| sort| uniq| wc -l

# 查看每个物理CPU中core的个数(即核数)
cat /proc/cpuinfo| grep "cpu cores"| uniq

# 查看逻辑CPU的个数
cat /proc/cpuinfo| grep "processor"| wc -l

# 查看CPU信息（型号）
cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c

完整代码

以下代码是将任意大小的矩阵分成6个线程运算

// CPP Program to multiply two matrix using pthreads 
#include <bits/stdc++.h> 
using namespace std; 

// maximum size of matrix 
#define INPUT 20
#define HIDDEN 40
#define OUTPUT 30

// maximum number of threads 
#define MAX_THREAD 6

int matA[INPUT][HIDDEN]; 
int matB[HIDDEN][OUTPUT]; 
int matC[INPUT][OUTPUT]; 
int step_i = 0; 

int (*matmul(int matA[INPUT][HIDDEN], int matB[HIDDEN][OUTPUT]))[OUTPUT]
{
    int (*matC)[OUTPUT] = new int[INPUT][OUTPUT];
	
	for (size_t i = 0; i < INPUT; ++i)
	{
		for (size_t j = 0; j < OUTPUT; ++j)
		{
			for (size_t k = 0; k < HIDDEN; ++k)
				matC[i][j] += matA[i][k] * matB[k][j];
		}
	}
	
	return matC;
}

void* multi(void* arg) 
{ 
	int core = step_i++; 
    // Each thread computes 1/MAX_THREAD th of matrix multiplication 
    for (int i = core * INPUT / MAX_THREAD; i < (core + 1) * INPUT / MAX_THREAD; i++)  
        for (int j = 0; j < OUTPUT; j++)  
            for (int k = 0; k < HIDDEN; k++)  
                matC[i][j] += matA[i][k] * matB[k][j]; 
}

// Driver Code 
int main() 
{ 
	// Generating random values in matA and matB 
	for (int i = 0; i < INPUT; i++) { 
		for (int j = 0; j < HIDDEN; j++) { 
			matA[i][j] = i+j; 
		} 
	} 

	for (int i = 0; i < HIDDEN; i++) { 
		for (int j = 0; j < OUTPUT; j++) { 
			matB[i][j] = i+j; 
		} 
	} 

	// Displaying matA 
	cout << endl 
		<< "Matrix A" << endl; 
	for (int i = 0; i < INPUT; i++) { 
		for (int j = 0; j < HIDDEN; j++) 
			cout << matA[i][j] << " "; 
		cout << endl; 
	} 

	// Displaying matB 
	cout << endl 
		<< "Matrix B" << endl; 
	for (int i = 0; i < HIDDEN; i++) { 
		for (int j = 0; j < OUTPUT; j++) 
			cout << matB[i][j] << " ";		 
		cout << endl; 
	} 

	// declaring four threads 
	pthread_t threads[MAX_THREAD]; 

	// Creating four threads, each evaluating its own part 
	for (int i = 0; i < MAX_THREAD; i++) { 
		int* p; 
		pthread_create(&threads[i], NULL, multi, (void*)(p)); 
	} 

	// joining and waiting for all threads to complete 
	for (int i = 0; i < MAX_THREAD; i++) 
		pthread_join(threads[i], NULL);	 

	// Displaying the result matrix 
	cout << endl 
		<< "Multiplication of A and B with Multi Thread" << endl; 
	for (int i = 0; i < INPUT; i++) { 
		for (int j = 0; j < OUTPUT; j++) 
			cout << matC[i][j] << " ";		 
		cout << endl; 
	} 

    

    int (*matC2)[OUTPUT] = new int[INPUT][OUTPUT];
    matC2 = matmul(matA, matB);
    // Displaying the result matrix 
	cout << endl 
		<< "Multiplication of A and B with For Recursion" << endl; 
	for (int i = 0; i < INPUT; i++) { 
		for (int j = 0; j < OUTPUT; j++) 
			cout << matC2[i][j] << " ";		 
		cout << endl; 
	} 


	return 0; 
} 

其效率的话需要对比进行量化,使用colck()函数统计

clock_t begin , end;

begin = clock();

//这里是要统计时间的代码

end = clock();

unsigned uRunTime = (end - begin) * 1.0 / CLOCKS_PER_SEC * 1000000; // 得到微秒数

TODO
有点打脸的是统计得到的多线程更加耗时?可能多线程创建销毁耗时?还是它不是用来做这个事的?

参考

• GeeksForGeeks
• learn & think

不浮躁，不自傲，学习，思考，总结

这都是我最欠缺的啊