時間片輪轉演算法性能指標

⑴ 軟考嵌入式系統設計師考什麼

軟考嵌入式系統設計師，包含兩個考試科目：基礎知識與應用技術；基礎知識科目在上午考試，應用技術科目在下午考試。軟考嵌入式系統設計師各科目考試內容有所不同。
根據軟考嵌入式系統設計師考試大綱，各科目考試范圍如下：
考試科目1：嵌入式系統基礎知識
1.計算機科學基礎
1.1數制及轉換
·二進制、八進制、十進制和十六進制等常用數制及其相互轉換
1.2數據的表示
·數的機內表示（原碼、反碼、補碼、移碼，定點和浮點，精度和溢出）
·字元、漢字、聲音、圖像的編碼方式
·校驗方法和校驗碼（奇偶驗碼、海明校驗碼、循環校驗碼）
1.3算術和邏輯運算
·計算機中的二進制數運算方法
·邏輯代數的基本運算和邏輯表達式的化簡
1.4計算機系統結構和重要部件的基本工作原理
· CPU和存儲器的組成、性能、基本工作原理
·常用I/O設備、通信設備的性能，以及基本工作原理
·I/O介面的功能、類型和特點
·虛擬存儲存儲基本工作原理，多級存儲體系
1.5安全性、可靠性與系統性能評測基礎知識
·診斷與容錯
·系統可靠性分析評價
·計算機系統性能評測方法
2.嵌入式系統硬體知識
2.1數字電路和邏輯電路基礎
2.1.1組合電路和時序電路
2.1.2匯流排電路與電平轉換電路
2.1.3可編程邏輯器件
2.2嵌入式微處理器基礎
2.2.1嵌入式微處理器體系結構
·馮·諾伊曼結構與哈佛結構
· CISC與RISC
·流水線技術
·信息存儲的位元組順序（大端存儲法和小端存儲法）
2.2.2嵌入式系統處理器的結構和類型
·常用8位處理器的體系結構和類型
·常用16位處理器的體系結構特點
·常用32位處理器的體系結構特點
·常用DSP處理器的體系結構特點
·多核處理器的體系結構特點
2.2.3異常
·同步異常（陷阱、故障、終止）
·非同步異常（中斷）
·可屏蔽中斷、不可屏蔽中斷
·中斷優先順序、中斷嵌套
2.3嵌入式系統的存儲體系
2.3.1存儲器系統
·存儲器系統的層次結構
·高速緩存（Cache）
·內存管理單元（MMU）
2.3.2 ROM的種類與選型
·常見ROM的種類
· PROM、EPROM、E2PROM型ROM的典型特徵和不同點
2.3.3 Flash Memory的種類與選型
· Flash Memory的種類
· NOR和NAND型Flash Memory的典型特徵和不同點
2.3.4 RAM的種類與選型
·常見RAM的種類
· SRAM、DRAM、DDRAM、NVRAM的典型特徵和不同點
2.3.5外存
·常見外存的種類
·磁碟、光碟、CF、SD等的典型特徵和不同點
2.4嵌入式系統I/O介面
2.4.1定時器和計數器基本原理與結構
2.4.2 GPIO、PWM介面基本原理與結構
2.4.3 A/D、D/A介面基本原理與結構
2.4.4鍵盤、顯示、觸摸屏介面基本與結構
2.4.5嵌入式系統音頻介面
2.5嵌入系統通信及網路介面
· PCI、USB、串口、紅外、並口、SPI、IIC、PCMCIA的基本原理與結構
·乙太網、CAN、WLAN、藍牙、1394的基本原理與結構
2.6嵌入式系統電源分類及電源原理
2.7電子電路設計
2.7.1電子電路設計基礎知識
·電子電路設計原理
·電子電路設計方法及步驟
·電子電路設計中的可靠知識
2.7.2 PCB設計基礎知識
· PCB設計原理
· PCB設計方法及步驟
·多層PCB設計的注意事項及布線原則
· PCB設計中的可靠性知識
2.7.3電子電路測試基礎知識
·電子電路測試原理與方法
·硬體抗干擾測試
3.嵌入式系統軟體知識
3.1嵌入式軟體基礎知識
3.1.1嵌入式軟體的分類（系統軟體、支撐軟體、應用軟體）
3.1.2無操作系統支持的嵌入式軟體體系結構（輪詢、中斷、前後台）
3.1.3有操作系統支持的嵌入式軟體體系結構
3.1.4板極支持包基礎知識（系統初始化、設備驅動程序）
3.1.5嵌入式中間件（GUI、資料庫）
3.2嵌入式操作系統基礎知識
3.2.1嵌入式操作系統體系結構
·單體結構、分層結構和微內核結構
3.2.2任務管理
·多道程序技術
·進程、線程、任務的概念
·任務的實現（任務的層次結構、任務控制塊、任務的狀態及狀態轉換、任務隊列）
·任務調度（調度演算法的性能指標、可搶占調度、不可搶占調度、先來先服務、短作業優先演算法、時間片輪轉演算法、優先順序演算法）
·實時系統及任務調度（RMS、EDF演算法）
·任務間通信（共享內存、消息、管道、信號）
·同步與互斥（競爭條件、臨界區、互斥、信號量、死鎖）
3.2.3存儲管理
· Flat存儲管理方式
·分區存儲管理（固定分區、可變分區）
·地址重定位（邏輯地址、物理地址、地址映射）
·頁式存儲管理
·虛擬存儲技術（程序局部性原理、虛擬頁式存儲管理、頁面置換演算法、工作集模型）
3.2.4設備管理
·設備無關性、I/O地址、I/O控制、中斷處理、緩沖技術、假離線技術）
3.2.5文件系統基礎知識
·文件和目錄
·文件的結構和組織
·存取方法、存取控制
·常見嵌入式文件系統（FAT、JFFS、YAFFS）
3.2.6操作系統移植基礎知識
3.3嵌入式系統程序設計
3.3.1嵌入式軟體開發基礎知識
3.3.2嵌入式程序設計語言
·匯編、編譯、解釋系統的基礎知識和基本工作原理
·匯編語言
·基於過程的語言（過程/函數、參數傳遞、全局變數、遞歸、動態內存分配、數據類型）
·面向對象的語言（對象、數據抽象、繼承、多態、自動內存管理）
·各類程序設計語言的主要特點和適用情況
3.3.3嵌入式軟體開發環境
·宿主機、目標機
·編輯器、編譯器、鏈接器、調試器、模擬器
·常用嵌入式開發工具（編程器、硬體模擬器、邏輯分析儀、示波器）
·集成開發環境
·開發輔助工具
3.3.4嵌入式軟體開發
·軟體設計（模塊結構設計、數據結構設計、內存布局、面向對象的分析與設計）
·嵌入式引導程序的設計、設備驅動程序設計、內核設計、網路程序設計、應用軟體設計）
·編碼（編程規范、代碼審查）
·測試（測試環境、測試用例、測試方法、測試工具）
·下載和運行
3.3.5嵌入式應用軟體移植
4.嵌入式系統的開發與維護知識
4.1系統開發過程及其項目管理
·系統開發生命周期各階段的目標和任務的劃分方法
·系統開發項目掛你基礎知識及其常用管理工具使用方法
·主要的系統開發方法
·系統開發工具與環境知識
4.2系統分析基礎知識
·系統分析的目的和任務
·系統分析方法
·系統規格說明書的編寫方法
4.3系統設計知識
·傳統系統設計方法
·軟硬體協同設計方法
4.4系統實施知識
·系統架構設計
·系統詳細設計
·系統調試技術
·系統測試
4.5系統維護知識
·系統運行管理知識
·系統維護知識
·系統評價知識
5.安全性知識
·安全性基本概念
·加密與解密機制
6.標准化知識
·標准化的概念
·國際標准、標准、行業標准、企業標准基本知識
·代碼標准、文件格式標准、安全標准、軟體開發規范和文檔標准知識
·標准化機構
·嵌入式系統相關標准
7.信息化基礎知識
·信息化和信息系統基本概念
·有關的法律、法規
8.嵌入式技術發展趨勢
9.計算機專業英語
·正確閱讀和理解相關領域的英文資料
考試科目2：嵌入式系統設計應用技術
1.嵌入式系統開發過程
1.1系統需求分析方法與步驟
1.2系統設計
·系統硬體配置
·系統功能組成分配
·軟硬體功能的分配
·可行性驗證及設計審查
·系統規格
·周期，成本及工作量估計
·開發計劃
1.3軟硬體協同設計
1.4硬體設計
1.5軟體設計
·軟體結構
·設計評審
·軟體詳細設計
1.6系統測試
·測試環境
·測試計劃（內容、方法、標准、過程、檢驗）
·硬體測試
·軟體測試（單元測試、集成測試）
·軟硬體聯合測試
·實施測試
1.7系統評估
1.8軟體維護
2.嵌入式系統硬體設計
2.1嵌入式系統硬體基本結構
2.1.1嵌入式微處理結構與應用
2.1.2異常及中斷處理技術
2.1.3 DMA技術
2.1.4多處理系統
·多處理器系統特點
·多處理器系統構建技術
2.1.5匯流排架構
·應用系統中的匯流排配置
2.1.6內存種類及架構
·存儲器系統介面設計
2.1.7數字電路和邏輯電路
·專用集成電路
·可編程邏輯控制器件
2.2輸入/輸出介面設計
2.2.1輸入/輸出介面
·介面信號電平轉換
·介面驅動電路設計
2.2.2輸入/輸出介面應用技術
·外圍設備
·串口通信
·並口通信
·模擬介面
·通信介面設備
·通信標准和協議
·數據傳輸方式
2.3外圍設備介面應用技術
2.3.1外圍存儲設備
·存儲卡，記憶棒，IC卡，MMC卡，SD卡
· DVD、CD-R、CD-RW
2.3.2外圍輸入/輸出設備
·鍵盤，滑鼠，觸摸屏
·液晶板、LED、7段數碼管、蜂鳴器
2.3.3電源設計技術
2.4可靠性與安全性設計技術
2.4.1錯誤檢測與隔離技術
2.4.2冗餘設計
2.4.3系統恢復設計
2.4.4診斷技術
2.4.5常用安全標准
2.4.6抗干擾設計
2.4.7電磁兼容設計
2.4.8系統加密
3.嵌入式系統軟體設計
3.1嵌入式系統軟體結構設計
3.2嵌入式操作系統應用技術
3.2.1時間管理
·系統時間
·時鍾中斷
3.2.2內存管理
·靜態內存管理
·動態內存管理
3.2.3任務管理和任務間的通信
·任務間的通信機制
·信號量
·郵箱
·消息隊列
3.2.4異常處理
·異常處理方法
·中斷優先順序處理方法
·系統調用
3.2.5嵌入式文件系統應用技術
3.2.6嵌入式系統圖形用戶介面（GUI）應用技術
3.2.7嵌入式系統資料庫應用技術
3.3嵌入式軟體設計技術
3.3.1匯編語言設計
·數據類型
·匯編語言程序結構
·匯編語言程序設計及優化
·子程序調用
3.3.2嵌入式C語言設計
· ANSI-C的數據類型
· C程序結構
· C語言程序設計及優化
·程序的編譯與鏈接
3.3.3面向對象程序設計與開發
·面向對象的分析與設計方法UML
·面向對象的編程語言
·使用C++進行嵌入式系統開發
·使用Java進行嵌入式系統開發
3.4系統級軟體設計技術
·嵌入式系統固件與系統初始化設計
·設備驅動程序設計
·硬體抽象層、板級支持包設計
·嵌入式軟體的移植技術
4.嵌入式系統開發技術
4.1系統開發環境
4.1.1開發工具
·文本編輯器
·匯編、編譯和連接程序
· ICE和ICE監控器
·配置管理工具
·逆工程工具
4.1.2平台
·操作系統
·分布式開發環境
4.1.3開發環境創建方法及評估
·開發工作分析
·開發環境的建立
·維護、管理、使用開發環境的方法
·開發環境的平測
4.2實時系統的分析技術
4.2.1實時系統的分析技術
·結構化分析方法
·面向對象分析方法
4.2.2實時系統的設計技術
·結構化分析方法
·面向對象分析方法
4.3硬體設計環境
4.3.1硬體描述語言
·硬體開發設計過程
·硬體描述語言的種類與特點
4.3.2模擬技術
·邏輯模擬方法
·邏輯模擬工具
4.3.3大規模集成電路系統的開發方法
· ASIC開發方法
· FPGA設計方法
· IP（intellectual property）
4.4協同設計
·軟硬體任務工和切調
·設計平審
4.5嵌入式系統低功耗設計技術
·低功耗系統工作機制
·低功耗系統模型結構
·低功耗的硬體設計技術
·低功耗的軟體設計技術
4.6分布式嵌入系統設計
·分布式系統設計原理
·分布式系統的通信技術
·分布式系統設計應用
5.嵌入式系統應用
5.1嵌入式系統在控制領域中的應用
5.2嵌入式系統在手持設備中的應用
5.3嵌入式系統在模式識別中的應用

