基本介紹
- 中文名：VxWork
- 類型：作業系統
- 地區：美國
- 屬於：WindRiver公司
區別,特點,可靠性,實時性,可裁減性,要求,系統編程,
區別
實時作業系統和分時作業系統的區別
從作業系統能否滿足實時性要求來區分，可把作業系統分成分時作業系統和實時作業系統。
實時作業系統能夠在限定的時間內執行完所規定的功能，並能在限定的時間內對外部的異步事件作出回響。分時系統主要套用於科學計算和一般實時性要求不高的場合。實時性系統主要套用於過程控制、數據採集、通信、多媒體信息處理等對時間敏感的場合。
特點
可靠性
作業系統的用戶希望在一個工作穩定，可以信賴的環境中工作，所以作業系統的可靠性是用戶首先要考慮的問題。而穩定、可靠一直是VxWorks的一個突出優點。自從對中國的銷售解禁以來，VxWorks以其良好的可靠性在中國贏得了越來越多的用戶。
實時性
實時性是指能夠在限定時間內執行完規定的功能並對外部的異步事件作出回響的能力。實時性的強弱是以完成規定功能和作出回響時間的長短來衡量的。
VxWorks的實時性做得非常好，其系統本身的開銷很小，進程調度、進程間通信、中斷處理等系統公用程式精練而有效，它們造成的延遲很短。VxWorks 提供的多任務機制中對任務的控制採用了優先權搶占（Preemptive Priority Scheduling）和輪轉調度（Round-Robin Scheduling）機制，也充分保證了可靠的實時性，使同樣的硬體配置能滿足更強的實時性要求，為套用的開發留下更大的餘地。
可裁減性
VxWorks由一個體積很小的核心及一些可以根據需要進行定製的系統模組組成。VxWorks核心最小為 8kB，即便加上其它必要模組，所占用的空間也很小，且不失其實時、多任務的系統特徵。由於它的高度靈活性，用戶可以很容易地對這一作業系統進行定製或作適當開發，來滿足自己的實際套用需要。
要求
對一個實時核心的要求
一個實時作業系統核心需滿足許多特定的實時環境所提出的基本要求，這些包括：
搶占調度：真實世界的事件具有繼承的優先權，在分配CPU的時候要注意到這些優先權。基於優先權的搶占調度，任務都被指定了優先權，在能夠執行的任務（沒有被掛起或正在等待資源）中，優先權最高的任務被分配CPU資源。換句話說，當一個高優先權的任務變為可執行態，它會立即搶占當前正在運行的較低優先權的任務。
任務與中斷之間的通信：儘管真實世界的事件通常作為中斷方式到來，但為了提供有效的排隊、優先化和減少中斷延時，我們通常希望在任務級處理相應的工作。所以需要雜任務級和中斷級之間存在通信。
系統編程
了解系統編程對程式設計師來說尤為重要。根據Drew個人的經驗基本上作業系統編程都是類似的，認真讀懂一種，就很容易的理解另一種。
下面是Drew翻的VxWorks programmer guide中的基本內容，有一些內容是Drew個人的理解。理解這些內容對實時操作編程非常重要。
一個多任務環境允許實時應用程式以一套獨立任務的方式構築，每個任務擁有獨立的執行執行緒和它自己的一套系統資源。進程間通信機制使得這些任務的行為同步、協調。 wind使用中斷驅動和優先權的方式。它縮短了上下文轉換的時間開銷和中斷的時延。在 VxWorks 中，任何例程都可以被啟動為一個單獨的任務，擁有它自己的上下文和堆疊。還有一些其它的任務機制可以使任務掛起、繼續、刪除、延時或改變優先權。
Task State Transitions
中斷延遲(Interrupt Latency) 中斷延遲是指從硬體中斷髮生到開始執行中斷處理程式第一條指令之間的這段時間。
優先權驅動(Priority-Driven) 優先權驅動是指多任務系統中，當前運行任務總是具有最高優先權的就緒任務。
多任務調度
兩種方式: 優先搶占和輪轉調度(Preemptive Priority,Round-Robin Scheduling).
優先搶占(Preemptive Priority): 每一個任務都有一個優先權,系統核心保證優先權最高的任務運行於CPU.如果有任務優先權高於當前的任務優先權,系統立刻保存當前任務的上下文,切換到優先權高的上下文.
Priority Preemption
上下文切換（Context Switching）: 多任務系統中，上下文切換是指CPU的控制權由運行任務轉移到另外一個就緒任務時所發生的事件，當前運行任務轉為就緒（或者掛起、刪除）狀態，另一個被選定的就緒任務成為當前任務。上下文切換包括保存當前任務的運行環境，恢復將要運行任務的運行環境。上下文的內容依賴於具體的CPU.
輪轉調度(Round-Robin Scheduling):使所有相同優先權,狀態為ready的任務公平分享CPU(分配一定的時間間隔,使個任務輪流享有CPU).
Round-Robin Scheduling
系統由256個優先權,從0到255,0為最高,255為最低. 任務在被創建時設定了優先權.也可用taskPrioritySet ( ) 來改變任務優先權.
任務的主要狀態: READY,PEND,DELAY,SUSPEND...
ready-------->pended -----------semTake( )/msgQReceive( )-其他任務
ready-------->delayed-----------taskDelay( )
ready-------->suspended---------taskSuspend( )
pended------->ready-------------semaGive( )/msgQSend( )-其他任務
pended------->suspended---------taskSuspend( )
delayed------>ready-------------expired delay
delayed------>suspended---------taskSuspend( )
suspended---->ready-------------taskResume( )/taskActivate( )
suspended---->pended------------taskResume( )
suspended---->delayed-----------taskResume( )
輪轉調度 (Round-Robin): 輪轉調度可以擴充到優先搶占方式中,當多個任務優先權相同的情況下,輪轉調度算法使任務按平等的時間片運行於CPU,共享CPU.避免一個任務長時間占用CPU,而導致其他任務不能運行.可以用 kernelTimeSlice( ) 來定義時間長度.
taskLock ( )和 taskUnlock ( ) 用來取消優先搶占方式 和恢復優先搶占方式.
注意: 一個任務可以調用taskDelete ( ) 刪除另一個任務,但是如果一個當前正在運行的任務被刪除後,該任務的記憶體沒有釋放,而其他任務不知道,依然在等待,結果導致系統stop.用 taskSafe ( ) 和 taskUnsafe ( ) 來保證正在運行的任務不被刪除.
用法如下:
taskSafe ();
semTake (semId, WAIT_FOREVER);
/* Block until semaphore available */
. . . . critical region .
semGive (semId); semGive (semId);
/* Release semaphore */
taskUnsafe ();
任務間的同步和進程間協調
信號量作為任務間同步和互斥的機制。在 wind 核中有幾種類型的信號量，它們分別針對不同的套用需求：二進制信號量、計數信號量、互斥信號量和 POSIX 信號量。所有的這些信號量是快速和高效的，它們除了被套用在開發設計過程中外，還被廣泛地套用在VxWorks 高層套用系統中。對於進程間通信，wind 核也提供了諸如訊息佇列、管道、套接字和信號等機制。
任務間的同步和進程間協調的幾種方式:
訊息佇列(Message queues)和管道(Pipe),單個CPU中,任務間的信息傳遞.
套結字(Socket)和遠程調用(Remote procedure calls),相對於網路任務間的通信.
信號(Signals),出錯處理(Exception handling).
記憶體共享(Shared Memory)
任務間通信最通常的方式是通過共享的數據結構進行通信,因為所有VxWorks的任務存在於一個單一的線性地址空間，任務間共享數據。全局變數、線性佇列、環形佇列、鍊表、指針都可被運行在不同上下文的代碼所指向。
Shared Data Structures
互斥(Mutual Exclusion)
互斥是用來控制多任務對共享數據進行串列訪問的同步機制。在多任務套用中，當兩個或多個任務同時訪問共享數據時，可能會造成數據破壞。互斥使它們串列地訪問數據，從而達到保護數據的目的.
解決互斥的幾種方法:
1. 關閉中斷的方法(intLock): 能解決任務和中斷ISR之間產生的互斥.
funcA ()
{ int lock = intLock();
. . critical region that cannot be interrupted .
intUnlock (lock); }
2. 關閉系統優先權(taskLock): 關閉系統優先權,這樣在當前任務執行時,除了中斷外,不會有其他優先權高的任務來搶占CPU,影響當前程式運行.
funcA ()
{ taskLock ();
. . critical region that cannot be interrupted .
taskUnlock (); }
這種方法阻止了高優先權的任務搶先運行,在實時系統中也是不適合的,除非關閉優先權的時間特別短.
VxWorks信號量提供最快速的任務間通信機制，它主要用於解決任務間的互斥和同步。針對不同類型的問題，有以下三種信號量：
Ÿ 互斥信號量(mutual exclusion) 特殊的二進制信號量，主要用於優先權繼承、安全刪除和回溯；
Ÿ 計數器信號量(counting) 和二進制信號量類似，保持信號量被釋放（gaven)的次數 ,主要用於保護一個資源的多個例程（multiple instances of a resource）
信號量控制，函式介紹:
semBCreate( ) 分配並初始化一個二進制信號量
semMCreate( ) 分配並初始化一個互斥信號量
semCCreate( ) 分配並初始化一個計數信號量
semDelete( ) 終止一個自由的信號量
semTake( ) 占有一個信號量
semGive( ) 釋放一個信號量
semFlush( ) 解鎖所有等待信號量的任務
semBCreate( ), semMCreate( ), and semCCreate( )返回一個信號量ID作為其它後續任務使用該信號量的的句柄。當一個信號量被創建，它的佇列（queue)類型就被確定。等待信號量的任務佇列以優先權的高低排列(SEM_Q_PRIORITY)，或者一先到先得的方式排列（SEM_Q_FIFO).
當一個Semaphore創建時,指定了任務佇列的種類
semBCreat( SEM_Q_PRIORITY, SEM_FULL), SEM_Q_PRIORITY 指明處於等待狀態的任務在等待佇列中以優先權的順序排列
semBCreat(SEM_Q_FIFO,SEM_FULL), SEM_Q_FIFO指明 處於等待狀態的任務在等待佇列中以先進先出的順序排列
Taking a Semaphore
Giving a Semaphore
互斥進程（Mutual Exclusion）
互斥信號量有效的內鎖對共享資源的進入，與禁止中斷(disabling interrupts)和優先權鎖定（preemptive locks）相比，二進制信號量將互斥的範圍限制在僅與其有關的資源上。從技術上說，創建一個信號量來保護(guarding)資源。信號量初始化位可用的（FULL）。
semBCreat( SEM_Q_FIFO, SEM_FULL) , SEM_FULL 指明用於任務間互斥.
SEM_ID semMutex;
semMutex = semBCreate (SEM_Q_PRIORITY, SEM_FULL);
當一個任務要進入資源，首先要得到一個信號量（take that semaphore），只要有任務在使用這個信號量，其它的要進入資源的任務要停止執行（blocked from execution），當這個任務完成了對資源的使用，它會釋放信號量，允許另一個任務來使用資源。
semTake (semMutex, WAIT_FOREVER);
. . critical region, only accessible by a single task at a time .
semGive (semMutex);
同步協調進程（Synchronization）
semBCreat(SEM_Q_FIFO,SEM_EMPTY), SEM_EMPTY 指明用於任務間同步.
/* includes */
#include "vxWorks.h"
#include "semLib.h"
SEM_ID syncSem;
/* ID of sync semaphore */
init ( int someIntNum )
{ /* connect interrupt service routine */
intConnect (INUM_TO_IVEC (someIntNum), eventInterruptSvcRout, 0);
/* create semaphore */
syncSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
/* spawn task used for synchronization. */
taskSpawn ("sample", 100, 0, 20000, task1, 0,0,0,0,0,0,0,0,0,0);
}
task1 (void)
{ ...
semTake (syncSem, WAIT_FOREVER);
/* wait for event to occur */
printf ("task 1 got the semaphore\n");
...
/* process event */
}
eventInterruptSvcRout (void)
{ ...
semGive (syncSem);
/* let task 1 process event */
...
}
semTake(semID,time out)--------有Semaphore空閒,就Take, 如果沒有,由time out 定,逾時則向下執行
互斥信號量
互斥信號量的使用基本和二進制信號量是類似的。但有以下不同：
僅僅被用做互斥。
只能被使用它的任務釋放.(It can be given only by the task that took it.)
ISR 不能釋放它。
不能使用函式semFlush( )。
優先權反轉(Priority Inversion)
優先權反轉是指一個任務等待比它優先權低的任務釋放資源而被阻塞，如果這時有中等優先權的就緒任務，阻塞會進一步惡化。優先權繼承技術可用來解決優先權反轉問題。
Priority inversion arises when a higher-priority task is forced to wait an indefinite period of time for a lower-priority task to complete.
優先權繼承(Priority Inheritance)
優先權繼承可用來解決優先權反轉問題。當優先權反轉發生時，優先權較低的任務被暫時地提高它的優先權，使得該任務能儘快執行，釋放出優先權較高的任務所需要的資源。
Priority Inheritance
The mutual-exclusion semaphore has the option SEM_INVERSION_SAFE, which enables a priority-inheritance algorithm. The priority-inheritance protocol assures that a task that owns a resource executes at the priority of the highest-priority task blocked on that resource. Once the task priority has been elevated, it remains at the higher level until all mutual-exclusion semaphores that the task owns are released; then the task returns to its normal, or standard, priority. Hence, the "inheriting" task is protected from preemption by any intermediate-priority tasks. This option must be used in conjunction with a priority queue (SEM_Q_PRIORITY).
計數信號量（Counting Semaphores）
計數信號量是任務同步和互斥的另一種實現方式.計數信號量除了保留信號量被釋放的次數以外和二進制信號量是一樣的。每次信號量被釋放（gaven)一次，計數增加；每次信號量被占用（taken)一次，計數減少;當計數減少為0時，要求得到信號量的任務被阻塞（blocked)。二進制信號量是如果一個信號量被釋放，有一個任務阻塞等待，則這個任務就被unblock.而計數信號量如果一個信號量被釋放，沒有任務阻塞等待，則計數增加。這說明一個被釋放兩次的計數信號量可以被占用(taken)兩次,沒有阻塞。
Counting semaphores are useful for guarding multiple copies of resources. For example, the use of five tape drives might be coordinated using a counting semaphore with an initial count of 5, or a ring buffer with 256 entries might be implemented using a counting semaphore with an initial count of 256. The initial count is specified as an argument to the semCCreate( ) routine.
Counting Semaphore Example
--------------------------------------------------------------------------------
Semaphore Call
Count after Call
Resulting Behavior
--------------------------------------------------------------------------------
semCCreate( )
3
Semaphore initialized with initial count of 3.
semTake( )
2
Semaphore taken.
semTake( )
1
Semaphore taken.
semTake( )
0
Semaphore taken.
semTake( )
0
Task blocks waiting for semaphore to be available.
semGive( )
0
Task waiting is given semaphore.
semGive( )
1
No task waiting for semaphore; count incremented.
--------------------------------------------------------------------------------
訊息佇列(Message queues)
現實的實時套用由一系列互相獨立又協同工作的任務組成。信號量為任務間同步和聯鎖提供了高效機制。在VxWorks中，用於但一CPU任務之間通信主要（primary）的機制是訊息佇列。
Full Duplex Communication Using Message Queues
訊息佇列允許一定數量不同長度的訊息進行排列。任何任務或中斷服務程式(ISR)能夠傳送訊息給訊息佇列。任何任務可以從訊息佇列接受訊息。多任務可以從同意訊息佇列傳送和接受訊息。兩個任務之間的全雙工（Full-duplex）通信需要針對不同方向的兩個訊息佇列。
訊息佇列函式介紹msgQCreate( ) 創建並初始化一個訊息佇列
msgQDelete( ) 終止並釋放一個訊息佇列
msgQSend( ) 傳送一個訊息到訊息佇列
msgQReceive( ) 從訊息佇列接受一個訊息
訊息佇列是由函式msgQCreate (MAX_MSGS, MAX_MSG_LEN, MSG_Q_PRIORITY)創建。它的參數MAX_MSGS指定了訊息佇列中可允許最多可以排列的訊息數和每個訊息允許的最大的位元組數MAX_MSG_LEN。
一個任務或中斷服務程式(ISR)用函式msgQSend( )傳送一個訊息到訊息佇列。如果沒有任務等待訊息佇列的訊息，這個訊息被添加訊息快取的佇列里。如果某些任務已經在等待訊息佇列中的訊息，訊息立刻被傳遞給第一個等待的訊息的任務。
一個任務用函式msgQReceive( )從訊息佇列得到一個訊息。如果訊息佇列快取中有訊息存在，第一個訊息立刻出列並回到調用處(caller).如果沒有訊息存在，則任務（calling task）停止（blocks)並被添加到等待訊息的任務佇列中。這個等待的任務佇列按照優先權或先進先出（FIFO)規則排列，這個規則有訊息佇列創建時所指定。
等待時間限制（time out)
msgQSend( ) 和 msgQReceive( )都有時間限制參數。當傳送一個訊息，如果訊息佇列快取這時沒有空間，這個參數指定允許等待的時間（ticks數），直到佇列快取有空間來接收訊息。當接收訊息時，如果訊息佇列沒有訊息，這個參數指定允許等待的時間（ticks數），直到訊息佇列有訊息。
/* In this example, task t1 creates the message queue and sends a message
* to task t2. Task t2 receives the message from the queue and simply
* displays the message.
*/
/* includes */
#include "vxWorks.h"
#include "msgQLib.h"
/* defines */
#define MAX_MSGS (10)
#define MAX_MSG_LEN (100)
MSG_Q_ID myMsgQId;
task2 (void)
{
char msgBuf[MAX_MSG_LEN];
/* get message from queue; if necessary wait until msg is available */
if (msgQReceive(myMsgQId, msgBuf, MAX_MSG_LEN, WAIT_FOREVER) == ERROR)
return (ERROR);
/* display message */
printf ("Message from task 1:\n%s\n", msgBuf);
}
#define MESSAGE "Greetings from Task 1"
task1 (void)
{
/* create message queue */
if ((myMsgQId = msgQCreate (MAX_MSGS, MAX_MSG_LEN, MSG_Q_PRIORITY))
== NULL)
return (ERROR);
/* send a normal priority message, blocking if queue is full */
if (msgQSend (myMsgQId, MESSAGE, sizeof (MESSAGE), WAIT_FOREVER,
MSG_PRI_NORMAL) == ERROR)
return (ERROR);
}
管道（Pipes）
管道對訊息佇列提供了一個可供選擇的接口，VxWorks的I/O系統。管道是虛擬的I/O設備，由驅動pipeDrv管理。函式pipeDevCreate()創建一個管道設備，這個調用指定管道的名字，能被排列的最多的訊息數，和每個訊息允許的長度。
status = pipeDevCreate ("/pipe/name", max_msgs, max_length);
被創建的管道是一個通常命名（named)的I/O設備,任務能用標準的I/O函式打開，讀，寫管道，並能調用ioctl例程。當任務試圖從一個空的管道中讀取數據，或向一個滿的管道中寫入數據時，任務被阻塞。和訊息佇列一樣，ISR可以向管道寫入，但不能從管道讀取。
做為I/O設備，管道提供了訊息佇列所沒有的重要特性，調用select()
