(筆記)Linux下的準確延時,#include <linux/delay.h>調用出錯

標籤：style   io   ar   os   使用   sp   strong   on   檔案   

在編寫應用程式層程式時，有時需要延時一下，這個時候該怎麼辦呢？

 

在核心代碼中，我們經常會看到這樣的標頭檔使用#include <linux/delay.h>,心想著直接調用這個就可以了吧！可是在編譯時間發現，壓根通不過，

提示錯誤如下：error: No such file or directory.

 

是不是覺得很奇怪，明明檔案是存在的，怎麼就不能調用了，而且核心很多檔案調用得很歡。這是為什麼呢？

因為核心程式跟應用程式是有區別的，有些特殊的核心標頭檔編譯器不允許被應用程式調用。故編譯應用程式使用核心的標頭檔，報錯是難免的

但是，這個時候該怎麼呢？

 

哈哈！#include <unistd.h>標頭檔出現了！功能與#include <linux/delay.h>一致，但是可以在應用程式層隨便調用。不錯的東西吧！以下是其詳細介紹：

 

 

應用程式層：
   #include <unistd.h>
 
   1、unsigned int sleep(unsigned int seconds); 秒級
   2、int usleep(useconds_t usec);              微秒級：1/10^-6

 
   #define _POSIX_C_SOURCE 199309
   #include <time.h>
   3、int nanosleep(const struct timespec *req, struct timespec *rem);
       struct timespec {
                  time_t tv_sec;        /* seconds */
                  long   tv_nsec;       /* nanoseconds */
              };
       // The value of the nanoseconds field must be in the range 0 to 999999999.
 
 核心層：
   include <linux/delay.h>
   1、void ndelay(unsigned long nsecs);         納秒級：1/10^-10
   2、void udelay(unsigned long usecs);         微秒級: 1/10^-6
   3、void mdelay(unsigned long msecs);         毫秒級：1/10^-3 

   udelay用軟體迴圈指定的微妙數，mdelay調用前者達到延遲毫秒級。udelay 函數只能用於擷取較短的時間延遲，因為loops_per_second值的精度只有8位，所以，當計算更長的延遲時會積累出相當大的誤差。儘管最大能允 許的延遲將近1秒(因為更長的延遲就要溢出)，推薦的 udelay 函數的參數的最大值是取1000微秒(1毫秒)。延遲大於 11 毫秒時可以使用函數 mdelay。mdelay 在 Linux 2.0 中並不存在，標頭檔 sysdep.h 彌補了這一缺陷。
   要特別注意的是 udelay 是個忙等待函數（所以 mdelay 也是），在延遲的時間段內無法運行其他的任務，因此要十分小心，尤其是 mdelay，除非別無他法，要盡量避免使用。 

   首先, 我會說不保證你在使用者模式 (user-mode) 中執行的行程 (process) 能夠精確地控制時序因為 Linux 是個多工的作業環境. 你在執行中的行程 (process) 隨時會因為各種原因被暫停大約 10 毫秒到數秒 (在系統負荷非常高的時候). 然而, 對於大多數使用 I/O 埠的應用而言, 這個延遲時間實際上算不了什麽. 要縮短延遲時間, 你得使用函式 nice 將你在執行中的行程 (process ) 設定成高優先權(請參考nice(2)使用說明檔案) 或使用即時排程法 (real-time scheduling) (請看下面).

  如果你想獲得比在一般使用者模式 (user-mode) 中執行的行程 (process) 還要精確的時序, 有一些方法可以讓你在使用者模式 (user-mode) 中做到 `即時‘ 排程的支援. Linux 2.x 版本的核心中有軟體方式的即時排程支援; 詳細的說明請參考 sched_setscheduler(2) 
使用說明檔案. 有一個特殊的核心支援硬體的即時排程; 詳細的資訊請參考網頁 luz.cs.nmt.edu/~rtlinux/

休息中 (Sleeping) :

sleep() 與 usleep()

  現在, 讓我們開始較簡單的時序函式呼叫. 想要延遲數秒的時間, 最佳的方法大概 是使用函式 sleep(). 想要延遲至少數十毫秒的時間 (10 ms 似乎已是最短的 延遲時間了), 函式 usleep()應該可以使用. 
  這些函式是讓出 CPU 的使用權 給其他想要執行的行程 (processes) (“自己休息去了‘‘), 所以沒有浪費掉 CPU 的時間. 細節請參考: sleep(3) 與 usleep(3) 的說明檔案.

  如果讓出 CPU 的使用權因而使得時間延遲了大約 50 毫秒 (這取決於處理器與機器的速度, 以及系統的負荷), 就浪費掉 CPU 太多的時間, 因為 Linux 的排程器 (scheduler) (單就 x86 架構而言) 在將控制權發還給你的行程 (process) 之前通常至少要花費 10-30 毫秒的時間. 因此, 短時間的延遲, 使用函式 usleep(3) 所得到的延遲結果通常會大於你在參數所指定的值, 大約至少有 10 ms.

nanosleep()

  在 Linux 2.0.x 一系列的核心發行版本中, 有一個新的系統呼叫 (system call),nanosleep() (請參考 nanosleep(2)的說明檔案), 他讓你能夠休息或延遲一個短的時間 (數微秒或更多).

  如果延遲的時間 <= 2 ms, 若(且唯若)你執行中的行程 (process) 設定了軟體的即時 排程 (就是使用函式 tt/sched_setscheduler()/), 呼叫函式 nanosleep()  時不是使用一個忙碌迴圈來延遲時間; 就是會像函式 usleep() 一樣讓出 CPU 的使用權休息去了.

  這個忙碌迴圈使用函式 udelay() (一個驅動程式常會用到的核心內部的函式) 來達成, 並且使用 BogoMips 值 (BogoMips 可以準確量測這類忙碌迴圈的速度) 來計算迴圈延遲的時間長度. 其如何動作的細節(請參考/usr/include/asm/delay.h).

使用 I/O 埠來延遲時間

  另一個延遲數微秒的方法是使用 I/O 埠. 就是從埠位址 0x80 輸入或輸出任何 byte 的資料 (請參考前面) 等待的時間應該幾乎只要 1 微秒這要看你的處理器的型別與速度. 如果要延遲數微秒的時間你可以將這個動作多做幾次. 在任何標準的機器上輸出資料到該 埠位址應該不會有不良的後果□對 (而且有些核心的裝置驅動程式也在使用他).

{in|out}[bw]_p()等函式就是使用這個方法來產生時間延遲的 (請參考檔案asm/io.h).

  實際上, 一個使用到埠位址範圍為 0-0x3ff 的 I/O 埠指令幾乎只要 1 微秒的時間, 所以如果你要如此做, 例如, 直接使用並列埠, 只要加上幾個inb()函式從該埠位址□圍讀入 byte 的資料即可.

使用組合語言來延遲時間

  如果你知道執行程式所在機器的處理器型別與時脈速度, 你可以執行某些組合語言指令以便獲得較短的延遲時間 (但是記住, 你在執行中的行程 (process) 隨時會被暫停, 所以有時延遲的時間會比實際長). 如下面的表格所示, 內部處理器的速度決定了所要使用的刻度數; 如, 一個 50 MHz 的處理器 (486DX-50 或 486DX2-50), 一個刻度要花費 1/50000000 秒 (=200 奈秒).

    指令 i386 刻度數 i486 刻度數

    nop 3 1

    xchg %ax,%ax 3 3

    or %ax,%ax 2 1

    mov %ax,%ax 2 1

    add %ax,0 2 1

(對不起, 我不知道 Pentiums 的資料, 或許與 i486 接近吧. 我無法在 i386 的資料上找到只花費一個刻度的指令. 如果能夠就請使用花費一個刻度的指令, 要不然就使用管線技術的新式處理器也是可以縮短時間的.)

  上面的表格中指令 nop 與 xchg 應該不會有不良的後果. 指令最後可能會改變旗號暫存器的內容, 但是這沒關係因為 gcc 會處理. 指令 nop 是個好的選擇.

  想要在你的程式中使用到這些指令, 你得使用 asm("instruction"). 指令的文法就如同上面表格的用法; 如果你想要在單一的asm()敘述中使用多個指令, 可以使用分號將他們隔開. 
例如,
  asm("nop ; nop ; nop ; nop")

會執行四個 nop 指令, 在 i486 或 Pentium 處理器中會延遲四個刻度 (或是 i386 會延遲 12 個刻度).

gcc 會將 asm() 翻譯成單行組合語言程式碼, 所以不會有呼叫函式的負荷.

在 Intel x86 架構中不可能有比一個刻度還短的時間延遲.

在 Pentiums 處理器上使用函式 rdtsc

對於 Pentiums 處理器而言, 你可以使用下面的 C 語言程式碼來取得自從上次重新開機 到現在經過了多少個刻度:

extern __inline__ unsigned long long int rdtsc()

{

unsigned long long int x;

__asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));

return x;

}


你可以詢問參考此值以便延遲你想要的刻度數.

想要時間精確到一秒鐘, 使用函式 time() 或許是最簡單的方法. 想要時間更精確, 函式 gettimeofday() 大約可以精確到微秒 (但是如前所述會受到 CPU 排程的影響). 至於 Pentiums 處理器, 使用上面的程式碼片斷就可以精確到一個刻度.

如果你要你執行中的行程 (process) 在一段時間到了之後能夠被通知 (get a signal), 你得使用函式 setitimer() 或 alarm(). 細節請參考函式的使用說明檔案.

應用程式：

#include <syswait.h>

usleep(n) //n微秒

Sleep（n）//n毫秒

sleep（n）//n秒

驅動程式：

#include <linux/delay.h>

mdelay(n) //milliseconds 其實現

#ifdef notdef

#define mdelay(n) (\

{unsigned long msec=(n); while (msec--) udelay(1000);})

#else

#define mdelay(n) (\

(__builtin_constant_p(n) && (n)<=MAX_UDELAY_MS) ? udelay((n)*1000) : \

({unsigned long msec=(n); while (msec--) udelay(1000);}))

#endif

調用 asm/delay.h的udelay,udelay應該是納秒級的延時

 

Dos:

sleep(1); //停留1秒

delay(100); //停留100毫秒   

Windows:

Sleep(100); //停留100毫秒

Linux:

sleep(1); //停留1秒

usleep(1000); //停留1毫秒

每一個平台不太一樣, 最好自己定義一套跨平台的宏進行控制秒還是微秒？

關於延時函數sleep()

    因為要寫一段代碼，需要用到sleep（）函數，在我印象中，sleep(10)好像是休眠10微秒，結果卻是休眠了10秒（在Linux下）。覺得很奇怪，因為頭兒也記得好像是微秒為單位的。所以就查了一下。

原來linux下的sleep函數原型為：

        unsigned int sleep(unsigned int seconds);

而MFC中的 Sleep函數原型為：

        void Sleep(DWORD dwMilliseconds);

  也就是說，Linux下（使用的gcc的庫），sleep()函數是以秒為單位的，sleep(1);就是休眠1秒。而MFC下的sleep()函數是以微秒為單位的，sleep(1000); 才是休眠1秒。原來如此啊。而如果在Linux下也用微妙為單位休眠，可以使用線程休眠函數:void usleep(unsigned long usec);當然，使用的時候別忘記#include <system.h>哦。

    另外值得一提的是，linux下還有個delay()函數，原型為extern void delay(unsigned int msec);它可以延時msec*4毫秒，也就是如果想延時一秒鐘的話，可以這麼用 delay(250);


當一個裝置驅動需要處理它的硬體的反應時間, 涉及到的延時常常是最多幾個毫秒. 

核心功能 ndelay, udelay, 以及 mdelay 對於短延時好用, 分別延後執行指定的納秒數, 微秒數或者毫秒數. 它們的原型是:

#include <linux/delay.h>
void ndelay(unsigned long nsecs);
void udelay(unsigned long usecs);
void mdelay(unsigned long msecs); 
有另一個方法獲得毫秒(和更長)延時而不用涉及到忙等待. 檔案 <linux/delay.h> 聲明這些函數:

void msleep(unsigned int millisecs);
unsigned long msleep_interruptible(unsigned int millisecs);
void ssleep(unsigned int seconds) 
前 2 個函數使調用進程進入睡眠給定的毫秒數. 一個對 msleep 的調用是不可中斷的; 你能確保進程睡眠至少給定的毫秒數. 如果你的驅動位於一個等待隊列並且你想喚醒來打斷睡眠, 使用 msleep_interruptible. 從 msleep_interruptible 的傳回值正常地是 0; 如果, 但是, 這個進程被提早喚醒, 傳回值是在初始請求睡眠周期中剩餘的毫秒數. 對 ssleep 的調用使進程進入一個不可中斷的睡眠給定的秒數.

(筆記)Linux下的準確延時,#include <linux/delay.h>調用出錯