溫馨提示：因考試政策、內容不斷變化與調整，獵考網提供的以上信息僅供參考，如有異議，請考生以權威部門公布的內容為准！
下方免費復習資料內容介紹：2018下半年軟體設計師真題PDF
格式：ZIP大小：1151.75KB 2022下半年信息系統項目管理師知識點口訣
格式：DO大小：55.11KB
資格考試有疑問、不知道如何總結考點內容、不清楚報考考試當地政策，點擊底部咨詢獵考網，免費領取復習資料

⑵ 操作系統中關於時間片輪轉調度演算法！大家幫解答下！

時間片第一級1s，第二級2s，第三級4s...優先順序第一級>第二級>第三級...首先A進入第一級執行1s，進入第二級，由於此時B還沒有到達，所以A在第二級執行2s，完成，此時是第3s。B第2s已進入第一級，此時回到第一級B執行1s進入第二級，4s的時候c進入第一級，C執行1s進入第二級排在B的後面。此時候為5S，D沒有到達，第一級沒有進程，所以第二級B執行2S，進入第三級，此時為7S，D已進入第一級，D執行一S，轉入第二級排在C後面，8S，E進入第一級，執行一S，進入第二級，排在D後面。第一級沒有進程，第二級的C執行2S，進入第三級，D執行2s進入第三級，E執行1S完成，此時是14S。第二級沒有進程，由第三級的D開始，執行3S完成，此時是17S，C執行1S完成，此時是18S，D執行2S完成，此時是20S。所以答案是，3，17，18，20，14

