JP4132802B2

JP4132802B2 - Method, apparatus and program for simulating general multitask software

Info

Publication number: JP4132802B2
Application number: JP2001374886A
Authority: JP
Inventors: 稔庄司
Original assignee: Fujitsu Ltd
Current assignee: Fujitsu Ltd
Priority date: 2001-12-07
Filing date: 2001-12-07
Publication date: 2008-08-13
Anticipated expiration: 2021-12-07
Also published as: JP2003177943A

Description

【０００１】
【発明の属する技術分野】
本発明は、入出力信号をリアルタイム処理するマルチタスクソフトウェアの詳細設計前に、該マルチタスクソフトウェアの入出力信号のタイミングの概略をシミュレーションする概略マルチタスクソフトウェアのシミュレーションを行う方法、装置及びプログラムに関する。
【０００２】
【従来の技術】
例えば、プロセッサで車のエンジン制御を行うシステムでは、多数の入力データに基づいてリアルタイムでマルチタスク処理を行う必要がある。このシステムの開発において、処理遅延によりリアルタイム制御ができない場合、より高性能のプロセッサを用いることによりこの問題を解決できる場合がある。しかし、ハードウェアがコスト高になると共に、ＯＳが複雑になってソフトウェアもコスト高になる。このため、ソフトウェアとハードウェアの両面からできるだけ低コストになるよう該問題を解決する必要がある。
【０００３】
従来では、ソフトウェアを開発し、これを既存の又は新たに開発したプロセッサにロードし、プロセッサと外部周辺装置との間の様々な入出力条件の下で実行させることにより、所望のリアルタイム制御を行うことが可能であるかどうかという、ソフトウェアとハードウェアの総合的なタイミング検証を行っていた。
【０００４】
【発明が解決しようとする課題】
しかし、検証の結果、問題が確認された場合、ソフトウェア（及びハードウェア）の設計をやり直す必要が生じ、部分的にタイミングをずらすと他の部分でタイミングがずれたりする。このため、設計と実試験の繰り返しが行われて開発期間が長くなる原因となっていた。
【０００５】
本発明の目的は、このような問題点に鑑み、ソフトウェア（及びハードウェア）を詳細設計する前にこれを概略設計しそのシミュレーションを行うことにより、詳細設計条件をより限定して、設計と実試験の繰り返しを避け開発期間を短縮することが可能な概略マルチタスクソフトウェアのシミュレーションを行う方法、装置及びプログラムを提供することにある。
【０００６】
本発明の一態様では、プロセッサに対し入出力信号をリアルタイム処理させるマルチタスクソフトウェアの概略動作をコンピュータでシミュレーションする方法において、複数のタスクのそれぞれに対応したモデルタスクは、信号の入出力以外の処理が、該処理の見積時間τだけ経過すればリターンするスペンドタイム関数の呼び出しで表され、該見積時間τは該スペンドタイム関数の引数であり、該コンピュータが、全てのモデルタスクで使用されるスペンドタイム関数の引き数τの最小値を１サイクルとし、現時刻ｔが１サイクル経過する毎に、
（ａ）該複数のモデルタスクのいずれを実行するかを所定アルゴリズムで決定し、
（ｂ）実行対象と決定したモデルタスクｉのみについて、実行中のスペンドタイム関数の見積時間τ_iを１サイクルだけデクリメントし、
（ｃ）現時刻ｔで各モデルタスクが実行中であるか否かの状態を該コンピュータの記憶装置に格納する。
【０００７】
この構成によれば、ソフトウェア（及びハードウェア）の詳細設計前に、リアルタイム制御を正常に行うための各タスクに要求される処理時間や処理のタイミングを知ることができるので、これに基づきハードウェア（及びソフトウェア）を詳細設計することにより、従来のような設計と実試験の繰り返しによる開発期間の長期化を避けることができる。
【０００８】
本発明の他の目的、構成及び効果は以下の説明から明らかになる。
【０００９】
【発明の実施の形態】
以下、図面を参照して本発明の実施形態を説明する。
【００１０】
［第１実施形態］
図１は、本発明の第１実施形態の概略マルチタスクソフトウェアシミュレーション方法を示す。
【００１１】
この概略マルチタスクソフトウェアシミュレーション方法は、ソフトウェア（及びハードウェア）の詳細設計前にプロセッサが所望のリアルタイム処理を行うことが可能であるかどうかを概略的に確認するとともに、問題が生ずる場合にはこれを解決するための詳細設計条件を知ることにより詳細設計と実テストの繰り返しを回避するためのものである。
【００１２】
概略マルチタスクソフトウェアシミュレーション方法は、コンピュータ１０に入力装置１１及び表示装置１２が接続された一般的なコンピュータシステムである。図１ではコンピュータ１０のソフトウェア構成を機能ブロックで示している。コンピュータ１０の記憶部には、モデル２０が格納されている。モデル２０は概略的なものであり、リアルタイム制御用プロセッサ及びこのプロセッサを動作させるソフトウェアの詳細設計前に作成される。
【００１３】
モデル２０は、コンピュータ２１と、周辺装置２２と、これらの間に接続されるレジスタＲＥＧ１〜ＲＥＧｍとを備えている。コンピュータ２１は、プロセッサと、メモリと、入出力インタフェースと、これらを相互接続するバスとを含む構成のモデルであり、１チップ又は複数のチップで構成されるが、その具体的な構成は考慮されない。周辺装置２２は、例えば家電製品のモデルであり、周辺装置２２又はその周囲の状態を示す信号ＳＧ１〜ＳＧｎをコンピュータ２１に供給する。コンピュータ２１は、これらの信号に基づき、制御データを生成してレジスタＲＥＧ１〜ＲＥＧｍに格納する。周辺装置２２は、レジスタＲＥＧ１〜ＲＥＧｍの内容に基づきリアルタイム制御される。
【００１４】
モデル２０は、入力装置１１からの開始指令に基づいて動作を開始する。動作トレース部３０は、モデル２０の内部状態を検出しトレースするプログラムであり、その結果が表示装置１２に供給されて表示される。
【００１５】
コンピュータ２１のアプリケーションプログラムの概略は、リアルタイム制御を行うモデルタスクtask1〜taskNで表される。以下、簡単化のために、モデルタスクを単にタスクと称す。タスク実行制御部２３は、プログラムであり、記憶部に格納されたＮ個のtask１〜taskNの内容に基づいて各タスクに対応したスレッド（実際の処理の流れ）を生成させ、タスクを実行又は停止（スリープ）させる。この際、状態記憶部２４内に各スレッドの状態（タスクの実行又は停止の状態）が格納される。
【００１６】
図１において、スレッドＳＬ１〜ＳＬ４は例えばそれぞれtask1〜task4に対応している。図１は、時刻ｔ０で主スレッドＳＬ１が生成され、時刻ｔ１でtask1により副スレッドＳＬ２が生成され、時刻ｔ２でtask2により副スレッドＳＬ３及びＳＬ４が生成され、時刻ｔ３及びｔ４でそれぞれtask4及びtask3の処理が終了し、時刻ｔ５でtask1及びtask2の処理が終了していることを示している。
【００１７】
各タスクにおける入出力以外の処理は、処理時間τだけを考慮する。τは相対的な時間であり、その単位をｕで表す。例えばtask1〜task3は、図２に示すように表される。すなわち、task1は関数f11とf12のシーケンスで表され、task2は関数f21とf22とf23のシーケンスで表され、task3は関数f31とf32のシーケンス又は関数f31とf33のシーケンスで表される。関数f32とf33の選択は、関数f31の処理において入力信号ＳＧ１の値に基づき行われる。
【００１８】
task1〜taskNは例えばＳｙｓｔｅｍＣ（商標、http://www.systemc.org）言語で記述されている。上記task1及びtask3は例えば次のように記述される。

