國立高雄大學資訊工程學系研究所
碩士論文
多核心系統上具多個可平行化片段之即時任務省電排程機制
Energy-Efficiency Schedule Algorithm for Real-Time Tasks with
Multiple Parallel Segments on Multicore Systems
研究生：林建興 撰
指導教授：郭錦福
i
多核心系統上具多個可平行化片段之即時任務省電排程機制
指導教授：郭錦福 博士 國立高雄大學資訊工程學系 學生：林建興 國立高雄大學資訊工程學系摘要
多核心系統在運作時，系統上執行了許多具有即時需求的應用程式，然而，有 些程式需要使用到處理器大量的計算能力，僅依靠多核心處理器中的單一核心計 算能力可能無法在截限時間前完成，因此需要對這些程式進行平行化處理，以多執 行緒分散到各個處理器上執行，以此滿足即時需求。本論文所要探討的議題為在一 個多核心系統上排程具有可平行化任務(Parallel Task)與循序任務(Sequential Task) 之任務集合，針對可平行化任務進行平行化處理，使整個任務集合能成功排程於系 統 上 ， 並 能 在 執 行 時 有 較 低 的 電 能 消 耗 。 可 平 行 化 任 務 是 由 數 個 循 序 片 段 (Sequential Segment)與可平行化片段(Parallel Segment)組成的 Fork-Join 模式，循序 片段只能由一個執行緒執行，而可平行化片段則可由多個執行緒執行。我們提出一 套機制，先為每個平行化任務找到適當的平行度組合，每個片段衍生出子任務，並 且採用Equal Flexibility (EQF)機制設定子任務的相對截限時間，讓執行順序限制轉 換成時間限制，每個子任務都有自己的執行區間，並且只能在自己的區間中執行。 只要可平行化任務的所有子任務都能在截限時間前執行完成，則代表可平行化任 務也可以在截限時間前完成。考量到可平行化任務的各個片段的執行區間不會重 疊，因此提出處理器計算能力共享機制，讓同一個任務不同片段所衍生的子任務盡 量分配到同一個處理器，成為一個共享集合，屬於同一個共享集合中的子任務可以 共享處理器的計算能力，如此一來，僅需保留該集合中之子任務的最大使用密度大 小之計算能力，即能滿足其他子任務的需求。當某一子任務無法參與共享集合時， 為降低耗電性才以Worst Fit (WF)機制將子任務分配至處理器。論文中並以理論方 式探討這套機制中為何採用這些方法，證明方法之優劣。最後，以模擬實驗驗證所ii
提出之機制，比較不同機制下分配任務後的可排程率以及耗電性，並以可排程率與 耗電性之整體表現為評比基準，驗證我們提出的排程機制有較佳的表現。
關鍵字：多核心系統、可平行化任務、處理器計算能力共享、(子)任務分配機 制、省電機制
iii
Energy-Efficiency Schedule Algorithm for Real-Time Tasks
with Multiple Parallel Segments on Multicore Systems
Advisor: Dr. Chin-Fu Kuo
Department of Computer Science and Information Engineering National University of Kaohsiung
Student: Jian-Xing Lin
Department of Computer Science and Information Engineering National University of Kaohsiung
ABSTRACT
In a multiple-processor system, there are many applications with real-time requirements. Some applications need a lot of computing capacity from the processors. Such an application can not satisfy its real-time requirement if it is executed on only a processor. If the application is parallelized to be executed on multiple processors, the real-time requirement will be satisfied. In this thesis, we investigate the problem where there is a task set including parallel tasks and sequential tasks executing in a multiple-processor system. To schedule the tasks and energy-efficiently execute them, we propose a systematic mechanism to do parallelization for parallel tasks and assign subtasks to processors. A parallel task consists of several sequential segments and parallel segments. A sequential segment is executed only with a thread while a parallel segment can be executed with multiple threads. We try to derive a suitable parallel combination for the segments of a parallel task and divide it into several subtasks. Each segment has its corresponding subtasks. The Equal Flexibility mechanism is used to set the relative deadline for the subtasks. Then, the execution order constraints are transformed into timing constraints. Each subtask has its feasible interval and it only can be executed in the interval. If all the subtasks of a parallel task meet their deadlines, the task can meet its end-to-end deadline. Considering that the feasible interval of the subtasks of different segments of a parallel task have no overlaps, we propose a computing-capacity share
iv
mechanism to assign the subtasks of different segments into the same processor as a share group. The subtasks in a share group can share the computing capacity which is equal to the maximum density of the subtasks. If a subtask can not join a share group, the Worst Fit (WF) mechanism is adopted to assign the subtask for energy efficiency. The related properties are also proposed. Finally, we build a simulation model to verify our proposed mechanism. We compare the compared mechanism in term of schedulability, energy consumption, and the combination of schedulability and energy consumption. The experimental results demonstrate that the performance of the proposed mechanism is better than the compared mechanisms.
Keywords: Multiple-Processor System, Parallel Task, Computing-Capacity Share Mechanism, Allocation Mechanisms, Energy-Efficiency
v
致謝
光陰似箭，在高雄大學就學的歲月有如白駒過隙般稍縱即逝，回首宛如一場夢 卻瞬息萬變。在這求學的兩年間亦是萬分踏實，自己不只能在學術方面精益求精， 更能在做人處事方面有所成長。憶起剛來到新環境、新階段求學的我，如同初出茅 廬的初生之犢，對於許多事都感到萬事起頭難而無從著手。然而，在我迷茫無助時， 身旁的親朋好友、師長同學總是義無反顧的給予我最大的幫助，讓我擁有面對難題 的精神。我能順利畢業並不是我一個人的成就，首先我要感謝我的父母與家兄對我 的愛護與關懷，時時刻刻都能包容並支持我，無怨無悔的將心力付出在我身上。再 來感謝與我教學相長互相扶持的朋友與同學，以及在學業上幫助我增長見聞或給 予建議的各位老師與系務秘書。還有感謝我的口試委員盧永豐老師與余亞儒老師， 耐心聆聽我的報告並用心審查我的論文，給予我寶貴的意見希望我能追求卓越。最 後，我要特別感謝我的指導教授郭錦福老師，一日為師，終身為父，千言萬語也道 不盡我的感激之情，老師在教學總是抱持著熱忱，對我的照顧無微不至，常常會配 合我的步調來做出適當的指導，並且時常犧牲自己的時間、耗費大量的精力，孜孜 不倦地教導不成熟的我，字字句句諄諄教誨都令我如沐春風，讓我再次感受到杏壇 的偉大。vi
目錄
目錄 . . . vi 圖目錄 . . . viii 表目錄 . . . x 1 導論 . . . 1 1.1 前言 . . . 1 1.2 全文架構 . . . 5 2 系統模式 . . . 6 3 多核心系統上具多個可平行化片段任務之排程機制 . . . 11 3.1 任務分配機制. . . 12 3.2 可平行化任務衍生子任務與處理器計算能力共享 . . . 15 3.3 為(子)任務尋找適合的處理器 . . . 27 3.4 實例說明 . . . 33 4 效能評估 . . . 42 4.1 實驗相關設定. . . 42 4.2 實驗結果 . . . 44 4.2.1 隨著γ變動的效能呈現結果 . . . 44 4.2.2 隨著𝑁𝑝變動的效能呈現結果 . . . 56 4.2.3 隨著𝛼變動的效能呈現結果 . . . 66 4.2.4 隨著𝑁𝑠變動的效能呈現結果 . . . 76vii
5 結論與未來方向 . . . 87
viii
圖目錄
2.1 可平行化任務𝜏𝑖的片段之分類與執行關係示意圖 . . . 7 2.2 可平行化片段以不同執行緒個數下的執行時間變化示意圖 . . . 8 2.3 可平行化任務𝜏𝑖的各片段與其衍生的子任務之關係示意圖 . . . 9 3.1 將任務片段之子任務的執行順序限制轉換成執行時間限制示意圖 . . . 17 3.2 可平行化任務𝜏𝑖平行度組合為〈1, l, … , l, 1〉時，子任務與共享集合之關係 . 26 4.1 𝑁𝑝 = 1、𝛼 = 0.2、𝑁𝑠 = 7之任務集合可排程率 . . . 47 4.2 𝑁𝑝 = 1、𝛼 = 0.2、𝑁𝑠 = 7之任務集合耗電性 . . . 47 4.3 𝑁𝑝 = 1、𝛼 = 0.2、𝑁𝑠 = 7之任務集合整體表現 . . . 47 4.4 𝑁𝑝 = 2、𝛼 = 0.2、𝑁𝑠 = 7之任務集合可排程率 . . . 50 4.5 𝑁𝑝 = 2、𝛼 = 0.2、𝑁𝑠 = 7之任務集合耗電性 . . . 50 4.6 𝑁𝑝 = 2、𝛼 = 0.2、𝑁𝑠 = 7之任務集合整體表現 . . . 50 4.7 𝑁𝑝 = 1、𝛼 = 0.3、𝑁𝑠 = 7之任務集合可排程率 . . . 52 4.8 𝑁𝑝 = 1、𝛼 = 0.3、𝑁𝑠 = 7之任務集合耗電性 . . . 52 4.9 𝑁𝑝 = 1、𝛼 = 0.3、𝑁𝑠 = 7之任務集合整體表現 . . . 52 4.10 𝑁𝑝 = 1、𝛼 = 0.2、𝑁𝑠 = 9之任務集合可排程率 . . . 54 4.11 𝑁𝑝 = 1、𝛼 = 0.2、𝑁𝑠 = 9之任務集合耗電性 . . . 54 4.12 𝑁𝑝 = 1、𝛼 = 0.2、𝑁𝑠 = 9之任務集合整體表現 . . . 54 4.13 γ= 0.6、𝛼 = 0.3、𝑁𝑠 = 7之任務集合可排程率 . . . 58 4.14 γ= 0.6、𝛼 = 0.3、𝑁𝑠 = 7之任務集合耗電性 . . . 58 4.15 γ= 0.6、𝛼 = 0.3、𝑁𝑠 = 7之任務集合整體表現 . . . 58 4.16 γ= 0.7、𝛼 = 0.3、𝑁𝑠 = 7之任務集合可排程率 . . . 60 4.17 γ= 0.7、𝛼 = 0.3、𝑁𝑠 = 7之任務集合耗電性 . . . 60 4.18 γ= 0.7、𝛼 = 0.3、𝑁𝑠 = 7之任務集合整體表現 . . . 60ix 4.19 γ= 0.6、𝛼 = 0.4、𝑁𝑠 = 7之任務集合可排程率 . . . 62 4.20 γ= 0.6、𝛼 = 0.4、𝑁𝑠 = 7之任務集合耗電性 . . . 62 4.21 γ= 0.6、𝛼 = 0.4、𝑁𝑠 = 7之任務集合整體表現 . . . 62 4.22 γ= 0.6、𝛼 = 0.3、𝑁𝑠 = 9之任務集合可排程率 . . . 64 4.23 γ= 0.6、𝛼 = 0.3、𝑁𝑠 = 9之任務集合耗電性 . . . 64 4.24 γ= 0.6、𝛼 = 0.3、𝑁𝑠 = 9之任務集合整體表現 . . . 64 4.25 γ= 0.5、𝑁𝑝 = 2、𝑁𝑠 = 5之任務集合可排程率 . . . 68 4.26 γ= 0.5、𝑁𝑝 = 2、𝑁𝑠 = 5之任務集合耗電性 . . . 68 4.27 γ= 0.5、𝑁𝑝 = 2、𝑁𝑠 = 5之任務集合整體表現 . . . 68 4.28 γ= 0.6、𝑁𝑝 = 2、𝑁𝑠 = 5之任務集合可排程率 . . . 70 4.29 γ= 0.6、𝑁𝑝 = 2、𝑁𝑠 = 5之任務集合耗電性 . . . 70 4.30 γ= 0.6、𝑁𝑝 = 2、𝑁𝑠 = 5之任務集合整體表現 . . . 70 4.31 γ= 0.5、𝑁𝑝 = 3、𝑁𝑠 = 5之任務集合可排程率 . . . 72 4.32 γ= 0.5、𝑁𝑝 = 3、𝑁𝑠 = 5之任務集合耗電性 . . . 72 4.33 γ= 0.5、𝑁𝑝 = 3、𝑁𝑠 = 5之任務集合整體表現 . . . 72 4.34 γ= 0.5、𝑁𝑝 = 2、𝑁𝑠 = 7之任務集合可排程率 . . . 74 4.35 γ= 0.5、𝑁𝑝 = 2、𝑁𝑠 = 7之任務集合耗電性 . . . 74 4.36 γ= 0.5、𝑁𝑝 = 2、𝑁𝑠 = 7之任務集合整體表現 . . . 74 4.37 γ= 0.5、𝑁𝑝 = 1、𝛼 = 0.2之任務集合可排程率 . . . 78 4.38 γ= 0.5、𝑁𝑝 = 1、𝛼 = 0.2之任務集合耗電性 . . . 78 4.39 γ= 0.5、𝑁𝑝 = 1、𝛼 = 0.2之任務集合整體表現 . . . 78 4.40 γ= 0.6、𝑁𝑝 = 1、𝛼 = 0.2之任務集合可排程率 . . . 80 4.41 γ= 0.6、𝑁𝑝 = 1、𝛼 = 0.2之任務集合耗電性 . . . 80 4.42 γ= 0.6、𝑁𝑝 = 1、𝛼 = 0.2之任務集合整體表現 . . . 80 4.43 γ= 0.5、𝑁𝑝 = 2、𝛼 = 0.2之任務集合可排程率 . . . 82 4.44 γ= 0.5、𝑁𝑝 = 2、𝛼 = 0.2之任務集合耗電性 . . . 82 4.45 γ= 0.5、𝑁𝑝 = 2、𝛼 = 0.2之任務集合整體表現 . . . 82 4.46 γ= 0.5、𝑁𝑝 = 1、𝛼 = 0.3之任務集合可排程率 . . . 84 4.47 γ= 0.5、𝑁𝑝 = 1、𝛼 = 0.3之任務集合耗電性 . . . 84 4.48 γ= 0.5、𝑁𝑝 = 1、𝛼 = 0.3之任務集合整體表現 . . . 84
x
表目錄
3.1 任務集合𝑇中的可平行化任務之時間特性. . . 33 3.2 任務集合𝑇中的循序任務之時間特性 . . . 33 3.3 𝜏1各平行化組合之狀況 . . . 36 3.4 𝜏2各平行化組合之狀況 . . . 37 3.5 「子任務總使用密度為最小」集合Γ𝐴之(子)任務順序與其使用率(密度) . . 38 3.6 「共享後之子任務總使用密度」集合Γ𝐵之(子)任務順序與其使用率(密度) 38 3.7 「子任務總使用密度為最小」集合Γ𝐴使用 BF 法排程之結果 . . . 40 3.8 「子任務總使用密度為最小」集合Γ𝐴使用 WF 法排程之結果 . . . 40 3.9 「共享後之子任務總使用密度」集合Γ𝐵使用 BF 法排程之結果 . . . 41 3.10 「共享後之子任務總使用密度」集合Γ𝐵使用 WF 法排程之結果 . . . 411
第
一
章
導論
1.1 前言
范紐曼型架構(Von Neumann architecture)可以說是奠定了電腦結構的根基，此架構 中蘊含的重要概念就是將記憶體與處理器分開，以此概念設計出了可儲存程式的電腦， 也就是現今我們普遍所使用的電腦。此架構的運作方式非常簡單明確，先將程式碼放置 於記憶體，當需要時再由處理器去記憶體中取得程式碼。起初，如此架構的處理器一次 只能處理一個程式碼，如今隨著科技蓬勃的發展，大數據時代的來臨，需要運算的資料 越來越多，對於處理器效能的要求也相對越來越高，而身處這個凡事要求效率的世代， 單核心處理器漸漸的難以與時代接軌。耗電性的提高與散熱問題，使得單核心處理器效 能提升遭遇到瓶頸，因此在晶片中置入多核心分工合作，變成了處理器發展的突破點， 處理器的架構也漸漸的從傳統的單核心發展至現今的多核心。因此「平行化」成為了提 升效能的研究重點與發展趨勢，平行化的研究重心朝向了各式各樣的應用方向，如：執 行緒、應用、資料等不同層面的平行化，雖然平行化的研究已經不勝枚舉，由於可實現 平行化的方式、層面與功用之廣，如今在多核心系統的領域中仍是炙手可熱的議題之一。 多核心系統在運作時，系統上執行了許多具有即時需求的應用程式，有些程式所需 要花的執行時間不多，然而有些則需要使用處理器大量的計算能力，若僅使用單一核心 的計算能力，需花費大量的時間才能執行完成，甚至是在單一核心計算能力不足的情況
2 下，有可能造成無法在截限時間之前完成執行。此時，可以利用平行化，將應用程式以 多個執行緒分散到各個處理器核心上執行，雖然平行化可能會額外提高系統的負擔，但 如此一來能促使程式可以在截限時間之前完成執行。然而，並非是所有應用程式皆可以 平行化，有些程式的指令之間，因為存在資料相依性(Data Dependence)的限制，而無法 同時以多個執行緒執行。可以平行化的程式可以將整個運作流程分割成多個部分，某些 部份因為不受資料相依性的限制，且執行時間較長(如：迴圈)，即可進行平行化。而這 些可進行平行化的片段會在一開始衍生出多個執行緒執行，當所有執行緒執行完成時， 參與執行的執行緒將只留下主執行緒(Master Thread)，以主執行緒再進行程式的下一個 部分，像這樣的結構稱之為Fork-Join 模型。 系統中有多個即時應用要執行，要使系統上的所有程式符合即時要求，不能只依靠 單純的任意平行化，我們需要考慮到應該如何有效的平行化？譬如：每個應用程式應該 以多少個執行緒平行化執行？如何將這些執行緒分別分配至哪個處理器核心上執行才 能有較佳的排程結果與省電效果等問題，需要深入探討。因此，將相關文獻分成以下三 類：任務平行化的方法、可平行化任務之子任務的設定方法、分配任務於處理器的方法。 首先是任務平行化的方法，最簡單的實現方法即是使用 OpenMP [2]或是 OpenCL [1]的模組，提供了可以用來設定任務的執行緒個數，以此達成平行化的目的。在[18]中， 將可平行化任務分成兩種主要模組：Gang 模組[4]與 Thread 模組[7]。Gang 模組是將一 個任務平行化所分出來的物件(Instance)，同步的開始與停止使用處理器。換句話說，就 是要執行該任務的物件時，必須有剛好等於物件數量的可用處理器才能執行。而Thread 模組則無此限制，只要有執行緒被釋放，即可獨立執行於某個處理器。而在[9]與[16]都 提出以 Fork-Join 為基礎的可平行化任務模組，概念皆為將一個任務視為由數個連續的 片段(Segment/Phase)所組成，其中片段可以細分成循序片段(Sequential Segment)與可平 行化片段(Parallel Segment)，並且所有片段是由循序片段與可平行化片段連貫交錯而成， 循序片段在執行時只能由一個執行緒負責執行，而可平行化片段則可由數個執行緒同時 執行，不同執行緒各別負責可平行化片段的不同部分，每個執行緒都可單獨執行於處理
3
器，並且可以同時執行。更複雜的Fork-Join 任務模式有如[19]的可平行化任務所使用的 Directed Acyclic Graph (DAG)模組，其概念為將每個執行緒視為一個節點，而每個節點 間的連線則代表之間存在相依性，執行某個節點前必須先完成之前的節點，並且一個節 點的執行需求可以任意變化，在同一個DAG 中不同節點可以有不同的執行需求。而於 本篇論文將採用[9]與[16]的 Fork-Join 可平行化任務模組為基礎。我們將排程機制大致 上歸類為三種方式：Global Scheduling，系統執行時允許任務可以更動至其他處理器， 如[5]；Partitioned Scheduling，系統執行前先將任務分配至處理器且執行時不可更動，如 [3]；Semi-Partitioned Scheduling，介於 Global 與 Partitioned 兩者之間，系統執行時大部 分任務不可更動，而少部分任務則被允許，如[13]與[17]。[17]與本篇研究目標以及使用 的任務模型相似，該論文中提出work-stealing 的機制解決無法滿足即時需求的可平行化 任務，流程上大致可以分成兩個階段，第一階段在離線(Offline)模式時，先將任務分配 至處理器，並替無法滿足即時需求的可平行化任務尋找其他處理器中可用的區間；第二 階段在線上(Online)模式時，將無法滿足即時需求的可平行任務的部分可平行片段之執 行時間遷移至於其他閒置處理器的可用區間。而我們的排程機制屬於 Partitioned Scheduling，並且考慮到了同一個任務不同片段所衍生的子任務在執行上是不會交疊的， 也就是子任務互相不會占用到各自的執行時間，因此若將同一任務不同片段所衍生的子 任務分配到同一個處理器，將可以共享該處理器的計算能力，只需保留使用密度(Density) 最大的子任務所需求的計算能力即可。[15]與本篇論文所探討之問題相似，並且也使用 了如本篇中的處理器計算能力共享機制，但其可平行化任務僅侷限於分成三個片段，若 要處理的可平行化任務有較多的片段時，同時也會衍生大量的子任務，此時則需要探討 更多層面的問題，才能有效的利用處理器計算能力共享機制，對於降低處理器負載與提 升可排程率將有莫大的助力。 關於可平行化任務之子任務截限時間設定方法部分，一個可平行化任務的不同片段 之子任務間存在著執行順序的關係，在排程時實則有諸多的限制。因此，將子任務從執 行順序限制轉成時間限制是一個可以採用想法，可以將各個子任務視為獨立個體，並且
4
可以單獨分配於處理器。而要將子任務執行順序限制轉成時間限制可採取的策略，如[14] 中的Equal Slack (EQS)與 Equal Flexibility (EQF)，或是[11]的 Boundary，都有各自的方 法設定子任務的截限時間，使每個子任務有一個自己的執行區間。Equal Slack 是將可平 行任務的週期扣除最短執行時間後所剩餘的時間區塊(Slack)依片段個數平均分配給每 個片段之子任務，將片段子任務所分配到的值加上自己的執行時間即為相對截限時間； 而 Equal Flexibility 亦是先計算出剩餘的時間區塊，並依照片段的執行時間於最短執行 時間中的比例分配，片段的子任務分配到的值加上自己的執行時間即為相對截限時間。 由於 Boundary 只針對三個片段的可平行化任務，對於含有更多片段的可平行化任務較 難以實行，於本篇中暫不考慮採用。而如何設定子任務的截限時間對於往後的步驟有著 牽一髮而動全身的影響力，因此設定適當的值也是需要重視的。 關於分配任務至處理器的方法，也就是如何將任務分配至處理器。分配機制會影響 整個系統的效能，有些機制可以讓系統耗電量降低，但無法排程的機率較大；相反的， 有些機制可以提升排程的成功率，但會有較大的系統耗電量。分配機制如[8]中的 First Fit (FF)、Best Fit (BF)和 Worst Fit (WF)，First Fit 是將任務分配給第一個有足夠計算能 力的處理器；Best Fit 是將任務分配給剩餘計算能力最少且足夠的處理器；Worst Fit 是 將任務分配給剩餘計算能力最多且足夠的處理器。以上三種機制皆是視處理器的現況而 採取不同的任務分配方式，在結果上也會有相異的表現。另外，在文獻[18]中，所探討 的是估算系統執行需要多少個處理器才能讓所有任務能夠滿足即時需求。
在本篇論文中，所要探討的議題為針對一個包含可平行化任務(Parallel Task)與循序 任務(Sequential Task)的週期性任務集合，其中可平行化任務具有多個片段(Segment)，循 序片段(Sequential Segment)與可平行化片段(Parallel Segment)交叉所組成的 Fork-Join 模 式。本論文之貢獻：將針對可平行化任務提出一個可衍生子任務的機制，藉由設定子任 務的相對截限時間，將其從執行順序限制轉程執行時間限制，並且制定篩選標準替可平 行化任務選擇適當的平行度。論文中也將考慮到同一個任務不同片段所衍生的子任務不 會互相占用執行時間，若分配至同一個處理器可以共享該處理器的計算能力。在分配任
5 務至處理器時，除了採用故有的分配機制外，也會額外考慮到共享處理器計算能力的機 制所帶來的可能性，希望能提高可排程率，且未來系統將以較低的耗電性執行運作。
1.2 全文架構
本篇論文之組織如以下所示：第二章將說明任務與系統的模式，以及定義問題；第 三章將提出整個任務排程機制，並詳細說明相關機制，如：可平行化任務衍生子任務的 機制、設定子任務相對截限時間的機制、篩選平行度組合機制、處理器計算能力共享機 制、任務分配機制，並在最後以實例說明；第四章將會說明實驗方法，並解說各種機制 組合下的效果呈現；第五章將進行結論與提出未來的研究方向。6
第
二
章
系統模式
在本研究中，我們探討的環境為具有𝑀個同質性 DVS 處理器架構的系統，處理器 集合定義為П＝{𝑃𝑟1，𝑃𝑟2， … ，𝑃𝑟𝑀}並且在此系統中執行一組有𝑛個週期性任務的集 合，任務集合為𝑇＝{𝜏1，𝜏2， … ，𝜏𝑛}，並且假設任務集合𝑇中的每個任務互為獨立，之 間並不會互相影響。於本篇論文中，核心與處理器所代表的意義相同，這兩個名詞將會 交替使用。 其中任務集合𝑇中的每個任務可以依據其能否平行化，可進一步的被分類為兩種任 務子集合：第一種為週期性循序任務(Sequential Task)子集合，以符號𝑇𝑠代表；另一種為 週期性可平行化任務(Parallel Task)子集合，以符號𝑇𝑝代表。 每個週期性循序任務𝜏𝑖 ∈ 𝑇𝑠，因受程式中連續資料相依性(Program-Data Dependence) 的限制，無法將執行進行平行化。由於只有一個執行片段(Segment)，並且該片段無法以 多個執行緒平行化執行，任務執行時行程中只有一個執行緒，只能使用單一個處理器上 的計算資源。而我們將賦予每個週期性循序任務𝜏𝑖 ∈ 𝑇𝑠以下屬性定義：週期為𝑃𝑖、截限 時間為𝐷𝑖，而執行時間為𝐸𝑖，並且假設截限時間與週期相等𝐷𝑖 = 𝑃𝑖(Implicit Deadline)， 使用率𝑢𝑖 =𝐸𝑖 𝑃𝑖。 另一方面，每一個可平行化任務𝜏𝑖 ∈ 𝑇𝑝，其執行具有𝐾𝑖個片段，𝐾𝑖為奇數，我們以 𝑠𝑖,1、𝑠𝑖,2、…、𝑠𝑖,𝐾𝑖表示任務𝜏𝑖的每個片段，而這些片段可以再進一步分成兩種型態：如7 圖2.1 所示，以𝑠𝑖,𝑘表示任務𝜏𝑖的第𝑘個片段，若片段屬於{𝑠𝑖,𝑘|𝑘%2 = 1 且 1 ≤ 𝑘 ≤ 𝐾𝑖}(即 為奇數片段)，則此片段為循序片段(Sequential Segment)，無法將其平行化；片段屬於 {𝑠𝑖,𝑘|𝑘%2 = 0 且 1 ≤ 𝑘 ≤ 𝐾𝑖} ( 即 為 偶 數 片 段 ) ， 則 此 片 段 為 可 平 行 化 片 段 (Parallel Segment)，由於不受程式資料相依性的限制，可以同時以多個執行緒執行，而一開始的 𝑠𝑖,1與最後的s𝑖,𝐾𝑖皆為循序片段。每個任務的循序片段和可平行化片段交錯執行，即為符 合可平行化任務中 Fork-Join 的特性。𝜏𝑖的每個片段之間具有順序性的前後執行關係， 𝑠𝑖,1執行結束後，才能執行下一個片段𝑠𝑖,2；而當𝑠𝑖,2執行結束後，才能執行下一個片段𝑠𝑖,3， 依此類推，亦即片段的執行順序為𝑠𝑖,1→𝑠𝑖,2→ … →s𝑖,𝐾𝑖。 圖2.1：可平行化任務𝜏𝑖的片段之分類與執行關係示意圖 而我們將賦予可平行化任務𝜏𝑖 ∈ 𝑇𝑝以下屬性定義：週期為𝑃𝑖、截限時間為𝐷𝑖，並且 截限時間與週期相等𝐷𝑖 = 𝑃𝑖；而執行時間為𝐸⃗⃗⃗ ，𝐸𝑖 ⃗⃗⃗ 為一個向量，包含每個片段的執行時𝑖 間向量，我們以(𝑒𝑖,1，𝑒 𝑖,2， … ，𝑒 𝑖,𝐾𝑖−1，𝑒𝑖,𝐾𝑖)代表，𝑒𝑖,1、𝑒𝑖,3、 … 、𝑒𝑖,𝐾𝑖分別代表循序片 段𝑠𝑖,1、𝑠𝑖,3、 … 、𝑠𝑖,𝐾𝑖的單一執行緒之執行時間；而𝑒 𝑖,2、𝑒 𝑖,4、 … 、𝑒 𝑖,𝐾𝑖−1分別代表可平 行化片段𝑠𝑖,2、𝑠𝑖,4、 … 、𝑠𝑖,𝐾𝑖−1的在不同平行度下每個執行緒之最大執行時間向量。須 強調的是，循序片段的執行時間遠小於可平行化片段的執行時間。 其中對於可平行化片段𝑠𝑖,2𝑘(1 ≤ k ≤𝐾𝑖−1 2 )，由於我們使用的系統中擁有𝑀個處理器， 因此可平行化片段將會有𝑀 個平行化選擇，並且其執行時間向量𝑒 𝑖,2𝑘可以表示成
8 {𝑒𝑖,2𝑘,1、𝑒𝑖,2𝑘,2、 … 、𝑒𝑖,2𝑘,𝑀}，如圖 2.2 所示，𝑒𝑖,2𝑘,𝑥為可平行化片段𝑠𝑖,2𝑘在平行度為𝑥(1 ≤ 𝑥 ≤ 𝑀)時的每個執行緒所需的最大執行時間，隨著平行度𝑥提高，可平行化片段的最大 執行時間會隨之降低，𝑒𝑖,2𝑘,𝑥 > 𝑒𝑖,2𝑘,𝑥+1，但也會因平行化較高，有較高的平行化成本， 導致片段整體所需的執行時間總和增加，因此𝑒𝑖,2𝑘,𝑥⋅ 𝑥 < 𝑒𝑖,2𝑘,𝑥+1⋅ (𝑥 + 1)，所以為每個 可平行化片段選擇一個適當的平行度是很重要的議題。 當執行可平行化片段𝑠𝑖,2𝑘時，如果平行度為𝑥𝑖,2𝑘(1 ≤ 𝑥𝑖,2𝑘 ≤ 𝑀)，代表任務𝜏𝑖的第2𝑘 個片段將以𝑥𝑖,2𝑘個執行緒來執行，同時該可平行化片段在執行時將衍生出一個擁有𝑥𝑖,2𝑘 個相同執行時間的子任務之集合；而對於循序片段𝑠𝑖,2𝑘+1(0 ≤ k ≤ 𝐾𝑖−1 2 )而言，因不可平 行化的特性只能以單一執行緒執行，故平行度𝑥𝑖,2𝑘+1只會是 1，因此循序片段將會衍生 出只有一個子任務的子任務集合。 圖2.2：可平行化片段以不同執行緒個數下的執行時間變化示意圖
9 綜合以上描述，我們將以{𝜏𝑖,𝑘,𝑥|1 ≤ 𝑥 ≤ 𝑥𝑖,𝑘}代表任務 τi的第k 個執行片段𝑠𝑖,𝑘平行 度為𝑥𝑖,𝑘時所衍生出的子任務集合，屬於該集合的每個子任務之執行時間皆為𝑒𝑖,𝑘,𝑥𝑖,𝑘。以 圖2.3 為例，可平行化任務𝜏𝑖有𝐾𝑖個片段，𝑠𝑖,1、𝑠𝑖,3、…、𝑠𝑖,𝐾𝑖為循序片段，並且在執行 時分別衍生子任務集合{𝜏𝑖,1,1}、{𝜏𝑖,3,1}、…、{𝜏𝑖,𝐾𝑖,1}，各子任務集合內中的唯一子任務執 行時間分別𝑒𝑖,1,1、𝑒𝑖,3,1、…、𝑒𝑖,𝐾𝑖,1；而𝑠𝑖,2、𝑠𝑖,4、…、𝑠𝑖,𝐾𝑖−1為可平行化片段，並且在執 行 階 段 也 各 自 衍 生 一 個 子 任 務 集 合 {𝜏𝑖,2,1，𝜏𝑖,2,2， … ，𝜏𝑖,2,𝑥𝑖,2} 、 {𝜏𝑖,4,1，𝜏𝑖,4,2， … ， 𝜏𝑖,4,𝑥𝑖,4}、…、{𝜏𝑖,𝐾𝑖−1,1，𝜏𝑖,𝐾𝑖−1,2， … ，𝜏𝑖,𝐾𝑖−1,𝑥𝑖,𝐾𝑖−1}，同一子任務集合的所有子任務之執 行時間皆相同，屬於各集合的子任務之執行時間分別為𝑒𝑖,2,𝑥𝑖,2、𝑒𝑖,4,𝑥𝑖,4、…、𝑒𝑖,𝐾𝑖−1,𝑥 𝑖,𝐾𝑖−1。 圖2.3：可平行化任務𝜏𝑖的各片段與其衍生的子任務之關係示意圖 當任務τi的可平行化片段𝑠𝑖,2、𝑠𝑖,4、…、𝑠𝑖,𝐾𝑖−1的平行度分別為𝑥𝑖,2、𝑥𝑖,4、…、𝑥𝑖,𝐾𝑖−1 時 ， 我 們 將 任 務 所 需 之 最 短 執 行 時 間 表 示 成 𝐸̂𝑖(1, 𝑥𝑖,2 ,1, 𝑥𝑖,4 ,…, 𝑥𝑖,𝐾𝑖−1, 1) = ∑ 𝑒𝑖,2𝑘+1,1 𝐾𝑖−1 2 𝑘=0 + ∑ 𝑒𝑖,2𝑘,𝑥𝑖,2𝑘 𝐾𝑖−1 2 𝑘=1 ，並且可以透過任務的執行時間𝐸̂𝑖與週期𝑃𝑖之關係，判斷 此任務是否可以在限定之截限時間內完成：若𝐸̂𝑖 ≤ 𝑃𝑖，代表任務可以在截限時間完成；
10 而𝐸̂𝑖 > 𝑃𝑖，將無法在截限時間內完成，此時我們必須調整該任務可平行化片段的平行度， 以 𝐸̂𝑖 ≤ 𝑃𝑖為 任 務 可 以 進 行 排 程 之 最 低 門 檻 ， 找 出 符 合 條 件 的 片 段 平 行 度 組 合 〈1, 𝑥̅𝑖,2, … , 𝑥̅𝑖,𝐾𝑖−1, 1〉。 當我們找出所有符合𝐸̂𝑖 ≤ 𝑃𝑖為前提的平行度組合時，我們必須從可能的組合中慎選 一組適當的平行度組合，例如：當考慮到平行化所需的成本時，選擇的平行度越高，總 執行時間∑𝐾𝑖−12 𝑒𝑖,2𝑘+1,1 𝑘=0 + ∑ 𝑒𝑖,2𝑘,𝑥𝑖,2𝑘 𝐾𝑖−1 2 𝑘=1 × 𝑥𝑖,2𝑘可能也會與之劇增，換句話說，在某些條 件下，過高的平行度或許可以降低片段單一執行緒的最大執行時間，但也極有可能會產 生多餘的執行成本，進而造成對整個系統額外的負擔增加，甚至容易造成任務無法排程， 因此為每個可平行化任務的片段選擇一個適當的平行度是需要被重視的。 接下來，我們將估算整個系統的電量消耗，根據[6]所提出之計算能耗為針對單一處 理器，將其套用於我們的多核心處理器架構上，假設處理器𝑃𝑟𝑗正規化後的速度為𝑆𝑝𝑑𝑗， 其範圍為0 < 𝑆𝑝𝑑𝑗 ≤ 1，並且速度可以於此區間進行動態調整，且無須調整成本。我們 以𝑝(𝑆𝑝𝑑𝑗)代表在速度為𝑆𝑝𝑑𝑗時，每單位時間所需的電量消耗𝑝(𝑆𝑝𝑑𝑗) = 𝑆𝑝𝑑𝑗2 [10]，並 將每個處理器之耗電量總和∑𝑀𝑗=1𝑝(𝑆𝑝𝑑𝑗)，代表系統執行時的耗電性。 總結以上所描述之任務模式與處理器模式，我們將定義出本論文所探討的問題：針 對同質性多核心DVS 處理器的系統中的可平行化週期性即時任務與循序週期性即時任 務之任務集合，提出一個任務排程機制，設法將所有任務集合中的每個任務分配到處理 器，並且保證該任務集合的即時需求，也就是任務在執行階段皆可在截限時間時間完成。 此外，也要試圖最小化任務集合執行於系統時所需之電量消耗。須強調的是，為了提高 任務集合的可排程率，將可平行化任務的平行度提高是有利的，但勢必會以增加整體執 行時間為代價，造成耗電性的增高，兩者難以求其全，因此我們在機制評估上，將整體 考量任務集合的可排程率與系統執行時所需之耗電性作為機制評估的準則。
11
第
三
章
多核心系統上具多個可平行化片段任務之
排程機制
本章將要探討具有多個可平行化片段的週期性任務集合，排程於多核心系統時的演 算法流程以及相關運作機制。首先於3.1 節中，我們將給予任務排程演算法總概念，該 排程演算法運用在離線(Offline)階段，在系統尚未開始執行任務集合前，以所提出之排 程演算法處理任務集合，過程中將會對可平行化任務做特殊處理產生對應獨立的子任務 集合，再將循序任務與可平行化任務之子任務分配給系統中適當處理器，若每個處理器 的循序任務使用率與可平行化任務之子任務使用密度總和不超過 1，即能保證所有(子) 任務可以執行於自己分配到的處理器上並滿足即時需求，將產生分配結果以供系統未來 執行時使用，且回傳TRUE；否則，回傳 FALSE。。 於3.2 節中將說明可平行化任務衍生其子任務的方法，在實行任務分配前，針對每 一個可平行化任務，必須將所需最短執行時間大於其週期的任務進行平行化，我們需要 在能使所需最短執行時間滿足小於或等於其週期的條件平行度組合中，進一步篩選出適 合任務之所有片段的平行度組合。此外，亦將分配可平行化任務片段所衍生出的子任務 各自的執行時間區間，使之無須再考慮片段間的執行順序性限制，並且從這些子任務執 行的時間區間不重疊的特性，將衍生出一個機制：同一可平行化任務之不同片段的子任12 務在同一處理器時可共享計算能力。 於3.3 節中將探討分配(子)任務時，如何將(子)任務分配至適當的處理器中，根據分 配方式的不同，其可排程率與耗電性結果也會有所不同。為了能更有效的使用處理器， 我們將結合處理器能力共享的機制，並採用三種不同的分配方式，為每個任務找到最適 合的處理器。 在最後3.4 節，我們將舉一個實例，對 3.1 節至 3.3 節之論述實際推演。
3.1 任務分配機制
本節說明任務分配機制為離線(Offline)方式，也就是在系統執行任務前，需要先將 每個任務或其衍生之子任務分配到適當的處理器上，並計算每個處理器上分配到的(子) 任務所需的負載使用密度總和，當系統開始執行工作時每個處理器以自己負載的使用密 度和設定處理器執行速度，執行屬於自己的任務。 任務分配的整體流程大致上如Algorithm 1 所示，為分配任務集合𝑇，一開始將會定 義並初始化幾個變數：新(子)任務集合Γ將會作為每個任務𝜏𝑖 ∈ 𝑇經處理過後存放(子)任 務的新集合；每個處理器𝑃𝑟𝑗(1 ≤ 𝑗 ≤ 𝑀)有(子)任務集合𝐺𝑗用於儲存分配到𝑃𝑟𝑗的(子)任務 之集合；每個處理器𝑃𝑟𝑗(1 ≤ 𝑗 ≤ 𝑀)有變數∆𝑗儲存分配到𝑃𝑟𝑗的任務之使用率與子任務使 用密度總和；𝑆ℎ𝑟𝐺𝑟𝑝𝑁𝑢𝑚𝑗,𝑖,𝑘為記錄可平行化任務𝜏𝑖第 k 個片段的子任務在(子)任務集 合𝐺𝑗中的個數，同時也可視為𝐺𝑗中有𝑆ℎ𝑟𝐺𝑟𝑝𝑁𝑢𝑚𝑗,𝑖,𝑘個k 片段的子任務已加入了共享集 合；𝑚𝑎𝑥𝑆ℎ𝑟𝐺𝑟𝑝𝑁𝑢𝑚𝑗,𝑖為在𝐺𝑗中，屬於可平行化任務𝜏𝑖的所有片段之中最大的子任務個 數，同時也可視為𝐺𝑗中屬於𝜏𝑖的共享集合目前的數量。關於子任務的使用密度(Density) 與共享機制將於本章3.2 節進行定義。 定義並初始化必要變數後，會依任務之類型處理每個任務𝜏𝑖 ∈ 𝑇，當𝜏𝑖為循序任務 時，無須經過處理，直接將其加入系統新(子)任務集合Γ；當𝜏𝑖為可平行化任務時，首先 判斷該可平行化任務是否需要進行平行化，若所有的平行片段的平行度皆為1 時，執行 時所需之最短執行時間超過其週期，一定無法在截限時間之前完成，則將任務𝜏𝑖以函式13 𝐷𝑒𝑟𝑖𝑣𝑒_𝑆𝑢𝑏𝑡𝑎𝑠𝑘(. ) 處 理 ； 若 為 循 序 任 務 ， 則 直 接 加 入 新 ( 子 ) 任 務 集 合 Γ 。 函 式 𝐷𝑒𝑟𝑖𝑣𝑒_𝑆𝑢𝑏𝑡𝑎𝑠𝑘(. )將會對可平行化任務𝜏𝑖的平行片段進行平行度的選擇，找出適當的平 行度組合〈1, 𝑥̅𝑖,2, … , 𝑥̅𝑖,𝐾𝑖−1, 1〉，並衍生出此任務的子任務集合Γ𝑖。若𝐷𝑒𝑟𝑖𝑣𝑒_𝑆𝑢𝑏𝑡𝑎𝑠𝑘(. )回 傳 空 集 合 ， 代 表 該 任 務 平 行 化 失 敗 ， 無 法 找 到 適 當 的 平 行 度 組 合 滿 足 𝐸̂𝑖(1, 𝑥̅𝑖,2, … , 𝑥̅𝑖,𝐾𝑖−1, 1) ≤ 𝑃𝑖，故宣告任務集合排程失敗；若回傳值非空集合，則將子任 務集合Γ𝑖加入集合Γ。關於函式𝐷𝑒𝑟𝑖𝑣𝑒_𝑆𝑢𝑏𝑡𝑎𝑠𝑘(. )細節將在 3.2 節進一步的詳細說明。 當每個任務𝜏𝑖 ∈ 𝑇皆處理完成後，令(子)任務集合Γ內的所有(子)任務依使用率(與使 用密度)由大到小排序。最後，依排序結果順序將循序任務𝜏𝑖與子任務𝜏𝑖,𝑘,𝑥逐一分配至處 理器，以函式𝐹𝑖𝑡_𝑡𝑜_𝑃𝑟𝑜𝑐𝑒𝑠𝑠𝑜𝑟(. )將(子)任務依採用的分配機制回傳適合的處理器𝑝∗， 之後並將此任務𝜏𝑖或子任務𝜏𝑖,𝑘,𝑥分配給該處理器。若𝐹𝑖𝑡_𝑡𝑜_𝑃𝑟𝑜𝑐𝑒𝑠𝑠𝑜𝑟(𝜏𝑖/𝜏𝑖,𝑘,𝑥, 𝐺, ∆)的 回傳值為-1，代表每個處理器皆無法再負荷下此(子)任務，故宣告排程失敗；若回傳值 1 ≤ 𝑝∗ ≤ 𝑀，則將此(子)任務加入𝐺 𝑝∗，並更新其使用率與使用密度總和∆𝑝∗。關於函式 𝐹𝑖𝑡_𝑡𝑜_𝑃𝑟𝑜𝑐𝑒𝑠𝑠𝑜𝑟(𝜏𝑖/𝜏𝑖,𝑘,𝑥, 𝐺, ∆)將在 3.3 節進一步的詳細說明。
14 Algorithm 1 分配任務至處理器
1: Function Assign _Task_to_Processor(T)
2: 定義衍生的(子)任務集合Γ，並初始化為空集合; 3: 定義每個處理器Prj(1 ≤ 𝑗 ≤ 𝑀)的未來將執行的(子)任務集合 Gj，並初始 化為空集合; 4: 定義每個處理器Prj(1 ≤ 𝑗 ≤ 𝑀)所分配到的任務使用率與子任務使用密 度之總和∆𝑗，並初始化為0; 5: 定義在(子)任務集合 Gj(1 ≤ 𝑗 ≤ 𝑀)中，已放置屬於𝜏𝑖的第k 個片段之子 任務個數𝑆ℎ𝑟𝐺𝑟𝑝𝑁𝑢𝑚𝑗,𝑖,𝑘，並初始化為0; 6: 定義在(子)任務集合 Gj(1 ≤ 𝑗 ≤ 𝑀)中，已放置屬於𝜏𝑖的所有片段中的子 任務最大個數𝑚𝑎𝑥𝑆ℎ𝑟𝐺𝑟𝑝𝑁𝑢𝑚𝑗,𝑖，並初始化為0; 7: for 𝜏𝑖 ∈ 𝑇 do 8: if 𝜏𝑖 ∈ 𝑇𝑠 then //若屬於循序任務 9: Γ ← Γ ∪ 𝜏𝑖; 10: else if 𝜏𝑖 ∈ 𝑇𝑝 then //若屬於可平行化任務 11: if 𝐸̂𝑖(1, … ,1) > 𝑃𝑖 then 12: if (Γ𝑖 ← 𝐷𝑒𝑟𝑖𝑣𝑒_𝑆𝑢𝑏𝑡𝑎𝑠𝑘(𝜏𝑖)) = ∅ then //衍生子任務 13: return FALSE; 14: else 15: Γ ← Γ ∪ Γ𝑖; 16: else 17: Γ ← Γ ∪ 𝜏𝑖; 18: 將Γ依使用率(密度)由大到小排序; 19: for 𝜏𝑖(/𝜏𝑖,𝑘,𝑥) ∈ Γ do 20: if (𝑝∗ ← 𝐹𝑖𝑡_𝑡𝑜_𝑃𝑟𝑜𝑐𝑒𝑠𝑠𝑜𝑟(𝜏𝑖((/𝜏𝑖,𝑘,𝑥), 𝐺, 𝑆ℎ𝑟𝐺𝑟𝑝𝑁𝑢𝑚, 𝑚𝑎𝑥𝑆ℎ𝑟𝐺𝑟𝑝𝑁𝑢𝑚, ∆)) = −1 then 21: return FALSE; 22: else 23: 將𝜏𝑖(或𝜏𝑖,𝑘,𝑥)分配至處理器𝑝∗，也就是𝐺𝑝∗ ← 𝐺𝑝∗ ∪ 𝜏𝑖(或𝜏𝑖,𝑘,𝑥); 24: 將𝜏𝑖的使用率或是𝜏𝑖,𝑘,𝑥的使用密度累加至∆𝑝∗; 25: return TRUE; 26: Function end
15
3.2 可平行化任務衍生子任務與處理器計算能力共享
本節將描述如何處理可平行化任務以提高可排程率，當可平行化任務不做任何平行 化時，也就是以單一執行緒，所有片段平行度皆為1，所需之最短執行時間𝐸̂𝑖(1, … ,1)不 超過其週期𝑃𝑖，亦即𝐸̂𝑖(1, … ,1) ≤ 𝑃𝑖，代表該可平行化任務𝜏𝑖無須進行平行化，亦不會衍 生其子任務，可將此任務直接分配至某個處理器任務可執直接進行分配給處理器。 當𝐸̂𝑖(1, … ,1) ≤ 𝑃𝑖條件不滿足時，則代表須將此任務進行平行化，針對該任務的某 些可平行化片段提高其平行度，求得適當平行度組合〈1, 𝑥̅𝑖,2, … , 𝑥̅𝑖,𝐾𝑖−1, 1〉，藉此降低所需 之 最 短 執 行 時 間 的 長 度 ， 滿 足 最 短 執 行 時 間 的 長 度 不 超 過 週 期 ， 亦 即 𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1) ≤ 𝑃𝑖。 然而，漫無目的的提高平行度將有可能增加產生整體多餘的執行時間，反而降低可 排程率。本節中將會提出提高可平行化片段平行度時的考量方向，說明如何從眾多可能 的平行度組合中，挑選一組適當的平行度組合，衍生子任務之過程。 可平行化任務的每個片段之間存在著執行順序(Precedence Constraint)關係：一個片 段執行完成才可以開始進行下一個片段，如圖 2.1 所示。若某個片段因為優先權關係， 被其他任務影響，導致無法盡快執行，拖了很長時間才執行完成，則會影響到之後片段 的執行，嚴重可能導致無法如期在截限時間前完成。因此，為了避免上述狀況的發生， 且方便未來進行任務分配，我們將使得片段的執行順序限轉換成每個片段的時間限制 (Timing Constraint)，也就是給予每個片段自己的可開始執行時間與絕對截限時間，而這 段時間區間稱之為可執行區間(Active Interval)=(可開始執行時間, 絕對截限時間]，可執 行區間是為了限制片段的子任務執行必須在此時間內開始執行與執行完畢。當可平行化 任務的每個片段對應之子任務若都能在自己的可執行區間內完成執行，也就代表著該可 平行化任務能在截限時間前完成。16 定理1. 一個可平行化任務𝜏𝑖最多可以衍生出𝐾𝑖+1 2 + ( 𝐾𝑖−1 2 × 𝑀)個子任務。 證明：可平行化任務𝜏𝑖的片段個數為𝐾𝑖，其中循序片段則有𝐾𝑖+1 2 個，其平行度固定 為1 只會衍生一個子任務，故所有循序片段最多可衍生𝐾𝑖+1 2 個子任務；而可平行化片段 有𝐾𝑖−1 2 個，其平行度最高可為𝑀，故所有可平行化片段最多可衍生 𝐾𝑖−1 2 × 𝑀個子任務。因 此可平行化任務𝜏𝑖最多可以衍生出𝐾𝑖+1 2 + ( 𝐾𝑖−1 2 × 𝑀)個子任務。□ 接下來我們將說明如何設定可平行化任務𝜏𝑖的片段之子任務的可執行區間，之後子 任務能根據新的執行時間限制執行而忽略片段間既有的執行順序限制。如圖 3.1 所示， 我們將會分配給任務𝜏𝑖的每個片段之子任務各自的相對截限時間，片段𝑠𝑖,𝑘的子任務所 分配到的相對截限時間以𝑑𝑖,𝑘表示，並且屬於同一個片段之所有子任務的相對截限時間 皆相同。每個片段的子任務之相對截限時間是從任務𝜏𝑖之週期𝑃𝑖所分割出來的，為了讓 子 任 務 有 適 當 的 相 對 截 限 時 間 ， 任 務 之 週 期 應 完 全 分 配 給 所 有 子 任 務 ， 所 以 ∑𝐾𝑖 𝑑𝑖,𝑘 = 𝑘=1 𝑃𝑖。子任務獲得相對截限時間後，可以接著推算出可開始執行的時間及絕對 截限時間，片段𝑠𝑖,𝑘的子任務之絕對截限時間即為片段𝑠𝑖,𝑘+1的子任務之開始執行時間， 而第一片段𝑠𝑖,1的子任務開始執行時間即為任務𝜏𝑖的開始執行時間。 定理 2. 可平行化任務𝜏𝑖的每個片段之子任務的相對截限時間總和在等於任務週期𝑃𝑖， 也就是∑𝐾𝑖 𝑑𝑖,𝑘 = 𝑘=1 𝑃𝑖時，子任務會有較小的使用密度。 證明：假設每個片段之子任務的相對截限時間總和大於週期𝑃𝑖，∑𝐾𝑖 𝑑𝑖,𝑘 > 𝑘=1 𝑃𝑖，則 可能發生時間已抵達任務𝜏𝑖的截限時間，但其片段之子任務仍在執行當中，造成𝜏𝑖無法 在截限時間前完成；若是∑𝐾𝑖 𝑑𝑖,𝑘 < 𝑘=1 𝑃𝑖，則代表每個片段之子任務的相對截限時間𝑑𝑖,𝑘皆 會降低，將會造成子任務的使用密度上升。□
17 我們以任務𝜏𝑖的第 k 個片段所衍生的第 x 個子任務子𝜏𝑖,𝑘,𝑥說明，假設任務𝜏𝑖的抵達 時間為t，則子任務𝜏𝑖,𝑘,𝑥的可開始執行時間為𝑡 + ∑𝑘−1𝑙=1 𝑑𝑖,𝑙，而其相對截限時間為𝑑𝑖,𝑘，執 行時間區間則為(𝑡 + ∑𝑘−1𝑙=1 𝑑𝑖,𝑙, 𝑡 + ∑𝑘𝑙=1𝑑𝑖,𝑙]，當子任務𝜏𝑖,𝑘,𝑥可開始執行後，必須在此時 間區間內執行完𝑒𝑖,𝑘,𝑥𝑖,𝑘執行時間。我們以𝜎𝑖,𝑘將代表子任務𝜏𝑖,𝑘,𝑥的使用密度(Density)， 𝜎𝑖,𝑘 =𝑒𝑖,𝑘,𝑥𝑖,𝑘 𝑑𝑖,𝑘 ，由於一個片段所衍生之子任務執行時間、相對截限時間皆相同，故屬於同 個片段的子任務之密度也會相同。系統必須在一個處理器上保留與子任務之使用密度值 相同的處理器能力，才能確保該子任務能符合即時要求。 圖 3.1：將任務片段之子任務的執行順序限制轉換成執行時間限制示意圖 當 可 平 行 化 任 務 𝜏𝑖 在 平 行 度 組 合 〈1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1〉 之 下 ， 若 𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1) ≤ 𝑃𝑖條件被滿足後，接下來我們將討論如何設定可平行化任務之 片段的子任務相對截限時間。設定可平行化任務之片段的子任務相對截限時間方面，有 兩種分配方法可以使用，分別是Equal Slack(EQS)[14]與 Equal Flexibility(EQF)[14]，其 方法說明如下：
18 1. Equal Slack(EQS) ： 將 可 平 行 化 任 務 𝜏𝑖的 週 期 𝑃𝑖 減 去 目 前 的 執 行 時 間 𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1)，所剩餘的時間區間𝑃𝑖− 𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1)平均分配 給每個片段之子任務，所得的平均值𝑃𝑖−𝐸̂𝑖(1,𝑥𝑖,2,…,𝑥𝑖,𝐾𝑖−1,1) 𝐾𝑖 相加於子任務的執行時 間後，即為子任務的相對截限時間，因此如果片段𝑠𝑖,𝑘之子任務的執行時間為 𝑒𝑖,𝑘,𝑥𝑖,𝑘 ， 則 片 段 𝑠𝑖,𝑘 之 子 任 務 的 相 對 截 限 時 間 為 𝑑𝑖,𝑘 = 𝑒𝑖,𝑘,𝑥𝑖,𝑘+ 𝑃𝑖−𝐸̂𝑖(1,𝑥𝑖,2,…,𝑥𝑖,𝐾𝑖−1,1) 𝐾𝑖 。 2. Equal Flexibility(EQF) ：將可平行 化任務 𝜏𝑖的 週 期 𝑃𝑖減 去 目 前 的 執 行 時 間 𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1)，所剩餘的時間區間𝑃𝑖− 𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1)依照各個 片段之執行時間於𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1)中所佔的比例分配給每個片段，其比 例所得出的值相加於子任務的執行時間後，即為子任務的相對截限時間，因此 如果片段𝑠𝑖,𝑘之子任務的執行時間為𝑒𝑖,𝑘,𝑥𝑖,𝑘，則相對截限時間為𝑑𝑖,𝑘 = 𝑒𝑖,𝑘,𝑥𝑖,𝑘+ (𝑃𝑖 − 𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1)) × 𝑒𝑖,𝑘,𝑥𝑖,𝑘 𝐸̂𝑖(1,𝑥𝑖,2,…,𝑥𝑖,𝐾𝑖−1,1)= 𝑃𝑖× 𝑒𝑖,𝑘,𝑥𝑖,𝑘 𝐸̂𝑖(1,𝑥𝑖,2,…,𝑥𝑖,𝐾𝑖−1,1)。 至於EQF 與 EQS 哪一個會較適合，我們將在以下做討論。一個可平行化任務的不 同片段之子任務的執行時間不一定相同。當使用 EQS 方法時，是將週期與任務所需之 最短執行時間的差值平均分配給每個片段，其子任務所分配到的值加上自己的執行時間 即為該子任務的相對截限時間。以 EQS 設定子任務之截限時間後，所計算出得子任務 之使用密度有以下特性。 定理3. 可平行化任務𝜏𝑖，當使用EQS 方法設定子任務之相對截限時間時，子任務使用 密度之值會隨著子任務執行時間越大，則使用密度將越大。 證明：假設𝜏𝑖有 n 個片段，在某個平行度組合時，所需之最短執行時間為𝐸，假設 某個子任務所需的執行時間為𝑒。在使用 EQS 方法之下，將週期與最短執行時間差值 𝑆𝐿𝐾 = 𝑃𝑖 − 𝐸平均分配給每個片段之值以𝑆𝐸𝑄𝑆 = 𝑆𝐿𝐾 𝑛 表示，子任務的使用密度為 𝑒 𝑆𝐸𝑄𝑆+𝑒， 此函式為開口向下，隨著𝑒值變大函式值逐漸增加且逼近 1，換言之，子任務的執行時間
19 較短，其使用密度就會較小；相對的，子任務執行時間較長，其使用密度就會較大。□ 而使用 EQF 方法時，是將週期與最短執行時間的差值依照各片段之執行時間比例 分配給每個片段，其子任務所分配到的比例值加上自己的執行時間即為該子任務的相對 截限時間。執行時間較短的子任務所分配到的值會較短，而執行時間較長的子任務所分 配到的值則會較多，得出每個子任務的相對截限時間後，最後所有子任務計算出的使用 密度皆會相等，也就是𝐸̂𝑖(1,𝑥𝑖,2,…,𝑥𝑖,𝐾𝑖−1,1) 𝑃𝑖 。 定理 4. 可平行化任務𝜏𝑖，使用 EQF 方法所得出的子任務使用密度之值，會介於使用 EQS 方法所得出的子任務最高使用密度與最低使用密度之間。 證明：假設𝜏𝑖有 n 個片段，在某個平行度組合時，所需之最短執行時間為𝐸，片段 的子任務中所需的最大執行時間為𝑒𝑚𝑎𝑥而最小的執行時間為𝑒𝑚𝑖𝑛。所有片段的平均執行 時間則為𝑒𝑎𝑣𝑔 =𝐸 𝑛，並且𝑒𝑚𝑖𝑛< 𝑒𝑎𝑣𝑔 < 𝑒𝑚𝑎𝑥。對於 EQS 而言，將週期與最短執行時間 差值𝑆𝐿𝐾 = 𝑃𝑖 − 𝐸平均分配給每個片段之值以𝑆𝐸𝑄𝑆 = 𝑆𝐿𝐾 𝑛 表示，所有子任務中最大的使 用密度為 𝑒𝑚𝑎𝑥 𝑆𝐸𝑄𝑆+𝑒𝑚𝑎𝑥，而最小的使用密度為 𝑒𝑚𝑖𝑛 𝑆𝐸𝑄𝑆+𝑒𝑚𝑖𝑛；而EQF 方面，由於每個子任務的使 用密度皆相同，每個子任務的使用密度為𝐸 𝑃𝑖，而 𝐸 𝑃𝑖又可以表示成 𝐸 𝑆𝐿𝐾+𝐸 = 𝐸 𝑛 𝑆𝐿𝐾 𝑛 + 𝐸 𝑛 = 𝑒𝑎𝑣𝑔 𝑆𝐸𝑄𝑆+𝑒𝑎𝑣𝑔。 從定理3 可以得知，使用密度 𝑒 𝑆𝐸𝑄𝑆+𝑒會因子任務的執行時間𝑒的長短而較大或較小，又因 已知條件𝑒𝑚𝑖𝑛 < 𝑒𝑎𝑣𝑔< 𝑒𝑚𝑎𝑥，故 𝑒𝑚𝑖𝑛 𝑆𝐸𝑄𝑆+𝑒𝑚𝑖𝑛< ( 𝐸 𝑃𝑖= 𝑒𝑎𝑣𝑔 𝑆𝐸𝑄𝑆+𝑒𝑎𝑣𝑔) < 𝑒𝑚𝑎𝑥 𝑆𝐸𝑄𝑆+𝑒𝑚𝑎𝑥，得證。□ 定理 5. 無論使用 EQS 方法或 EQF 方法來設定可平行化任務𝜏𝑖衍生之子任務的相對截 限時間，提高可平行化片段之平行度會使所有片段中既有的每個子任務之使用密度減少。 證明：由於提高片段的平行度會衍生更多新的子任務，而新的子任務無前後關係可 比較，因此只論既有的每個子任務。當提高某個可平行化片段的平行度時，可以降低該
20 片段的執行時間，而可平行化任務的最短執行時間𝐸也會減少，因此週期與最短執行時 間之差值𝑆𝐿𝐾將會增加。在 EQS 的方面，當𝑆𝐿𝐾增加時，分配給每個片段之值𝑆𝐸𝑄𝑆 = 𝑆𝐿𝐾 𝑛 也會增加，而𝑆𝐸𝑄𝑆相加於子任務的執行時間即為相對截限時間，因此相對截限時間將增 加，並且可以知道平行度提高的片段之子任務執行時間減少，而其他片段之子任務的執 行時間不變，因此所有片段原有的每個子任務之使用密度將降低；在 EQF 的方面，可 以從 EQF 的特性，每個子任務的使用密度等於任務所需之最短執行時間除以週期，當 提高某個可平行化片段的平行度將使所需之最短執行時間減少，使用密度之值也會減少， 因此所有片段中原有的每一個子任務之使用密度也將降低。□ 當所有可平行化任務皆已完成平行化，並衍生其子任務後，任務集合的處理也隨即 完成，接下來將進行(子)任務排程。而在排程的過程中，所有的循序任務以及由可平行 化任務衍生而成的子任務皆視為相互獨立，每個(子)任務只需要在自己的截限時間前完 成即可。當排程時，在分配給處理器後，計算處理器上負載時，可以將每個(子)任務的 使用密度加總計算。然而，對於屬於同一個任務之不同片段的子任務之間，其實存在著 一個特殊的關係，藉由這層關係，將可提升系統的可排程率，下面將做說明。 實際上，我們給予了每個子任務自己的執行時間區間後，一個片段之子任務的絕對 截限時間等於下一個片段之子任務的可開始執行時間，如圖3.1 所示，可以從此關係得 知每個片段之子任務在執行時並不會占用到其他片段之子任務的時間。因此，我們在排 程任務時，其實當同一個可平行化任務之不同片段的子任務被分配到同一處理器時，這 些子任務可以共享處理器的計算能力，我們將此處理器上的該任務之子任務集合稱為共 享集合。而一個子任務只能屬於一個共享集合，不可能同時存在於兩個集合中。 定理 6. 由於不同片段的子任務使用處理器的時間並不重疊，因此保留共享集合中子任 務所需的最大計算能力(使用密度)給予共享，將能保證集合中的所有子任務可以滿足自 己的即時需求，也就是在截限時間之前完成。
21 證明：只要給予的計算能力足夠共享集合中最大使用密度的子任務滿足即時需求， 則該計算能力對於其他使用密度需求較低子任務而言已是足夠的，因此同一共享集合中 所有子任務都可以滿足即時需求。□ 定理 7. 一個處理器可能被分配到來自不同可平行化任務或是同一個可平行化任務之多 個共享集合。 證明：只要一個處理器中的所有循序任務與各個共享集合中之最大使用密度總和不 超過1，則代表該處理器可負荷這些任務與共享集合。□ 定理8. 採用共享機制分配一個可平行化任務之子任務時，其片段中最大的平行度之值， 即為共享集合的個數。 證明：由於不同片段之子任務才能共享處理器能力，若屬於同一片段所衍生的子任 務則無法互相進行共享，故平行度最高的片段所衍生出的子任務個數，即為共享集合的 個數。□ 一個可平行化任務如何衍生出其子任務集合的方法流程如Algorithm 2 所示，在此， 我們先說明此函式的概念，之後將完整介紹過程中各步驟的細節。此函式處理未提高任 務平行化片段平行度前未符合𝐸̂𝑖(1, … ,1) ≤ 𝑃𝑖的可平行化任務，若其片段之平行度皆為 1 時即符合上述條件，則無須再經此函式處理，之後將直接完整分配到一個處理器。當 需要處理的可平行化任務𝜏𝑖輸入時，首先為其定義一個子任務集合Γ𝑖，之後便開始進入 主要處理迴圈直到測試完所有組合，每次迴圈會逐次提升所有可平行化片段的平行度， 並比較不同平行度下的該任務所有分享集合所需之處理器能力總和(也就是各集合中子 任務之最大使用密度總和)，最後回傳最適當的平行度組合下的子任務集合，也就是有 最小所需之處理器能力總和的平行度組合。
22 定理9. 當可平行化任務𝜏𝑖有𝐾𝑖個可平行化片段時，每個可平行化片段有M 種平行度可 以選擇，因此最多可以有𝑀𝐾𝑖−12 種平行度組合，然而，當使用EQF 設定子任務截限時間 時，並考慮到處理器計算能力共享的機制，其實只需測試 M 種平行度組合即可，因為 測試𝑀𝐾𝑖−12 種平行度組合後，所得到之所有子任務之處理器能力最小之平行度組合與只 測試M 種結果一樣。 證明：從定理6 與定理 8 可以得知，可平行化任務的片段中最大之平行度等於共享 集合的個數，並且只需保留共享集合中子任務的最大使用密度即可。假設𝜏𝑖的每個可平 行化片段的平行度皆不相同，若提高平行度較低的可平行化片段之平行度，讓所有可平 行化片段的平行度一致，則在保持共享集合個數不變的情況下，由定理5 可以得知所有 既有的子任務之使用密度也會變小，其中也包括所有的共享集合之子任務最大使用密度。 而提升平行度的片段雖然會衍生新的子任務，但可以加入既有的共享集合，由於使用 EQF 會使所有子任務的使用密度一致，可以保證新的子任務加入共享集合後，其子任務 之最大使用密度不會增加。因此，只需要測試不同個數下的共享集合，其最大使用密度 總和為最小的平行度組合，也就是每個可平行化片段的平行度皆相同的組合，即為 M 種。□ 上述定理在使用 EQS 時，無法絕對保證所有情況下都滿足，以下舉出一個不符合 之反例說明：假設𝜏𝑖可平行化片段𝑠𝑖,𝐴的執行時間為所有片段中最長，且遠大於其他所有 片段之執行時間；而可平行化片段𝑠𝑖,𝐵的執行時間為所有片段中第二長，但仍遠小於𝑠𝑖,𝐴。 由定理 4 可以判斷𝑠𝑖,𝐴之子任務使用密度也遠大於其他所有片段之子任務使用密度。同 樣的假設𝜏𝑖的每個可平行化片段的平行度皆不相同，並且𝑠𝑖,𝐵的平行度為最高，此時若 𝑠𝑖,𝐴的平行度提高與𝑠𝑖,𝐵一致，則𝑠𝑖,𝐴會衍生新的子任務，並加入既有的共享集合，而這些 被加入的共享集合之最大使用密度勢必會被𝑠𝑖,𝐴之子任務使用密度所取代。即使因定理 5 而使未被加入的共享集合之最大使用密度減少，仍無法彌補𝑠𝑖,𝐴的新子任務加入其他 共享集合後所增加的量。因此，若使用EQS，並選擇可平行化片段的平行度皆相同的組
23 合，無法保證此組合在同樣個數的共享集合下，其最大使用密度總和為最小，也就是說， 使用EQS 時所選擇的最佳平行度組合不一定在 M 種組合之中。 定理10. 對一可平行化任務進行平行化時，如果分別以 EQF 和 EQS 方法設定子任務的 相對截限時間，且可平行化片段的平行度皆相同，在子任務共享處理器計算能力的機制 下，將可平行化任務所衍生的所有子任務分配至處理器後，使用 EQF 方法下共享集合 的使用密度總和比使用EQS 時更低。 證明：首先說明以下兩個已知條件：○1 由於可平行化片段的執行時間遠大於循序片 段的執行時間，藉由定理3 可以推測使用 EQS 時，擁有最大使用密度者為某個可平行 化片段所衍生的子任務。○2 於定理8 可知，片段中最高之平行度即為共享集合的個數。 由於可平行化片段的平行度皆相同，經由上述○1 、○2 可以確定，使用 EQS 後所產生的 所有共享集合都包含了最大使用密度的子任務；而 EQF 因其特性所有子任務之使用密 度皆相同，亦可保證其產生的共享集合皆包含了最大使用密度的子任務。由於對象為同 平行度組合的可平行化任務，使用EQF 與 EQS 所產生的共享集合個數皆相同，根據定 理6 我們需要保留共享集合中子任務最大的使用密度，又因定理 4 可以知道由 EQF 所 產生的共享集合之最大使用密度，小於由 EQS 所產生的共享集合之最大使用密度。因 此，於共享的機制下，使用 EQF 設定可平行化任之子任務的相對截限時間會有較小的 使用密度總和。□ Algorithm 2 的主要迴圈運作在當各個可平行化片段的平行度都設定成某個平行度𝑙 後，也就是平行度組合為〈1, 𝑙, … , 𝑙, 1〉，一開始，判斷是否符合𝐸̂𝑖(1, 𝑙, … , 𝑙, 1) ≤ 𝑃𝑖條件， 若是，將進行 EQF 方法將週期分配給每個片段之子任務，每個片段之子任務都有各自 的執行時間和相對截限時間後，則可計算每個片段中的每一個子任務之使用密度 〈𝜎𝑖,1, 𝜎𝑖,2, … , 𝜎𝑖,𝐾𝑖〉。再利用函式𝐶𝑜𝑚𝑝𝑢𝑡𝑒_𝑆ℎ𝑎𝑟𝑒𝑑_𝐷𝑒𝑛𝑠𝑖𝑡𝑦(. )計算出平行度組合下的共享 集合之使用密度總和是否比目前最小值∆σ𝑚𝑖𝑛小，若是，則更新∆σ𝑚𝑖𝑛與𝑙∗。之後，再提 高平行度𝑙，做上述處理，直到𝑙為𝑀為止。
24 在Algorithm 2 最重要的概念在於如何為可平行化任務選擇適當之平行度組合，以 下將做討論。雖然提高平行度可以有效的降低可平行化片段之個別子任務之值行時間， 間接的減少任務所需之最短執行時間，但也會因此增加總執行時間∑ 𝑒𝑖,2𝑘+1,1 𝐾𝑖−1 2 𝑘=0 + ∑ 𝑒𝑖,2𝑘,𝑥𝑖,2𝑘 𝐾𝑖−1 2 𝑘=1 × 𝑥𝑖,2𝑘，因此挑選一個適當的平行度組合是一個很重要的議題，而片段衍 生的子任務之使用密度正是我們判斷如何挑選的重要依據。 在一般狀況下會直覺的制定一個篩選平行度組合的標準：將子任務視為各自獨立， 以可平行化任務𝜏𝑖的每個子任務之總使用密度∑ 𝜎𝑖,2𝑘+1 𝐾𝑖−1 2 𝑘=0 + ∑ 𝜎𝑖,2𝑘 𝐾𝑖−1 2 𝑘=1 × 𝑥𝑖,2𝑘為最小 的平行度組合為最適當的組合，此機制稱為「子任務總使用密度為最小」的篩選標準。 而此標準對於可平行化任務在平行化成本較低時，某些片段更高的平行度可能有助於降 低總使用密度，因此會挑選某些片段平行度高一點的組合；但若平行化成本較高時，任 何片段提高平行度都會大幅度增加總使用密度，因此只會挑選較低平行度組合。 在處理器計算能力可以共享的想法下，可以衍生出一個新的篩選標準：挑選「共享 後之子任務總使用密度為最小」的平行度組合。在共享的機制下，片段中最高的平行度 即為共享集合的數量，而實際所需之處理器計算能力應為共享集合的子任務最大使用密 度，所以，應該盡量降低共享集合之子任務最大使用密度總和。若只單純考慮每個子任 務各自獨立下之所有子任務之使用密度總和，或許會因此選擇了某些片段的平行度為較 高，或某些片段的平行度較低的組合，之後在處理器計算能力共享的機制下，會產生較 多的共享集合，或是令共享集合的子任務最大使用密度較大，這些狀況會導致實際所需 的處理器計算能力提高。因此，我們會考慮到共享集中之子任務對於處理器計算能力共 享的可能性，挑選共享後能使總使用密度為最小的平行度組合。 在Algorithm 2 中我們所採用的篩選標準為「共享後之子任務總使用密度為最小」 的平行化組合。經過函式𝐶𝑜𝑚𝑝𝑢𝑡𝑒_𝑆ℎ𝑎𝑟𝑒𝑑_𝐷𝑒𝑛𝑠𝑖𝑡𝑦(. )計算出每個平行化組合於排程中 子任務共享處理器能力時的總計算能力需保留多少，從中挑選出該值為最小的平行度組 合，即可確立可平行化任務𝜏𝑖的平行度組合〈1, 𝑥̅𝑖,2, … , 𝑥̅𝑖,𝐾𝑖−1, 1〉。最後，將此平行度組合
25 衍生之子任務加入集合Γ𝑖並回傳，即完成函式𝐷𝑒𝑟𝑖𝑣𝑒_𝑆𝑢𝑏𝑡𝑎𝑠𝑘(. )衍生可平行化任務𝜏𝑖子 任務之流程。 而計算共享後的總使用密度之函式𝐶𝑜𝑚𝑝𝑢𝑡𝑒_𝑆ℎ𝑎𝑟𝑒𝑑_𝐷𝑒𝑛𝑠𝑖𝑡𝑦(. )如 Algorithm 3 所 示，將可平行化任務𝜏𝑖與其每個可平行化片段之平行度𝑙，以及所有片段之單一子任務使 用密度〈𝜎𝑖,1, 𝜎𝑖,2, … , 𝜎𝑖,𝐾𝑖〉輸入此函式，在最後會輸出𝜏𝑖在平行度組合為〈1, 𝑙, … , 𝑙, 1〉時，處 理器計算能力共享後的子任務總使用密度。演算流程可配合圖3.2 說明，𝜏𝑖的所有可平 行化片段之平行度皆為𝑙，代表最高平行度也是𝑙，因此有𝑙個共享集合。每次迴圈都將處 理一個共享集合，並將此共享集合中的最大使用密度紀錄於σ𝑚𝑎𝑥。進行處理時都會將每 個片段的平行度暫時減1，以此表示該片段已有一個子任務參與共享，當片段的平行度 為小於等於0 時，為了記錄已無子任務能再參與共享集合，雖然仍會扣除其值，但不再 列入參與共享，視為片段衍生出的所有子任務皆已參與共享。以圖3.2 中的𝑠𝑖,1說明，其 Algorithm 2 衍生可平行化任務之子任務 1: Function 𝐷𝑒𝑟𝑖𝑣𝑒_𝑆𝑢𝑏𝑡𝑎𝑠𝑘(𝜏𝑖) 2: 定義暫存的最小使用密度總和∆σ𝑚𝑖𝑛← ∞; 3: 定義最佳組合之平行度𝑙∗ ← −1; 4: 定義𝜏𝑖之子任務集合Γ𝑖，並初始化為空集合; 5: for 𝑙 = 1 to 𝑀 do 6: 將可平行化片段之平行度𝑥𝑖,2, 𝑥𝑖,4, … , 𝑥𝑖,𝐾𝑖−1設定成𝑙; //設定平行度 7: if 𝐸̂𝑖(1, 𝑥𝑖,2, … , 𝑥𝑖,𝐾𝑖−1, 1) ≤ 𝑃𝑖 then 8: 使用 EQF 方法，設定每個片段之子任務相對截限時間; 9: 計算每個片段的單一子任務的使用密度〈𝜎𝑖,1, 𝜎𝑖,2, … , 𝜎𝑖,𝐾𝑖〉; 10: ∆← 𝐶𝑜𝑚𝑝𝑢𝑡𝑒_𝑆ℎ𝑎𝑟𝑒𝑑_𝐷𝑒𝑛𝑠𝑖𝑡𝑦(𝜏𝑖, 𝑙, 〈𝜎𝑖,1, 𝜎𝑖,2, … , 𝜎𝑖,𝐾𝑖〉); 11: if ∆< ∆σ𝑚𝑖𝑛 then 12: ∆σ𝑚𝑖𝑛← ∆; 13: 𝑙∗ = 𝑙; 14: if 𝑙∗ ≠ −1 then //有解並結束 15: 以平行度組合〈1, 𝑙∗, … , 𝑙∗, 1〉設定每個對應片段之子任務個數，並將 子任務加到Γ𝑖集合中； 16: return Γ𝑖; 17: Function end