⑶ 時間片輪轉調度演算法的演算法

多級反饋隊列調度演算法
(1) 設置多個就緒隊列,並為各個隊列賦予不同的優先順序. 第一個隊列的優先順序最高,第二個隊列次之,其餘各隊列的優先權逐個降低.
該演算法賦予各個隊列中進程執行時間片的大小也各不相同:
在優先權愈高的隊列中,為每個進程所規定的執行時間片就愈小.
例如:第二個隊列的時間片要比第一個隊列的時間片長一倍,……,第i+1個隊列的時間片要比第i個隊列的時間片長一倍.
(2) 當一個新進程進入內存後,首先將它放入第一隊列的末尾,按FCFS原則排隊等待調度.當輪到該進程執行時,如它能在該時間片內完成,便可准備撤離系統;如果它在一個時間片結束時尚未完成,調度程序便將該進程轉入第二隊列的末尾,再同樣地按FCFS原則等待調度執行;如果它在第二隊列中運行一個時間片後仍未完成,再依次將它放入第三隊列,……,如此下去,當一個長作業(進程)從第一隊列依次降到第n隊列後,在第n隊列中便採取按時間片輪轉的方式運行.
(3) 僅當第一隊列空閑時,調度程序才調度第二隊列中的進程運行; 僅當第1~(i-1) 隊列均空時,才會調度第i隊列中的進程運行.如果處理機正在第i隊列中為某進程服務時,又有新進程進入優先權較高的隊列(第1~(i-1)中的任何一個隊列),則此時新進程將搶占正在運行進程的處理機,即由調度程序把正在運行的進程放回到第i隊列的末尾,把處理機分配給新到的高優先權進程.?
性能
(1)終端型作業用戶
(2) 短批處理作業用戶
(3) 長批處理作業用戶
滿足了多數用戶的需求 優先權調度演算法
1,優先權調度演算法的類型
非搶占式優先權演算法
在這種方式下,系統一旦把處理機分配給就緒隊列中優先權最高的進程後,該進程便一直執行下去,直至完成; 或因發生某事件使該進程放棄處理機時,系統方可再將處理機重新分配給另一優先權最高的進程.這種調度演算法主要用於批處理系統中;也可用於某些對實時性要求不嚴的實時系統中.
搶占式優先權調度演算法
系統同樣把處理機分配給優先權最高的進程,使之執行.但在其執行期間,只要又出現了另一個其優先權更高的進程,進程調度程序就立即停止當前進程(原優先權最高的進程)的執行,重新將處理機分配給新到的優先權最高的進程.
這種搶占式的優先權調度演算法,能更好地滿足緊迫作業的要求,常用於要求比較嚴格的實時系統中, 以及對性能要求較高的批處理和分時系統中.
2,優先權的類型
(1) 靜態優先權
靜態優先權是在創建進程時確定的,且在進程的整個運行期間保持不變.
一般地,優先權是利用某一范圍內的一個整數來表示的,例如,0~7或0~255中的某一整數, 又把該整數稱為優先數.只是具體用法各異:有的系統用0表示最高優先權,當數值愈大時,其優先權愈低;而有的系統恰恰相反.
確定進程優先權的依據有如下三個方面:
1.進程類型.(系統進程/用戶進程)
2.進程對資源的需求.(需求量的大小)
3.用戶要求.(用戶進程緊迫程度)
(2) 動態優先權
動態優先權是指在創建進程時所賦予的優先權,可以隨進程的推進或隨其等待時間的增加而改變的,以便獲得更好的調度性能.
例如,我們可以規定,在就緒隊列中的進程,隨其等待時間的增長,其優先權以速率a提高.若所有的進程都具有相同的優先權初值,則顯然是最先進入就緒隊列的進程,將因其動態優先權變得最高而優先獲得處理機,此即FCFS演算法.
優先權的變化規律可描述為:
由於等待時間與服務時間之和,就是系統對該作業的響應時間,故該優先權又相當於響應比RP.據此,又可表示為:
3,高響應比優先調度演算法
由上面的式子可以得到以下結論:
(1) 如果作業的等待時間相同,則要求服務的時間愈短,其優先權愈高,因而該演算法有利於短作業.
(2) 當要求服務的時間相同時,作業的優先權決定於其等待時間,等待時間愈長,其優先權愈高,因而它實現的是先來先服務.
(3) 對於長作業,作業的優先順序可以隨等待時間的增加而提高,當其等待時間足夠長時,其優先順序便可升到很高, 從而也可獲得處理機.
該演算法照顧了短作業,且不會使長作業長期得不到服務 1. 非搶占式調度演算法
為每一個被控對象建立一個實時任務並將它們排列成一輪轉隊列,調度程序每次選擇隊列中的第一個任務投入運行.該任務完成後便把它掛在輪轉隊列的隊尾等待下次調度運行.
2. 非搶占式優先調度演算法.
實時任務到達時,把他們安排在就緒隊列的對首,等待當前任務自我終止或運行完成後才能被調度執行.
3. 搶占式調度演算法
1）基於時鍾中斷的搶占式優先權調度演算法.
實時任務到達後,如果該任務的優先順序別高於當前任務的優先順序並不立即搶占當前任務的處理機,而是等到時鍾中斷到來時,調度程序才剝奪當前任務的執行,將處理機分配給新到的高優先權任務.
2）立即搶占的優先權調度演算法.
在這種調度策略中,要求操作系統具有快速響應外部時間中斷的能力.一旦出現外部中斷,只要當前任務未處於臨界區便立即剝奪當前任務的執行,把處理機分配給請求中斷的緊迫任務，實時進程調度，實時進程搶占當前。 1 實現實時調度的基本條件
1-1. 提供必要的信息-就緒時間.
1-2. 開始截止時間和完成截止時間.
1-3. 處理時間.
1-4. 資源要求.
1-5. 優先順序.
2. 系統處理能力強
在實時系統中,通常都有著多個實時任務.若處理機的處理能力不夠強,則有可能因處理機忙不過來而使某些實時任務不能得到及時處理, 從而導致發生難以預料的後果.假定系統中有m個周期性的硬實時任務,它們的處理時間可表示為Ci,周期時間表示為Pi,則在單處理機情況下,系統可調度必須滿足下面的限制條件:
當系統不可調度時解決的方法是提高系統的處理能力,其途徑有二:
其一仍是採用單處理機系統,但須增強其處理能力, 以顯著地減少對每一個任務的處理時間;
其二是採用多處理機系統.假定系統中的處理機數為N,則應將上述的限制條件改為:
3. 採用搶占式調度機制
當一個優先權更高的任務到達時,允許將當前任務暫時掛起,而令高優先權任務立即投入運行.採用這種方式去滿足那些開始截止時間即將到來的任務.?
4. 具有快速切換機制
應具有的能力:
(1) 對外部中斷的快速響應能力.為使在緊迫的外部事件請求中斷時系統能及時響應,要求系統具有快速硬體中斷機構,還應使禁止中斷的時間間隔盡量短,以免耽誤時機(其它緊迫任務).?
(2) 快速的任務分派能力.在完成任務調度後,便應進行任務切換.為了提高分派程序進行任務切換時的速度, 應使系統中的每個運行功能單位適當的小,以減少任務切換的時間開銷.實時調度實例
一, 最早截止時間優先演算法(EDF)
EDF演算法用於非搶占調度方式
優先順序:根據任務的開始截止時間來確定任務的優先順序.
二,最低鬆弛優先演算法(LLF)
例如:系統中有兩個周期性實時任務A和B,任務A要求每20ms執行一次,執行時間為10ms;任務B要求每50ms執行一次,執行時間為25ms.這樣可知A和B每次必須完成的時間和開始截止時間如圖所示
優先順序:根據任務緊急程度來確定任務優先順序
A和B任務每次必須完成的時間
A1 (10) A2 (30) A3(50) A4 (70) A5(90) A6 (110) A7(130) A8(150)
0 、10、 20、 30 、40、 50 、60、 70、 80 、90 、100 、110、 120、130、 140、 150
B1(25) B2(75) B3(125)
A和B任務每次必須開始的時間
時間(ms) A截止時間 B截止時間 調度對象
0 A1(10) B1(25) A1
10 A2(20) B1(15) B1
30 A2(0) B1(15) A2
40 A3(10) B1(5) B1
45 A3(5) B2(30) A3
55 A4(15) B2(20) B2
70 A4(0) B2(20) A4
鬆弛度
鬆弛度
( 20-10-0 ) ( 50-25-0 )
(40-10-10 ) ( 50-25-10 )
(40-10-30) (50-5-30)
(60-10-40) (50-5-40)
(60-10-45) (100-25-45)
(80-10-55) (100-25-55)
(80-10-70) (100-10-70 )
3.4.1 多處理器系統的類型
(1) 緊密耦合(Tightly Coupted)MPS.
這通常是通過高速匯流排或高速交叉開關,來實現多個處理器之間的互連的.它們共享主存儲器系統和I/O設備,並要求將主存儲器劃分為若干個能獨立訪問的存儲器模塊,以便多個處理機能同時對主存進行訪問.系統中的所有資源和進程,都由操作系統實施統一的控制和管理.
3.4 多處理機系統中的調度
從處理器之間耦合的緊密程度上劃分:
鬆散耦合(Loosely Coupled)MPS.
在鬆散耦合MPS中,通常是通過通道或通信線路,來實現多台計算機之間的互連.每台計算機都有自己的存儲器和I/O設備,並配置了OS來管理本地資源和在本地運行的進程.因此,每一台計算機都能獨立地工作, 必要時可通過通信線路與其它計算機交換信息,以及協調它們之間的工作.
根據系統中所用處理器的相同與否劃分:
(1) 對稱多處理器系統SMPS. 在系統中所包含的各處理器單元,在功能和結構上都是相同的,當前的絕大多數MPS都屬於SMP系統.例如,IBM公司的SR/6000 Model F50, 便是利用4片Power PC處理器構成的.?
(2) 非對稱多處理器系統.在系統中有多種類型的處理單元,它們的功能和結構各不相同,其中只有一個主處理器,有多個從處理器：
1. 對稱多處理器系統中的進程分配方式
在SMP系統中,所有的處理器都是相同的,因而可把所有的處理器作為一個處理器池(Processor pool),由調度程序或基於處理器的請求,將任何一個進程分配給池中的任何一個處理器去處理.在進行進程分配時,可採用以下兩種方式之一.
1) 靜態分配(Static Assigenment)方式
2) 動態分配(Dynamic Assgement)方式?
3.4.2 進程分配方式
靜態分配(Static Assigenment)方式
一個進程從開始執行直到完成,都被固定分配到一個處理器上去執行.
2) 動態分配(Dynamic Assgement)方式
系統中設置有公共的就緒隊列.分配進程時,可以將進程分配到任何一個處理器上.
動態分配方式的主要優點是消除了各處理器忙閑不均的現象
2. 非對稱MPS中的進程分配方式?
對於非對稱MPS,其OS大多採用主—從(Master-Slave)式OS,即OS的核心部分駐留在一台主機上(Master),而從機(Slave)上只是用戶程序,進程調度只由主機執行.每當從機空閑時,便向主機發送一索求進程的信號,然後,便等待主機為它分配進程.在主機中保持有一個就緒隊列,只要就緒隊列不空,主機便從其隊首摘下一進程分配給請求的從機.從機接收到分配的進程後便運行該進程,該進程結束後從機又向主機發出請求.
缺點:對主機要求高,出現故障導致整個系統癱瘓
1. 自調度(Self-Scheling)方式
1) 自調度機制?
在系統中設置有一個公共的進程或線程就緒隊列, 所有的處理器在空閑時,都可自己到該隊列中取得一進程(或線程)來運行.在自調度方式中,可採用在單處理機環境下所用的調度演算法,如先來先服務(FCFS)調度演算法,最高優先權優先(FPF)調度演算法和搶占式最高優先權優先調度演算法等.
3.4.3 進程(線程)調度方式
2) 自調度方式的優點?
1,系統中的公共就緒隊列可按照單處理機系統中所採用的各種方式加以組織;其調度演算法也可沿用單處理機系統所用的演算法,即很容易將單處理機環境下的調度機制移植到多處理機系統中
2,只要系統中有任務(公共就緒隊列不空)就不會出現處理機空閑的情況,也不會發生處理器忙閑不均的現象,因而有利於提高處理器的利用率.
3)自調度方式的缺點
3.4.4進程調度過程
1、進程名：作為進程的標識。
指針：進程按順序排成循環鏈表，用指針指出下一個進程的進程式控制制塊首地址，最後一個進程中的指針指出第一個進程的進程式控制制塊首地址。
2、要求運行時間：假設進程需要運行的單位時間數。
已運行時間：假設進程已經運行的單位時間數，初值為0。
狀態：可假設有兩種狀態，就緒狀態和結束狀態。進程的初始狀態都為就緒狀態。
3、每次運行所設計的處理器調度程序調度進程之前，為每個進程任意確定它的要求運行時間。
4、此程序是模擬處理器調度，因此，被選中的進程並不實際啟動運行，而是執行
已運行時間+1
來模擬進程的一次運行，表示進程已經運行過一個單位時間。
.5、在所設計的程序中應有顯示或列印語句，能顯示或列印每次被選中的進程名以及運行一次後進程隊列的變化。
6、為進程任意確定要求運行時間，運行所設計的處理器調度程序，顯示或列印逐次被選中進程的進程名以及進程式控制制塊的動態變化過程。
7、設有一個就緒隊列，就緒進程按優先數（優先數范圍0－100）由小到大排列（優先數越小，級別越高）。當某一進程運行完一個時間片後，其優先順序應下調（如優先數加2或3）。
8、例如一組進程如下表： 進程名 A B C D E F G H J K L M 到達時間 0 1 2 3 6 8 12 12 12 18 25 25 服務時間 6 4 10 5 1 2 5 10 4 3 15 8

