test cpu performance with matrix multiplication

一 需求：

测试cpu计算性能

二 方法：

1.使用一定规模方阵执行乘法运算，不需要保存结果。

2.根据CPU核数开启线程执行乘法运算

3.事先将线程执行任务放入线程对应的任务容器，然后开启线程，统计时间

4.采用cpu绑定，程序没有加锁，几乎没有系统开销。

三 代码

1.cpu_binding.hpp

#ifndef CPU_BINDING_HPP_
#define CPU_BINDING_HPP_
#include <pthread.h>
#include <thread>
using namespace std;
class cpu_binding {
public:
	static cpu_binding &get_instance() {
		static cpu_binding cpu_binding_;
		return cpu_binding_;
	}
	inline int get_cpu_num() const {
		return cpu_num_;
	}
	bool binding(int cpu) {
		if (cpu < 0) {
			return false;
		}
		cpu = (cpu + 1) % cpu_num_;
		if (0 == cpu) {
			return true;
		}
		cpu_set_t cpu_set = {0};
		CPU_SET(cpu, &cpu_set);
		return pthread_setaffinity_np(pthread_self(), sizeof(cpu_set), &cpu_set) >= 0;
	}
private:
	cpu_binding() {
		cpu_num_ = thread::hardware_concurrency();
	}
	virtual ~cpu_binding() = default;
private:
	int cpu_num_;
};

#endif /* CPU_BINDING_HPP_ */

2.cpu_performance_test.hpp

#ifndef CPU_PERFORMANCE_TEST_HPP_
#define CPU_PERFORMANCE_TEST_HPP_
#include <iostream>
#include <vector>
#include <random>
#include <chrono>
#include <functional>
#include "cpu_binding.hpp"
using namespace std;
struct coordinate {
	coordinate(int a = 0, int b = 0) : row(a), col(b) {
	}
	int row;
	int col;
};
class cpu_performance_test {
public:
	static inline cpu_performance_test &get_instance() {
		static cpu_performance_test test;
		return test;
	}
	inline void set_matrix_dimension(int d) {
		matrix_dimension_ = d;
	}
	void init() {
		init_square_matrix(square_matrix0_);
		init_square_matrix(square_matrix1_);
		init_coordinate_array();
		init_threads();
	}
private:
	cpu_performance_test() {
		thread_num_ = thread::hardware_concurrency();
		matrix_dimension_ = 100;
	}
	cpu_performance_test(const cpu_performance_test &) = delete;
	cpu_performance_test & operator = (const cpu_performance_test &) = delete;
	virtual ~cpu_performance_test() {
		join_threads();
	}
private:
	void init_square_matrix(vector<vector<int> >&square_matrix) {
		int number = 0;
		vector<int>matrix_line;
		random_device rd;
		matrix_line.reserve(matrix_dimension_);
		cout << "square matrix as following:" << endl;
		cout << "===============================================" << endl;
		for (int i = 0;i < matrix_dimension_;i++) {
			for (int j = 0;j < matrix_dimension_;j++) {
				number = rd() % 1888;
				matrix_line.emplace_back(number);
				cout << number << " ";
			}
			square_matrix.emplace_back(matrix_line);
			matrix_line.clear();
			cout << endl;
		}
		cout << "===============================================" << endl;
	}
	void init_coordinate_array() {
		corrdinate_array_.resize(thread_num_);
		int loop = 0;
		for (int i = 0;i < matrix_dimension_;i++) {
			for (int j = 0;j < matrix_dimension_;j++) {
				corrdinate_array_[loop].emplace_back(coordinate(i, j));
				cout << "thread id = " << loop << endl;
				cout << "thread task data is " << "(" << i << "," << j << ")" << endl;
				loop = (loop + 1) % thread_num_;
 
			}
		}
	}
	void init_threads() {
		cout << "thread number = " << thread_num_ << endl;
		threads_.resize(thread_num_);
		int thread_id = 0;
		now_ = std::chrono::steady_clock::now();
		for (auto &thread_obj : threads_) {
			thread_obj = thread(bind(&cpu_performance_test::thread_compute, this, thread_id++));
		}
	}
	void join_threads() {
		for (auto &thread_obj : threads_) {
			if (thread_obj.joinable()) {
				thread_obj.join();
			}
		}
		auto end_time = chrono::steady_clock::now();
		chrono::duration<double>time_span = chrono::duration_cast<chrono::duration<double>>(end_time - now_);
		cout << "elapse time = " << time_span.count() << " seconds." << endl;
	}
	void thread_compute(int thread_id) {
		cpu_binding::get_instance().binding(thread_id);
		const auto vec = corrdinate_array_[thread_id];
		int sum = 0;
		for (auto &coordinate_obj : vec) {
			for (int i = 0;i < matrix_dimension_;i++) {
				sum += square_matrix0_[coordinate_obj.row][i] * square_matrix1_[i][coordinate_obj.col];
			}
			sum = 0;
		}
	}
private:
	int thread_num_;
	int matrix_dimension_;
private:
	vector<vector<int> >square_matrix0_;
	vector<vector<int> >square_matrix1_;
	vector<vector<coordinate>>corrdinate_array_;
	vector<thread>threads_;
private:
	chrono::steady_clock::time_point now_;
};
 
#endif /* CPU_PERFORMANCE_TEST_HPP_ */

3.main.cpp

#include "cpu_performance_test.hpp"
int main() {
	cpu_performance_test::get_instance().init();

	return 0;
}

4.make.sh

g++ -std=c++17 -g -o Test main.cpp cpu_performance_test.hpp cpu_binding.hpp -pthread