上記タスクは簡単化のため出力処理がない場合を示しているが、各spend_time(τ)の前又は後に出力処理を含んでもよい。
【００１９】
図３は、タスクＴｉ中の関数 spend_time( τ ) に対する、図１のタスク実行制御部２３の処理を示す。但し、ステップＳ３及びＳ４は、全スレッドに共通の処理である。以下、括弧内は図中のステップ識別符号を示す。
【００２０】
（Ｓ１）spend_time(τ)の引き数τの時間単位ｕをサイクルタイムｃに変換する。１サイクルタイムは、全てのタスクで使用されるspend_time(τ)の引き数τの最小値であり、例えば図２の場合、５ｕ＝１ｃと決定され、この場合、τ／５がτに代入される。１サイクルタイムは通常、数μ〜数ｍ秒である。
【００２１】
（Ｓ２）τ＝０であれば処理を終了し、そうでなければステップＳ３へ進む。
【００２２】
（Ｓ３）全スレッドの同期を取るために、すなわち全スレッドの時間軸上の現時刻を一致させるために、現サイクルまで経過していないスレッドがあれば、その経過を待つ。
【００２３】
（Ｓ４）次サイクルで実行すべきタスクＴＸを、後述のように決定する。
【００２４】
（Ｓ５）spend_time(τ)を呼び出したタスクＴｉが次サイクル実行タスクＴＸと一致すればステップＳ６へ進み、そうでなければステップＳ３へ戻る。
【００２５】
（Ｓ６）τの値を１だけデクリメントし、ステップＳ２へ戻る。
【００２６】
図４は、図３中のステップＳ４の詳細を、ラウンドロビン方式を採用した場合について示すフローチャートであり、この方法では、タスクをサイクリックに切り換えて実行するように次サイクル実行タスクを決定する。
【００２７】
（Ｓ１０）状態記憶部２４において、次サイクルで実行可能なタスク候補が存在すればステップＳ１１へ進み、そうでなければ、すなわちスレッド上の全タスクがスリープ状態（停止状態）であればステップＳ１４へ進む。
【００２８】
（Ｓ１１）図５に示すようなタスクリスト中の先頭タスク名ＴＮを取り出す。タスクリストは状態記憶部２４内の現サイクルの状態に対応しているので、新たに作成する必要はない。タスクリスト中のタスク名は、現サイクルにおいて存在するスレッドに対応している。
【００２９】
（Ｓ１２）取り出したタスク名ＴＮを、実質的にタスクリストの最後へ移動させる。「実質的に」とは、実際に移動していなくても論理的に移動したとみなせる場合を含む意味である。例えば、各スレッドにフラグを設け、‘１’のフラグをタスクリストの先頭行とみなし、フラグ列中の‘１’をシフトさせることによりタスク名ＴＮを実質的に移動させる。
【００３０】
（Ｓ１３）取り出したタスク名ＴＮのタスクを、次サイクルで実行すべきタスクＴＸと判定し、処理を終了する。
【００３１】
（Ｓ１４）ＴＸ＝φとし、処理を終了する。ここにφは空であることを示す。
【００３２】
このような方法により次サイクルで実行すべきタスクを決定すれば、現存するスレッド上の、スリープ状態でないタスクが、１サイクル毎に切り替えられて実行される。
【００３３】
図６は、上述の２つのタスクtask1()及びtask2()が図４の方法で実行される場合を示すタイムチャートである。
【００３４】
以上のような処理により、信号ＳＧ１〜ＳＧｎに応じてタスクの実行内容が変化し、これによりレジスタＲＥＧ１〜ＲＥＧｍの内容の更新時点が変化し、これらの制御データを用いて制御される周辺装置２２の制御結果も変わる。コンピュータ２１によるリアルタイム処理が遅れてレジスタＲＥＧ１〜ＲＥＧｍの内容更新周期が遅れる場合には、spend_time(τ)の引き数τの値を変更し、タスクの実行と停止のタイミングを調整し、又はプロセッサの処理速度を向上させる。引き数τの値の変更は、処理方法の変更やプログラム言語の変更などに対応している。
【００３５】
本第１実施形態によれば、ソフトウェア（及びハードウェア）の詳細設計前に、リアルタイム制御を正常に行うための各タスクに要求される処理時間や処理のタイミングを知ることができるので、これに基づきソフトウェア（及びハードウェア）を詳細設計することにより、従来のような設計と実試験の繰り返しによる開発期間の長期化を避けることができる。
【００３６】
［第２実施形態］
図７は、図３のステップＳ４の他の処理方法を本発明の第２実施形態として示すフローチャートであり、この方法では、タスク優先度に基づいて次サイクル実行タスクを決定する。
【００３７】
ステップＳ１０及びＳ１４は、図４の対応するステップと同一である。
【００３８】
（Ｓ２０）初期値として、次サイクル実行タスクＴＸにφ、該タスクの優先度ＰＬＸに最低優先度ＰＬminを代入する。
【００３９】
（Ｓ２１）タスクリストの第ｉ行を示す変数ｉに初期値１を代入する。
【００４０】
図８はタスクリストを示しており、各行はタスク名とそのタスクの優先度とからなる。第ｉ行のタスク名及び優先度をそれぞれタスクＴＮ（ｉ）及ＰＬＮ（ｉ）で表す。優先度は例えばレベル０〜７であり、値の小さいほど優先度が高い。
【００４１】
（Ｓ２２）図１の状態記憶部２４を参照して、タスクＴＮ（ｉ）のタスクが次サイクルにおいてスリープ状態であるかどうかを判定し、スリープ状態であればステップＳ２５へ進み、そうでなければステップＳ２３へ進む。
【００４２】
（Ｓ２３）次サイクル実行タスクＴＸの優先度ＰＬＸが優先度ＰＬＮ（ｉ）より低ければ、すなわちＰＬＸ＞ＰＬＮ（ｉ）であれば、ステップＳ２４へ進み、そうでなければステップＳ２５へ進む。
【００４３】
（Ｓ２４）ＴＸ及びＰＬＸにそれぞれＴＮ（ｉ）及びＰＬＮ（ｉ）を代入する。
【００４４】
（Ｓ２５）ｉを１だけインクリメントする。
【００４５】
（Ｓ２６）タスクＴＮ（ｉ）が存在すればステップＳ２２へ戻り、そうでなければＴＸを次サイクルで実行すべきタスクとし図７の処理を終了する。
【００４６】
このような処理により、スレッド上の次サイクルにおけるタスクのうち、スリープ状態でなく優先度が最も高いタスクが次サイクル実行タスクＴＸとして決定される。タスクＴＸと同一優先度のタスクが複数存在する場合には、これらのタスクリスト中の順序（記憶装置内の配列順）により実行タスクＴＸを決定する。
【００４７】
図９は、優先度が異なる次の２つのタスクtask1()及びtask2()が実行される場合を示す。
【００４８】