⑷ 模擬短作業優先演算法、時間片輪轉演算法（RR）和優先數演算法的執行情況

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#define LENsizeof(struct job)

struct job
{
char name[2];
int cometime;
int runtime;
int priority;
int finishtime;
int state;
struct job *next;
};

void readtxt();
void SJF();
void (structjob *,struct job *);
void RR(int);
void FPF();
void print1(structjob *);
void print2(structjob *);

int n=0;
struct job*head=NULL;
struct job*end=NULL;
FILE*fp=NULL;

void main()
{
if((fp=fopen("JOB1.txt","rb"))==NULL){
printf("can not find file\n");
exit(0);
}
while(!feof(fp)){
readtxt();
}
fclose(fp);

int x,y;
printf("請選擇進程調度演算法：\n");
printf("1.短作業優先演算法 2.時間片輪轉演算法 3.優先數演算法\n");
printf("選擇序號：");
scanf("%d",&x);
if((x!=1)&&(x!=2)&&(x!=3))printf("序號不存在！\n");
else{
switch(x){
case 1: SJF(); break;
case 2: {
printf("輸入時間片：");
scanf("%d",&y);
RR(y);
break;
}
case 3: FPF(); break;
}
}
}

void readtxt(){
struct job *p1;
p1=(struct job *)malloc(LEN);
fscanf(fp,"%s %d %d%d",(*p1).name,&((*p1).cometime),&((*p1).runtime),&((*p1).priority));
(*p1).state=0;
(*p1).finishtime=0;
if(n==0){
head=p1;
end=p1;
(*end).next=NULL;
n++;
}
else{
(*end).next=p1;
end=p1;
(*end).next=NULL;
n++;
}
}

