rtos 環境でのスレッドセーフについて

RTOS 環境でのスレッドセーフについて

nagayah

http://nagayah.blog46.fc2.com/

目次マルチタスクについて

マルチタスクOSって？

マルチタスクOS特有の注意点

スレッドセーフとは？

リエントラントについて

スタックと関数コール

bss/dataセクション

関数の再入って？

非リエントラント関数の動き

リエントラント関数の動き

リエントラントの要件

排他制御について

クリティカルセクション

クリティカルセクションの保護の仕方

アトミックアクセスについて少しだけ

まとめ

目次

マルチタスクについて


マルチタスクOS特有の注意点

スレッドセーフとは？



まとめ


1つの CPU で複数のタスクを平行して実行

時分割で実行するタスクを切り替える

トータルで見れば並行して実行している

擬似的なマルチ CPU 環境

擬似CPU 1 タスクA

擬似CPU 2

擬似CPU 3

タスクB

タスクC

本当のCPU

マルチタスクOSの注意点

1つの資源を複数のタスクが使うときに問題

あるタスクが資源にアクセス中に

他のタスクがアクセスする場合

アクセスが競合して処理が破綻！

共有資源

競合発生！！

競合を回避するにはどうするの？

競合が起きないようにする手法があります

これをスレッドセーフ化といいます

スレッド≒タスク

マルチタスク環境では必須

スレッドセーフ化すればOK!

共有資源

スレッドセーフ化するための方法

一般的にこんな方法があります

リエントラント

排他制御

アトミックアクセス

これらについて、順次説明していきます

一旦、ここまでをまとめます

マルチタスクOS

1CPU での、擬似的なマルチコア環境

複数タスクから共有資源を使う場合の問題

競合の可能性がある

スレッドセーフ化で解決可能


排他制御


目次



スタックと関数コール

bss/dataセクション


非リエントラント関数の動き

リエントラント関数の動き

リエントラントの要件


まとめ

リエントラント｜Reentrant

「再入可能な関数」という意味

Re:再び entrant:入れる

マルチタスクOS 環境では

普通に起こる現象

再入を前提にしておく必要あり

void f(void)

{

/*

* 何かしらの処理

*/

return;

}

void f(void)

{

/*


*/

return;

}


関数の途中で実行を中断し、

他のタスクが同じ関数をコールすること

例

タスクAがf()をコール

タスクA

void f(void)

{

/*


*/

return;

}




例


タスクAはf()の途中まで実行

タスクA

void f(void)

{

/*


*/

return;

}




例



タスクAが実行を中断、

タスクBがf()をコール

タスクA タスクB

void f(void)

{

/*


*/

return;

}


関数の途中で実行を中断し、他のタスクが同じ関数をコールすること

例



タスクAが実行を中断、タスクBがf()をコール

再入が起きても破綻しないリエントラント

タスクA タスクB

ちょっとC言語の変数の基本をおさらい

自動変数

ローカル変数とも呼ばれる

スタック上に配置される

静的変数

グローバル変数と static 変数のこと

初期値があれば data セクションに配置

初期値がなければ bss セクションに配置

bss は 0 クリアされます

int g = 1;

void f(void)

{

int a;

static b;

}

スタックと自動変数についておさらい

関数をコールするたびに確保

引数や自動変数をそこに置く

アドレスの若い方へ伸張

関数を抜けるたびに解放

void funcB(int arg) {

int ret = arg;

return ret;

}

void funcA(void) {

int dat = 3;

funcB(dat);

}

自動変数 dat

0番地







int ret = arg;

return ret;

} 自動変数 dat

引数 arg

自動変数 ret

void funcA(void) {

int dat = 3;

funcB(dat);

}

0番地







int ret = arg;

return ret;

}

void funcA(void) {

int dat = 3;

funcB(dat);

}

0番地

自動変数 dat

複数タスクからコールされたとき

複数タスクからコールされれば

スタックも複数個確保される

自動変数 dat

引数 arg

自動変数 ret

0番地

TaskA用のスタック領域


int ret = arg;

return ret;

}

void funcA(void) {

int dat = 3;

funcB(dat);

}

TaskA

複数タスクからコールされたとき