上記タスクは簡単化のため入力処理がない場合を示しているが、各spend_time(τ)の前又は後に入力処理を含んでもよい。spend_time(τ)の引数τの最小値が１であるので、１ｃ＝１ｕと決定される。
【００４９】
スレッドＳＬ１はtask1()のスレッドであり、時刻ｔ＝０で図１のレジスタＲＥＧ１に制御データｄｔ１が格納され、該スレッドにより時刻ｔ＝１ｃでtask2()のスレッドＳＬ２が生成される。task2()はtask1()よりも優先度の高い計算処理を実行することが求められており、task2()の優先度はtask1()のそれより高く設定されているとする。タスクリストにはスリープ状態でないtask1()及びtask2()が存在し、task1()よりtask2()の方が優先度が高いので、次サイクル実行タスクＴＸとしてtask2()が選択されて、spend_time(4)が実行される。
【００５０】
次にスレッドＳＬ２が削除され、タスクリストにはスリープ状態でないtask1()のみ存在し、次サイクル実行タスクＴＸとしてtask1()が選択されて、レジスタＲＥＧ１に制御データｄｔ２が格納され、次いでspend_time(3)が実行される。
【００５１】
図１において、周辺装置２２がレジスタＲＥＧ１の制御データを時間３ｕ毎に読み出し、この読み出し前に制御データの更新がコンピュータ２１により行われなければならないとする。
【００５２】
図９の場合、この要求が満たされないので、例えば次の１つ以上を詳細設計条件とすることにより、この要求を満たす。
【００５３】
（１）task2()の処理内容を減らす。
【００５４】
（２）task2()の実行のタイミングをずらす。
【００５５】
（３）task2()について、より高速の機械語コードを生成する。
【００５６】
（４）より高速のコンピュータ２１を用いる。
【００５７】
［第３実施形態］
図１０は、図３のステップＳ４のさらに他の処理方法を本発明の第３実施形態として示すフローチャートであり、この方法では、タスク優先度よりも割込を優先させてそのタスクを次サイクル実行タスクと決定する。図１の周辺装置は例えば、センサーを含む車のエンジンのモデルである。
【００５８】
１個の割込に対し８個の割り込み要因があり、これらが０〜７で識別され、要因ｉの割込処理がタスクＴｉで実行され、タスクＴｉがポインタＰＴＲ（ｉ）で指定されるとする。また、要因ｉの割込要求があると、割込フラグＩＦが‘１’になるとともに割込要因フラグＩＲＱ（０）〜ＩＲＱ（７）のうちＩＲＱ（ｉ）のみ‘１’になるとする。図１において、フラグＩＦ及びＩＲＱ（０）〜ＩＲＱ（７）はコンピュータ２１の内部レジスタに対応しており、周辺装置２２からコンピュータ２１への信号により該フラグが設定される。
【００５９】
（Ｓ３０）ＩＦ＝‘０’であれば図７のステップＳ１０へ進み、そうでなければステップＳ３１へ進む。
【００６０】
（Ｓ３１）ｉに初期値０を代入する。
【００６１】
（Ｓ３２）ｉ＜８であればステップＳ３３へ進み、そうでなければ、すなわちＩＲＱ（０）〜ＩＲＱ（７）のいずれも‘０’であれば図７のステップＳ１０へ進む。
【００６２】
（Ｓ３３）ＩＲ（ｉ）＝‘１’であればステップＳ３５へ進み、そうでなければステップＳ３４へ進む。
【００６３】
（Ｓ３４）ｉの値を１だけインクリメントし、ステップ３２へ戻る。
【００６４】
（Ｓ３５）ポインタＰＴＲ（ｉ）で指定されるタスクＴｉのスレッドを生成する。
【００６５】
（Ｓ３６）ＩＦ＝‘０’及びＩＲＱ（ｉ）＝‘０’として、同じ割込要求の再受付を避ける。
【００６６】
（Ｓ３７）タスクＴｉを次サイクル実行タスクＴＸと決定する。
【００６７】
図１１は、次のタスクが図１０の方法を用いて実行された場合の動作を示すタイムチャートである。
【００６８】