void SJF(){
struct job *shead,*send,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).runtime<(*p1).runtime)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
shead=p;
send=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).runtime<(*p1).runtime)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*send).next=p;
send=p;
}
(*send).next=NULL;
printf("%s\n","短作業優先演算法執行結果：");
printf("%s\n","進程執行順序 周轉時間");
print1(shead);
}

void RR(intpertime){
structjob *rhead,*rend,*rrhead,*rrend,*p1,*p2,*p;
int i,curtime=0,m=0,temp1=0,temp2;
while(m!=n){
p1=head;
temp2=temp1;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).runtime!=0)&&((*p1).state!=1)){temp1++;break;}
else p1=(*p1).next;
}
if(p1!=NULL){
p2=(*p1).next;
for(i=i+1;i<n;i++){
if((((*p2).cometime<(*p1).cometime)&&((*p2).runtime!=0)&&((*p2).state!=1))||
(((*p2).cometime==(*p1).cometime)&&((*p2).priority<(*p1).priority)&&((*p2).runtime!=0)&&((*p2).state!=1)))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
}

if(temp2!=temp1){
(*p1).state=1;
p=(struct job *)malloc(LEN);
(p,p1);
if(temp1==1) {rhead=p;rend=p;}
else{
(*rend).next=p;
rend=(*rend).next;
}
}
else{
if((temp1==1)&&(m==0)){
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
}
p=(struct job *)malloc(LEN);
(p,rhead);
rrhead=p;
rrend=p;
}
else{
if(strcmp((*rhead).name,(*rrend).name)==0){
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}

}
else{
curtime+=pertime;
(*rhead).runtime-=pertime;
if((*rhead).runtime<=0){
curtime+=(*rhead).runtime;
(*rhead).runtime=0;
(*rhead).finishtime=curtime;
m++;
temp1--;
p=(struct job *)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
rhead=(*rhead).next;
}
else{
p=(struct job*)malloc(LEN);
(p,rhead);
(*rrend).next=p;
rrend=(*rrend).next;
(*rend).next=rhead;
rend=rhead;
rhead=(*rhead).next;
(*rend).next=NULL;
}
}
}
}
}
(*rrend).next=NULL;
printf("%s%d%s\n","時間片輪轉演算法執行結果(時間片",pertime,")：");
print2(rrhead);
}

