DS 's RoOm: Parallel 예제모음

병렬 프로그래밍
Parallel Programming
병렬처리는
Data Parallellism 대량의 데이터를 처리하는데 있어 각 CPU에 일감을 나눠서 주고 동시에 병렬로 처리
즉 대량의 데이터를 분할하여 다중 CPU를 사용하고 다중스레드들이 각각 할당된 데이터를 처리하는데
일반적으로 스레드 당 처리 내용은 동일하다.
(PLINQ와 Parallel클래스(For, Foreach메소드)

Task Parallelism은 큰 작업 Task를 분할하여 각 스레드들이 나눠서 다른 작업 Task들을 실행하는것
Task, TaskFactory (Parallel.Invoke())
PLINQ
PLINQ는 LINQ쿼리들을 병렬로 처리한다.
프레임워크의 작업분할,결과들을 처리하는 부담을 줄이는 이점이 있다?
AsParallel()을 호출하여 3 ~ 100,000 사이의 소수를 구하는 예제를 보자
LINQ 쿼리를 입력으로 하는
AsParallel은 System.Linq.ParallelEnumerable을 확장 메소드로

struct IndexedWord { public string Word; public int Index; }

public static void Main(string[] args)
        {

/*
           IEnumerable<int> numbers = Enumerable.Range(3, 500 - 3);
           var parallelQuery = from n in numbers.AsParallel()
                               where Enumerable.Range(2, (int)Math.Sqrt(n)).All(i => n % i > 0)
                               select n;
           int[] primes = parallelQuery.ToArray();
           foreach (int nn in primes)
               Console.Write(nn + " ");
           Console.ReadLine();

//############################
           if (!File.Exists("WordLookup.txt"))
               new WebClient().DownloadFile("http://www.albahari.com/ispell/allwords.txt", "WordLookup.txt");
            
           var wordLookup = new HashSet<string>(
                   File.ReadAllLines("WordLookup.txt"),
                   StringComparer.InvariantCultureIgnoreCase);

var random = new Random();
           string[] wordList = wordLookup.ToArray();

string[] wordsToTest = Enumerable.Range(0, 1000000)
                   .Select(i => wordList[random.Next(0, wordList.Length)]).ToArray();

wordsToTest[12345] = "woozsh";
           wordsToTest[23456] = "wubsite";

var query = wordsToTest
               .AsParallel()
               .Select((word, index) => new IndexedWord{ Word = word, Index = index})
               .Where(iword => !wordLookup.Contains(iword.Word))
               .OrderBy(iword=> iword.Index);

Console.WriteLine(query.Count());
           foreach (IndexedWord w in query)
           {
               Console.WriteLine("Index: {0}, Word: {1}", w.Index, w.Word);
                
           }
            //############################
           int j = 0;
           var query = from n in Enumerable.Range(0, 999).AsParallel()
                       select n * j++;

var query2 = Enumerable.Range(0, 999).AsParallel().Select((n, i) => n * i);

Camera[] cameras = Enumerable.Range(0, 4)
               .Select(i => new Camera(i))
               .ToArray();

while (true)
           {
               string[] data = cameras.AsParallel().AsOrdered().WithDegreeOfParallelism(4)
                   .Select(c => c.GetNextFrame()).ToArray();
               Console.WriteLine(string.Join(", ", data));
           }
            
            //############################
            IEnumerable<int> million = Enumerable.Range(3, 1000000);

var cancelSource = new CancellationTokenSource();
            var primeNumberQuery =
                from n in million.AsParallel().WithCancellation(cancelSource.Token)
                where Enumerable.Range(2, (int)Math.Sqrt(n)).All(i => n % i > 0)
                select n;

new Thread(() =>
            {
                Thread.Sleep(100);
                cancelSource.Cancel();
            }).Start();

try
            {
                int[] primes = primeNumberQuery.ToArray();
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine("Query canceled");
            }
             * "abcedf".AsParallel().Select(c => char.ToUpper(c)).ForAll(Console.Write);
            //############################

int[] numbers = { 0, 2, 3, 4 };
            int sum = numbers.Aggregate(0, (total, n) => total + n);
            //  Console.WriteLine(sum);

int[] numbers2 = { 1, 2, 3 };
            int x = numbers2.Aggregate(0, (prod, n) => prod * n);
            int y = numbers2.Aggregate((prod, n) => prod * n);

int sum2 = numbers.Aggregate((total, n) => total + n * n);
            //  Console.WriteLine("d "+sum2);

int sum3 = numbers.Select(n => n * n).Aggregate((total, n) => total + n);
            //  Console.WriteLine("d " + sum3);
            numbers.AsParallel().Aggregate(
                () => 0, (localTotal, n) => localTotal + n, // seedFactory
                (mainTot, localTot) => mainTot + localTot,  //  updateAccumulatorFunc
                finalResult => finalResult);                //  resultSelector
           
            //#####################################
            string text = "Let's suppose this is a really long string";
            var letterFrequencies = new int[26];
            foreach (char c in text)
            {
                 int index = char.ToUpper(c) - 'A';
                  if (index > 0 && index <= 26) letterFrequencies[index]++;
            };

int[] result = text.AsParallel().Aggregate(
                    () => new int[26],
                    (localFrequencies, c) => // Aggregate into the local accmulator
                    {
                        int index = char.ToUpper(c) - 'A';
                        if (index >= 0 && index <= 26) localFrequencies[index]++;
                        return localFrequencies;
                    },
                    (mainFreq, localFreq) =>            //  Aggregate local ->main accumulator
                            mainFreq.Zip(localFreq, (f1, f2) => f1 + f2).ToArray(),
                            
                            finalResult => finalResult  //  Perform any final transformation
                                                                );
     
            //#####################################
            var data = new List<string>();
            Parallel.Invoke(
                () => data.Add(new WebClient().DownloadString("http://www.foo.com")),
                () => data.Add(new WebClient().DownloadString("http://www.naver.com")));
  
            var keyPairs = new string[6];
            Parallel.For(0, keyPairs.Length, i => keyPairs[i] = RSA.Create().ToXmlString(true));

string[] keyPiarss = ParallelEnumerable.Range(0, 6)
                                .Select(i => RSA.Create().ToXmlString(true))
                                .ToArray();
            
           
            Task.Factory.StartNew(() => Console.WriteLine("Hello from a task!"));
            Task<string> task = Task.Factory.StartNew<string>(() =>
                    {
                        using (var wc = new System.Net.WebClient())
                        {
                            return wc.DownloadString("http://linqpad.net");
                        }
                    });
            string result = task.Result;
            //Console.WriteLine(result);
             
            Console.WriteLine("+================");

var task2 = new Task(() => Console.WriteLine("HEll!!!!!!!!!o!!"));
            task2.Start();

var task3 = Task.Factory.StartNew(Greet, "HElLOOO");
            task3.Wait();

var task4 = Task.Factory.StartNew(state => Greet("hello"), "grettingState");
            Console.WriteLine(task4.AsyncState);
            task4.Wait();
             */

Task parent = Task.Factory.StartNew(() =>
                {
                    Console.WriteLine("I am a parent");

Task.Factory.StartNew(() =>
                    {
                        Console.WriteLine("I am detached");
                    });

Task.Factory.StartNew(() =>
                    {
                        Console.WriteLine("I am a child");
                    }, TaskCreationOptions.AttachedToParent);
                });
            Console.ReadLine();
        }

DS 's RoOm

2013년 1월 2일 수요일

Parallel 예제모음

댓글 없음:

댓글 쓰기

프로필

블로그 보관함