複数タスクからコールされれば

スタックも複数個確保される

自動変数 dat

引数 arg

自動変数 ret

0番地

自動変数 dat

引数 arg

自動変数 ret

TaskA用のスタック領域

TaskB用のスタック領域


int ret = arg;

return ret;

}

void funcA(void) {

int dat = 3;

funcB(dat);

}

TaskA TaskB

静的変数 [bss/data セクション]

静的変数の領域

初期値ある ⇒ dataセクション

初期値なし ⇒ bss セクション

スタックと違って１つしかない！

複数タスクからアクセスされても

新たに確保されたりはしない！

静的変数はタスク間の共有資源！

0番地

BSS

DATA

TaskA スタック領域

TaskB スタック領域

非リエントラント関数の例

非リエントラント関数で再入が

起きるとどうなるか見ていきます

静的変数を使用する下記の関数を

TaskA、TaskB からコールしてみます。

0番地


BSS セクション

data==0


int data;

void f(int arg)

{

data = arg;

printf(“data is %d¥n”, data)

}


TaskA が f(10); をコール

引数がスタックへ積まれる

int data;

void f(int arg)

{

data = arg;


}

0番地


BSS セクション

data:0

arg:10

TaskA TaskB スタック領域




dataセクションのdata が更新される

int data;

void f(int arg)

{

data = arg;


}

0番地


BSS セクション

data:10

arg:10

TaskA TaskB スタック領域


TaskB が再入、 f(20); をコール


int data;

void f(int arg)

{

data = arg;


}

0番地


BSS セクション

data:10

arg:10

arg:20

TaskA TaskB TaskB スタック領域





競合！TaskAの値を上書き！

int data;

void f(int arg)

{

data = arg;


}

0番地


BSS セクション

data:20

arg:10

arg:20

TaskB TaskB スタック領域 TaskA





競合！TaskAの値を上書き！

期待通り “data is 20.” と出力される

int data;

void f(int arg)

{

data = arg;


}

0番地


BSS セクション

data:20

arg:10

arg:20

TaskB スタック領域 TaskA TaskB


TaskA が実行再開



期待を裏切り “data is 20.” と出力される

引数は10だったのに！

int data;

void f(int arg)

{

data = arg;


}

0番地


BSS セクション

data:20

arg:10

arg:20

TaskB スタック領域 TaskB TaskA


再入が発生すると処理が破綻した

これは非リエントラントな関数

int data;

void f(int arg)

{

data = arg;


}

0番地


BSS セクション

data:20

arg:10

arg:20

TaskB スタック領域 TaskB TaskA

リエントラントな関数に修正

静的変数を使わないように修正

変数をBSSセクションでなく

スタックに積むように変更しただけ

void f(int arg)

{

int data;

data = arg;


}

0番地


BSS セクション





void f(int arg)

{

int data;

data = arg;


}

0番地


BSS セクション

arg:10

TaskB スタック領域 TaskA

void f(int arg)

{

int data;

data = arg;


}




自動変数 data が更新される

0番地


BSS セクション

arg:10

data:10

TaskB スタック領域 TaskA

void f(int arg)

{

int data;

data = arg;


}




0番地


BSS セクション

arg:20

arg:10

data:10


void f(int arg)

{

int data;

data = arg;


}




自動変数 dataが更新される

TaskA の変数 data には影響しない

0番地


BSS セクション

arg:10

arg:20

data:10

data:20


void f(int arg)

{

int data;

data = arg;


}




自動変数 dataが更新される

TaskA の変数 data には影響しない


0番地


BSS セクション

arg:10

arg:20

data:10

data:20


void f(int arg)

{

int data;

data = arg;


}


TaskA が実行再開


自動変数 data が更新される


0番地


BSS セクション

arg:10

arg:20

data:10

data:20



再入しても破綻しなかった！

これはリエントラントな関数

void f(int arg)

{

int data;

data = arg;


}

0番地


BSS セクション

arg:10

arg:20

data:10

data:20


リエントラントの条件

「１つしかない」ものにアクセスしない

使ってはダメなものの例

静的変数（static、グローバル変数）

ASIC レジスタ

volatile 変数

非リエントラント関数