void FPF(){
structjob *fhead,*fend,*p1,*p2,*p;
int i,j,curtime;
p1=head;
for(i=0;i<n;i++){
if((*p1).cometime==0) break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime==0)&&((*p2).priority<(*p1).priority)){p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
fhead=p;
fend=p;
for(j=0;j<n-1;j++){
p1=head;
for(i=0;i<n;i++){
if(((*p1).cometime<=curtime)&&((*p1).state!=1))break;
else p1=(*p1).next;
}
p2=(*p1).next;
for(i=i+1;i<n;i++){
if(((*p2).cometime<=curtime)&&((*p2).priority<(*p1).priority)&&((*p2).state!=1))
{p1=p2;p2=(*p2).next;}
else p2=(*p2).next;
}
(*p1).state=1;
curtime=(*p1).runtime+curtime;
(*p1).finishtime=curtime;
p=(struct job *)malloc(LEN);
(p,p1);
(*fend).next=p;
fend=p;
}
(*fend).next=NULL;
printf("%s\n","最高優先權優先演算法執行結果(非搶占方式)：");
printf("%s\n","進程執行順序 周轉時間");
print1(fhead);
}

void (structjob *p,struct job *p1){
strcpy((*p).name,(*p1).name);
(*p).cometime=(*p1).cometime;
(*p).runtime=(*p1).runtime;
(*p).priority=(*p1).priority;
(*p).finishtime=(*p1).finishtime;
(*p).state=(*p1).state;
}

