1. .NET PARALLEL FRAMEWORK
1

2. AGENDA
Introduction
Concurrency
Parallel Extensions
Parallel Programming
Conclusion
2

3. INTRODUCTION
從單核心轉變到多核心的平行處理，在重疊的時間執行多個運算
3
Introduction
Concurrency
Parallel Extensions
Parallel Programming
Conclusion

4. INTRODUCTION
4

5. INTRODUCTION
從單核心轉變到多核心的平行處理，在重疊的時間執行多個運算
 回應式介面(Responsive UI)
 非同步程序(Asynchronous)
 更好的效能(Performance)
5

6. CONCURRENCY
6
Introduction
Concurrency
Parallel Extensions
Parallel Programming
Conclusion

7. THREADS
7

8. THREADS
 簡單的Thread範例
 ThreadStart 是委派(delegate)函式，經由Thread類別建立實體，呼叫Start函式執行
Alpha alpha = new Alpha();
Thread thread = new Thread(new ThreadStart(alpha.Beta));
thread.Start();
8

9. CONCURRENCY CHALLENGES
 同步問題
 Race Condition
 Deadlock
 倚賴記憶體和硬體架構支援
 除錯困難
9

10. AMDAHL'S LAW
平行運算之後效率提升 整體效能獲得
 1 = ((1-P) + (P/Speedup))
 P : 支援平行運算的部分
 Speedup = CPU的數量
圖片來源：WIKI 10

11. MULTITHREADING VS PARALLEL
 Multithreading：Overlapping time periods 在
重疊的時間執行多個運算
 Parallel：Simultaneously 同時執行多個運算
圖片來源：MSDN 11

12. MULTITHREADING VS PARALLEL
 多執行序
 長時間處理時，維持UI程式的反應
 允許多個需求和過程可以分別被處理
 卸載可以發生在應用程式的背後
 平行程式
 計算效能提高
 效能與核心/處理器數量呈正比，並在核心/處理器數量增加時，不需要程式碼來指定硬體的設定
12

13. MULTITHREADING
 用多執行序來做平行程式的問題
 複雜的撰寫
 race condition
 執行序的數量最好跟CPU一樣
 並不是每一項工作都在相同時間完成
13

14. MULTITHREADING
 是同時處理多個獨立的任務(task)，在邏輯(logically)上是獨立的，主要目的是避免延遲(latency)
 當多個執行緒(thread)同時執行，如果需要共享系統資源，要面對死結(deadlocks)和數據競爭(race
condition)的問題，使得除錯變得極其困難和複雜
14

15. PARALLEL
 實際(realistic)將任務(task)分割成一組相關的任務，同時執行
 同樣也有死結(deadlocks)和數據競爭(race condition)的問題，還有資源共享(sharing)和資料分區
(partitioning)，這讓除錯變得極其困難和複雜
15

16. LIMITATIONS
 Serial Code
 Sequential input/output
 同步(Synchronization)
16

17. PARALLEL EXTENSIONS
17
Introduction
Concurrency
Parallel Extensions
Parallel Programming
Conclusion

18. TASK PARALLELISM
 分解程序分成部分例如方法，報表等
 識別哪些可以並行執行的部分
 分配每部分單獨任務
 在不同核心(Core)並行執行的任務
 每個任務有可能執行不同的操作
18

19. ARCHITECTURE
圖片來源：MSDN 19

20. CONCURRENT COLLECTIONS
 Thread-safe collection
 ConcurrentStack
 ConcurrentQueueo
 ConcurrentDictinary
 Work exchange
 BlockingCollection
 IProducerConsuerCollection
 Initialization
 LazyInit
 Phased Operation
 CountdownEvent
 Barrier
 Lock
 ManualResetEventSlim
 SemaphoreSlim
 SpinLock
 SpinWait
20

21. 平行執行
1. Tasks
2. The Task Parallel Library (TPL):
1. For
2. Foreach
3. Invoke
3. Parallel LINQ (PLINQ)
21

22. 合併平行結果
 控制的時機
 處理分割後
 緩衝結果直到所有的分割都完成
 AsParallel
 AsOrdered
 Sorting
22

23. 查詢分析
 WithExecutionMode - 強制平行運算
23

24. 分割
 Chunk
 來源資料沒法被加上索引時使用
 Range
 確認執行序的數量，將輸入來源分割成最佳化的大小
 Striped
 給資料前端做處理和評估的標準查詢運算子用
 Hash
 給需要比較資料元素查詢用的
24

25. WORK STEALING
圖片來源：A JAVA FORK/JOIN DOUG LEA
25

26. OVERHEAD
 工作分割有一個最佳的大小，需要測試才能確定
 執行時間需比分割負載的時間長
 同步、平行分割的部分相互輔助
 平行工作越獨立越好，任何一個外來的同步，都會降低效能和發生不容易除錯的race condition
26

27. PARALLEL PROGRAMMING
27
Introduction
Concurrency
Parallel Extensions
Parallel Programming
Conclusion

28. DEMO 1 : TASKS
 Task programming model
 給予更多控制的thread
 Return Result
 Task Channing
28

29. DEMO 1 : TASKS
Task t1 = null;
t1 = Task.Factory.StartNew(() =>
{
Console.WriteLine("Task 1");
});
Console.WriteLine("Main");
var t2 = t1.ContinueWith(delegate
{
Thread.Sleep(1000);
Console.WriteLine("Continue With Task 1");
});
29

