[C++] 멀티 스레드로 소수 구하기

소수 구하기

각각의 소수 판단 로직은 다른 로직에 영향을 끼치지 않으므로, 소수 갯수 구하는 로직은 멀티스레드로 구현하면 좋을 것이다

1~MAX_NUMBER까지의 소수 갯수는?

• 틀

#include <vector>
#include <thread>

int main()
{
	const int MAX_NUMBER = 1'000'000;
	// 1~MAX_NUMBER까지의 소수 갯수는?

	
	return 0;
}	

• 소수 구하기

// 소수 구하기
// 1과 자기 자신만으로 나뉘면, 그것을 소수라고 함
bool IsPrime(int number)
{
	if (number <= 1)
	{
		return false;
	}

	if (number == 2 || number == 3)
	{
		return true;
	}

	for (int i = 2; i < number; ++i)
	{
		if ((number % i) == 0)
		{
			return false;
		}
	}

	return true;
}

• 그리고 그걸 이용해서 갯수 세기

// [start ~ end]
int CountPrime(int start, int end)
{
	int count = 0;

	for (int number = start; number <= end; ++number)
	{
		if (IsPrime(number))
		{
			++count;
		}

		return count;
	}
}

만약 싱글스레드였다면

int main()
{
	const int MAX_NUMBER = 1'000'000;
	// 1~MAX_NUMBER까지의 소수 갯수는?

	int primeCount = CountPrime(1, MAX_NUMBER); // 싱글 스레드라면... 오래걸림

	std::cout << primeCount << std::endl;

	return 0;
}	

• 매우 오래걸렸을 것이다. (1'000'000 개 대상으로, 약 1분 소요)

멀티 스레드 적용

int main()
{
	const int MAX_NUMBER = 1'000'000;
	// 1~MAX_NUMBER까지의 소수 갯수는?

	// CountPrime(1, MAX_NUMBER); // 싱글 스레드라면... 오래걸림

	std::vector<std::thread> threads;
	
	int coreCount = std::thread::hardware_concurrency();
	int jobCount = (MAX_NUMBER / coreCount) + 1; // 정수가 아니면 내림처리되므로, 반올림하기위해서 +1 처리했음

	std::atomic<int> primeCount = 0;
	for (int i = 0; i < coreCount; ++i)
	{
		int start = (i * jobCount) + 1;
		int end = std::min(MAX_NUMBER, ((i + 1) * jobCount));

		threads.push_back(std::thread([start, end, &primeCount]()
			{
				primeCount += CountPrime(start, end);
			}));
	}

	for (std::thread& t : threads)
	{
		t.join();
	}

	std::cout << primeCount << std::endl;

	return 0;
}	

• 지금 작성한 스레딩 특징 : 조사 대상 숫자의 크기가 클수록 연산이 많아진다. 즉, 후반부에 생산되는 스레드가 하는일이 더 많다 ^^
• 1'000'000 개 대상으로, 약 10초 정도 소요된다

전체 코드

#include <vector>
#include <thread>
#include <atomic>
#include <iostream>

// 소수 구하기
// 1과 자기 자신만으로 나뉘면, 그것을 소수라고 함
bool IsPrime(int number)
{
	if (number <= 1)
	{
		return false;
	}

	if (number == 2 || number == 3)
	{
		return true;
	}

	for (int i = 2; i < number; ++i)
	{
		if ((number % i) == 0)
		{
			return false;
		}
	}

	return true;
}

// [start ~ end]
int CountPrime(int start, int end)
{
	int count = 0;

	for (int number = start; number <= end; ++number)
	{
		if (IsPrime(number))
		{
			++count;
		}
	}

	return count;
}

int main()
{
	const int MAX_NUMBER = 1'000'000;
	// 1~MAX_NUMBER까지의 소수 갯수는?

	// int primeCount = CountPrime(1, MAX_NUMBER); // 싱글 스레드라면... 오래걸림

	std::vector<std::thread> threads;
	
	int coreCount = std::thread::hardware_concurrency();
	int jobCount = (MAX_NUMBER / coreCount) + 1; // 정수가 아니면 내림처리되므로, 반올림하기위해서 +1 처리했음

	std::atomic<int> primeCount = 0;
	for (int i = 0; i < coreCount; ++i)
	{
		int start = (i * jobCount) + 1;
		int end = std::min(MAX_NUMBER, ((i + 1) * jobCount));

		threads.push_back(std::thread([start, end, &primeCount]()
			{
				primeCount += CountPrime(start, end);
			}));
	}

	for (std::thread& t : threads)
	{
		t.join();
	}

	std::cout << primeCount << std::endl;

	return 0;
}