void print1(structjob *p){
while(p!=NULL){
printf("%-14s%d\n",(*p).name,(*p).finishtime-(*p).cometime);
p=(*p).next;
}
}

void print2(structjob *p){
struct job *head;
head=p;
printf("%s\n","進程執行順序");
while(head!=NULL){
printf("%3s",(*head).name);
head=(*head).next;
}
printf("\n%s\n","進程周轉時間");
head=p;
while(head!=NULL){
if(((*head).finishtime-(*head).cometime)>0)
printf("%-4s%d\n",(*head).name,(*head).finishtime-(*head).cometime);
head=(*head).next;
}
}

網上找的，自己看著辦

⑸ 操作系統中的 名詞解釋：時間片輪轉法

好不容易才找到答案：
時間片輪轉法主要是分時系統中使用的一種調度演算法。時間片輪轉法的基本思想是，將CPU 的處理
時間劃分成一個個時間片，就緒隊列中的諸進程輪流運行一個時間片。當時間片結束時，就強迫運行進程讓出CPU，該進程進入就緒隊列，等待下一次調度。同時，進程調度又去選擇就緒隊列中的一個進程，分配給它一個時間片，以投入運行。在輪轉法中，時間片長度的選擇非常重要，將直接影響系統開銷和響應時間。如果時間片長度很小，則調度程序剝奪處理機的次數頻繁，加重系統開銷；反之，如果時間片長度選擇過長，比方說一個時間片就能保證就緒隊列中所有進程都執行完畢，則輪轉法就退化成先進先出演算法
影響時間片大小設置的主要因素有：系統響應時間、就緒進程數目（終端數目）
和計算機處理能力。