引数とローカル変数のみを使えばOKです！

ローカル変数＝スタックに詰まれる変数

リエントラントはスレッドセーフ？

静的変数のような、タスク間の

共有資源となりうるものを一切使っていない

なのでそもそもタスク間の競合が発生しない

リエントラントなら必ずスレッドセーフ

共有資源

競合が発生しえない

リエントラントのまとめ

リエントラントにすればスレッドセーフになる

リエントラントにするには、

引数と自動変数だけを使用する

スタックは関数コールごとに確保される

同じ関数でも複数コールされれれば

複数別々のスタックを確保する

静的変数はbss/dataセクションに置かれる

bss/dataセクションは1つしかない

目次





クリティカルセクションの保護の仕方

アトミックなアクセスについて少しだけ

まとめ

リエントラントはわかったけど・・

どうしてもタスク共有資源が必要なときはどうする？

共有資源にアクセスしている間は

他のタスクがアクセスできないように

排他制御すればよい

排他制御が必要な区間


クリティカルセクションの例

再入がおきると破綻する区間はどこ？

共有資源にアクセスしているところは？

int sum(int arg)

{

static int sumv;

int tmp;

tmp = sumv;

tmp += arg;

sumv = tmp;

return sum;

}

クリティカルセクションの例

再入がおきると破綻する区間はどこ？

共有資源にアクセスしているところは？

ココのどこかで再入が

起きると破綻する！

つまりココが

クリティカルセクション！

int sum(int arg)

{

static int sumv;

int tmp;

tmp = sumv;

tmp += arg;

sumv = tmp;

return sumv;

}

クリティカルセクションの保護｜セマフォ

バイナリセマフォ

1 ：他タスクがクリティカル

セクション実行中

0：だれもクリティカル

セクション実行してない

先にクリティカルセクションに

入ったタスクが抜けるまで、

他のタスクは待たされる

int sum(int arg)

{

static int sumv;

int tmp;

wai_sem(id);

tmp = sumv;

tmp += arg;

sumv = tmp;

sig_sem(id);

return sumv;

}

バイナリセマフォでの排他例

TaskA が先に

クリティカルセクション突入

int sum(int arg)

{

static int sumv;

int tmp;

wai_sem(id);

tmp = sumv;

tmp += arg;

sumv = tmp;

sig_sem(id);

return sumv;

}

TaskA

int sum(int arg)

{

static int sumv;

int tmp;

wai_sem(id);

tmp = sumv;

tmp += arg;

sumv = tmp;

sig_sem(id);

return sumv;

}


TaskA が先に


TaskB が再入。

セマフォ取得で待たされる。

TaskB TaskA

int sum(int arg)

{

static int sumv;

int tmp;

wai_sem(id);

tmp = sumv;

tmp += arg;

sumv = tmp;

sig_sem(id);

return sumv;

}


TaskA が先に


TaskB が再入。


TaskA が再開。

クリティカルセクション終了。

TaskB TaskA

int sum(int arg)

{

static int sumv;

int tmp;

wai_sem(id);

tmp = sumv;

tmp += arg;

sumv = tmp;

sig_sem(id);

return sumv;

}


TaskA が先に


TaskB が再入。


TaskA が再開。

クリティカルセクション終了。

TaskB が再開。

無事セマフォを取得し

クリティカルセクション完了

TaskB

割込みからもコールされる場合は？

割込みハンドラ内ではセマフォは使えない

割込み禁止にするしかない

他タスクへディスパッチすることもありえません

割込みハンドラすらありえません

何人たりとも邪魔はできません

最強の方法です

他への迷惑度も大きい諸刃の剣。乱用はやめましょう

int sum(int arg)

{

static int sumv;

int tmp;

begin_intr_dis();

tmp = sumv;

tmp += arg;

sumv = tmp;

end_intr_dis();

return sumv;

}

いったん、排他制御についてまとめ

共有資源にアクセスしている箇所は

排他制御が必要となる


クリティカルセクションは

バイナリセマフォで保護できる

割込みハンドラからもアクセスする場合は

セマフォではダメ。割込み禁止が必要。

でも割込み禁止は悪影響大。

使うのはほんとに最後の手段。

