(57)【要約】【課題】データ処理の効率化を図る。【解決手段】データプロセッサは、ソフトウェアを実行することによって、命令準備処理ステージと命令実行ステージを有する命令処理プロセッサをエミュレートするように構成されている。そのソフトウェアは、第一に、２以上の命令からなるグループに関して命令準備処理ステージをエミュレートすることにより、準備処理された命令のグループを生成し、次いで、準備処理された命令のグループに関して命令実行ステージをエミュレートすることにより、準備処理された命令のグループの各命令について命令実行ステージのエミュレーションが命令の順番に順次完了するように動作できる。【選択図】図３
2006331415.tif 000002
【特許請求の範囲】
【請求項１】
命令処理プロセッサをエミュレートするソフトウェアを実行するように構成されたデータプロセッサであって、前記ソフトウェアは少なくとも命令準備処理ステージと命令実行ステージとを有し、
前記ソフトウェアは、
最初に、２以上の命令からなるグループに関して前記命令準備処理ステージを実行することにより、準備処理された命令のグループを生成し、
次いで、前記準備処理された命令のグループに関して前記命令実行ステージを実行することにより、前記準備処理された命令のグループの各命令に関する命令実行ステージが命令の順番に順次完了する、ように動作できるものである
ことを特徴とするデータプロセッサ。
【請求項２】
請求項１記載のデータプロセッサであって、
前記命令準備処理ステージは命令フェッチステージと命令デコードステージとを有する、
ことを特徴とするデータプロセッサ。
【請求項３】
請求項１あるいは２記載のデータプロセッサであって、
前記命令は、命令準備処理ステージで処理される前に、１以上のキャッシュラインを有するキャッシュに保持され、
前記グループの命令の数は、前記グループが２以上のキャッシュラインからの命令とならないように選択されている、
ことを特徴とするデータプロセッサ。
【請求項４】
請求項１ないし３のいずれか１項に記載のデータプロセッサであって、
準備処理された命令の各グループの実行に応じて、エミュレートされるプロセッサにおける割込みをチェックするように動作可能であるソフトウェアを有する、
ことを特徴とするデータプロセッサ。
【請求項５】
請求項１ないし４のいずれか１項に記載のデータプロセッサであって、
前記準備処理された命令のいずれかの命令が実行する必要のないものであるかを検出し、そのような命令を検出した場合その命令の実行を禁止する手段、
を有することを特徴とするデータプロセッサ。
【請求項６】
請求項５記載のデータプロセッサであって、
不連続なプログラムフローの段階を検出する手段と、
不連続なプログラムフローの段階に応じて、前記準備処理された命令のグループ中の１以上の命令の実行を取り消す取消し手段と、
を有することを特徴とするデータプロセッサ。
【請求項７】
請求項６記載のデータプロセッサであって、
前記不連続なプログラムフローの段階が前記準備処理された命令のグループ中の分岐命令に関するものである場合、前記取消し手段は、前記グループにおいて前記分岐命令に後続するいかなる命令も実行を取り消すように構成されている、
ことを特徴とするデータプロセッサ。
【請求項８】
請求項６あるいは７記載のデータプロセッサであって、
前記不連続なプログラムフローの段階が前記準備処理された命令のグループ中のターゲット命令への分岐に関するものである場合、前記取消し手段は、前記グループにおいて前記ターゲット命令に先行するいかなる命令も実行を取り消すように構成されている、
ことを特徴とするデータプロセッサ。
【請求項９】
請求項１ないし８のいずれか１項に記載のデータプロセッサであって、
少なくとも前記命令準備処理ステージをエミュレートするソフトウェアは、前記命令のグループに関して並列に前記命令準備処理ステージをエミュレートするように動作可能なベクトルプロセッサ上で実行される、
ことを特徴とするデータプロセッサ。
【請求項１０】
請求項１ないし９のいずれか１項に記載のデータプロセッサであって、
前記データプロセッサは、前記命令のグループに関して、前記命令準備処理ステージを並列なオペレーションとして実行するように動作できる、
ことを特徴とするデータプロセッサ。
【請求項１１】
請求項１ないし１０のいずれか１項に記載のデータプロセッサであって、
エミュレートされる前記命令処理プロセッサは、命令準備処理ステージと命令実行ステージとを少なくとも含むパイプライン型オペレーションを有する、
ことを特徴とするデータプロセッサ。
【請求項１２】
ソフトウェアを実行することにより、命令準備処理ステージと命令実行ステージを少なくとも有する命令処理プロセッサをエミュレートするデータ処理方法であって、
最初に、２以上の命令からなるグループに関して前記命令準備処理ステージを実行することにより、準備処理された命令のグループを生成するステップと、
次いで、前記準備処理された命令のグループに対して前記命令実行ステージを実行することにより、前記準備処理された命令のグループの各命令に関する命令実行ステージが命令の順番に順次完了するステップと、
を有するデータ処理方法。
【請求項１３】
請求項１２記載の方法を実行するためのプログラムコードを有するコンピュータソフトウェア。
【請求項１４】
請求項１３記載のプログラムコードを提供する媒体。
【請求項１５】
請求項１４記載の媒体であって、伝送媒体であることを特徴とする媒体。
【請求項１６】
請求項１４記載の媒体であって、記憶媒体であることを特徴とする媒体。
【発明の詳細な説明】
【技術分野】
【０００１】
本発明は、データ処理に関する。
【背景技術】
【０００２】
本発明は、パイプライン型データ処理および非パイプライン型データ処理の双方に適用可能である。パイプライン型システムを技術的背景として説明するが、それは対象となる問題を示すためにすぎない。
【０００３】
いわゆる「パイプライン型」データ処理では、データ処理命令を処理するために必要なオペレーションは、連続する２以上の命令処理サイクル（例えば、クロックサイクル）にわたって実行される。
【０００４】
例えば、パイプライン型データプロセッサにおいては、「プログラムカウンタ」の制御のもとで、第一サイクルでメモリから命令を「フェッチ」すなわち取り出し、次のサイクルで「デコード」して命令の意味とオペランドを決定し、第三サイクルでその命令を「実行」する。これを繰り返すと、１つの命令がパイプラインのあるステージにあるとき別の命令は異なるステージにあることになる。これは、パイプライン全体を可能な限り十分に利用されている状態に維持することを意図したものである。
【発明の開示】
【発明が解決しようとする課題】
【０００５】
そのようなパイプラインを、他のデータプロセッサ上で動作するソフトウェアを用いてエミュレートしようとすると、問題が生じる。
【０００６】
このようなエミュレーションの状況では、エミュレートすべきデータプロセッサの各ハードウェアオペレーションは、エミュレートプロセッサ上においてソフトウェアサブルーチンにより実行される。従って、クロックサイクル期間に相当するものは、それらのサブルーチンのうち最も遅いサブルーチンの動作速度に依存し、後者は、エミュレートされたタスクを実行するためにエミュレートプロセッサが必要とするオペレーションの数に依存する。
【０００７】
エミュレーションクロック速度は、この最も遅いエミュレーションタスクを考慮して設定されなければならない。リアルタイムオペレーションをエミュレートするシステムあるいは何らかの外部処理装置と相互作用するシステムでは、エミュレーションクロック速度を一定に保たなければならない。言い換えれば、実行されている現行の命令に合わせてエミュレーションクロックの速度を上げたり、下げたりすることはできない。
【０００８】
こうしたことすべては、パイプライン型プロセッサのエミュレーションに更に影響を及ぼす可能性があるので、異なる命令に関するフェッチオペレーション、デコードオペレーション、実行オペレーションが同時に生じるようにパイプラインをエミュレートする能力は制約されることになる。むしろ、各命令がフェッチされ、デコードされ、実行された後に、次の命令がフェッチ等されるようにしたシステムが一般に用いられている。これは、４つの命令Ｉ１、Ｉ２、Ｉ３、Ｉ４を実行するのに、次のように１２のエミュレーションクロックサイクルを要することを意味する。
【０００９】
第一のエミュレーションクロックサイクル        Ｉ１のフェッチ
第二のエミュレーションクロックサイクル        Ｉ１のデコード
第三のエミュレーションクロックサイクル        Ｉ１の実行
第四のエミュレーションクロックサイクル        Ｉ２のフェッチ
第五のエミュレーションクロックサイクル        Ｉ２のデコード
第六のエミュレーションクロックサイクル        Ｉ２の実行
・・・
第十二のエミュレーションクロックサイクル        １４の実行
【課題を解決するための手段】
【００１０】
本発明は、命令準備処理ステージと命令実行ステージとを有する命令処理プロセッサをエミュレートするソフトウェアを実行するように構成されたデータプロセッサであって、
前記ソフトウェアは、
最初に、２以上の命令からなるグループに関して前記命令準備処理ステージをエミュレートすることにより、準備処理された命令のグループを生成し、
次いで、前記準備処理された命令のグループに関して前記命令実行ステージをエミュレートすることにより、前記準備処理された命令のグループの各命令に関する命令実行ステージのエミュレーションが命令の順番に順次完了する、
ように動作できる、ものである、データプロセッサを提供する。
【００１１】
本発明は、（例えば）単一パイプラインでもスーパースケーラでもない、ハイブリッドアプローチを用いることにより、命令処理プロセッサのエミュレーション速度の向上を達成する。２以上の命令のグループを準備処理した後に（例えば、それらの命令をフェッチし、デコードした後に）、グループ内の命令を（エミュレーション）実行する。次いで、エミュレーションでは、命令の実行が命令の順番で１つ１つ完了される。
【００１２】
その結果、エミュレーションシステムにおける向上が達成される。なぜなら、１つの命令のフェッチとデコードをエミュレートするのに必要なソフトウェア処理は、１つの命令の実行をエミュレートするのに要求される処理よりも、しばしばかなり手間が少ないからである。
【００１３】
従って、４つの命令Ｉ１、Ｉ２、Ｉ３、Ｉ４からなるグループの例では、エミュレーションプロセスは次のように進むことができる。
【００１４】
第一のエミュレーションクロックサイクル        Ｉ１−Ｉ４のフェッチ
第二のエミュレーションクロックサイクル        Ｉ１−Ｉ４のデコード
第三のエミュレーションクロックサイクル        Ｉ１の実行
第四のエミュレーションクロックサイクル        Ｉ２の実行
第五のエミュレーションクロックサイクル        Ｉ３の実行
第六のエミュレーションクロックサイクル        Ｉ４の実行
従って、この例の場合、上に説明された例では１２のエミュレーションクロックサイクルを要したが、ここでは６エミュレーションクロックサイクルを要するだけである。
【００１５】
本発明の実施形態では、パイプラインは、命令準備処理ステージが命令フェッチステージと命令実行ステージとを有するという意味で、少なくとも３ステージのパイプラインである。
【００１６】
本発明の実施形態においては、命令準備処理に処する前に命令を１以上のキャッシュラインを有するキャッシュに保持するとともに、２以上のキャッシュラインからの命令が１つのグループに含まれないように１グループの命令の数が選択されているので、オペレーションの効率性を向上することができる。
【００１７】
本発明は、また、ソフトウェアを実行することにより、命令準備処理ステージと命令実行ステージとを少なくとも有する命令処理プロセッサをエミュレートするデータ処理方法であって、
最初に、２以上の命令からなるグループに関して前記命令準備処理ステージをエミュレートすることにより、準備処理された命令のグループを生成するステップと、
次いで、前記準備処理された命令のグループに対して前記命令実行ステージをエミュレートすることにより、前記準備処理された命令のグループの各命令に関する命令実行ステージのエミュレーションが命令の順番に順次完了するステップと、を有する
本発明の更に別の特徴としては、上記方法を実行するプログラムコードを含むコンピュータソフトウェアと、そのようなプログラムコードを提供する媒体（例えば、伝送媒体あるいは記憶媒体）が含まれる。
【発明を実施するための最良の形態】
【００１８】
《実施例》
図１は、エミュレートされるデータ処理システムを概略的に示したものである。本システムはプロセッサ１０と主メモリ２０を有し、プロセッサ１０は主メモリ２０からデータおよび命令を読み出し、主メモリ２０へデータおよび修正された命令を書き込む。
【００１９】
以下の説明は、エミュレートされるシステムの主メモリ２０のイメージを保持するには小さすぎるローカルメモリを有するプロセッサを用いて図１のシステムのオペレーションをエミュレートする技術に関するものである。この制約があるため、キャッシュを用いた解決策を採用する必要がある。
【００２０】
図２は、エミュレーションのための構成を概略的に示したものである。エミュレーション技術は一般的によく知られており、説明を明瞭にするために、本実施形態に直接関係のない特徴については省略する。エミュレーションにはエミュレーションプロセッサがそのエミュレーションプロセッサにネイティブな言語でかかれたエミュレーションソフトウェアを実行することが関係し、従ってエミュレートされるシステムにおける命令の処理をエミュレートするために、そのようなネイティブな命令の一群が実行される。以下の説明において、「命令」という語は、エミュレートされるシステムにおける命令を指しており、エミュレーションソフトウェアのネイティブな命令を指しているものではない。
【００２１】
図２を参照すると、エミュレーションソフトウェア１２０を実行するプロセッサ（この場合、パラレルプロセッサあるいは「ベクトル」プロセッサ）１１０が、命令キャッシュ（Ｉ）１４０およびデータキャッシュ（Ｄ）１５０を介して主メモリ１３０にアクセスする。ＩキャッシュおよびＤキャッシュを用いる理由は、プロセッサ１１０のローカルメモリが小さすぎてエミュレートされるシステムの主メモリ２０のイメージを保持できないからであり、又、プロセッサ１１０に対応する主メモリ１３０にアクセスするには費用のかかる（すなわち、時間のかかる）ＤＭＡアクセスによる必要があるからである。
【００２２】
Ｉキャッシュ１４０はアクセス速度を考慮して直接マッピング方式であり、各々が４キロバイトのメモリページを８ページ保有している。本実施形態では少数の大きなメモリページを使用しているが、それはキャッシュヒットの検証をより効率的にするためである。ページサイズが大きいことにより、メモリに対するアクセスの遅さを埋め合わせることができる。主メモリ１３０からＩキャッシュ１４０にメモリページを読み込み、プロセッサはＩキャッシュ１４０から命令を読み出すことができる。しかし、Ｉキャッシュ１４０に格納された値が主メモリ１３０に書き戻されることは決してない。
【００２３】
Ｄキャッシュ１５０は、いわゆる「スラッシング」（即ち、キャッシュされたページのめまぐるしい変更）を減らすために完全に連想的であり、やはり各ページ４キロバイトのページを８ページ保有している。主メモリ１３０から新たなページをＤキャッシュに読み込む場合、Ｄキャッシュに格納されているページの中でアクセス頻度が最も低いページが（そのページが変更されている場合）主メモリに書き戻される。従って、プロセッサがＤキャッシュのいずれかの格納データを修正した場合、そのページが主メモリ１３０に書き戻されるまで、その修正はＤキャッシュ１５０に保持されている。
【００２４】
図３は、４つの命令の処理を示す概略的タイミング図である。時間は図の上から下に進むものとして示されている。明瞭さのために、命令の実行を拡大しているため、垂直方向の軸は正確な縮尺で描かれていない。
【００２５】
図の一番上に、フェッチされデコードされる４つの命令Ｉ１、Ｉ２、Ｉ３、Ｉ４のグループが示されている。このオペレーションは４つの命令すべてに対して並行してなされ、本実施形態では２エミュレートクロックサイクル（フェッチに１サイクル、デコードに１サイクル）を要する。
【００２６】
次いで、これらの命令が実行される。本実施形態では、Ｉ１はＩ２の実行が開始される前に実行され、以下同様である。しかし、他の実施形態では、命令の実行をエミュレートするために必要なオペレーションは、ある程度オーバーラップするように構成されていてもよい。いずれにしても、Ｉ１の実行の完了はＩ２の実行の完了より前に生じ、以下同様である。明瞭さのために垂直方向の縮尺が拡大されてはいるが、４つの命令Ｉ１−Ｉ４の実行は全部で４エミュレートクロックサイクルを要する。
【００２７】
従って、４つの命令のフェッチ、デコード、実行には６エミュレートサイクルを要する。
【００２８】
エミュレーションシステムにおいて４つの命令の実行が完了すると、次の４つの命令をフェッチし、デコードすることができ、以下同様である。
【００２９】
本実施形態において、各キャッシュページは４キロバイトの長さであり、命令はそれぞれ４バイトの長さである。それぞれ４つの命令からなる命令グループは１６バイト境界に配列され、従って１グループの４つの命令のフェッチが２キャッシュページにわたることはない。これによりキャッシュをより効率的に使用することができ、本システムでは特定の命令のフェッチオペレーションに対して主メモリから２キャッシュページを取り出す必要はない。
【００３０】
１グループが４つの命令からなることにより、ベクトル（ホスト）プロセッサ１１０をより効率的に使用することができる。本実施形態においては、ベクトルプロセッサ１１０は単一の並列オペレーションで１６バイト値を処理することができる。
【００３１】
図４および図５は、命令のうち１つ（この例では、命令Ｉ２）が分岐命令であるオペレーション関する図である。この状況は図４に略図的に示されており、その図において矢印は、命令Ｉ２がプログラムのフローをメモリの他の位置に分岐させることを示しており、命令Ｉ３およびＩ４を表示する必要はない。
【００３２】
図５を参照すると、４つの命令Ｉ１−Ｉ４すべてが前と同様にフェッチされデコードされる。しかし、命令Ｉ２が分岐命令であることが明らかになるやいなや、命令Ｉ３およびＩ４の実行は放棄される。命令Ｉ２のエミューレート実行の終わりに、次の（即ち、分岐先アドレスからの）４つの命令がフェッチされ、プロセスが継続される。
【００３３】
図６はグループ内にターゲット命令を含む命令のグループを概略的に示したものである。この例の場合、他で実行された分岐命令の結果、プログラムのフローがこのグループ内の命令の１つへと分岐させられた。
【００３４】
原理的には、４つの命令をフェッチすることによりターゲット命令が常に４つの命令からなる１グループの最初の命令（ここでの表記では、命令Ｉ１）となるようにすることが可能である。しかし、それは上に述べた取り決め、すなわち単一のオペレーションに対して複数のキャッシュページからフェッチすることを避けるという取り決めを破る結果になり得る。従って、１６バイト境界が維持されるが、それは、１つのグループの４つの命令のどの命令もそれに先立つ分岐オペレーションのターゲットになり得ることを意味する。
【００３５】
図６および図７に示された例では、三番目の命令Ｉ３がターゲットである。これは、この特定のグループでは命令Ｉ１およびＩ２を実行する時点が存在しないことを意味する。
【００３６】
図７を参照すると、グループの４つの命令すべてが正規の命令としてフェッチされデコードされる。４つの命令すべてをフェッチしデコードしても時間的な不利益は無い。なぜなら、それがプロセッサ１１０による並列オペレーションだからである。しかし、デコードされた命令Ｉ１およびＩ２を実際に実行する時点は存在しないので、図７に示されているように、これら２つの命令の実行は回避され、命令Ｉ３から実行が開始される。
【００３７】
図８は、プログラムのフロー中にブレークがある例を示すものであり、実行不可能な命令Ｉ２が含まれている。実行不可能な命令とは、例えば、存在しないメモリアドレス等への分岐あるいは参照を含むものである。ここでは図８および図９に示されているように、命令Ｉ２が実行不可能であることが明らかになるやいなや、その実行が放棄される。問題の性質に依存して、命令Ｉ３およびＩ４から実行を継続することもできるし、例外状況を開始することもできる。例えば、問題（どんなものであれ）の解決を意図して例外処理ルーティンに分岐し、ついで制御をＩ２に戻すことができる。
【図面の簡単な説明】
【００３８】
以下、本発明の実施形態を添付図面を参照して説明するが、これらの実施形態は説明のためだけのものである。
【図１】データ処理システムの概略図である。
【図２】データキャッシュおよび命令キャッシュを用いるデータ処理システムの概略図である。
【図３】４つの命令の処理を示す概略的タイミング図である。
【図４】第三の命令が分岐命令である命令のグループを概略的に示したものである。
【図５】図３に示した４つの命令の処理を示す概略的タイミング図である。
【図６】第三の命令がターゲット命令である命令のグループを概略的に示したものである。
【図７】図６に示した４つの命令の処理を示す概略的タイミング図である。
【図８】第二の命令が実行不可能な命令である命令のグループを概略的に示したものである。
【図９】図８に示した４つの命令の処理を示す概略的タイミング図である。
【符号の説明】
【００３９】
１０…プロセッサ、２０…主メモリ、１１０…プロセッサ、１２０…            エミュレーション用ソフトウェア、１３０…主メモリ、１４０…Ｉキャッシュ、１５０…Ｄキャッシュ
【図１】
2006331415.tif 000003
【図２】
2006331415.tif 000004
【図３】
2006331415.tif 000005
【図４】
2006331415.tif 000006
【図５】
2006331415.tif 000007
【図６】
2006331415.tif 000008
【図７】
2006331415.tif 000009
【図８】
2006331415.tif 000010
【図９】
2006331415.tif 000011
【外国語明細書】
DATA PROCESSING
This invention relates to data processing.
The present invention is applicable to pipelined data processing and non-pipelined data processing.  Technical background will be described with respect to a pipelined system merely to indicate a problem to be addressed.
So-called “pipelined” data processing is known, in which the operations required to handle a data processing instruction are carried out over two or more successive instruction-handling cycles (e.g. processor clock cycles).
For example, in a pipelined data processor, an instruction might be “fetched” or retrieved from memory during a first cycle under the control of a “program counter”, “decoded” during the next cycle in order to determine the meaning of the instruction and its operands, and then “executed” during a third cycle.  This happens repeatedly so that while one instruction is at a certain stage in the pipeline, other instructions are at different stages, the aim being to keep the whole pipeline fully occupied as much as possible.
A problem can arise when it is desired to emulate such a pipeline using software running on another data processor.
In an emulation situation like this, each hardware operation of the data processor to be emulated is executed by a software subroutine on the emulating processor.  The equivalent of the clock cycle period thus depends on the speed of operation of the slowest of these subroutines, which in turn depends on the number of operations that the emulating processor needs in order to carry out the emulated task.
The emulation clock speed has to be set to allow for this slowest emulation task.  In a system which emulates real time operations or interacts with any external processing apparatus, the emulation clock speed has to be kept constant.  That is to say, the emulation clock cannot be speeded up or slowed down to suit the current instruction being executed.
This can all have a further effect on the emulation of a pipelined processor, which is to restrict the ability to emulate the pipeline so that the fetch, decode and execute operations take place at the same time in respect of different instructions.  Rather, a system is generally used in which each instruction is fetched, decoded and executed before the next is fetched, and so on.  This means that the execution of four instructions I1, I2, I3 and I4 would take twelve emulation clock cycles:
first emulated clock cycle   fetch I1
second emulated clock cycle               decode I1
third emulated clock cycle   execute I1
fourth emulated clock cycle               fetch I2
fifth emulated clock cycle   decode I2
sixth emulated clock cycle   execute I2
. . .                               . . .
twelfth emulated clock cycle                          execute I4
This invention provides a data processor arranged to execute software to emulate an instruction-handling processor having an instruction preparation stage and an instruction execution stage, the software being operable:
first to emulate the instruction preparation stage in respect of a group of two or more instructions to generate a group of prepared instructions; and
then to emulate the instruction execution stage in respect of the group of prepared instructions, so that the completion of the emulation of the instruction execution stage in respect of each of the prepared instructions occurs serially in an instruction order.
The invention makes use of a hybrid approach  neither (for example) a single pipeline nor a superscalar pipeline  to achieve an improvement in the emulation speed of an instruction-handling processor.  A group of two or more instructions is prepared (e.g. the instructions are fetched and decoded) before any of the instructions in the group is executed (in the emulation).  The emulation then completes the execution of the instructions one after the other, in an instruction order.
This can achieve an improvement in an emulated system because the software processing needed to emulate the fetching and decoding of an instruction is often much less onerous than the processing required to emulate the execution of an instruction.  
So, in an example having a group of four instructions I1, I2, I3 and I4, the emulation processing might proceed as follows:
first emulated clock cycle   fetch I1 - I4
second emulated clock cycle               decode I1-I4
third emulated clock cycle   execute I1
fourth emulated clock cycle               execute I2
fifth emulated clock cycle   execute I3
sixth emulated clock cycle   execute I4
Accordingly, the example situation, which took twelve emulated clock cycles in the example described earlier, now takes six emulated clock cycles.
In embodiments of the invention the pipeline is at least a three-stage pipeline, in that the instruction preparation stage comprises an instruction fetching stage and an instruction decoding stage.
Efficiency of operation can be improved in embodiments of the invention in which the instructions are held, before being subject to instruction preparation, in a cache comprising one or more cache lines; and the number of instructions in the group is selected so as to avoid the group comprising instructions from more than one cache line.
This invention also provides a data processing method in which software is executed to emulate an instruction-handling processor having at least an instruction preparation stage and an instruction execution stage, the method comprising the steps of:
first emulating the instruction preparation stage in respect of a group of two or more instructions to generate a group of prepared instructions; and
then emulating the instruction execution stage in respect of the group of prepared instructions, so that the completion of the emulation of the instruction execution stage in respect of each of the prepared instructions occurs serially in an instruction order.
Further aspects of the invention include computer software comprising program code to carry out this method; and a medium (e.g. a transmission medium or a storage medium) by which such program code is provided.
Embodiments of the invention will now be described, by way of example only, with reference to the accompanying drawings in which:
Figure 1 schematically illustrates a data processing system;
Figure 2 schematically illustrates a data processing system using data and instruction caches;
Figure 3 is a schematic timing diagram illustrating the handling of four instructions;
Figure 4 schematically illustrates a group of instructions having a branch instruction as a third instruction;
Figure 5 is a schematic timing diagram illustrating the handling of the four instructions shown in Figure 3;
Figure 6 schematically illustrates a group of instructions having a target instruction as a third instruction;
Figure 7 is a schematic timing diagram illustrating the handling of the four instructions shown in Figure 6;
Figure 8 schematically illustrates a group of instructions having an unexecutable instruction as a second instruction; and
Figure 9 is a schematic timing diagram illustrating the handling of the four instructions shown in Figure 8.
Figure 1 schematically illustrates a data processing system to be emulated.  The system comprises a processor 10 which reads data and instructions from, and writes data and modified instructions to, a main memory 20.  
The following description relates to a technique for emulating the operation of the system of Figure 1 using a processor whose local memory is too small to hold an image of the main memory 20 of the system to be emulated.  Because of this restriction, a cache strategy has to be employed.  
Figure 2 schematically illustrates the emulation arrangement.  Emulation techniques are generally well known, and features which are not directly relevant to the present embodiment are omitted for clarity.  Emulation involves an emulation processor running emulation software written in a language native to the emulation processor, so that a group of such native instructions are run in order to emulate the handling of an instruction in the emulated system.  In the description which follows, the term “instruction” will refer to an instruction in the emulated system, and not to a native instruction of the emulation software.
Referring to Figure 2, a processor (in this case a parallel or “vector” processor) 110 running emulation software 120 accesses a main memory 130 via an instruction cache (I) 140 and a data cache (D) 150.  The reason that the I cache and the D cache are used is that the memory local to the processor 110 is too small to hold an image of the main memory 20 of the emulated system, and the main memory 130 associated with the processor 110 has to be accessed via an expensive (i.e. time consuming) DMA accesses.  
The I cache 140 is direct mapped for speed of access and holds 8 memory pages of 4 kilobytes each.  A small number of large memory pages are used in this embodiment to make the process of checking for a cache hit more efficient.  Large page sizes amortize slow memory accesses.  Memory pages may be read from the main memory 130 into the I cache 140, and the processor may read instructions from the I cache 140.  However, values stored in the I cache 140 are never written back to the main memory 130.  
The D cache 150 is fully associative to reduce so-called “thrashing”  i.e. a rapid changing of the cached pages - and again holds 8 pages of 4 kilobytes each.  When a new page is to be read into the D cache from the main memory 130, a least-recently-accessed page stored in the D cache is written back to the main memory (if that page has been changed).  So, if the processor modifies any stored data in the D cache, the modification is held in the D cache 150 until that page is written back to the main memory 130.  
Figure 3 is a schematic timing diagram illustrating the handling of four instructions.  Time is shown progressing from the top of the diagram towards the bottom.  The vertical access is not drawn to scale, as the execution of the instructions  has been expanded for clarity.  
At the top of the diagram, there is shown a group of four instructions I1, I2, I3 and I4 being fetched and decoded.  This operation occurs in parallel for all four instructions, and in the present embodiment takes two emulated clock cycles (one to fetch, one to decode).  
Instructions are then executed.  In the present embodiment I1 is executed before the execution of I2 commences, and so on, but in other embodiments the operations needed to emulate the execution of the instructions can be arranged to overlap to an extent.  In either case the completion of the execution of I1 occurs before the completion of execution of I2, and so on.  Although the vertical scale has been expanded for clarity, the execution of the four instructions I1..I4 takes a total of four emulated clock cycles. 
So, the fetching, decoding and execution of the four instructions has taken six emulated clock cycles.  
Once the four instructions have been executed in the emulated system, a further four instructions can be fetched and decoded, and so on.
In the present embodiment, each cache page is four kilobytes long, and the instructions are each four bytes long.  The groups of four instructions are arranged at sixteen byte boundaries so that the fetching of a group of four instructions never bridges two cache pages.  This allows a more efficient use of the cache and avoids the system ever having to retrieve two cache pages from the main memory for a particular instruction fetch operation.  
A four instruction group also allows a more efficient use of the vector (host) processor 110, which in this embodiment is capable of processing 16 byte values in a single parallel operation.
Figures 4 and 5 relate to the operation where one of the instructions (in this example, the instruction I2) is a branch instruction.  This situation is shown schematically in Figure 4, where an arrow indicates the instruction I2 branches the program flow to another position in memory, thus rendering the instructions I3 and I4 not required.  
Referring to Figure 5, all four instructions I1..I4 are fetched and decoded as before.  However, as soon as it becomes clear that the instruction I2 is a branch instruction, execution of the instructions I3 and I4 is aborted.  At the end of the emulated execution of the instruction I2, the next four instructions (from the branch target address) are fetched and the process continues.  
Figure 6 schematically illustrates a group of instructions having a target instruction contained within the group.  In this instance, a branch instruction executed elsewhere has caused the program flow to branch to one of the instructions in the group.
It would in principal be possible to fetch four instructions so that the target instruction was always the first of the group of four (i.e. instruction I1 in this notation) but this could lead to a breakdown of the convention described above which avoids fetching from multiple cache pages in a single operation.  So, the sixteen byte boundaries are maintained, which could mean that any one of the four instructions in the group may be the target of the previous branch operation. 
In the present example of Figures 6 and 7, the third instruction I3 is the target.  This means that the there is no point executing the instructions I1 and I2 in this particular group.
Referring to Figure 7, all four instructions in the group are fetched and decoded as normal.  There is no time penalty in fetching and decoding all four instructions, because this is parallel operation by the processor 110.  However there is no point actually executing the decoded instructions I1 and I2, so as shown in Figure 7, the execution of these two is prevented and execution starts with the instructions I3.
The final example to be given of a break in program flow is shown in Figure 8, where an unexecutable instruction I2 is included.  An unexecutable instruction might contain a branch or a reference to a non-existent memory address or alike.   Here, as shown in Figures 8 and 9, as soon as it becomes apparent that the instruction I2 cannot be executed, its execution is aborted.  Depending on the nature of the problem, execution may continue with the instructions I3 and I4, or an exception situation may be initiated.  For example, a branch may be made to an exception handling routine in an attempt to resolve the problem (whatever that is), with control then returning to I2.
1.A data processor arranged to execute software to emulate an instruction-handling processor, the software having at least an instruction preparation stage and an instruction execution stage, the software being operable:
first to carry out the instruction preparation stage in respect of a group of two or more instructions to generate a group of prepared instructions; and
then to carry out the instruction execution stage in respect of the group of prepared instructions, so that the completion of the instruction execution stage in respect of each of the prepared instructions occurs serially in an instruction order.
2.A data processor according to claim 1, in which the instruction preparation stage comprises an instruction fetching stage and an instruction decoding stage.
3.A data processor according to claim 1 or claim 2, in which:
the instructions are held, before being subject to instruction preparation, in a cache comprising one or more cache lines; and
the number of instructions in the group is selected so as to avoid the group comprising instructions from more than one cache line.
4.A data processor according to any one of the preceding claims, comprising software operable to check for interrupts in the emulated processor in response to execution of each group of prepared instructions.
5.A data processor according to any one of the preceding claims, comprising means for detecting whether any of the prepared instructions need not be executed; and if so, for inhibiting execution of such instructions.
6.A data processor according to claim 5, comprising:
means for detecting an instance of non-sequential program flow; and
means responsive to an instance of non-sequential program flow for cancelling the execution of one or more instructions in the group of prepared instructions.
7.A data processor according to claim 6 in which, when the instance of non-sequential program flow relates to a branch instruction within the group of prepared instructions, the cancelling means is arranged to cancel execution of any instructions in the group following the branch instruction.
8.A data processor according to claim 6 or claim 7 in which, when the instance of non-sequential program flow relates to a branch to a target instruction within the group of prepared instructions, the cancelling means is arranged to cancel execution of any instructions in the group preceding the target instruction.
9.A data processor according to any one of the preceding claims, in which at least the software to emulate the instruction preparation stage runs on a vector processor operable to emulate the instruction preparation stage for the group of instructions in parallel.
10.A data processor according to any one of the preceding claims, the data processor being operable to carry out the instruction preparation stage as a parallel operation with respect to the group of instructions.
11.A data processor according to any one of the preceding claims, in which the emulated instruction-handling processor has a pipelined operation involving at least an instruction preparation stage and an instruction execution stage.
12.A data processing method in which software is executed to emulate an instruction-handling processor having at least an instruction preparation stage and an instruction execution stage, the method comprising the steps of:
first carrying out the instruction preparation stage in respect of a group of two or more instructions to generate a group of prepared instructions; and
then carrying out the instruction execution stage in respect of the group of prepared instructions, so that the completion of the instruction execution stage in respect of each of the prepared instructions occurs serially in an instruction order.
13.Computer software comprising program code to carry out a method according to claim 12.
14.A medium by which program code according to claim 13 is provided.
15.A medium according to claim 14, the medium being a transmission medium.
16.A medium according to claim 14, the medium being a storage medium.
A data processor is arranged to execute software to emulate an instruction-handling processor having an instruction preparation stage and an instruction execution stage.  The software is operable first to emulate the instruction preparation stage in respect of a group of two or more instructions to generate a group of prepared instructions; and then to emulate the instruction execution stage in respect of the group of prepared instructions, so that the completion of the emulation of the instruction execution stage in respect of each of the prepared instructions occurs serially in an instruction order.
(Figure 3 to accompany the abstract)
【Ｆｉｇ．1】
2006331415.tif 000012
【Ｆｉｇ．2】
2006331415.tif 000013
【Ｆｉｇ．3】
2006331415.tif 000014
【Ｆｉｇ．4】
2006331415.tif 000015
【Ｆｉｇ．5】
2006331415.tif 000016
【Ｆｉｇ．6】
2006331415.tif 000017
【Ｆｉｇ．7】
2006331415.tif 000018
【Ｆｉｇ．8】
2006331415.tif 000019
【Ｆｉｇ．9】
2006331415.tif 000020