⑴ 求一份答案。。。。不知道是什麼分類的。
15分要我回答那麼多？這些題目3個小時內完成不了的
簡單說下吧，這題目比較復雜，涉及到匯編 C 數字邏輯等等方面
1、C D都錯了，DB位元組型數據H為8位由0~F組成，G在裡面錯且28位超過16位了
G在裡面錯
錯誤答案只有一個吧？語法錯誤不知道指的什麼，應該是C吧
2、答案B，SCAS是掃描指令，將累加器AL（或AX）的內容與目的串（指針為ES:DI）中的位元組（或字）進行比較，存儲單元(DS:SI)可以自動增加或減少
其餘的有高人指點最好，這題目是在太復雜了，沒有的話分給我吧
⑵ 華為平板開不了機，充著電，顯示著一個紅閃電
請觀察您的平板故障現象，按照以下對應的方法進行排查：
1、開機時平板黑屏，但是有鈴聲或振動
可能是屏幕問題，請提前備份好數據（QQ，微信等第三方應用需單獨備份）並攜帶相關購機憑證到附近的華為客戶服務中心檢修。
2、開機時平板黑屏，無響應，或閃紅燈，或亮屏後又立即關機
（1）可能是電量已耗盡，建議您使用標配充電器持續充電30分鍾以上，然後再嘗試開機。
（2）建議您長按電源鍵15秒以上，嘗試強制重啟平板。
（3）如果以上方法未能解決您的問題，請您提前備份好數據（QQ，微信等第三方應用需單獨備份）並攜帶相關購機憑證到附近的華為客戶服務中心檢修。
3、開機進入Harmony OS界面、EMUI界面、FASTBOOT界面
（1）可能是無意按到了開機鍵+音量鍵的組合鍵進入了特殊模式，建議您長按電源鍵15秒以上，嘗試強制重啟平板，即可正常進入手機桌面。
（2）為避免您後續再次出現此情況，建議您檢查按鍵是否容易卡住，或者佩戴的保護殼擠壓到了按鍵。
（3）如果以上方法未能解決您的問題，請您提前備份好數據（QQ，微信等第三方應用需單獨備份）並攜帶相關購機憑證到附近的華為客戶服務中心檢修。
⑶ 在vxworks中，period命的具體用法是怎樣的
嵌入式實時操作系統VxWorks入門嵌入式 Linux 系統是標准 Linux 在嵌入式領域的延伸，其特點和功能與標准 Linux 幾乎完全相同。 Linux 系統的穩定性和健壯性已經在真實世界中得到了證明，在工業控制領域也有許多非常成功的應用。但是，在針對一些有較強實時性要求的特定工業應用中， Linux 系統仍然暴露 出 了許多技術缺陷。其主要原因是因為 Linux 系統起初是為 PC 開發的，在功能和性能選擇上更多的兼顧了 PC 應用的特點，追求系統的功能完備性和整體性能最優。這一點在 Linux 系統的調度策略上表現的尤為明顯，如任務之間採用的是基於 分時技術 ( time-sharing ) 的調度策略，而且不支持內核態搶占式調度，這樣系統就無法保證緊急任務總是會被優先執行，且調度延遲不確定，是隨機可變的。
因此，有相當多機構和公司都在研究如何提高 Linux 實時性能，並取得了一些富有成效的成果。同時，開源社區也做著同樣的事情，那就是 Linux 2.6 版本的開發。開源社區採用的實時化思想是直接對 Linux 內核的調度機制和演算法進行修改和優化。 Linux 2.6 內核開發大約是從 2001 年開始，經過三年左右的開發，在 2004 年發布了穩定版本，經過了這幾年的測試與改進，已經在桌面 PC 和伺服器領域內得到了大量使用，在嵌入式系統上的應用也在不斷發展中。 Linux 2.6 版本中與實時性相關的改進主要體現在以下幾個方面。
⑴ 調度計算的分散性。 2.6 版本中採用了由 Ingo Molnar 實現的調度演算法，該演算法將進程優先順序的計算分散在多處進行，而不是集中在一個統一的調度函數中，這樣不僅提高了計算效率，還減小了 CPU 因集中調度計算所消耗的時間，並且使調度器的時間開銷是與系統負載無關，是 O(1) 恆定的。
⑵ 搶占式內核的支持。 2.6 版本中提供了對搶占式內核的支持，而 2.4 內核是不支持內核搶占的。支持搶占式調度是實時操作系統的標志之一，這也是早期 Linux 系統應用於實時應用時最為詬病的地方。
⑶ 系統同步機制的改進。 2.6 內核中則對系統中同步機制的使用進行了優化，大大減小了因同步機制引起的時間消耗。
⑷ 更細的時間粒度。在 2.6 內核中，定時器的頻率被定義為 1000Hz ，而 2.4 內核中為 100Hz 。
雖然， Linux 2.6 系統仍然不是嚴格實時系統，但它的實時性能得到了很大提高卻是個不爭的事實，有關文獻採用統計的方法對 Linux 2.6 和 2.4 內核中任務響應和中斷響應的進行了 310 萬次測試，然後對平均響應時間和最壞響應時間進行了對比，下圖 (a) 和 (b) 給出了時間比較結果。從結果可以看出 2.6 內核的實時響應能力要遠高於 2.4 內核，差距至少在十多倍以上。這一結果更增強了用戶將 2.6 內核應用到各種非嚴格實時應用中的信心。
⑷ 求一份烽火S4800基本配置
豐富的業務控制
S4800支持基於不同欄位劃分VLAN，並支持VLAN映射和基本QinQ，可基於埠、VLAN、流等不同關鍵欄位對包進行分類，實現更加靈活的業務分流和多業務承載。
S4800提供擴展的ACL功能，具備L2～L4包過濾能力，支持帶寬限速、優先順序調度和映射，以及靈活的隊列調度演算法，能夠通過多樣化的方法實現對業務的豐富的管理功能。
S4800支持豐富的組播協議，支持IGMP Snooping、IGMP Proxy、IGMP Fast Leave等。
完備的QoS策略
S4800每個埠支持高達8個優先順序隊列，支持DiffServ區分服務，能夠根據源MAC、目的MAC、源IP、目的IP及TCP/UDP埠等規則智能地區分不同的應用流，並支持基於埠、流、VLAN等的帶寬限制，支持SP、WRR、SP +WRR等模式的調度演算法及WRED丟棄演算法，滿足實時多媒體應用的需求，為視頻、語音等實時性業務的發展提供網路基礎。
可靠的網路質量
S4800支持STP/RSTP/MSTP生成樹協議， 支持R-Link、G.8032以太環網保護，構建環型、樹型等多種拓撲結構，並可實現以太環網的50毫秒級快速保護倒換，保證高可靠性的網路質量。
完善的安全機制
S4800提供多種安全保護功能，支持防ARP攻擊，可以防止因ARP欺騙攻擊將交換機ARP表項占滿，導致正常用戶無法上網。
同時，S4800支持IP Source Guard特性，防止包括MAC 欺騙、IP欺騙、MAC/IP欺騙在內的非法地址仿冒帶來的DoS攻擊。
S4800支持802.1X認證、RADIUS認證、用戶綁定（埠+源MAC+源IP地址訪問控制），可有效識別安全用戶，防範用戶的非法侵入和未經授權的訪問。
S4800支持基於埠的源MAC地址學習限制功能，有效防止用戶源MAC欺騙沖擊設備MAC表項，導致正常用戶無法學到MAC表而泛洪的問題等。
S4800還可以通過配置ACL來清除網路流量中的非法攻擊，最大程度的保護網路的安全性。
靈活的PoE特性
S4800-PE嚴格符合IEEE 802.3af 標准及IEEE 802.3at標准，支持30W大功率網路設備長距離供電，很好的滿足了用戶的大功率供電需求。
此外，S4800-PE支持自動功率調節、分時供電，滿足用戶靈活供電配置需求。設備高效散熱、靜音降噪，支持綠色節能。
高效的綠色節能
S4800電口設備採用無風扇設計，大幅降低設備功耗，實現設備運行無噪音，減少機械故障點，同時免除凝露腐蝕和塵土侵害。
S4800採用新一代高集成晶元節能電路設計，散熱均衡，支持空閑埠休眠，充分節省電源功耗。
S4800輻射低，達到家用電器標准，對人體無危害。
⑸ 高分急求！ 關於 粒子群解決車間調度的英文文獻 ！ ！先50 滿意再加50
基於動態雙種群粒子群
演算法的柔性工作車間調度
摘 要: 針對標准粒子群優化演算法存在易陷入局部最優點的缺點,提出了一種基於動態雙種群的粒子群
優化演算法(DPSO) ·DPSO 演算法將種群劃分成兩個種群規模隨進化過程不斷變化的子種群,兩個子種群分別采
用不同的學習策略進行進化,並在進化過程中相互交換信息·該演算法提高了全局尋優能力,有效地避免了早熟
收斂的發生·將以DPSO 演算法為基礎的排序演算法和啟發式分配演算法(HA) 相結合形成了解決柔性工作車間調
度問題的新方法(DPSO2HA) ·通過對算例的研究和與其他方法的比較表明,該方法是有效可行的·
A Dynamic Double2Population Particle Swarm Optimization
Algorithm for Flexible Job2Shop Scheling
L I Dan , GA O L i2qun , MA Jia , L I Yang
( School of Information Science & Engineering , Northeastern University , Shenyang 110004 , China.
Correspondent : L I Dan , E2mail : lidanneu @163. com)
Abstract : A dynamic double2population particle swarm optimization ( DPSO) algorithm is
presented to solve the problem that the standard PSO algorithm is easy to fall into a locally
optimized point , where the population is divided into two sub2populations varying with their own
evolutionary learning st rategies and the information exchange between them. The algorithm thus
improves it s solvability for global optimization to avoid effectively the precocious convergence.
Then , an ordering algorithm based on DPSO is integrated with the heuristic assignation ( HA)
algorithm to form a new algorithm DPSO2HA so as to solve the flexible job2shop scheling
problem (FJ SP) . The new algorithm is applied to a set of benchmark problems as instances , and
the simulation result s show the effectiveness and feasibility of DPSO2HA algorithm for the flexible
job2shop scheling.
Key words : double population ; PSO(particle swarm optimization) ; learning st rategy ; DPSO2HA
algorithm; flexible job2shop scheling
柔性工作車間調度問題( flexible job2shop
scheling problem , FJ SP) 是經典工作車間調度
問題的一個延伸,它允許工件被給定的有處理能
力的任何機器處理·柔性工作車間調度問題由於
減少了機器約束,擴大了可行解的搜索范圍,提高
了問題的復雜性,所以與傳統工作車間調度問題
相比更加接近實際生產環境的模擬·
相對於傳統工作車間調度,關於柔性工作車
間調度問題的文獻還比較少·目前所採用的方法
主要有分枝定界法[1 ] 、多項式演算法、分等級法和
傳統進化演算法( EA) [2 ]等,在近幾年中,很多研究
者使用禁忌搜索和遺傳演算法對FJ SP 進行求
解[3 - 4 ]
·
本文提出一個新的求解柔性工作車間調度問
題的方法———基於動態雙種群粒子群優化的分階
段方法·本方法的主要思想是:將柔性工作車間調
度問題分解成兩個有時間順序的子問題來考慮,
首先考慮工序排序子問題,在獲得可行的排序後
再考慮機器分配子問題·本文首先利用動態雙種
群粒子群優化演算法為工序進行排序,使其滿足約
束條件從而獲得一個可行解,然後利用文中所提
出的分配演算法為每道工序分配合適的機器,形成
可行的調度方案·本文所考慮的優化目標是最小
化最大完工時間(makespan) ·
1 柔性工作車間調度問題描述
柔性工作車間調度問題可描述為將n 個加工
順序不同的工件在m 台機器上加工完成·每個工
件使用同一台機器可以多於一次,每道工序的加工
過程不允許中斷·機器的集合用U 來表示,每個工
件J 包含nj 道工序,各工序之間的順序不允許改
變·Oij表示工件J 的第i 道工序,它可以在有處理
能力的任何一台機器上被加工·Ti , j , k表示工序Oij
用機器Mk 來加工所需要的時間, 可用集合T =
{ Ti , j , k| 1 ≤j ≤N ;1 ≤i ≤nj ;1 ≤k ≤M}表示, N 為
工件的數量, M 為機器的數量·例如表1 即是一個
實際的柔性工作車間調度加工時間表·
表1 柔性工作車間調度加工時間表
Table 1 Proce ssing schele for FJ SP
工件工序M1 M2 M3 M4
J1
O1 ,1 1 3 4 1
O2 ,1 3 8 2 1
O3 ,1 3 5 4 7
J2
O1 ,2 4 1 1 4
O2 ,2 2 3 9 3
O3 ,2 9 1 2 2
J3
O1 ,3 8 6 3 5
O2 ,3 4 5 8 1
在柔性工作車間調度問題中, 應滿足以下假
設:
(1) 所有的機器在時間t = 0 時都是可以使
用的,每個工件都可以在t = 0 時開始加工;
(2) 在給定的時間內, 一台機器只能加工一
道工序,直到加工完此工序後方可加工其他工序,
這就是所謂的資源約束;
(3) 對於每個工件的各道工序只能按照事先
給定的順序加工,這就是所謂的優先約束·
對於每一道工序Oi , j , 本文用ri , j來表示其
最早開始加工時間, 對不同的工序分別用下式進
行計算:
ri , j =
0 , 1 ≤ j ≤ N ;
ri - 1 , j +γi , j , 2 ≤ i ≤ nj ,1 ≤ j ≤ N ·
式中,γi , j = mink ( Ti , j , k) ,1 ≤i ≤nj ;1 ≤j ≤N·
對於FJ SP 來說一般存在兩個難題:第一個
是如何為每道工序選擇合適的機器;第二個是如
何計算每道工序的開始加工時間t i , j和結束加工
時間tf i , j·
本文所要研究的FJ SP 的優化目標是,在滿
足上述優先約束和資源約束的條件下尋找最優調
度方案,使全部工件的最大完工時間(Makespan)
最短·
2 排序演算法———動態雙種群粒子群
優化演算法
2. 1 標准粒子群優化演算法
粒子群優化(particle swarm optimization ,簡
稱PSO) 演算法是由Kennedy 和Eberhart 在1995
年提出·在PSO 系統中,每個潛在解被稱為一個
粒子,多個粒子共存、合作尋優,每個粒子根據它
自身的經驗在目標搜索空間中向更好的位置飛
行,搜索最優解·由文獻[ 5 ]可知,每個粒子根據如
下的公式來更新自己的速度和在解空間的位置·
v ( t +1)
id = w v ( t)
id + c1 r1 p ( t)
id - x ( t)
id +
c2 r2 p ( t)
gd - x ( t)
id , (1)
x ( t +1)
id = x ( t)
id + v ( t +1)
id · (2)
其中, d = 1 ,2 , ⋯, n , i = 1 ,2 , ⋯, m , m 為種群規
模; t 為當前進化代數; r1 和r2 為均勻分布於[0 ,
1]的隨機數; w 為慣性權重, 其值由下式來確
定[6 ] :
w = w max -
w max - w min
itermax
×iter · (3)
式中, w max , w min分別是w 的最大值和最小值;
iter ,itermax分別是當前迭代次數和最大迭代次數·
2. 2 粒子群優化演算法的學習策略
由標准粒子群優化演算法可知,粒子通過跟蹤
自己迄今為止所找到的最優解和種群迄今為止所
找到最優解這兩個極值來更新自己的速度,從而
更新自己的位置·這種行為也可以理解為,粒子在
借鑒自身和整個群體所取得的成功經驗,通過對
以往的成功經驗的學習獲得有用的信息,指導自
己下一步的行動策略·但人們也常說「失敗乃成功
之母」「, 吃一塹,長一智」,可見從一些失敗的嘗試
中也可以獲得有用的信息,基於這一點,提出了新
的粒子群優化演算法學習策略,這就是從以往的失
敗中獲得有價值的信息,使粒子遠離粒子本身和
整個群體所找到的最差的位置,從而更新粒子的
速度和位置·粒子在搜索過程中的失敗可以表現
為搜索到的具有較差適應值的位置,記第i 個粒
子迄今為止搜索到的最差位置為si = ( si1 , si2 ,
⋯, sin) ,整個粒子群迄今為止搜索到的最差位置
為sg = ( sg1 , sg2 , ⋯, sg n) ,則第i 個粒子的速度和
位置更新公式如下:
v ( t +1)
id = w v ( t)
id + c1 r1 x ( t)
id - s ( t)
id +
c2 r2 x ( t)
id - s ( t)
gd , (4)
x ( t +1)
id = x ( t)
id + v ( t +1)
id · (5)
如果只是利用上述的位置和速度更新公式更
新粒子,也就是說只是從失敗中獲取經驗,這與實
際經驗不符·一般來說,還是更多地從成功的經歷
中獲取信息,而從失敗的經歷中獲得相對少的信
息,基於這一點本文的演算法同時從成功和失敗的
經歷中獲取信息來更新粒子·
2. 3 動態雙種群粒子群優化演算法
由上面的敘述可以知道粒子群中的粒子可以
按照不同的學習策略進行學習,對速度和位置作
出更新·所以本文將一個種群分成兩個子種群,每
個子種群選用不同的學習策略,即第一個子種群
中的粒子選用從成功經歷中獲得學習信息的策
略,更新自己;第二個子種群中的粒子選用從失敗
的經歷中獲得學習信息的策略進行進化·本文可
以設置一個比例系數ρ來控制兩個子種群中粒
子的個數·
ρ =
m1
m2
, m1 + m2 = m · (6)
式中, m 為粒子群中的粒子總數; m1 為第一個子
種群中的粒子個數; m2 為第二個子種群中的粒
子個數·
為了使每個粒子都能從自身和群體的經歷中
獲得充分的學習, 本文規定兩個子種群中的粒子
是不斷變化的, 即每隔一定的代數後將整個種群
按照比例系數ρ重新隨機劃分成兩個子種群·從
粒子群優化演算法的進化過程中知道在優化的初期
粒子的位置比較分散, 得到較優值和較差值的機
會相差不多,所以此時採用上述兩種不同學習策
略的粒子的個數應大致相等·在優化搜索的後期
粒子將聚集在最優值的附近,這時將很難出現比
歷史最差值更差的值了,第二個子種群將從失敗
經歷中得不到太多的有價值的信息·此時第二個
子種群中的粒子數應該遠遠小於第一個子種群中
的粒子個數,直至完全採用跟蹤最優值來更新粒
子,即第二個子種群消亡·基於上述原因將ρ設
為一個線性變化的量,其值由下式確定:
ρ = ρmax -
ρmax - ρmin
018 ×itermax
×iterc · (7)
式中,ρmax和ρmin分別是ρ的最大值和最小值;
iterc 和itermax分別是種群重新劃分時的進化代數
和最大進化代數·
動態雙種群粒子群優化演算法的實現步驟如
下:
(1) 設PSO 種群規模為m , 加速常數為c1
和c2 ,慣性權重的最大值和最小值為w max , w min ,
比例系數ρ的最大值和最小值為ρmax ,ρmin ,種群
重新劃分代數iterc ,最大進化代數為Tmax·將當前
進化代數置為t = 1 ;
(2) 在解空間中初始化粒子的速度和位置;
(3) 將種群按照比例系數ρ劃分為兩個子種
群;
(4) 按式(3) 更新慣性權重w , 按式(7) 更新
比例系數ρ, 第一個子種群按式(1) 和(2) 更新粒
子速度和位置,第二個子種群按式(4) 和(5) 更新
子種群中的粒子,從而產生新種群Xt ;
(5) 評價種群Xt·將第i 個粒子當前點適應
值與該粒子迄今找到的最優位置pi (最差位置
si) 的適應值進行比較, 若更優(差) , 則更新pi
( si) ,否則保持pi ( si) 不變,再與種群迄今找到的
最優位置pg (最差位置sg) 的適應值進行比較,若
更優(差) ,則更新pg ( sg) ;否則保持pg ( sg) 不變;
(6) 檢查是否滿足尋優結束條件, 若滿足則
結束尋優, 求出最優解; 否則, 置t = t + 1 , 轉至
(3) ;結束條件為尋優達到最大進化代數Tmax·
2. 4 基於動態雙種群粒子群優化演算法的工序排序
2. 4. 1 粒子的編碼和解碼
根據第1 節對柔性工作車間調度問題的描
述,本文定義所有工件的總工序數L = 6n
j =1
nj ,把
一個粒子表示為一個L 維的向量·對所有工序進
行連續編號,即為每道工序指定一個固定的編號·
例如可以對表1 所給出的例子中的工序進行編
號,如表2 所示,則粒子的位置向量x [ L ]就是由
一組連續的自然數組成的L 維的向量,自然數的
順序決定了工序調度的順序·xi = [1 ,7 ,2 ,4 ,8 ,3 ,
5 ,6 ]就表示了一個滿足優先約束的可行的工序排
序·
表2 工序編號
Table 2 Serial numbers of operations
工序O1 ,1 O2 ,1 O3 ,1 O1 ,2 O2 ,2 O3 ,2 O1 ,3 O2 ,3
編號1 2 3 4 5 6 7 8
2. 4. 2 位置向量和速度向量的更新
對每個粒子, 粒子的速度向量可以用v [ L ]
表示·按照上面所述的更新公式對x [ L ] , v [ L ]
進行更新·由於粒子群優化演算法經常用在連續空
間上,而柔性工作車間調度問題為整數規劃問題
而且有工序先後順序約束,所以將粒子群演算法用
於柔性工作車間調度問題時,在速度和位置更新
方式上要做如下的修改:令粒子i 的當前的位置
為xi = [1 , 7 , 2 , 4 , 8 , 3 , 5 , 6 ] , 在經過一次迭代以
後位置向量變為xi = [ 2. 5 , 6. 7 , 3. 6 , 5. 9 , 8. 5 ,
112 ,4. 1 ,7. 6 ]·位置向量里存放的是工序的編號,
很明顯不能為小數, 本文對迭代後的位置向量進
行如下的處理:將更新後的位置向量中各分量的
值按照由小到大的順序進行排列, 並為其進行重
新編號:1. 2 (1) < 2. 5 (2) < 3. 6 (3) < 4. 1 (4) < 5. 9
(5) < 6. 7 (6) < 7. 6 (7) < 8. 5 (8) ,式中括弧內的數
字為該分量的編號, 然後位置向量中各分量用其
獲得的相應的編號代替·例如,第一個分量2. 5 用
編號2 代替,第二個分量6. 7 用編號6 代替等等,
此時位置向量變為xi = [2 , 6 , 3 , 5 , 8 , 1 , 4 , 7 ]·但
是這個工序排序不滿足優先約束,還要對其進行
調整,使其滿足約束條件·例如第一個分量2 代表
的是工序O21 ,第6 個分量1 代表的是工序O11 ,
工序O21應在工序O11之後進行加工, 所以要對
其進行調整·調整的方法為:對屬於同一個工件的
工序調換其相應先後位置使其滿足約束, 對每個
工件都做相似的處理, 則可以得到滿足優先順序約
束的位置向量: xi = [1 ,4 ,2 ,5 ,7 ,3 ,6 ,8 ]·
3 啟發式分配演算法
通過上一節介紹的排序演算法本文可以獲得一
個滿足工序優先約束的可行的工序序列·這一節
通過一個啟發式演算法為這一工序序列中的每一工
序分配一台合適的機器對其進行加工·
本文所採用的分配演算法的主要思想是:選擇
一台能使本道工序獲得最小完工時間的機器分配
給待加工的工序·可以用如下公式表示選擇機器
Mk 分配給待加工的工序以使本道工序的完工時
間最短:
tf i , j = min k ( ri , j + Ti , j , k) ,
ri , j = max ( rpfk , ropf) ·
式中, tf i , j 為工序Oi , j 的完工時間; ri , j 為工序的
開始加工時間; Ti , j , k為工序用機器k 加工消耗的
時間; rpfk為機器Mk 當前狀態下所加工的最後一
個工件的完工時間; ropf為待加工工序緊前工序的
完工時間·
利用排序演算法和分配演算法就可以獲得一個滿
足優先約束和資源約束的可行的調度方案, 並且
利用分配演算法還可以得到目標函數———全部工件
的最大完工時間的值·
將前面介紹的排序演算法和分配演算法綜合起來
便形成本文所採用的處理柔性工作車間調度優化
問題的方法,記為DPSO2HA·該方法將柔性工作
車間調度問題分解為兩個子問題———排序問題和
分配問題,在每一次迭代中首先通過動態雙種群
粒子群演算法獲得一個可行的工序序列, 然後利用
分配演算法給該序列分配合適的機器並計算目標函
數值,直至達到最大進化代數·
4 算例模擬
4. 1 模擬研究1
本文選用文獻[ 7 ]中的一個10 ×10 (10 個工
件,10 台機器) ,30 道工序的柔性工作車間調度問
題來計算最大完工時間·實驗參數如下:粒子群的
種群規模為m = 30 , c1 = c2 = 2 ,ρmax = 015 ,ρmin =
0 ,每隔5 代重新劃分種群,最大迭代次數Tmax =
150·
實驗中採用本文所提出的演算法運行10 次,和
傳統的GA 方法、文獻[8 ]中採用的MSA 演算法相
比較,比較結果如表3 所示·
表3 實驗結果比較
Table 3 Comparison of te sting re sults
方 法最優值平均值標准偏差
GA 8 11. 5 2. 67
MSA 7 7. 9 0. 97
DPSO2HA 7 7. 1 0. 32
從表3 中可以看出DPSO2HA 求得的平均值
和標准偏差都明顯優於GA 和VEGA , 這說明
DPSO2HA 的精度與穩定性明顯優於GA 和
VEGA 演算法·實驗中所獲得的一個較優的調度方
案的甘特圖如圖1 所示·圖中方框內的數字「i . j」
表示第j 個工件的第i 道工序·,
（不好意思，圖粘貼不下來，要不你告我郵箱）
圖1 柔性工作車間調度優化結果
Fig. 1 Optimization solution to the problem
10 ×10 with 30 operations
4. 2 模擬研究2
為了進一步對本文提出的演算法的性能加以驗
證,選用文獻[ 9 ]中所給出的實驗數據,利用本文
提出的演算法進行求解,並將調度結果與文獻[ 9 ]及
文獻[ 10 ]中所提演算法的調度結果加以比較·比較
結果如表4 所示·
表4 不同方法的調度結果比較
Table 4 Comparison of different scheling re sults
算例描述Brandimarte GENACE DPSO2HA
MK1 10 ×6 42 41 40
MK2 10 ×6 32 29 28
MK4 15 ×8 81 67 61
MK5 15 ×4 186 176 173
MK6 10 ×15 86 68 62
MK7 20 ×5 157 148 141
MK8 20 ×10 523 523 523
MK9 20 ×10 369 328 307
MK10 20 ×15 296 231 207
由上述的比較結果可以看出,本文所提出的
DPSO2HA 方法對上述算例的求解結果較另外兩
種方法有了較大的提高·
5 結 論
本文提出了一種動態雙種群粒子群優化演算法
(DPSO) ·DPSO 將種群劃分成兩個種群規模隨進
化過程不斷變化的子種群,兩個子種群分別採用
不同的學習策略進行進化,並在進化過程中相互
交換信息·該演算法在保持PSO 演算法高效簡單的基
礎上提高了全局尋優能力·將以DPSO 演算法為基
礎的排序演算法和啟發式分配演算法相結合形成了解
決柔性工作車間調度問題的新方法·通過對算例
的研究和與其他方法的比較表明,該方法是有效
可行的·
參考文獻:
[ 1 ] Carlier J , Pinson E. An algorithm for solving the job2shop
problem[J ] . Management Science , 1989 ,35 (2) :164 - 176.
[ 2 ] Reynolds R G. An introction to cultural algorithms[ C] ‖
Proceedings of the Third Annual Conference on Evolutionary
Programming. River Edge : World Scientific , 1994 : 131 -
139.
[ 3 ] Mastrolilli M , Gambardella L M. Effective neighborhood
functions for the flexible job shop problem[ J ] . Journal of
Scheling , 2002 ,3 (1) :3 - 20.
[ 4 ] Kacem I , Hammadi S , Borne P. Pareto2optimality approach
for flexible job2shop scheling problems : hybridization of
evolutionary algorithms and fuzzy logic[J ] . Mathematics and
Computers in Simulation , 2002 ,60 (3) :245 - 276.
[ 5 ] Kennedy J , Eberhart R. Particle swarm optimization [ C] ‖
Proceedings of IEEE International Conference on Neural
Networks. Perth : IEEE Press , 1995 :1942 - 1948.
[ 6 ] Shi Y, Eberhart R C. Empirical study of particle swarm
optimization [ C ] ‖Proceedings of the 1999 Congress on
Evolutionary Computation. Washington , 1999 : 1945 -
1950.
[ 7 ] Xia WJ , Wu Z M. An effective hybrid optimization approach
for multi2objective flexible job2shop scheling problems[J ] .
Computers & Inst rial Engineering , 2005 ,48 (2) :409 -
425.
[ 8 ] Najid N M , Stephane D P , Zaidat A. A modified simulated
annealing method for flexible job shop scheling problem[C]
‖Proceedings of the IEEE International Conference on
Systems , Man and Cybernetics. Hammamet : IEEE Press ,
2002 :89 - 94.
[ 9 ] Brandimarte P. Routing and scheling in a flexible job shop
by tabu search[J ] . A nnals of Operations Research , 1993 ,41
(3) :158 - 183.
[ 10 ] Ho N B , Tay J C. GENACE: an efficient cultural algorithm
for solving the flexible job2shop problem[C] ‖Proceedings of
the IEEE Congress on Evolutionary Computation. Portland :
IEEE Press , 2004 :1759 - 1766.
（do you know）
⑹ 主存空間的分配和回收，
#include "iostream.h"
#include "iomanip.h"
#define nofreearea 2
#define noadequacyarea 3
#define allocated 4
#define noprocess 2
#define nosuchprocess 3
#define reclaimed 4
typedef struct TUN
{
int address;
int size;
char name;
struct TUN *next;
} usedarea , *usedtable;
typedef struct TFN
{
int address;
int size;
struct TFN *next;
} freearea, *freetable;
usedtable usedTable = NULL;
freetable freeTable = NULL;
int alloc( char processname , int processsize )
{
if( freeTable == NULL )
return 1;
freetable p = freeTable;
freetable q = p;
while( p != NULL && p->size < processsize )
{
q = p;
p = p->next;
}
if( p == NULL )
return 3;
usedtable x = new usedarea;
x->address = p->address;
x->size = processsize;
x->name = processname;
x->next = NULL;
if( p->size > processsize )
{
p->size -= processsize;
p->address += processsize;
}
else
{
if( p == freeTable )
freeTable = NULL;
else
q->next = p->next;
delete p;
}
usedtable r = usedTable;
usedtable t = r;
while( r != NULL && r->address < x->address )
{
t = r;
r = r->next;
}
if( usedTable == NULL )
usedTable = x;
else
{
x->next = r;
t->next = x;
}
return 4;
}
int Reclaim( char processname )
{
if( usedTable == NULL )
return 1;
usedtable p = usedTable;
usedtable q = p;
while( p != NULL && p->name != processname )
{
q = p;
p = p->next;
}
if( p == NULL )
return 3;
freetable r = freeTable;
freetable t = r;
freetable x;
while( r != NULL && r->address < p->address )
{
t = r;
r = r->next;
}
x = new freearea;
x->address = p->address;
x->size = p->size;
x->next = NULL;
if( r == freeTable )
{
x->next = r;
freeTable = x;
t = freeTable;
}
else
{
x->next = r;
t->next = x;
}
while( t->next != NULL && t->address + t->size == t->next->address )
{
t->size += t->next->size;
r = t->next;
t->next = t->next->next;
delete r;
}
if( p == usedTable )
{
usedTable = usedTable->next;
}
else
q->next = p->next;
delete p;
return 4;
}
int Init()
{
freeTable = new freearea;
freeTable->address = 0;
freeTable->size = 128;
freeTable->next = NULL;
return 1;
}
void processrequest()
{
char processname;
int processsize;
cout<<"...................."<<endl;
cout<<"作業名: ";
cin >> processname;
cout<<"作業長度: ";
cin >> processsize;
if(processsize<=128)
{int i;
if( alloc( processname , processsize) == 4 )
{
i=i+processsize;
if(i>128)
{cout<<"該作業超出空間"<<endl;
}
if(i<=128)
cout<<"該作業已成功獲得所需空間"<<endl;
i=i+processsize;
cout<<"........................................"<<endl;
}
else
cout<<"該作業超出空間,沒有獲得所需空間"<<endl;
cout<<"........................................"<<endl;
return;
}
if(processsize>128)
{cout<<"該作業超出空間"<<endl;
cout<<"........................................"<<endl;
}
}
void processreclaim()
{
int processname;
cout<<"...................."<<endl;
cout<<"作業名: ";
cin >>processname;
int result = Reclaim( processname );
if( result == 4 )
cout<<"該作業已成功回收"<<endl;
else if( result == 2 || result == 1 )
cout<<"系統沒有作業或該作業不存在"<<endl;
cout<<"...................."<<endl;
}
void freeTablePrint()
{
cout<<endl<<endl<<endl<<"***********************************"<<endl;
cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<endl<<endl;
freetable p = freeTable;
usedtable q = usedTable;
int x , y;
while( p || q )
{
if( p )
x = p->address;
else
x = 0x7fffffff;
if( q )
y = q->address;
else
y = 0x7fffffff;
if( x < y )
{
cout<<setw(10)<<p->address<<setw(10)<<p->size<<setw(10)<<"空閑"<<endl;
p = p->next;
}
if( x > y )
{
cout<<setw(10)<<q->address<<setw(10)<<q->size<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->name<<endl;
q = q->next;
}
}
cout<<endl<<endl<<endl<<"************************************"<<endl<<endl<<endl;
}
void main()
{
Init();
int choose;
bool exitFlag = false;
while( !exitFlag )
{
cout<<"************************0 - 退出 ************************"<<endl;
cout<<"************************1 - 分配主存 ************************"<<endl;
cout<<"************************2 - 回收主存 ************************"<<endl;
cout<<"************************3 - 顯示主存 ************************"<<endl<<endl<<endl;
cout<<"************************選擇所要執行的操作:";
cin>>choose;
switch( choose )
{
case 0:
exitFlag = true;
break;
case 1:
processrequest();
break;
case 2:
processreclaim();
break;
case 3:
freeTablePrint();
break;
}
}
}
⑺ 關於操作系統的內存管理問題，100分請高手，答案好的再加100分！急！就今天！請最好用C或C++編寫。謝謝！
#include <iostream.h>
#include <stdio.h>
#include <string.h>
struct program
{
char name[30];
long start;
long length;
struct program *next;
};
struct space
{
long start;
long length;
struct space *next;
};
void creat();
void allot();
void back();
void callback(program *r);
void sort(space *L);
void sort(program *S);
void display(space *L);
void display(program *S);
space *L;
program *S;
void creat()
{
L=new space;
space *p=new space;
p->start=0;
p->length=128;
p->next=NULL;
L->next=p;
S=new program;
S->next=NULL;
}
void allot()
{
program *q;
q=new program;
cout<<"請輸入進程名和佔用空間大小:"<<endl;
cin>>q->name>>q->length;
if(q->length<=0)
{
cout<<"進程空間大小錯誤."<<endl;
delete q;
return;
}
space *p,*r;
p=L;
r=p;
while(p->next!=NULL&&p->next->length<q->length)
{
r=p;
p=p->next;
}
if(p->next==NULL)
{
cout<<"佔用空間過大，分配失敗"<<endl;
delete q;
return;
}
else
{
q->start=p->next->start;
q->next=S->next;
S->next=q;
p->next->length-=q->length;
if(p->next->length!=0)
p->next->start+=q->length;
else
{
if(p->next->next!=NULL)
p->next=p->next->next;
else
{
r->next=NULL;
delete p->next;
}
}
}
display(L);
display(S);
}
void back()
{
char name[30];
cout<<"輸入要回收的進程名：";
cin>>name;
program *p;
p=S;
while(p->next!=NULL)
{
if(strcmp(p->next->name, name)==0)
{
callback(p);
return;
}
p=p->next;
}
if(p->next==NULL)
cout<<"此進程不存在,內存回收失敗"<<endl;
}
void callback(program *t)
{
program *r;
r=t->next;
space *p,*q;
long n;
n=r->length;
if(L->next==NULL)
{
space *w=new space;
w->start=0;
w->length=n;
w->next=NULL;
L->next=w;
t->next=r->next;
delete r;
cout<<"此進程內存回收完畢."<<endl;
display(L);
display(S);
return;
}
p=L->next;
while(p!=NULL&&p->start<r->start)
{
q=p;
p=p->next;
}
if((q->start+q->length==r->start)&&(r->start+n==p->start)) //上下均空
{
q->next=p->next;
q->length=q->length+p->length+n;
t->next=r->next;
delete r;
}
else if(r->start+n==p->start) //下鄰空
{
p->start-=n;
p->length+=n;
t->next=r->next;
delete r;
}
else if(q->start+q->length==r->start)
{
q->length+=n;
t->next=r->next;
delete r;
}
else
{
space *sp=new space;
sp->start=r->start;
sp->length=n;
sp->next=L->next;
L->next=sp;
t->next=r->next;
delete r;
}
cout<<"此進程內存回收完畢."<<endl;
display(L);
display(S);
}
void display(space *L)
{
sort(L);
space *p=L->next;
cout<<endl<<"空閑區情況："<<endl;
if(p==NULL)
{ cout<<"無空閑區了."<<endl; return;}
while(p!=NULL)
{
cout<<"起始地址:"<<p->start<<" 長度:"<<p->length<<endl;
p=p->next;
}
}
void display(program *S)
{
sort(S);
program *p=S->next;
cout<<endl<<"進程內存分配情況："<<endl;
if(p==NULL)
{ cout<<"內存中無進程."<<endl; return;}
while(p!=NULL)
{
cout<<"進程名:"<<p->name<<" 起始地址:"<<p->start<<" 長度:"<<p->length<<endl;
p=p->next;
}
cout<<endl;
}
void sort(space *L) //鏈表排序
{
space *p=L->next, *q, *r;
if(p!=NULL)
{
r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=L;
while(q->next!=NULL&&q->next->start<p->start)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}
void sort(program *S) //鏈表排序
{
program *p=S->next, *q, *r;
if(p!=NULL)
{
r=p->next;
p->next=NULL;
p=r;
while(p!=NULL)
{
r=p->next;
q=S;
while(q->next!=NULL&&q->next->start<p->start)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}
void main()
{
creat();
int a;
cout<<" 內存分配與回收模擬"<<endl;
cout<<"1:分配內存"<<endl;
cout<<"2:回收內存"<<endl;
cout<<"0:退出"<<endl;
while(1)
{
cout<<endl<<"請按鍵選擇：";
cin>>a;
if(a>2||a<0)
{
cout<<endl<<"輸入錯誤，請重新輸入：";
continue;
}
switch(a)
{
case 1: allot(); break;
case 2: back(); break;
case 0: goto end;
}
}
end:
getchar();
}
#include "iostream.h"
#include "iomanip.h"
#define ERR_NOFREEAREA 1
#define ERR_NOADEQUACYAREA 2
#define ERR_ALLOCATED 4
#define ERR_NOJOBS 1
#define ERR_NOSUCHJOB 2
#define ERR_RECLAIMED 4
typedef struct tagUsedNode
{
long address;
long length;
int flag; //作業名
struct tagUsedNode *next;
} USED_AREA , *USED_TABLE;
typedef struct tagFreeNode
{
long address;
long length;
struct tagFreeNode *next;
} FREE_AREA , *FREE_TABLE;
//空閑區、作業區鏈表
USED_TABLE usedTable = NULL;
FREE_TABLE freeTable = NULL;
//給作業分配空間
//jobname: 作業名
//jobsize: 作業所需空間大小
int Allocate( int jobname , long jobsize )
{
//如果沒有空閑區
if( freeTable == NULL )
return ERR_NOFREEAREA;
FREE_TABLE p = freeTable;
FREE_TABLE q = p;
//找首次適應空閑區
while( p != NULL && p->length < jobsize )
{
q = p;
p = p->next;
}
//如果找不到有足夠空間的分區
if( p == NULL )
return ERR_NOADEQUACYAREA;
USED_TABLE x = new USED_AREA;
x->address = p->address;
x->length = jobsize;
x->flag = jobname;
x->next = NULL;
//如果該分區大於作業需求，空間大小減去作業大小
if( p->length > jobsize )
{
p->length -= jobsize;
p->address += jobsize;
}
//如果該分區等於作業大小，刪除該分區
else
{
if( p == freeTable )
freeTable = NULL;
else
q->next = p->next;
delete p;
}
//作業加入「作業表」中
USED_TABLE r = usedTable;
USED_TABLE t = r;
while( r != NULL && r->address < x->address )
{
t = r;
r = r->next;
}
if( usedTable == NULL )
usedTable = x;
else
{
x->next = r;
t->next = x;
}
return ERR_ALLOCATED;
}
//回收作業空間
//jobname: 作業名
int Reclaim( int jobname )
{
if( usedTable == NULL )
return ERR_NOJOBS;
USED_TABLE p = usedTable;
USED_TABLE q = p;
while( p != NULL && p->flag != jobname )
{
q = p;
p = p->next;
}
//如果沒有該作業
if( p == NULL )
return ERR_NOSUCHJOB;
//回收後的空間加入到空閑區
FREE_TABLE r = freeTable;
FREE_TABLE t = r;
FREE_TABLE x;
while( r != NULL && r->address < p->address )
{
t = r;
r = r->next;
}
x = new FREE_AREA;
x->address = p->address;
x->length = p->length;
x->next = NULL;
if( r == freeTable )
{
x->next = r;
freeTable = x;
t = freeTable;
}
else
{
x->next = r;
t->next = x;
}
//合並分區
while( t->next != NULL && t->address + t->length == t->next->address )
{
t->length += t->next->length;
r = t->next;
t->next = t->next->next;
delete r;
}
//刪除該作業
if( p == usedTable )
{
usedTable = usedTable->next;
}
else
q->next = p->next;
delete p;
return ERR_RECLAIMED;
}
int Init()
{
freeTable = new FREE_AREA;
freeTable->address = 0;
freeTable->length = 1024;
freeTable->next = NULL;
return 1;
}
void jobrequest()
{
int jobname;
int jobsize;
cout<<"...................."<<endl;
cout<<"作業名: ";
cin >> jobname;
cout<<"作業長度: ";
cin >> jobsize;
if( Allocate( jobname , jobsize ) == ERR_ALLOCATED )
cout<<"該作業已成功獲得所需空間"<<endl;
else
cout<<"該作業沒有獲得所需空間"<<endl;
cout<<"...................."<<endl;
}
void jobreclaim()
{
int jobname;
cout<<"...................."<<endl;
cout<<"作業名: ";
cin >>jobname;
int result = Reclaim( jobname );
if( result == ERR_RECLAIMED )
cout<<"該作業已成功回收"<<endl;
else if( result == ERR_NOSUCHJOB || result == ERR_NOJOBS )
cout<<"系統沒有作業或該作業不存在"<<endl;
cout<<"...................."<<endl;
}
void freeTablePrint()
{
cout<<"........................................"<<endl;
cout<<setw(10)<<"address"<<setw(10)<<"length"<<setw(10)<<"state"<<endl<<endl;
FREE_TABLE p = freeTable;
USED_TABLE q = usedTable;
int x , y;
while( p || q )
{
if( p )
x = p->address;
else
x = 0x7fffffff;
if( q )
y = q->address;
else
y = 0x7fffffff;
if( x < y )
{
cout<<setw(10)<<p->address<<setw(10)<<p->length<<setw(10)<<"空閑"<<endl;
p = p->next;
}
if( x > y )
{
cout<<setw(10)<<q->address<<setw(10)<<q->length<<setw(10)<<"已分配"<<setw(10)<<"ID="<<q->flag<<endl;
q = q->next;
}
}
cout<<"........................................"<<endl;
}
void main()
{
Init();
int choose;
bool exitFlag = false;
while( !exitFlag )
{
cout<<"選擇功能項 ( 0 - 退出 1 - 分配主存 2 - 回收主存 3 - 顯示主存 )"<<endl;
cout<<"?>";
cin>>choose;
switch( choose )
{
case 0:
exitFlag = true;
break;
case 1:
jobrequest();
break;
case 2:
jobreclaim();
break;
case 3:
freeTablePrint();
break;
}
}
}
⑻ 籃球讓分勝負獎金怎麼算的
每場比賽賽果的sp乘以本金就是獎金了
比如 ：兩場sp都是2.0，本金是2塊。就是2×2×2=8
⑼ 東秦的操作系統答案
一、 選擇題：（每題1分，共10分）
1、（B）的主要特點是提供即時響應和高可靠性。生產過程的控制、武器系統、
航空訂票系統、銀行業務就是這樣的系統。
A.分時系統 B.實時系統 C.批處理系統 D.分布式系統
2、下列進程狀態的轉換中，哪一個是不正確的(C)。
A.就緒一運行 B.運行一就緒 C.就緒一阻塞 D.阻塞一就緒
3、利用信號量實現進程的（B），應為臨界區設置一個信號量mutex，其初值
為1，表示該資源尚未使用，臨界區應置於P（mutex）和V（mutex）原語
之間。
A.同步 B.互斥 C.競爭 D.合作
4、作業調度的關鍵在於(B)。
A.選擇恰當的進程管理程序 B.選擇恰當的作業調度演算法
C.用戶作業准備充分 D.有一個較好的操作環境
5、下列存儲管理方案中，不採用動態重定位的是（C）。
A.頁式管理 B.可變分區 C.固定分區D.段式管理
6、關於虛擬存儲器，以下說法正確的是（D）。
A.可提高計算機運算速度的設備 B.容量擴大了的主存實際空間
C.通過SPOOLING 技術實現的 D.可以容納和超過主存容量的多個作業
同時運行的一個地址空間
7、下面幾個設備中，（C）是共享設備。
A.列印機 B.磁碟 C.讀卡機 D.掃描儀
8、文件系統採用多級目錄結構的目的,不包括是（B）
A.縮短訪問文件的尋找時間 B.節省存儲空間
C.解決文件的命名沖突 D.易於實現文件共享
9、磁碟驅動調度演算法中（B）演算法可能會隨時改變移動臂的運動方向。
A.電梯調度 B.先來先服務 C.掃描 D.循環掃描
10、正在運行的進程在信號量S上作P操作之後，當S<0的時候，進程進入信號量的
（A）。
A.等待隊列 B.提交隊列 C.後備隊列 D.就緒隊列
二、填空題：（每空1分，共15分）
1、不論是分時系統、實時系統還是批處理系統都具有四個基本特徵 並發 、
共享 、 虛擬 、 非同步 。
2、特權指令只能在__系統 _態下執行，若在用戶態下執行則被認為是非法指令。
3、__PCB______是進程存在的唯一標志。
4、設基址寄存器內容為1000，在採用動態重定位的系統中，當執行指令
「LOAD A,2000」時，操作數的實際地址是__3000_________。
5、按照調度的層次我們把調度分為 高級 、 低級 、 中級 。
6、根據文件的邏輯結構，文件可以分為 有結構文件 和__無結構文件_兩類。
7、目前常用的外存分配方法有：連續分配、_鏈接______分配、 索引 分配。
三、名詞解釋（每題3分，共12分）
1、操作系統：
操作系統是一組控制和管理計算機硬體和軟體資源、合理地對各類作業進行調度、以及方便用戶的程序的集合。
2、臨界區：
每個進程中訪問臨界資源的那段代碼稱為臨界區
3、對換：所謂對換，是指把內存中暫不能運行的進程，或暫不用的程序和數據，換出到外存上，以騰出足夠的內存空間，把已具備運行條件的進程，或進程所需的程序和數據，換入內存
4、設備獨立性：
應用程序獨立於具體的物理設備。
四、簡單題（每題6分，共24分）
1、比較程序、進程的區別。
進程是動態的，程序是靜態的，程序是有序代碼的集合；進程是程序的執行；進程是暫時的，程序的永久的，進程是一個狀態變化的過程，程序可長久保存；進程與程序的組成不同，進程的組成包括程序、數據和進程式控制制塊（即進程狀態信息）；通過多次執行，一個程序可對應多個進程；通過調用關系，一個進程可包括多個程序。
2、什麼是死鎖？死鎖預防的措施有哪些？
所謂死瑣，是指多個進程因競爭資源而造成的一種僵局，若無外力作用，這些進程都將永遠不能再向前推進。
死鎖預防的措施有：屏棄「請求和保持」條件，屏棄「不剝奪」條件，， 摒棄「環路等待」條件。
3、簡述分頁與分段的主要區別
（1）頁是信息的物理單位，已削減內存零頭，提高內存利用率為目的，而
不是用戶的需求。段是信息的邏輯單位，具有相對完整的意義，是
為了滿足用戶的需求。
（2）頁的大小固定，由系統確定。段的大小不固定，決定於用戶編寫的程序。
（3）分頁的作業地址是一維的。分段的作業地址是二維的。
4、什麼是局部性原理？什麼是抖動？你有什麼辦法減少系統的抖動現象？
局部性原理是指在幾乎所有程序的執行過程中，在一段時間內，CPU總是集中地訪問程序中的某一個部分而不是對程序的所有部分具有平均的訪問概率。
抖動是指當給進程分配的內存小於所要求的工作區時，由於內存外存之間交換頻繁，訪問外存的時間和輸入輸出處理時間大大增加,反而造成CPU因等待數據而空轉,使得整個系統性能大大下降。
在物理系統中，為了防止抖動的產生，在進行淘汰或置換時，一般總是把缺頁進程鎖住，不讓其換出，從而防止抖動的產生。
防止抖動產生的另一個辦法是設置較大的內存工作區。
五、應用與計算（共39分）
1、現有一個具有n個緩沖區的緩沖池，Proce進程把它生產的消息放入一個緩沖區，Consumer進程可從一個緩沖區中取得一個消息消費。用信號量實現生產者和消費者之間的同步與互斥。請將下面的生產者和消費者演算法補充完整。生產者和消費者對緩沖池互斥訪問的信號量為SM，緩沖池的初值SB=n，緩沖池中消息個數初值為SP=0。（本題9分）
初值設置
SM= 1 ；SB=n；sp=0
P生產者：
While(1)
{...
Procer an item
Wait( SB )
Wait(SM)
緩沖操作
Singal(SM
Singal( SB )
…
}
C消費者：
While(1)
{...
Wait(SB )
Wait(SM
緩沖操作
Singal(SM
Singal(SB )
Consume the item
…
}
2、銀行家演算法中，若出現下述的資源分配情況：
Process Allocation Need Available
P0 0 , 1 , 0 7 , 4 , 3 3 , 3 , 2
P1 2 , 0 , 0 1 , 2 , 4
P2 3 , 0 , 2 6 , 5 , 0
P3 2 , 1 , 1 0 , 1 , 1
P4 0 , 0 , 2 4 , 3 , 1
試問：（1）當前系統狀態是否安全？如果安全寫出安全序列。（7分）
（2）若進程P1 提出請求 Request ( 1 , 0 , 2 ) 後，系統能否將資源分配給它？（3分）
（1）存在如下進程序列，可使進程順利執行完畢：
進程 可用資源數
P3：執行完 5 ，4 ，3
P4：執行完 5 ，4 ，5
P1：執行完 7 ，4 ，5
P0：執行完 7 ，5 ，5
P2：執行完 10 ，5 ，7
當前系統是安全的，安全序列是：P3 , P4 , P1 , P0 , P2 . （8分）
(2) 如果將資源分配給進程P1 ,這時所有待執行的進程中就沒有滿足所需資源數
<=系統可提供資源數條件的，所以系統不可以將資源分配P1（2分）
3、假設一磁軌有200個柱面，編號為0 — 199 ，在完成了磁軌125處的請求後，當前正在磁軌143處為一請求服務，若請求隊列的先後順序為86，147，91，177，94，150，102，175，130。試分別採用FCFS（先來先服務）、SSTF（最短尋道時間優先）演算法完成上述請求，寫出磁軌移動的順序，並計算磁頭移動的總距離。（本題8分）
（1）採用FCFS演算法調度，磁頭移動順序為：
143-86-147-91-177-94-150-102-175-130
磁頭移動總量為：565（柱面）。（4分）
（2）採用SSTF演算法調度，磁頭移動順序為：
143-147-150-130-102-94-91-86-175-177
磁頭移動總量為：162（柱面）。（4分）
4、我們打開計算機中的某個word文檔，然後通過列印機列印文檔中的內容，在這個過程中，操作系統為我們做了什麼？試從操作系統功能的角度加以分析。（本題12分）
進程管理：執行時完成調度（2分）
存儲管理：為調度的進程分配內存，以及從硬碟中讀取文件。（2分）
文件管理：所調度文件的查詢與讀取（2分）
設備管理：列印機的驅動，以及列印工作的執行。（2分）
用戶介面：執行程序時的界面，以及程序進程本身所含的系統調度。（2分）
整個過程是五個功能合作完成。（2分）
菠蘿包 15:03:19
一、 選擇題：（每題1分，共10分）
1、（B）的主要特點是提供即時響應和高可靠性。生產過程的控制、武器系統、
航空訂票系統、銀行業務就是這樣的系統。
A.分時系統 B.實時系統 C.批處理系統 D.分布式系統
2、下列進程狀態的轉換中，哪一個是不正確的(C)。
A.就緒一運行 B.運行一就緒 C.就緒一阻塞 D.阻塞一就緒
3、利用信號量實現進程的（B），應為臨界區設置一個信號量mutex，其初值
為1，表示該資源尚未使用，臨界區應置於P（mutex）和V（mutex）原語
之間。
A.同步 B.互斥 C.競爭 D.合作
4、作業調度的關鍵在於(B)。
A.選擇恰當的進程管理程序 B.選擇恰當的作業調度演算法
C.用戶作業准備充分 D.有一個較好的操作環境
5、下列存儲管理方案中，不採用動態重定位的是（C）。
A.頁式管理 B.可變分區 C.固定分區D.段式管理
6、關於虛擬存儲器，以下說法正確的是（D）。
A.可提高計算機運算速度的設備 B.容量擴大了的主存實際空間
C.通過SPOOLING 技術實現的 D.可以容納和超過主存容量的多個作業
同時運行的一個地址空間
7、下面幾個設備中，（C）是共享設備。
A.列印機 B.磁碟 C.讀卡機 D.掃描儀
8、文件系統採用多級目錄結構的目的,不包括是（B）
A.縮短訪問文件的尋找時間 B.節省存儲空間
C.解決文件的命名沖突 D.易於實現文件共享
9、磁碟驅動調度演算法中（B）演算法可能會隨時改變移動臂的運動方向。
A.電梯調度 B.先來先服務 C.掃描 D.循環掃描
10、正在運行的進程在信號量S上作P操作之後，當S<0的時候，進程進入信號量的
（A）。
A.等待隊列 B.提交隊列 C.後備隊列 D.就緒隊列
二、填空題：（每空1分，共15分）
1、不論是分時系統、實時系統還是批處理系統都具有四個基本特徵 並發 、
共享 、 虛擬 、 非同步 。
2、特權指令只能在__系統 _態下執行，若在用戶態下執行則被認為是非法指令。
3、__PCB______是進程存在的唯一標志。
4、設基址寄存器內容為1000，在採用動態重定位的系統中，當執行指令
「LOAD A,2000」時，操作數的實際地址是__3000_________。
5、按照調度的層次我們把調度分為 高級 、 低級 、 中級 。
6、根據文件的邏輯結構，文件可以分為 有結構文件 和__無結構文件_兩類。
7、目前常用的外存分配方法有：連續分配、_鏈接______分配、 索引 分配。
三、名詞解釋（每題3分，共12分）
1、操作系統：
操作系統是一組控制和管理計算機硬體和軟體資源、合理地對各類作業進行調度、以及方便用戶的程序的集合。
2、臨界區：
每個進程中訪問臨界資源的那段代碼稱為臨界區
3、對換：所謂對換，是指把內存中暫不能運行的進程，或暫不用的程序和數據，換出到外存上，以騰出足夠的內存空間，把已具備運行條件的進程，或進程所需的程序和數據，換入內存
4、設備獨立性：
應用程序獨立於具體的物理設備。
四、簡單題（每題6分，共24分）
1、比較程序、進程的區別。
進程是動態的，程序是靜態的，程序是有序代碼的集合；進程是程序的執行；進程是暫時的，程序的永久的，進程是一個狀態變化的過程，程序可長久保存；進程與程序的組成不同，進程的組成包括程序、數據和進程式控制制塊（即進程狀態信息）；通過多次執行，一個程序可對應多個進程；通過調用關系，一個進程可包括多個程序。
2、什麼是死鎖？死鎖預防的措施有哪些？
所謂死瑣，是指多個進程因競爭資源而造成的一種僵局，若無外力作用，這些進程都將永遠不能再向前推進。
死鎖預防的措施有：屏棄「請求和保持」條件，屏棄「不剝奪」條件，， 摒棄「環路等待」條件。
3、簡述分頁與分段的主要區別
（1）頁是信息的物理單位，已削減內存零頭，提高內存利用率為目的，而
不是用戶的需求。段是信息的邏輯單位，具有相對完整的意義，是
為了滿足用戶的需求。
（2）頁的大小固定，由系統確定。段的大小不固定，決定於用戶編寫的程序。
（3）分頁的作業地址是一維的。分段的作業地址是二維的。
4、什麼是局部性原理？什麼是抖動？你有什麼辦法減少系統的抖動現象？
局部性原理是指在幾乎所有程序的執行過程中，在一段時間內，CPU總是集中地訪問程序中的某一個部分而不是對程序的所有部分具有平均的訪問概率。
抖動是指當給進程分配的內存小於所要求的工作區時，由於內存外存之間交換頻繁，訪問外存的時間和輸入輸出處理時間大大增加,反而造成CPU因等待數據而空轉,使得整個系統性能大大下降。
在物理系統中，為了防止抖動的產生，在進行淘汰或置換時，一般總是把缺頁進程鎖住，不讓其換出，從而防止抖動的產生。
防止抖動產生的另一個辦法是設置較大的內存工作區。
五、應用與計算（共39分）
1、現有一個具有n個緩沖區的緩沖池，Proce進程把它生產的消息放入一個緩沖區，Consumer進程可從一個緩沖區中取得一個消息消費。用信號量實現生產者和消費者之間的同步與互斥。請將下面的生產者和消費者演算法補充完整。生產者和消費者對緩沖池互斥訪問的信號量為SM，緩沖池的初值SB=n，緩沖池中消息個數初值為SP=0。（本題9分）
初值設置
SM= 1 ；SB=n；sp=0
P生產者：
While(1)
{...
Procer an item
Wait( SB )
Wait(SM)
緩沖操作
Singal(SM
Singal( SB )
…
}
C消費者：
While(1)
{...
Wait(SB )
Wait(SM
緩沖操作
Singal(SM
Singal(SB )
Consume the item
…
}
2、銀行家演算法中，若出現下述的資源分配情況：
Process Allocation Need Available
P0 0 , 1 , 0 7 , 4 , 3 3 , 3 , 2
P1 2 , 0 , 0 1 , 2 , 4
P2 3 , 0 , 2 6 , 5 , 0
P3 2 , 1 , 1 0 , 1 , 1
P4 0 , 0 , 2 4 , 3 , 1
試問：（1）當前系統狀態是否安全？如果安全寫出安全序列。（7分）
（2）若進程P1 提出請求 Request ( 1 , 0 , 2 ) 後，系統能否將資源分配給它？（3分）
（1）存在如下進程序列，可使進程順利執行完畢：
進程 可用資源數
P3：執行完 5 ，4 ，3
P4：執行完 5 ，4 ，5
P1：執行完 7 ，4 ，5
P0：執行完 7 ，5 ，5
P2：執行完 10 ，5 ，7
當前系統是安全的，安全序列是：P3 , P4 , P1 , P0 , P2 . （8分）
(2) 如果將資源分配給進程P1 ,這時所有待執行的進程中就沒有滿足所需資源數
<=系統可提供資源數條件的，所以系統不可以將資源分配P1（2分）
3、假設一磁軌有200個柱面，編號為0 — 199 ，在完成了磁軌125處的請求後，當前正在磁軌143處為一請求服務，若請求隊列的先後順序為86，147，91，177，94，150，102，175，130。試分別採用FCFS（先來先服務）、SSTF（最短尋道時間優先）演算法完成上述請求，寫出磁軌移動的順序，並計算磁頭移動的總距離。（本題8分）
（1）採用FCFS演算法調度，磁頭移動順序為：
143-86-147-91-177-94-150-102-175-130
磁頭移動總量為：565（柱面）。（4分）
（2）採用SSTF演算法調度，磁頭移動順序為：
143-147-150-130-102-94-91-86-175-177
磁頭移動總量為：162（柱面）。（4分）
4、我們打開計算機中的某個word文檔，然後通過列印機列印文檔中的內容，在這個過程中，操作系統為我們做了什麼？試從操作系統功能的角度加以分析。（本題12分）
進程管理：執行時完成調度（2分）
存儲管理：為調度的進程分配內存，以及從硬碟中讀取文件。（2分）
文件管理：所調度文件的查詢與讀取（2分）
設備管理：列印機的驅動，以及列印工作的執行。（2分）
用戶介面：執行程序時的界面，以及程序進程本身所含的系統調度。（2分）
整個過程是五個功能合作完成。（2分）
⑽ 怎樣計算sp和WRR的優先順序調度
QOS優先順序隊列調度:每埠支持8個優先順序隊列,3個丟棄優先順序,支持SP、WRR、CBWFQ隊列調度演算法,支持WRED擁塞避免演算法,支持流量整形,支持802.1P,DSCP/TOS優先順序和重新。