クリティカルセクション応用編

静的変数に、もし1行でアクセスしてたら、

再入することはなくない・・・？

アクセス中に中断できる場所がなさそう

TaskA が tmp にアクセス中に

TaskB は再入できるのか？

もし再入できなければ、

これはスレッドセーフ！

void and_tmp (void)

{

static tmp;

tmp &= 0xfe;

}

TaskA TaskB


C言語の行数と実際のCPU命令数は

一致しない

普通、値の変更には3命令以上必要

（CPUにもよるんですけど）

今の値をリードして、

それをモディファイして、

その結果をライトする。

void and_tmp (void)

{

static tmp;

tmp &= 0xfe;

}

ldr r0 [tmp] // リード and r0 r0 #0xfe // モディファイ str r0 [tmp] // ライト

ldr r0 [tmp] // リード and r0 r0 #0xfe // モディファイ str r0 [tmp] // ライト


結局、CPU 命令の間で再入が発生

このクリティカルセクションを排他しない限り

スレッドセーフではない・・

C言語のコードに惑わされてはダメ！

void and_tmp (void)

{

static tmp;

tmp &= 0xfe;

}

TaskA TaskB

でも、ということは、逆にいうと？

CPU 1命令でアクセスすれば再入できない

つまり、スレッドセーフ！

実行中に分割できないアクセス


CPU によって色々違うのですが、

一般的に通用しそうことをまとめてみます

一応、 ARM のような RISC CPU を想定

アトミックアクセスの簡単なまとめ

アトミックアクセスならスレッドセーフでもかなり難易度が高い

アトミックアクセスになる場合 CPU が用意しているアトミック専用命令を使用

ARM なら swap, ldrex, strex など

int 型へのライトアクセス（絶対というわけではない）

リード・モディファイ・ライト操作はダメ

char/short などはマスクやシフトが必要だからダメ

アトミックかどうかの判断専用命令を使う以外の場合は、実際にコンパイラが生成した命令を確認する必要があります

CPU やコンパイラによって結果は変わる

目次




まとめ

今日のまとめ

マルチタスク OS ではスレッドセーフが必要

スレッドセーフにする方法

リエントラントにする

クリティカルセクションを排他する

セマフォ｜割込み禁止

もしくはアトミックアクセスにする

これは高難易度

スレッドセーフ化までの道のり（例）

複数タスクからコールされる？

共有資源使う？

割込みハンドラからもコールされる？

セマフォを使ってクリティカルセクション保護

[NO] スレッドセーフにする必要なし

リエントラントにしてスレッドセーフ化

アトミックアクセスにしてスレッドセーフ化

割り禁を使ってクリティカルセクション保護

リード・モディファイ・ライトする？

[Yes]

[NO]

[Yes]

[NO]

[Yes]

[Yes]

[NO]

今回出てきたキーワード

google 先生に聞けばたぶん教えてくれます

マルチタスクOS

スレッドセーフ

自動変数

bssセクション/dataセクション

スタック


排他制御

バイナリセマフォ

割込み禁止


リード・モディファイ・ライト

参考文献組み込みソフトウェアの設計&検証

藤倉俊幸 [CQ出版]

RTOS でのスレッドセーフやアトミック操作についての説明があります

C言語ポインタ完全制覇前橋和弥 [技術評論社]

スタックについて分かりやすい説明があります

エキスパートCプログラミング Peter van der Linden [アスキー]

bss, data セクションについて分かりやすい説明があります

C言語デバッグ完全解説坂井弘亮 [技術評論社]

スレッドセーフ関係のデバッグについて記載が在ります

ARM組み込みソフトウェア入門 Andrew N. Sloss [CQ出版]

ARM アセンブラ関係ではたぶん一番分かりやすい

以上です

以下、メモ

リエントラントの例（再帰呼び出し版）

再帰関数でも再入は発生します

たとえば下記のような感じ

なので再帰関数もリエントラントである必要があります

void f(void)

{

if(!終了条件)

f();

return;

}

void f(void)

{

if(!終了条件)

f();

return;

}

void f(void)

{

if(!終了条件)

f();

return;

}

rtos 環境でのスレッドセーフについて

Documents