上記タスクは簡単化のため入力処理がない場合を示しているが、各spend_time(τ)の前又は後に入力処理を含んでもよい。関数sleep(τ)は、他のタスクを実行させるため時間τだけ実行を休む処理である。上記の場合、task1()の実行中に、第２〜４サイクルの各々で割込がかかり、割込毎にtask2()が実行される。上記第２実施形態と同様に、図１において周辺装置２２がレジスタＲＥＧ１の制御データを３ｕ毎に読み出し、この読み出し前に制御データの更新がコンピュータ２１により行われなければならないとする。この要求が満たされないので、例えば次の１つ又は両方を詳細設計条件とすることにより、この要求を満たす。
【００６９】
（１）割込発生間隔を一定サイクル以上とする。
【００７０】
（２）割込処理task2()に関数sleep(τ)を含ませる、すなわち割込が発生してから所定時間経過後に割込処理を実行する。
【００７１】
なお、本発明には外にも種々の変形例が含まれる。
【００７２】
例えば１サイクルタイムを、全タスクに含まれる待ち処理時間の最小値の１／（自然数）と決定してもよい。これにより、入力信号読み取り、信号出力及び割込のタイミングを変えることができる。
【００７３】
また、上記第３実施形態では簡単化のために割込優先度が同一である場合を説明したが、異なる優先度の割込がある場合にも本発明が適用されることは勿論である。
【００７４】
さらに、モデルタスクは、１つのプロセスを複数のスレッドで実行する場合の各スレッドに対応したもののモデルも含む概念である。
【図面の簡単な説明】
【図１】図１は、本発明の第１実施形態の概略マルチタスクソフトウェアシミュレーション方法を示す概略ブロック図である。
【図２】図１のタスク実行制御部２３により実行されるタスクの概略説明図である。
【図３】タスクＴｉ中の関数 spend_time( τ ) に対する、図１のタスク実行制御部２３の処理を示すフローチャートである。
【図４】図３中のステップＳ４の詳細を、ラウンドロビン方式を採用した場合について示すフローチャートである。
【図５】図４の処理説明のためのタスクリストを示す図である。
【図６】２つのタスクtask1()及びtask2()が図４の方法で実行される場合を示すタイムチャートである。
【図７】図３のステップＳ４の他の処理方法を本発明の第２実施形態として示すフローチャートである。
【図８】図７の処理説明のためのタスクリストを示す図である。
【図９】優先度が異なる次の２つのタスクtask1()及びtask2()が図７の方法で実行される場合を示すタイムチャートである。
【図１０】図３のステップＳ４のさらに他の処理方法を本発明の第３実施形態として示すフローチャートである。
【図１１】主タスクtask1()と割込タスクtask2()が図１０の方法で実行される場合を示すタイムチャートである。[0001]
BACKGROUND OF THE INVENTION
The present invention relates to a method, an apparatus, and a program for performing general multitask software simulation for simulating an outline of timing of input / output signals of the multitask software before detailed design of the multitask software for processing the input / output signals in real time.
[0002]
[Prior art]
For example, in a system that controls a car engine with a processor, it is necessary to perform multitask processing in real time based on a large number of input data. In the development of this system, when real-time control cannot be performed due to processing delay, this problem may be solved by using a higher performance processor. However, the cost of hardware increases, and the complexity of the OS increases and the cost of software also increases. For this reason, it is necessary to solve the problem so as to reduce the cost as much as possible from both the software and hardware sides.
[0003]
Conventionally, software is developed, loaded into an existing or newly developed processor, and executed under various input / output conditions between the processor and an external peripheral device, thereby performing desired real-time control. We were performing comprehensive software and hardware timing verifications to see if this was possible.
[0004]
[Problems to be solved by the invention]
However, if a problem is confirmed as a result of the verification, it is necessary to redesign the software (and hardware), and if the timing is partially shifted, the timing is shifted in other portions. For this reason, the design and the actual test were repeated, causing a long development period.
[0005]
In view of such problems, the object of the present invention is to design a design and implementation by further designing detailed simulation conditions by roughly designing and simulating software (and hardware) before detailed design. An object of the present invention is to provide a method, apparatus, and program for simulating general multitasking software that can avoid repeated testing and shorten the development period.
[0006]
In one aspect of the present invention, in a method of simulating a general operation of multitask software that causes a processor to process input / output signals in real time, a model task corresponding to each of a plurality of tasks is processing other than signal input / output. Is represented by a call to a spent time function that returns when the estimated time τ of the process elapses. The estimated time τ is an argument of the spent time function, and the computer uses the spent time function that is used in all model tasks. The minimum value of the time function argument τ is one cycle, and every time the current time t passes,
(A) to determine whether to perform one of the plurality of model tasks in a predetermined algorithm,
(B) For only the model task i determined as the execution target, the estimated time τ _i of the spent time function being executed is decremented by one cycle ,
(C) The state of whether each model task is being executed at the current time t is stored in the storage device of the computer.
[0007]
According to this configuration, before the detailed design of the software (and hardware), it is possible to know the processing time and processing timing required for each task for performing real-time control normally. By designing in detail (and software), it is possible to avoid a prolonged development period due to repeated design and actual tests as in the past.
[0008]
Other objects, configurations and effects of the present invention will become apparent from the following description.
[0009]
DETAILED DESCRIPTION OF THE INVENTION
Hereinafter, embodiments of the present invention will be described with reference to the drawings.
[0010]
[First Embodiment]
FIG. 1 shows a schematic multitask software simulation method according to the first embodiment of the present invention.
[0011]
This general multitasking software simulation method is used to check whether the processor can perform the desired real-time processing before detailed design of the software (and hardware), and if a problem occurs, It is for avoiding the repetition of detailed design and actual test by knowing the detailed design conditions for solving the problem.
[0012]
The general multitask software simulation method is a general computer system in which an input device 11 and a display device 12 are connected to a computer 10. In FIG. 1, the software configuration of the computer 10 is shown as functional blocks. A model 20 is stored in the storage unit of the computer 10. The model 20 is schematic and is created before the detailed design of the real-time control processor and the software that operates the processor.
[0013]
The model 20 includes a computer 21, a peripheral device 22, and registers REG1 to REGm connected between them. The computer 21 is a model of a configuration including a processor, a memory, an input / output interface, and a bus interconnecting them, and is configured with one chip or a plurality of chips, but its specific configuration is not considered. . The peripheral device 22 is a model of home appliances, for example, and supplies signals SG <b> 1 to SGn indicating the peripheral device 22 or the surrounding state to the computer 21. Based on these signals, the computer 21 generates control data and stores it in the registers REG1 to REGm. The peripheral device 22 is controlled in real time based on the contents of the registers REG1 to REGm.
[0014]
The model 20 starts to operate based on a start command from the input device 11. The operation trace unit 30 is a program that detects and traces the internal state of the model 20, and the result is supplied to the display device 12 and displayed.
[0015]
The outline of the application program of the computer 21 is represented by model tasks task1 to taskN that perform real-time control. Hereinafter, for simplicity, the model task is simply referred to as a task. The task execution control unit 23 is a program, generates threads (actual processing flow) corresponding to each task based on the contents of N tasks1 to taskN stored in the storage unit, and executes or stops the task (Sleep). At this time, the state of each thread (task execution or stop state) is stored in the state storage unit 24.
[0016]
In FIG. 1, threads SL1 to SL4 correspond to, for example, task1 to task4, respectively. In FIG. 1, the main thread SL1 is created at time t0, the secondary thread SL2 is created by task1 at time t1, the secondary threads SL3 and SL4 are created by task2 at time t2, and task4 and task3 are created at times t3 and t4, respectively. It shows that the processing is completed and the processing of task1 and task2 is completed at time t5.
[0017]
For processing other than input / output in each task, only the processing time τ is considered. τ is a relative time, and its unit is represented by u. For example, task1 to task3 are represented as shown in FIG. That is, task1 is represented by a sequence of functions f11 and f12, task2 is represented by a sequence of functions f21, f22 and f23, and task3 is represented by a sequence of functions f31 and f32 or a sequence of functions f31 and f33. The functions f32 and f33 are selected based on the value of the input signal SG1 in the process of the function f31.
[0018]
task1 to taskN are described in, for example, the SystemC (trademark, http://www.systemc.org) language. The task1 and task3 are described as follows, for example.

Although the above task shows a case where there is no output processing for simplification, output processing may be included before or after each send_time (τ).
[0019]
FIG. 3 shows processing of the task execution control unit 23 of FIG. 1 for the function send_time ( τ ) in the task Ti . However, steps S3 and S4 are processes common to all threads. In the following, the step identification codes in the figure are shown in parentheses.
[0020]
(S1) The time unit u of the argument τ of the send_time (τ) is converted into the cycle time c. One cycle time is the minimum value of the argument τ of send_time (τ) used in all tasks. For example, in the case of FIG. 2, 5u = 1c is determined. In this case, τ / 5 is substituted for τ. The One cycle time is usually several μ to several milliseconds.
[0021]
(S2) If τ = 0, the process is terminated; otherwise, the process proceeds to step S3.
[0022]
(S3) In order to synchronize all threads, that is, to match the current time on the time axis of all threads, if there is a thread that has not elapsed until the current cycle, the process waits.
[0023]
(S4) The task TX to be executed in the next cycle is determined as described later.
[0024]
(S5) If the task Ti that called the send_time (τ) coincides with the next cycle execution task TX, the process proceeds to step S6; otherwise, the process returns to step S3.
[0025]
(S6) The value of τ is decremented by 1, and the process returns to step S2.
[0026]
FIG. 4 is a flowchart showing the details of step S4 in FIG. 3 in the case where the round robin method is adopted. In this method, the next cycle execution task is determined so as to execute the task while cyclically switching the task.
[0027]
(S10) If there are task candidates that can be executed in the next cycle in the state storage unit 24, the process proceeds to step S11. If not, that is, if all tasks on the thread are in the sleep state (stopped state), the process proceeds to step S14. move on.
[0028]
(S11) The first task name TN is extracted from the task list as shown in FIG. Since the task list corresponds to the state of the current cycle in the state storage unit 24, it is not necessary to create a new task list. The task name in the task list corresponds to a thread that exists in the current cycle.
[0029]
(S12) The extracted task name TN is substantially moved to the end of the task list. The term “substantially” means including a case where it can be regarded as logically moved even if it is not actually moved. For example, a flag is provided for each thread, the flag “1” is regarded as the first line of the task list, and the task name TN is substantially moved by shifting “1” in the flag string.
[0030]
(S13) The task with the extracted task name TN is determined as the task TX to be executed in the next cycle, and the process is terminated.
[0031]
(S14) Set TX = φ and terminate the process. Here, φ indicates empty.
[0032]
If a task to be executed in the next cycle is determined by such a method, a task that is not in a sleep state on an existing thread is switched and executed every cycle.
[0033]
FIG. 6 is a time chart showing a case where the above-described two tasks task1 () and task2 () are executed by the method of FIG.
[0034]
Through the processing as described above, the execution contents of the task change according to the signals SG1 to SGn, thereby changing the update time of the contents of the registers REG1 to REGm, and the peripheral device 22 controlled using these control data The control result also changes. When the real-time processing by the computer 21 is delayed and the content update period of the registers REG1 to REGm is delayed, the value of the argument τ of the send_time (τ) is changed, the task execution and stop timing is adjusted, or the processor Improve processing speed. The change in the value of the argument τ corresponds to a change in processing method, a change in program language, and the like.
[0035]
According to the first embodiment, before detailed design of software (and hardware), it is possible to know the processing time and processing timing required for each task for performing real-time control normally. By designing the software (and hardware) in detail, it is possible to avoid a long development period due to repeated design and actual tests.
[0036]
[Second Embodiment]
FIG. 7 is a flowchart showing another processing method of step S4 of FIG. 3 as the second embodiment of the present invention. In this method, the next cycle execution task is determined based on the task priority.
[0037]
Steps S10 and S14 are the same as the corresponding steps in FIG.
[0038]
(S20) As an initial value, φ is substituted for the next cycle execution task TX, and the minimum priority PLmin is substituted for the priority PLX of the task.
[0039]
(S21) The initial value 1 is assigned to the variable i indicating the i-th row of the task list.
[0040]
FIG. 8 shows a task list, and each line includes a task name and the priority of the task. The task name and priority in the i-th row are represented by tasks TN (i) and PLN (i), respectively. The priority is, for example, levels 0 to 7, and the lower the value, the higher the priority.
[0041]
(S22) Referring to the state storage unit 24 in FIG. 1, it is determined whether or not the task TN (i) is in the sleep state in the next cycle. If it is in the sleep state, the process proceeds to step S25. Proceed to step S23.
[0042]
(S23) if Kere priority PLX follows cyclic task TX low than the priority PLN (i), that is, if PLX> PLN (i), the process proceeds to step S24, the process proceeds to step S25 otherwise.
[0043]
(S24) TN (i) and PLN (i) are assigned to TX and PLX, respectively.
[0044]
(S25) Increment i by 1.
[0045]
(S26) If the task TN (i) exists, the process returns to step S22. If not, TX is set as a task to be executed in the next cycle, and the processing of FIG.
[0046]
By such processing, among the tasks in the next cycle on the thread, the task that is not in the sleep state and has the highest priority is determined as the next cycle execution task TX. If there are a plurality of tasks having the same priority as the task TX, the execution task TX is determined according to the order in the task list (the order of arrangement in the storage device).
[0047]
FIG. 9 shows a case where the next two tasks task1 () and task2 () having different priorities are executed.
[0048]

Although the above task shows a case where there is no input processing for simplification, input processing may be included before or after each send_time (τ). Since the minimum value of the argument τ of spend_time (τ) is 1, 1c = 1u is determined.
[0049]
The thread SL1 is a thread of task1 (), and the control data dt1 is stored in the register REG1 of FIG. 1 at time t = 0, and the thread SL2 of task2 () is generated by the thread at time t = 1c. It is assumed that task2 () is required to execute a calculation process having a higher priority than task1 (), and task2 () has a higher priority than task1 (). Task1 () and task2 () that are not in the sleep state exist in the task list, and task2 () has a higher priority than task1 (), so task2 () is selected as the next cycle execution task TX, and send_time ( 4) is executed.
[0050]
Next, the thread SL2 is deleted, and only task1 () that is not in the sleep state exists in the task list, task1 () is selected as the next cycle execution task TX, the control data dt2 is stored in the register REG1, and then send_time (3 ) Is executed.
[0051]
In FIG. 1, it is assumed that the peripheral device 22 reads out the control data of the register REG1 every time 3u, and that the control data must be updated by the computer 21 before this reading.
[0052]
In the case of FIG. 9, since this requirement is not satisfied, this requirement is satisfied, for example, by setting one or more of the following as detailed design conditions.
[0053]
(1) Reduce the processing content of task2 ().
[0054]
(2) Shift the execution timing of task2 ().
[0055]
(3) A faster machine language code is generated for task2 ().
[0056]
(4) A faster computer 21 is used.
[0057]
[Third Embodiment]
FIG. 10 is a flowchart showing still another processing method of step S4 of FIG. 3 as a third embodiment of the present invention. In this method, priority is given to interrupt over task priority, and the task is executed in the next cycle. Decide as a task. The peripheral device in FIG. 1 is, for example, a model of a car engine including a sensor.
[0058]
When there are 8 interrupt factors for one interrupt, these are identified by 0 to 7, the interrupt processing of the factor i is executed by the task Ti, and the task Ti is designated by the pointer PTR (i) To do. If there is an interrupt request for the factor i, the interrupt flag IF is set to “1” and only IRQ (i) is set to “1” among the interrupt factor flags IRQ (0) to IRQ (7). In FIG. 1, flags IF and IRQ (0) to IRQ (7) correspond to internal registers of the computer 21, and the flags are set by signals from the peripheral device 22 to the computer 21.
[0059]
(S30) If IF = '0', the process proceeds to step S10 in FIG. 7; otherwise, the process proceeds to step S31.
[0060]
(S31) The initial value 0 is substituted for i.
[0061]
(S32) If i <8, the process proceeds to step S33; otherwise, that is, if any of IRQ (0) to IRQ (7) is “0”, the process proceeds to step S10 in FIG.
[0062]
(S33) If IR (i) = '1', proceed to step S35, otherwise proceed to step S34.
[0063]
(S34) Increment the value of i by 1 and return to step 32.
[0064]
(S35) A thread for the task Ti specified by the pointer PTR (i) is generated.
[0065]
(S36) Set IF = '0' and IRQ (i) = '0' to avoid re-acceptance of the same interrupt request.
[0066]
(S37) The task Ti is determined as the next cycle execution task TX.
[0067]
FIG. 11 is a time chart showing the operation when the next task is executed using the method of FIG.
[0068]

Although the above task shows a case where there is no input processing for simplification, input processing may be included before or after each send_time (τ). The function sleep (τ) is a process that pauses execution for a time τ to execute another task. In the above case, while task1 () is being executed, an interrupt is generated in each of the second to fourth cycles, and task2 () is executed for each interrupt. As in the second embodiment, in FIG. 1, it is assumed that the peripheral device 22 reads the control data in the register REG1 every 3u, and the control data must be updated by the computer 21 before this reading. Since this requirement is not satisfied, this requirement is satisfied, for example, by setting one or both of the following as detailed design conditions.
[0069]
(1) Set the interrupt generation interval to a certain cycle or more.
[0070]
(2) The function sleep (τ) is included in the interrupt process task2 (), that is, the interrupt process is executed after a predetermined time has elapsed since the occurrence of the interrupt.
[0071]
Note that the present invention includes various other modifications.
[0072]
For example, one cycle time may be determined as 1 / (natural number) of the minimum value of the waiting processing time included in all tasks. Thus, read-input signal, it is possible to change the timing of the signal output and interrupt.
[0073]
In the third embodiment, the case where the interrupt priority is the same has been described for the sake of simplification, but the present invention is naturally applied to the case where there is an interrupt with a different priority.
[0074]
Furthermore, the model task is a concept including a model corresponding to each thread when one process is executed by a plurality of threads.
[Brief description of the drawings]
FIG. 1 is a schematic block diagram showing a schematic multitask software simulation method according to a first embodiment of the present invention.
2 is a schematic explanatory diagram of a task executed by a task execution control unit 23 of FIG.
FIG. 3 is a flowchart showing processing of the task execution control unit 23 of FIG. 1 for a function send_time ( τ ) in a task Ti .
FIG. 4 is a flowchart showing details of step S4 in FIG. 3 when a round robin method is adopted.
FIG. 5 is a diagram showing a task list for explaining the processing of FIG. 4;
6 is a time chart showing a case where two tasks task1 () and task2 () are executed by the method of FIG.
FIG. 7 is a flowchart showing another processing method of step S4 of FIG. 3 as a second embodiment of the present invention.
FIG. 8 is a diagram showing a task list for explaining the processing of FIG. 7;
9 is a time chart showing a case where the next two tasks task1 () and task2 () having different priorities are executed by the method of FIG.
FIG. 10 is a flowchart showing still another processing method of step S4 of FIG. 3 as a third embodiment of the present invention.
11 is a time chart showing a case where a main task task1 () and an interrupt task task2 () are executed by the method of FIG.

Claims

プロセッサに対し入出力信号をリアルタイム処理させるマルチタスクソフトウェアの概略動作をコンピュータでシミュレーションする方法において、複数のタスクのそれぞれに対応したモデルタスクは、信号の入出力以外の処理が、該処理の見積時間τだけ経過すればリターンするスペンドタイム関数の呼び出しで表され、該見積時間τは該スペンドタイム関数の引数であり、
該コンピュータが、全てのモデルタスクで使用されるスペンドタイム関数の引き数τの最小値を１サイクルとし、現時刻ｔが１サイクル経過する毎に、
（ａ）該複数のモデルタスクのいずれを実行するかを所定アルゴリズムで決定し、
（ｂ）実行対象と決定したモデルタスクｉのみについて、実行中のスペンドタイム関数の見積時間τ_iを１サイクルだけデクリメントし、
（ｃ）現時刻で各モデルタスクが実行中であるか否かの状態を該コンピュータの記憶装置に格納する、
ことを特徴とする概略マルチタスクソフトウェアシミュレーション方法。In a method of simulating the general operation of multitask software that causes a processor to process input / output signals in real time using a computer, model tasks corresponding to each of a plurality of tasks are processed in an estimated time for processing other than signal input / output. The estimated time τ is an argument of the spent time function.
When the computer sets the minimum value of the argument τ of the spend time function used in all model tasks as one cycle, and every time the current time t passes,
(A) to determine whether to perform one of the plurality of model tasks in a predetermined algorithm,
(B) For only the model task i determined as the execution target, the estimated time τ _i of the spent time function being executed is decremented by one cycle ,
(C) storing in the storage device of the computer whether or not each model task is being executed at the current time;
A multi-task software simulation method characterized by the above.

上記複数のモデルタスクの少なくとも１つは、互いに引数値のみ異なる２つのスペンドタイム関数呼び出しの一方を入力信号値に基づき選択する処理を含むことを特徴とする請求項１記載の概略マルチタスクソフトウェアシミュレーション方法。 2. The general multitask software simulation according to claim 1, wherein at least one of the plurality of model tasks includes a process of selecting one of two spend time function calls different from each other only in argument values based on an input signal value. Method.

上記複数のモデルタスクの少なくとも１つは、該スペンドタイム関数を呼び出す処理と、該スペンドタイム関数の呼び出しの前又は後で制御データ信号を模擬的に出力する処理とを含むことを特徴とする請求項１記載の概略マルチタスクソフトウェアシミュレーション方法。 The at least one of the plurality of model tasks includes a process of calling the spent time function and a process of outputting a control data signal in a simulated manner before or after the calling of the spent time function. Item 4. The multitasking software simulation method according to Item 1.

上記ステップ（ａ）では、上記ステップ（ｃ）で格納された各モデルタスクの状態を参照して上記決定をすることを特徴とする請求項１記載の概略マルチタスクソフトウェアシミュレーション方法。In the step (a), a schematic multitasking software simulation method according to claim 1, wherein with reference to the state of each model task stored in step (c), characterized in that said decision.

上記ステップ（ａ）の所定アルゴリズムは、上記複数のモデルタスクのうち生存しているものを順番に実行するものであることを特徴とする請求項１記載の概略マルチタスクソフトウェアシミュレーション方法。2. The general multi-task software simulation method according to claim 1, wherein the predetermined algorithm in step (a) is to execute the surviving ones of the plurality of model tasks in order.

上記複数のモデルタスクはそれぞれその属性として優先度を有し、
上記ステップ（ａ）の所定アルゴリズムは、実行可能なモデルタスク候補の中から最も優先度の高いモデルタスク候補を選択し、該選択されたモデルタスク候補が１つの場合にはこれを実行対象のモデルタスクと決定し、該選択されたモデルタスク候補が複数の場合にはこれらの記憶装置内配列順に従って実行対象のモデルタスクを決定するものであることを特徴とする請求項１記載の概略マルチタスクソフトウェアシミュレーション方法。Each of the above model tasks has a priority as its attribute,
The predetermined algorithm in the step (a) selects a model task candidate with the highest priority from the executable model task candidates. If there is one selected model task candidate, this is executed as a model to be executed. 2. The general multitask according to claim 1, wherein when a plurality of selected model task candidates are determined, a model task to be executed is determined according to the order of arrangement in the storage device. Software simulation method.

上記複数のモデルタスクの少なくとも１つは上記プロセッサに対する割込と対応づけられ、
上記ステップ（ａ）の所定アルゴリズムでは、該割込が生じた場合、該対応づけられたモデルタスクを実行対象と決定するものであることを特徴とする請求項１記載の概略マルチタスクソフトウェアシミュレーション方法。At least one of the plurality of model tasks is associated with an interrupt to the processor;
2. The general multitask software simulation method according to claim 1, wherein, in the predetermined algorithm of step (a), when the interruption occurs, the associated model task is determined as an execution target. .

第１プロセッサに対し入出力信号をリアルタイム処理させるマルチタスクソフトウェアの概略動作をシミュレーションする概略マルチタスクソフトウェアシミュレーション装置において、
第２プロセッサと、
該第２プロセッサに結合された記憶装置と、
を有し、該記憶装置には、複数のタスクのそれぞれに対応したモデルタスクと、これらモデルタスクの実行を該プロセッサに対し制御させるプログラムとが格納され、各モデルタスクは、信号の入出力以外の処理が、該処理の見積時間τだけ経過すればリターンするスペンドタイム関数の呼び出しで表され、該見積時間τは該スペンドタイム関数の引数であり、
該プログラムは該第２プロセッサに対し、全てのモデルタスクで使用されるスペンドタイム関数の引き数τの最小値を１サイクルとさせ、現時刻ｔが１サイクル経過する毎に、
（ａ）該複数のモデルタスクのいずれを実行するかを所定アルゴリズムで決定させ、
（ｂ）実行対象と決定したモデルタスクｉにおいて、実行中のスペンドタイム関数の見積時間τ_iを１サイクルだけデクリメントさせ、
（ｃ）現時刻ｔで各モデルタスクが実行中であるか否かの状態を該記憶装置に格納させる、
ことを特徴とする概略マルチタスクソフトウェアシミュレーション装置。In the general multitask software simulation apparatus for simulating the general operation of the multitask software that causes the first processor to process the input / output signals in real time,
A second processor;
A storage device coupled to the second processor;
The storage device stores a model task corresponding to each of a plurality of tasks, and a program for controlling the execution of the model task by the processor. Is represented by a call to a spent time function that returns when the estimated time τ of the process elapses, and the estimated time τ is an argument of the spent time function,
The program makes the minimum value of the argument τ of the spend time function used in all model tasks to be one cycle for the second processor, and every time the current time t passes,
(A) letting a predetermined algorithm determine which of the plurality of model tasks is executed;
(B) In the model task i determined as the execution target, the estimated time τ _i of the spent time function being executed is decremented by one cycle ,
(C) Store in the storage device whether or not each model task is being executed at the current time t.
An outline multitask software simulation device characterized by the above.

第１プロセッサに対し入出力信号をリアルタイム処理させるマルチタスクソフトウェアの概略動作をシミュレーションする概略マルチタスクソフトウェアシミュレーションプログラムにおいて、
第２プロセッサに対し、全てのモデルタスクで使用されるスペンドタイム関数の引き数τの最小値を１サイクルとさせ、現時刻ｔが１サイクル経過する毎に、
（ａ）複数のタスクのそれぞれに対応したモデルタスクのいずれを実行するかを所定アルゴリズムで決定させ、ここに各モデルタスクは、信号の入出力以外の処理が、該処理の見積時間τだけ経過すればリターンするスペンドタイム関数の呼び出しで表され、該見積時間τは該スペンドタイム関数の引数であり、
（ｂ）実行対象と決定したモデルタスクｉにおいて、実行中のスペンドタイム関数の見積時間τ_iを１サイクルだけデクリメントさせ、
（ｃ）現時刻ｔで各モデルタスクが実行中であるか否かの状態を該記憶装置に格納させる、
ことを特徴とする概略マルチタスクソフトウェアシミュレーションプログラム。In the general multitask software simulation program for simulating the general operation of the multitask software that causes the first processor to process the input / output signals in real time,
For the second processor, the minimum value of the argument τ of the spend time function used in all model tasks is set to one cycle, and every time the current time t passes,
(A) A predetermined algorithm is used to determine which model task corresponding to each of a plurality of tasks is to be executed, and each model task is subject to processing other than signal input / output for the estimated time τ of the processing. The estimated time τ is an argument of the spent time function.
(B) In the model task i determined as the execution target, the estimated time τ _i of the spent time function being executed is decremented by one cycle ,
(C) Store in the storage device whether or not each model task is being executed at the current time t.
An outline multitask software simulation program characterized by the above.