30. DEMO 1 : TASKS
Task t2 = null;
t2 = Task.Factory.StartNew(() =>
{
Thread.Sleep(1000);
return "Result of Task 2";
});
string result = t2.Result;
Console.WriteLine(result);
30

31. DEMO 2 : PARALLEL
 這裡使用了For method，對照Serially method
 Parallel Loop
 Parallel.For
31

32. DEMO 2 : PARALLEL
Stopwatch watch = new Stopwatch();
watch.Start();
for (int i = 0; i < 10; i++)
{
Thread.Sleep(1000);
}
watch.Stop();
Console
.WriteLine(watch.Elapsed.Seconds.ToString());
32

33. DEMO 2 : PARALLEL
Stopwatch watch = new Stopwatch();
watch.Start();
System.Threading.Tasks.Parallel
.For(0, 10, i =>
{
Thread.Sleep(1000);
});
watch.Stop();
Console
.WriteLine(watch.Elapsed.Seconds.ToString());
33

34. DEMO 3 : PLINQ
 Parallel LINQ 是 LINQ to Objects 的實作(implement)
 For和LINQ執行時間幾乎相同，使用PLINQ執行時間快了一倍
 Parallel.Invoke
34

35. DEMO 3 : PLINQ
int[] array = Enumerable.Range(0, 20000).ToArray();
bool[] results = new bool[array.Length];
Stopwatch watch = new Stopwatch();
watch.Start();
for (int i = 0; i < array.Length; i++)
{
//質數
results[i] = IsPrime(array[i]);
}
watch.Stop();
Console.WriteLine(watch.Elapsed.Seconds);
35

36. DEMO 3 : PLINQ
int[] array = Enumerable.Range(0, 20000).ToArray();
bool[] results = new bool[array.Length];
Stopwatch watch = new Stopwatch();
watch.Start();
//質數
results =
array
.Select(x => IsPrime(x))
.ToArray();
watch.Stop();
Console.WriteLine(watch.Elapsed.Seconds);
36

37. DEMO 3 : PLINQ
int[] array = Enumerable.Range(0, 20000).ToArray();
bool[] results = new bool[array.Length];
Stopwatch watch = new Stopwatch();
watch.Start();
//質數
results =
array
.AsParallel()
.Select(x => IsPrime(x))
.ToArray();
watch.Stop();
Console.WriteLine(watch.Elapsed.Seconds);
37

38. DEMO 4 : RACE CONDITION
 數據競爭
 遞增特定變數並將結果儲存起來，成為不可分割完成的作業
38

39. DEMO 4 : RACE CONDITION
int counter = 0;
Object o = new Object();
Stopwatch watch = new Stopwatch();
watch.Start();
Parallel.For(0, 100000, i =>
{
Thread.Sleep(1);
counter++;
});
watch.Stop();
Console.WriteLine(watch.Elapsed.Seconds);
Console.WriteLine(counter.ToString());
39

40. DEMO 4 : RACE CONDITION
int counter = 0;
Object o = new Object();
Stopwatch watch = new Stopwatch();
watch.Start();
Parallel.For(0, 100000, i =>
{
Thread.Sleep(1);
lock (o)
{
counter++;
}
});
watch.Stop();
Console.WriteLine(watch.Elapsed.Seconds);
Console.WriteLine(counter.ToString());
40

41. DEMO 4 : RACE CONDITION
int counter = 0;
Object o = new Object();
Stopwatch watch = new Stopwatch();
watch.Start();
Parallel.For(0, 100000, i =>
{
Thread.Sleep(1);
Interlocked.Increment(ref counter);
});
watch.Stop();
Console.WriteLine(watch.Elapsed.Seconds);
Console.WriteLine(counter.ToString());
41

42. DEMO 5 : DEADLOCKS
 使用鎖定(lock)可能會造成死結(Deadlocks)
 Nested/Child Tasks
42

43. DEMO 5 : DEADLOCKS
static void Main(string[] args)
{
int transfers = 0;
Deadlock.Break(() => transfers, 500);
Account a = new Account { amount = 1000 };
Account b = new Account { amount = 1000 };
while (true)
{
Parallel.Invoke(
() => Transfer(a, b, 100)
,() => Transfer(b, a, 100));
transfers += 2;
}
}
43

44. DEMO 5 : DEADLOCKS
static void Transfer(Account one, Account two, int amount)
{
lock (one)
{
lock (two)
{
one.amount -= amount;
two.amount += amount;
}
}
}
class Account
{
public int amount;
}
44

45. DEMO 5 : DEADLOCKS
class Deadlock
{
private static ConcurrentQueue<Timer> queue = new ConcurrentQueue<Timer>();
public static void Break<T>(Func<T> value, int milliseconds) where T : IEquatable<T>
{
bool initialized = false;
T last = default(T);
queue.Enqueue(new Timer(t =>
{
T current = value();
if (initialized && last.Equals(current))
{
Debugger.Break();
}
initialized = true;
last = current;
}, null, milliseconds, milliseconds));
}
}
45

46. CONCLUSION
46
Introduction
Concurrency
Parallel Extensions
Parallel Programming
Conclusion

47. CONCLUSION
 Parallel .NET 降低了 multi-thread 的複雜度
 更好的控制方法
 Parallel Loop
 For
 Foreach
 Invoke
 執行序安全物件
 ConcurrentDictionary
 ConcurrentQueue
 ConcurrentStack
 還是要注意 multi-thread 的問題
 Race Condition
 Deadlock
47

48. THANKS
48