< Return to Video

Understanding a Real-Time System by Steven Rostedt

  • 0:00 - 0:02
    好 我們開始吧~
  • 0:02 - 0:03
    我叫 Steve Rostedt
  • 0:05 - 0:06
    你們應該看的到螢幕吧?
  • 0:06 - 0:09
    我會走到螢幕中間，但盡量不要擋到
  • 0:12 - 0:13
    我在 Red Hat 工作
  • 0:13 - 0:15
    我常說我在 Red Hat 都在從事自己的興趣
  • 0:16 - 0:17
    但最近他們叫我做更多事
  • 0:17 - 0:20
    所以我必須開始工作了
  • 0:20 - 0:22
    我已從事近 10 年
  • 0:24 - 0:26
    打從我在 TimeSys 公司的工作開始
  • 0:26 - 0:29
    在那之前，我做顧問性質的工作
  • 0:29 - 0:35
    後來我開始 ... 試著把 Linux 變成即時系統
  • 0:35 - 0:37
    我找尋是否已有正在進行的解決方案
  • 0:37 - 0:42
    結果發現 Ingo Molnar 有個專案叫 Preempt Realtime
  • 0:42 - 0:45
    我就加入他們，從 2004 年開始工作
  • 0:46 - 0:47
    之後他們換到 PREEMPT_RT
  • 0:47 - 0:51
    之後 Ingo 把維護者的職責交給 Thomas Gleixner
  • 0:51 - 0:56
    他今天就在會場，就是你可能會不小心碰到的高大德國佬
  • 0:59 - 1:02
    我在這做了一段時間
  • 1:03 - 1:06
    Thomas 負責開發工作、加新東西
  • 1:06 - 1:12
    並且讓最新的 Linux 核心可以和最新的 Preempt_RT 核心整合運作
  • 1:12 - 1:15
    我負責維護穩定發行版
  • 1:15 - 1:17
    新的核心版本一旦發行
  • 1:17 - 1:19
    且 Thomas 決定投入開發
  • 1:19 - 1:22
    他會把前一個核心版本的成果交給我
  • 1:22 - 1:24
    我會在 kernel.org 維護它
  • 1:25 - 1:28
    現場還有很多位子 都進來吧
  • 1:28 - 1:29
    所以
  • 1:30 - 1:33
    我今天要講的其實不是即時核心
  • 1:33 - 1:34
    但我會提到
  • 1:34 - 1:37
    因為我已經講了很多關於即時核心的演講
  • 1:37 - 1:41
    我現在比較感興趣的是：什麼是一個即時系統？
  • 1:42 - 1:46
    不僅僅是核心，我更要讓你了解什麼是即時系統
  • 1:47 - 1:48
    什麼是「即時」？
  • 1:49 - 1:51
    我想有個心理準備
  • 1:51 - 1:53
    有人知道什麼是「即時系統」嗎？
  • 1:53 - 1:55
    我需要再講一遍吧？
  • 1:55 - 1:56
    別吝於舉手好嗎？
  • 1:56 - 2:00
    我知道大家才剛用完午餐，可能不願意表達
  • 2:00 - 2:02
    你們應該都知道吧？
  • 2:02 - 2:03
    欸~
  • 2:03 - 2:04
    好~ 不管
  • 2:05 - 2:06
    我討厭「即時」這個詞
  • 2:07 - 2:15
    我聽了微軟的人講有關即時系統 ....
  • 2:15 - 2:17
    有微軟的人在這嗎？
  • 2:17 - 2:18
    很有趣的演講
  • 2:18 - 2:23
    那是有關「即時系統」在即時串流的應用
  • 2:23 - 2:25
    你可以目睹事情發生的過程
  • 2:25 - 2:27
    那是另一回事，不是我要講的
  • 2:27 - 2:33
    目睹某件事即時的發生，這不是我要講的
  • 2:33 - 2:35
    "即時" 對我們來說，乃 "可預測性"
  • 2:35 - 2:40
    我討厭 "即時" 這個字，就是因為它會讓人聯想到 "很快" 這個概念
  • 2:40 - 2:42
    "即時" 等價於 "很快" ，這是錯的
  • 2:42 - 2:44
    我待會會提到這件事
  • 2:44 - 2:49
    大家把它當成 "即時作業系統" (RTOS)
  • 2:49 - 2:50
    我討厭這種稱呼
  • 2:50 - 2:55
    我想把他稱作 "可預測的作業系統" (Deterministic OS; DOS)
  • 2:58 - 3:02
    DOS 其實也能做到「符合預期」
  • 3:02 - 3:04
    你想做什麼，她就幫你做什麼
  • 3:04 - 3:05
    你讓她爛掉，她就爛給你看
  • 3:05 - 3:06
    還不錯吧
  • 3:06 - 3:09
    所以 ... 什麼是 "可預測的結果" ？
  • 3:09 - 3:10
    基本上，它有可重複性
  • 3:10 - 3:12
    你可以事先預測它的結果
  • 3:12 - 3:16
    如果你預測它要花 10 微秒，它真的就只花 10 微秒
  • 3:16 - 3:17
    或是在一個區間範圍內
  • 3:17 - 3:23
    如果限制它不會跑超過100毫秒，它就永遠不會
  • 3:23 - 3:25
    如果會，那就是一個 bug ，你得把它修好
  • 3:25 - 3:27
    我們看的是最壞情形
  • 3:29 - 3:32
    "無界的延遲" ，我待會也會講到
  • 3:34 - 3:40
    你在用一個即時系統的時候，所有行為都應該是可預測的
  • 3:40 - 3:48
    如果有一個元件無法預測，整個系統都會爛掉
  • 3:49 - 3:51
    什麼叫 "很快" ？
  • 3:52 - 3:56
    電腦裡很多元件讓電腦可以跑得很快
  • 3:56 - 4:01
    原因是：90%以上的使用者要的是"總處理能力"
  • 4:01 - 4:05
    他們想以最快的速度做完任何事
  • 4:05 - 4:12
    我曾經在巴西給一場演講，主題為「誰需要即時核心？絕對不是你」
  • 4:12 - 4:16
    因為大部分使用者不關心可預測性，他們只關心速度
  • 4:16 - 4:21
    大部分的狀況，可預測性被速度的需求掩蓋了
  • 4:21 - 4:26
    舉例來說：電腦有 "快取"，可以預載記憶體內容
  • 4:26 - 4:31
    在這個模式下，大部分時間程式都是循序執行的
  • 4:31 - 4:33
    程式不會跳來跳去
  • 4:33 - 4:36
    所以我們可以在程式還沒有用到之前，就先載入它
  • 4:36 - 4:37
    這讓速度變快了
  • 4:37 - 4:40
    "記憶體分頁" ，"記憶體管理單元" 會用到的東西
  • 4:40 - 4:43
    有人根本不在意這個，因為他們用缺乏記憶體管理單元 (MMU-less) 的系統
  • 4:43 - 4:45
    不是在講你們，那東西很無聊
  • 4:45 - 4:48
    Linus Torvalds 自己也說了，那東西一點都不有趣
  • 4:48 - 4:49
    但我卻笑了
  • 4:49 - 4:51
    因為在我年輕的時候
  • 4:51 - 4:56
    我的第一個專案就是把 Linux 移植到一個沒有 "記憶體管理單元"
  • 4:56 - 4:59
    它其實滿有趣的啦
  • 4:59 - 5:04
    "分頁" ，就有 "分頁查詢表"，還有一個 TLB"
  • 5:04 - 5:06
    那東西基本上就是 "分頁查詢表" 的快取
  • 5:06 - 5:08
    這我待會也會提到
  • 5:08 - 5:11
    "中斷" ，你想要的其實是 "批量" ，才可已讓速度變快
  • 5:11 - 5:14
    如果你要跑某個5分鐘的程式
  • 5:14 - 5:16
    然後你有很多程式要跑
  • 5:16 - 5:18
    你想讓它們快快跑完
  • 5:18 - 5:20
    你不希望某個程式真的連續跑5分鐘
  • 5:20 - 5:26
    且它掌控所有 CPU 資源、所有快取
  • 5:26 - 5:28
    它的確會跑得很快
  • 5:28 - 5:30
    但你沒有 "反應時間" 可言
  • 5:30 - 5:32
    如果某個東西突然需要跑，切換到它就會超慢
  • 5:32 - 5:40
    所以，如果某個程式跑得很快，事實上它犧牲了可預測性
  • 5:42 - 5:44
    優化最可能的連結
  • 5:44 - 5:46
    有一個東西叫 Transactional memory
  • 5:46 - 5:50
    那是個很有趣的功能
  • 5:50 - 5:54
    有人知道什麼是 Transactional memory 嗎？
  • 5:54 - 5:55
    呃... 很少人
  • 5:56 - 6:00
    基本上，假設你掌握一道鎖
  • 6:00 - 6:05
    不是一個特定的進程，就是一個大方向來說
  • 6:05 - 6:08
    你持有一道鎖，進入一個臨界區段（Critical section）
  • 6:08 - 6:11
    你跑就對了，根本不管有沒有鎖
  • 6:11 - 6:13
    你不做任何記憶體封鎖
  • 6:13 - 6:20
    你不用拿一道鎖，確保不同 CPU 間保持同步
  • 6:21 - 6:23
    但是 CPU 知道你有一道鎖
  • 6:23 - 6:30
    你可以進入那個臨界區間，如果沒有其他進程同時進入，那麼一切順利
  • 6:30 - 6:41
    如果真的有其他進程進來了，你回復至原本的樣子，等到下次再重頭開始
  • 6:41 - 6:43
    大部分時間頗快的
  • 6:43 - 6:48
    有時候卻很慢，而且無法預測
  • 6:48 - 6:49
    所以我們必須權衡
  • 6:49 - 6:51
    "即時" 與 "跑得快" ，孰重孰輕？
  • 6:51 - 6:54
    我們兩者皆想要
  • 6:54 - 6:56
    雖然我們犧牲某一部份
  • 6:56 - 7:00
    但我們致力於製作一個可用的系統
  • 7:00 - 7:12
    如果有一個即時系統，按一個按鍵都可以預期在20秒內回應，你根本不會想用
  • 7:12 - 7:14
    但它卻是 "即時" 的
  • 7:14 - 7:17
    我強調一次它有多快
  • 7:17 - 7:22
    當你打字的時候，螢幕絕對會在 20 秒內顯示你的字，絕對不會在第 21 秒才顯示
  • 7:22 - 7:26
    這個就是 "可預測的作業系統"，一個 "即時系統"
  • 7:26 - 7:28
    一個爛透的東西
  • 7:30 - 7:35
    在這個系統中，任何元件都必須是 "即時" 的
  • 7:35 - 7:48
    包括 硬體、BIOS、核心 (我的工作內容)、套件庫、應用程式
  • 7:48 - 7:53
    有些套件庫可以跳過核心直接與硬體溝通
  • 7:53 - 7:58
    應用程式可以透過套件庫直接與接觸硬體，或是透過核心
  • 7:58 - 8:08
    所以你想做 "即時系統" 的話，每一個元件都必須配合
  • 8:08 - 8:10
    我們由下而上
  • 8:10 - 8:13
    硬體：一切的根基
  • 8:13 - 8:16
    如果連硬體都不能預測，剩下的就免談了
  • 8:18 - 8:23
    有個 IRC 頻道
  • 8:23 - 8:28
    你可以去 OFTC 搜尋 #linux-rt，我們都在那個頻道上
  • 8:28 - 8:32
    我們很少在那裏談工作的事，那邊是我們的冷卻槽
  • 8:32 - 8:34
    就是你會在 IRC 上會做的事，但有時還是會聊工作啦
  • 8:34 - 8:44
    那個人在 IRC 站上提到，他在一個循環測試遇到 500 微秒的延遲( 其實是 1 毫秒 )
  • 8:44 - 8:48
    或 2 到 3 毫秒的延遲
  • 8:48 - 8:52
    循環測試就是一個測試誤差間隔的迴圈
  • 8:52 - 8:54
    測試程式什麼時候該被喚醒
  • 8:54 - 8:56
    什麼時候他真的被喚醒
  • 8:56 - 8:59
    這人卻遇到 5 毫秒的延遲
  • 8:59 - 9:00
    這根本不可思議
  • 9:00 - 9:05
    我們就幫他 debug 他的程式、看 dmesg、做各種事
  • 9:05 - 9:07
    然後我想到一件事
  • 9:07 - 9:11
    欸，你這個程式跑在什麼環境？
  • 9:11 - 9:14
    該不會是在一台虛擬機上吧？
  • 9:14 - 9:18
    沒錯~ 他在 Windows 上面跑 VxWorks 虛擬機
  • 9:20 - 9:21
    我跟他說
  • 9:21 - 9:25
    我封你為在 Windows 上 PREMPT_RT Linux 的維護者
  • 9:30 - 9:37
    這人真以為他把 VxWorks 虛擬機丟到 Windows 上面跑，就可以得到即時系統的行為
  • 9:37 - 9:39
    這東西不是那樣動的
  • 9:39 - 9:41
    再明顯不過了
  • 9:41 - 9:45
    所以，我們還會講到記憶體快取、分支預測、NUMA，你可以自己看
  • 9:45 - 9:46
    或我唸給你聽
  • 9:46 - 9:47
    或你想睡覺
  • 9:48 - 9:53
    閉上眼，我就對著你唸經：超執行緒、TLB、Transactional Memory、SMI、CPU 超頻
  • 9:54 - 9:56
    題外話：有人說我講太快了
  • 9:59 - 10:01
    記憶體快取
  • 10:01 - 10:02
    記憶體快取是個好物
  • 10:03 - 10:05
    因為它有加速效果
  • 10:05 - 10:09
    但是... 同時它也是一個時間上的炸彈，隨時會炸掉
  • 10:10 - 10:15
    假設你想要試著達到最壞的情形
  • 10:15 - 10:19
    即時系統的一部份精神是：你不會錯過任何死線
  • 10:19 - 10:21
    你期待看到可預測的結果
  • 10:21 - 10:24
    但你仍想知道：什麼才是最糟狀況？
  • 10:24 - 10:25
    你開始寫程式
  • 10:25 - 10:29
    你會試著在空快取上跑程式
  • 10:30 - 10:33
    有方法可以關掉快取
  • 10:33 - 10:37
    記得我曾說過：你按一個按鍵，20 秒後才在螢幕上出現？
  • 10:37 - 10:41
    這就是關掉快取的後果
  • 10:42 - 10:46
    有時你也會遇到 race condition ，你卻不知道
  • 10:46 - 10:48
    嗯~ 你運氣就是那麼背
  • 10:49 - 10:50
    有時你就是無法贏過大自然
  • 10:50 - 10:52
    "即時" 真的很難辦到
  • 10:52 - 10:53
    我曾試著說服別人
  • 10:53 - 10:57
    他們卻只想說：喔~ 我灌了即時系統核心，我做了這個、做了那個
  • 10:57 - 11:01
    我不用擔心其他東西，它就是會動
  • 11:01 - 11:03
    不！你必須了解整個系統
  • 11:03 - 11:05
    因為你的應用程式也要考慮到即時性
  • 11:07 - 11:11
    但在大部分情況下，有快取的系統跑得比較快
  • 11:11 - 11:15
    我之所以提到 race condition ，是因為如果系統跑得很慢，你可能不會觸發到 race condition
  • 11:15 - 11:19
    一旦有了快取，系統變快了，race condition 極有可能隨之而來
  • 11:22 - 11:23
    我寫過 ...
  • 11:24 - 11:27
    有人聽過我有關測量死線的演講嗎？
  • 11:27 - 11:29
    嗯~ 不錯 我等下就要講這個
  • 11:29 - 11:30
    人在哪？
  • 11:31 - 11:31
    喔~ 在這
  • 11:32 - 11:34
    你們一定很想念我那個演講 XD
  • 11:36 - 11:37
    不管
  • 11:37 - 11:40
    我在做死線的排程
  • 11:40 - 11:43
    這就是為什麼我會參與 strace 的開發
  • 11:43 - 11:45
    保證死線排程會動
  • 11:45 - 11:46
    因為這是未來趨勢
  • 11:47 - 11:48
    我寫了一個小工具
  • 11:50 - 11:51
    我追蹤它
  • 11:51 - 11:53
    我看到這個
  • 11:53 - 11:54
    你看這個
  • 11:57 - 12:00
    有兩個程序，其中一個跑得比較快
  • 12:00 - 12:02
    這個跑了一堆迴圈
  • 12:02 - 12:04
    它其實在計算質數
  • 12:05 - 12:07
    另一個其實也在算質數
  • 12:07 - 12:08
    但跑得比較久
  • 12:08 - 12:11
    其中一個表示：喔~ 我故意要多做運算
  • 12:11 - 12:15
    另一個做差不多的運算，但多了一些
  • 12:15 - 12:17
    我開始觀察到一個現象
  • 12:17 - 12:19
    短、短、長
  • 12:20 - 12:20
    看到沒
  • 12:20 - 12:23
    長、短、短、長、短、短、長
  • 12:23 - 12:24
    蠻像摩斯密碼的
  • 12:25 - 12:28
    長、短、長、短、長
  • 12:28 - 12:29
    我在想：到底是怎麼一回事？
  • 12:29 - 12:30
    我忘了自己犯了一個錯
  • 12:31 - 12:34
    它們用同一個變數去計算質數
  • 12:34 - 12:36
    它們倆個都不斷在更新質數
  • 12:36 - 12:42
    這根本是兩個進程強暴一個快取！
  • 12:42 - 12:44
    很容易用肉眼看出
  • 12:44 - 12:46
    正當它們倆玩的不亦樂乎時
  • 12:46 - 12:54
    一堆快取 thrashing 就被產生了
  • 12:55 - 12:56
    看它們有多不同
  • 12:56 - 13:02
    時間上幾乎有兩倍的差距
  • 13:02 - 13:03
    所以你得小心
  • Not Synced
    分支預測很有趣
  • Not Synced
    以下是另一個能讓你靈光乍現的點:
  • Not Synced
    CPU 預測你的進程的走向
  • Not Synced
    他會試著記得這個程式是否每次都走某個分支
  • Not Synced
    當進程在讀取 pipeline 的時候，他看到了他試著預測的分支
  • Not Synced
    他可以開始把那個分支的程式載入
  • Not Synced
    前二十次你分支都走這個方向，我就事先載入這個方向的程式，而不是另一個方向
  • Not Synced
    但如果你不再走那個方向，改走另一個方向
  • Not Synced
    你剛好遇到一個空快取
  • Not Synced
    你將遇到延遲
  • Not Synced
    你重新載入記憶體
  • Not Synced
    CPU 有更多事要做
  • Not Synced
    延遲直到記憶體被載進快去
  • Not Synced
    才可以被讀、告訴你正確的值
  • Not Synced
    所以，預測分支是另一個衡量最糟狀況的切入點
  • Not Synced
    舉個例子
Title:
Understanding a Real-Time System by Steven Rostedt
Description:
more » « less
Video Language:
English
Duration:
01:01:25

Chinese, Traditional subtitles

Incomplete

Revisions

Our website uses cookies for analysis purposes.