⑹ 時間片的輪轉調度

時間片輪轉調度是一種最古老，最簡單，最公平且使用最廣的演算法。每個進程被分配一個時間段，稱作它的時間片，即該進程允許運行的時間。如果在時間片結束時進程還在運行，則CPU將被剝奪並分配給另一個進程。如果進程在時間片結束前阻塞或結束，則CPU當即進行切換。調度程序所要做的就是維護一張就緒進程列表，當進程用完它的時間片後，它被移到隊列的末尾。
時間片輪轉調度中唯一有趣的一點是時間片的長度。從一個進程切換到另一個進程是需要一定時間的--保存和裝入寄存器值及內存映像，更新各種表格和隊列等。假如進程切換(process switch) - 有時稱為上下文切換(context switch)，需要5毫秒，再假設時間片設為20毫秒，則在做完20毫秒有用的工作之後，CPU將花費5毫秒來進行進程切換。CPU時間的20%被浪費在了管理開銷上。
為了提高CPU效率，我們可以將時間片設為500毫秒。這時浪費的時間只有1%。但考慮在一個分時系統中，如果有十個交互用戶幾乎同時按下回車鍵，將發生什麼情況？假設所有其他進程都用足它們的時間片的話，最後一個不幸的進程不得不等待0.5秒鍾才獲得運行機會。多數用戶無法忍受一條簡短命令要0.5秒鍾才能做出響應。同樣的問題在一台支持多道程序的個人計算機上也會發生。
通常狀況下，一個系統中所有的進程被分配到的時間片長短並不是相等的，盡管初始時間片基本相等（在Linux系統中，初始時間片也不相等，而是各自父進程的一半），系統通過測量進程處於「睡眠」和「正在運行」狀態的時間長短來計算每個進程的交互性，交互性和每個進程預設的靜態優先順序（Nice值）的疊加即是動態優先順序，動態優先順序按比例縮放就是要分配給那個進程時間片的長短。一般地，為了獲得較快的響應速度，交互性強的進程（即趨向於IO消耗型）被分配到的時間片要長於交互性弱的（趨向於處理器消耗型）進程。
結論可以歸結如下：時間片設得太短會導致過多的進程切換，降低了CPU效率；而設得太長又可能引起對短的交互請求的響應變差。將時間片設為100毫秒通常是一個比較合理的折衷。

⑺ 操作系統的時間片輪轉法具體的演算法

四、演算法實現
1）系統初始化時給每一個進程賦以一個needtime，並將所有進程按needtime從小到大的次序排成一個隊列。
2） 取隊頭進程,並投入運行。
3） 採用相對固定時間片（Time_piece），進程每執行一次，進程佔用的CPU時間加Time_piece。
4） 若進程沒有運行完，進程needtime減Time，並排到就緒隊列的尾部。
5） 如果尚有進程在隊列中,那麼轉入2）
PCB結構：N 進程個數
name 進程名
Time_piece 進程優先數/進程輪轉時間片
Cpu_time 進程佔用的CPU時間
Need_time 進程到完成還要的時間
Count 計數器
State 進程狀態(P,W,F)
Arrive_time到達時間
next 鏈指針
run 當前運行進程指針
start 就緒隊列頭指針
end 就緒隊列尾指針
finish 完成隊列頭指針
void insert(PCB *p) //時間片插入函數
void create() //時間片演算法創建進程函數
void roundrobin() //時間片演算法函數
void firstin() //運行就緒隊列的第一個進程

你可以到這個地址下載文章看一下。
'http://wenku..com/view/f3bca1d333d4b14e85246830.html'