[C#] Parallel Programming (병렬 프로그래밍)

.NET 병렬 프로그래밍 아키텍처

 

용어정리

• TPL(Task Parallel Library) : 애플리케이션에 병렬 처리 및 동시성 기능을 추가하는 과정을 단순화하여 개발자가 더 생상적으로 작업할 수 있도록 하는 것
• PFX(Parallel Framework) : .NET 4.0부터 System.Threading.Task에 추가된 병렬처리 프레임워크
• 병렬 컴퓨팅 : 순차적인 직렬 프로그램을 분할하고 동시에 병렬로 수행하는 형태
• 분산 컴퓨팅 : 단일 문제를 여러 작업으로 나누어 여러 컴퓨터에서 처리 후 결과를 모으는 형태

 

Parallel Programming (병렬 프로그래밍)

• .NET은 병렬 프로그래밍으로 TPL을 제공하며, TPL이 개발자를 대신하여 스레드 상태 모니터링, 유지 관리, 종료, 동시 실행 제어, 작업의 분할, 스레드 풀 관리 등 리소스 관리를 지원해준다.
  (TPL은 System.Threading 및 System.Threading.Tasks 네임스페이스로 구성)
• 병렬 프로그래밍은 비동기 프로그래밍과 다르다. 병렬 프로그래밍과 비동기 프로그래밍 모두 CPU 또는 GPU를 효율적으로 사용하기 위한 기법이지만, 이를 효율적으로 사용하는 방법이 다르다.

병렬 프로그래밍 : 작업을 분할 정복

비동기 프로그래밍 : 코드 흐름을 유연하게 변경

• 소스코드에 따라 병렬처리가 적합하지 않을 수 있다. 단순한 작업을 병렬처리하는건 오히려 실행 속도 저하를 발생 시킬 수 있다.
• 병렬 프로그래밍은 작업 분할 방식에 따라 Data Parallelism과 Task Parallelism으로 구분한다.

 

.NET의 Parallel Class

• .NET 4.0부터  PFX가 추가되어 Parallel Class 지원
• .NET의 Parallel 메서드
  
  • Parallel.For() : 0부터 특정 Index까지의 작업을 병렬 처리
  • Parallel.ForEach() : List의 사이즈를 자동 측정하여 병렬 처리
  • Parallel.Invoke() : 여러 코드를 Action delegate로 받아서 다중 스레드를 통해 병렬로 Task를 나누어 한번에 처리

 

Data Parallelism (데이터 병렬화)

• 동일한 처리를 다수의 데이터에 적용하는 방식
• .NET에서 Parallel.For(), Parallel.ForEach() 메서드를 제공

// 순차처리
for(int i = 0; i < 1000; i++)
{
    Console.WriteLine("Thread ID = {0} / Index = {1}", Thread.CurrentThread.ManagedThreadId, i);
}


// 병렬처리 : Parallel.For()
Parallel.For(0, 1000, (i) => {
    Console.WriteLine("Thread ID = {0} / Index = {1}", Thread.CurrentThread.ManagedThreadId, i);
});

// 순차 처리
int[] nums = Enumerable.Range(0, 100000).ToArray();
foreach (var item in nums)
{
    Console.WriteLine("Thread ID = {0}", Thread.CurrentThread.ManagedThreadId);
}

// 병렬 처리 : Parallel.ForEach()
int[] nums = Enumerable.Range(0, 100000).ToArray();
Parallel.ForEach(nums, item =>
{
    Console.WriteLine("Thread ID = {0}", Thread.CurrentThread.ManagedThreadId);
});

 

Task Parallelism (작업 병렬화)

• 일반적으로 생각하는 병렬 처리 방식
• 데이터 병렬화와 달리 독립적인 작업들을 동시에 처리하는 방식
• .NET에서 Parallel.Invoke() 메서드를 제공

Parallel.Invoke(() => DoSomeWork(), () => DoSomeOtherWork());

 

병렬 처리 제어하기

• 병럴 처리에서 발생하는 오류의 주 원인은 다수의 스레드가 공유 메모리에 접근하기 때문에 발생한다.
• 공유 메모리 접근 횟수를 최소화 할 수 있는 방법 중 하나는 "스레드 메모리" 사용이다. 스레드 메모리를 사용하면 공유 메모리에 다수의 스레드가 데이터 작업을 하는 데이터 레이스 현상을 방지 할 수 있다.

int[] nums = Enumerable.Range(0, 1000000).ToArray();
long total = 0; // 공유 메모리 변수

Parallel.For<long>(
    0, // 시작
    nums.Length, // 끝
    () => 0, // Func<TLocal> localInit : 스레드 로컬 변수 초기화 함수 
    
    // Func<int,ParallelLoopState,TLocal,TLocal> body : 병렬 처리 함수
    (j, loop, subtotal) =>
    {
        subtotal += nums[j];
        return subtotal;
    },

    // Action<TLocal> localFinally : 스레드 로컬 변수를 공유 메모리 변수에 적용하는 함수
    (x) => Interlocked.Add(ref total, x)
);

 

병렬 처리와 순차 처리 속도 비교 1

• N by M Matrix를 곱셈 연산하는 코드를 작성하여 병렬처리와 순차처리의 속도를 측정
• 테스트 환경 : CPU i5-4690 (4 Core)  (CPU 환경에 따라 속도는 다르게 측정될 수 있음)
• 결론 : 복잡한 연산에서는 순차 처리 방식보다 병렬 처리 방식을 적용 했을 때 보다 빠른 연산속도를 기대 할 수 있지만, 단순한 연산에서는 순차 처리 방식이 더 빠를 수 있다.

Matrix	병렬 처리 소요 시간	순차 처리 소요 시간
1000 by 1000	3,925ms	10,636ms
2000 by 2000	32,305ms	105,114ms
3000 by 3000	112,568ms	348,749ms
4000 by 4000	285,057ms	936,480ms
5000 by 5000	536,731ms	1,015,672ms

.NET 병렬처리, 순차처리 속도 비교

using System;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Parallel_TEST
{
    class Program
    {
        static void Main(string[] args)
        {
            int x = 1000;
            int y = 1000;

            for (int i = 0; i < 5; i++)
            {
                int _X = x + (x * i); // 1000, 2000, 3000, 4000, 5000
                int _Y = y + (y * i); // 1000, 2000, 3000, 4000, 5000

                double[,] matA = SetMatrix(_X, _Y);
                double[,] matB = SetMatrix(_X, _Y);
                double[,] result = new double[_X, _Y ];

                Console.WriteLine("---------------------------------");
                Console.WriteLine("X : " + _X + " / " + "Y : " + _Y);
                ParallelTest(matA, matB, result);
                LoopTest(matA, matB, result);
                Console.WriteLine("---------------------------------");
            }
        }

        static double[,] SetMatrix(int x, int y)
        {
            double[,] result = new double[x, y];

            for (int i = 0; i < x; i++)
            {
                for(int j = 0; j < y; j++)
                {
                    result[i, j] = 1;
                }
            }

            return result;
        }

        static void ParallelTest(double[,] matA, double[,] matB, double[,] result)
        {
            int matACols = matA.GetLength(1);
            int matBCols = matB.GetLength(1);
            int matARows = matA.GetLength(0);

            Stopwatch stopwatch = new Stopwatch(); //객체 선언
            stopwatch.Start(); // 시간측정 시작

            Parallel.For(0, matARows, i =>
            {
                for (int j = 0; j < matBCols; j++)
                {
                    double temp = 0;
                    for (int k = 0; k < matACols; k++)
                    {
                        temp += matA[i, k] * matB[k, j];
                    }
                    result[i, j] = temp;
                }
            }); // Parallel.For

            stopwatch.Stop(); //시간측정 끝
            Console.WriteLine("Parallel Time : " +  stopwatch.ElapsedMilliseconds  + "ms (" + stopwatch.ElapsedMilliseconds / 1000 + "sec)");
        }

        static void LoopTest(double[,] matA, double[,] matB, double[,] result)
        {
            int matACols = matA.GetLength(1);
            int matBCols = matB.GetLength(1);
            int matARows = matA.GetLength(0);
            Stopwatch stopwatch = new Stopwatch(); //객체 선언
            stopwatch.Start(); // 시간측정 시작

            for (int i = 0; i < matARows; i++)
            {
                for (int j = 0; j < matBCols; j++)
                {
                    double temp = 0;
                    for (int k = 0; k < matACols; k++)
                    {
                        temp += matA[i, k] * matB[k, j];
                    }
                    result[i, j] = temp;
                }
            }

            stopwatch.Stop(); //시간측정 끝
            Console.WriteLine("Loop Time : " + stopwatch.ElapsedMilliseconds + "ms (" + stopwatch.ElapsedMilliseconds / 1000 + "sec)");
        }
    }
}

 

병렬 처리와 순차 처리 속도 비교 2

• 입력된 정수 N의 0부터 N-1까지의 합을 구하는 코드를 작성하여 병렬처리와 순차처리의 속도를 측정
• 테스트 환경 : CPU i5-4690 (4 Core)  (CPU 환경에 따라 속도는 다르게 측정될 수 있음)

Number	병렬 처리 소요 시간	순차 처리 소요 시간
1,000,000,000	2,677ms	2,194ms
1,100,000,000	2,818ms	2,473ms
1,200,000,000	3,252ms	2,806ms
1,300,000,000	2,983ms	2,985ms
1,400,000,000	3,294ms	3,186ms

 

.NET 병렬처리 순차처리 속도 비교

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Parallel_TEST
{
    class Program
    {
        static void Main(string[] args)
        {
            long count = 1000000000; // 1000000000

            for (int i = 0; i < 5; i++)
            {
                long _count = count + (100000000 * i);
                Console.WriteLine("---------------------------------");
                Console.WriteLine("Count : " + _count);
                ParallelTest2(_count);
                LoopTest2(_count);
                Console.WriteLine("---------------------------------");
            }
        }

        static void ParallelTest2(long count)
        {
            long sum = 0;

            Stopwatch stopwatch = new Stopwatch(); //객체 선언
            stopwatch.Start(); // 시간측정 시작

            Parallel.For<long>(
                    0,
                    count,
                    () => 0,
                    (j, LoopTest, subsum) =>
                    {
                        subsum += j;
                        return subsum;
                    },
                    (x) => Interlocked.Add(ref sum, x)
            );

            stopwatch.Stop(); //시간측정 끝
            Console.WriteLine("SUM : " + sum);
            Console.WriteLine("Parallel Time : " + stopwatch.ElapsedMilliseconds + "ms (" + stopwatch.ElapsedMilliseconds / 1000 + "sec)");
        }

        static void LoopTest2(long count)
        {
            long sum = 0;

            Stopwatch stopwatch = new Stopwatch(); //객체 선언
            stopwatch.Start(); // 시간측정 시작

            for(int i = 0; i < count; i++)
            {
                sum += i;
            }

            stopwatch.Stop(); //시간측정 끝
            Console.WriteLine("SUM : " + sum);
            Console.WriteLine("Loop Time : " + stopwatch.ElapsedMilliseconds + "ms (" + stopwatch.ElapsedMilliseconds / 1000 + "sec)");
        }
}

 

병렬 처리와 순차 처리 속도 비교 결론

• 복잡한 연산에서는 순차 처리 방식보다 병렬 처리 방식을 적용했을 때, 빠른 연산속도를 기대할 수 있지만, 단순한 연산에서는 순차 처리 방식이 더 빠를 수 있다.

 

 

---

Parallel 클래스 (System.Threading.Tasks)

[C#] 병렬 프로그래밍 Parallel Programming (1) - 데이터 병렬화

Parallel 클래스 - C# 프로그래밍 배우기 (Learn C# Programming)

[IT에 한 걸음 더 다가가기] 연산처리의 성능 한계에 도전하는 병렬컴퓨팅 (5편) | 인사이트리포트

Data vs Task Parallelism in C#

.NET의 병렬 프로그래밍: 설명서 가이드