JP2007534066A

JP2007534066A - 複製メモリフィールドを備えたマルチコンピュータアーキテクチャ

Info

Publication number: JP2007534066A
Application number: JP2007508677A
Authority: JP
Inventors: ジョンマシューホルト
Original assignee: ワラテックプロプライエタリーリミテッド
Priority date: 2004-04-22
Filing date: 2005-04-22
Publication date: 2007-11-22
Also published as: CA2563900A1; MXPA06012209A; WO2005103924A1; ZA200608766B; JP2007534064A; JP2007534065A; JP2007534063A; EA009926B1; CN101908001A; CN1965308B; BRPI0508929A; IL178527A0; EP1763774A1; CN1965308A; WO2005103926A1; EP1763772A4; EP1763774A4; CA2563900C; CN101908001B; WO2005103928A1

Abstract

本発明は、アプリケーションプログラム（５０）を複数のコンピュータ（Ｍ１、．．．Ｍｎ）上で同時に実行できるようにする修正されたコンピュータアーキテクチャ（５０、７１、７２）を開示する。各コンピュータにある共有メモリは、全てのメモリ読み取り要求がローカルで満たされるように修正及び／又は上書きによって更新される。初期プログラムロード（７５）又は類似のプログラムロード中、メモリが再度書き込まれ又は操作されることになる命令が識別される（９２）。全コンピュータにおける等価のメモリロケーションが更新されるようにする追加命令が挿入される（１０３）。
【選択図】図８

Description

本発明は、コンピュータに関し、詳細には、改善された性能を達成可能な改良型マシーンアーキテクチャに関する。

コンピュータ及びコンピュータ関係の利用が出現して以来、コンピュータのソフトウェアは、単一のマシーン上で実行するように記述されてきた。図１に示されるように、当該従来技術の単一マシーン１は、バス４を介してメモリ３に接続された中央処理ユニット又はＣＰＵ２から構成される。また、モニタ５、キーボード６、及びマウス７のような単一マシーン１の種々の他の機能ユニットもバス４に接続されている。

マシーン１の性能に対する基本的制限は、ＣＰＵ２によって操作されるデータ及びこれらの操作の結果をバス４によって移動する必要があることである。バス４は、バスへのアクセスを要望するユニットによって形成されるいわゆるバス「待ち行列」、コンテンション問題、及び同様のものを含む幾つかの問題の影響を受ける。これらの問題は、キャッシュメモリを含む種々の方策によってある程度までは軽減することができるが、このような方策は、マシーン１の管理オーバーヘッドを必然的に増大させる。

当然、何年もの間マシーン性能を向上させる種々の試みがなされてきた。１つの手法は、対称的マルチプロセッサを使用することである。この従来技術の手法は、いわゆる「スーパー」コンピュータで使用されており、図２に概略的に示されている。ここで複数のＣＰＵ１２は、グローバルメモリ１３に接続されている。同様に、ボトルネックは、ＣＰＵ１２とメモリ１３との間の通信で発生する。このプロセスは、「シングルシステムイメージ」と呼ばれている。１つだけのアプリケーションと、グローバルメモリにわたり分散されるアプリケーション用のメモリの１つの全体コピーが存在する。単一のアプリケーションは、完全にトランスペアレントにいずれかのメモリロケーションとの間で読み込み及び書き込み（すなわち共有）を行うことができる。

ネットワークを介して相互接続された幾つかのこのようなマシーンが存在する場合には、これは、単一のマシーン用に記述された単一のアプリケーションを採用し、必要とされるメモリ資源を小部分に分割することによって達成される。次いで、これらの小部分は、幾つかのコンピュータにわたって分散され、全てのＣＰＵ１２がアクセス可能なグローバルメモリ１３を形成する。この手順は、単一の実行中のアプリケーションプログラムからメモリパーティションをマスキング又は隠すことに依存する。１つのマシーンの１つのＣＰＵが、異なるマシーン内に物理的に位置付けられたメモリロケーションにアクセス（ネットワークを介して）する必要がある場合には、性能が低下する。

スーパーコンピュータは、高速の計算速度を達成する点においては技術的に成功しているが、これらが本質的に複雑であることによって、製造だけでなく管理に対しても極めて高価なものである点で商業的には成功していない。特に、シングルシステムイメージの概念は、「製品」である（すなわち大量生産された）コンピュータ及びネットワークを越えて拡張することは決してできない。特に、シングルシステムイメージの概念は、超高速（及び従って極めて高価）ネットワークによって相互接続された超高速（及び同様に極めて高価）コンピュータ上でのみ実用的なアプリケーションが見られた。

複数のマシーンを使用することで増大されたコンピュータパワーの別の可能性は、図３に概略的に示されている分散コンピューティングの従来技術の概念から生じる。この公知の構成では、単一のアプリケーションプログラム（Ａｐ）は、その作成者（又はアプリケーションプログラムについてよく理解している別のプログラマー）によって種々の離散的タスクに区分され、例えば図３のケースｎが整数３である３つのマシーン上で実行できるようにする。ここでの目的は、マシーンＭ１．．．Ｍ３の各々がアプリケーション全体のうちで異なる１／３を実行することであり、更に、種々のマシーンに加えられる負荷をほぼ等しくすることである。マシーンは、通信リンク、インターネット、イントラネット、ローカルエリアネットワーク、及び同様のものなどの種々の形式で提供することができるネットワーク１４を介して通信する。通常、このようなネットワーク１４のオペレーションの速度は、個々のマシーンＭ１、Ｍ２、その他の各々におけるバス４のオペレーション速度よりもかなり遅い。

分散コンピューティングには幾つかの欠点がある。第１に、アプリケーションを分割するジョブは困難であり、これはマニュアルで行わなければならない。第２に、ネットワーク１４を介したデータ、部分的な結果、結果、及び同様のものの通信は、管理上のオーバーヘッドである。第３に、分割が必要であることにより、例えば３つに分割されたアプリケーションが４つのマシーン上ではうまく動作しないので、より多くのマシーンを用いることによって機能を高めることが極めて困難になる。第４に、マシーンの１つを無効にする必要がある場合、システム全体の性能がかなり低下する。

別の従来技術の構成は、図４に概略的に示された「クラスタ」を介したネットワークコンピューティングとして公知である。この方法では、アプリケーション全体がマシーンＭ１、Ｍ２．．．Ｍｎの各々にロードされる。各マシーンは、共通のデータベースと通信するが、他のマシーンとは直接通信しない。各マシーンは同じアプリケーションを実行するが、異なる「ジョブ」を実行しており、固有のメモリだけを使用する。これは、その各々が列車のチケットを一般の人に販売する幾つかの窓口に幾分類似している。この方法は機能を実行し、拡張可能であるが、大抵はネットワークを管理するのが難しいといった欠点がある。

本発明の目的は、上述の欠点の一部を克服又は少なくとも軽減するのに幾らかの助けとなる修正されたマシーンアーキテクチャを提供することである。

本発明の第１の態様によれば、単一のコンピュータでのみ動作するように各々記述されているが、通信ネットワークによって相互接続された複数のコンピュータ上で同時に実行する少なくとも１つのアプリケーションプログラムを有する多重コンピュータシステムであって、アプリケーションプログラムの異なる部分がコンピュータのうちの異なるコンピュータ上でほぼ同時に実行され、各コンピュータがアプリケーションプログラムの対応する部分によってのみアクセス可能な独立したローカルメモリを有し、同様の複数の実質的に同一のオブジェクトが対応するコンピュータに各々作成されることを特徴とする多重コンピュータシステムが開示される。

本発明の第２の態様によれば、通信リンクを介して相互接続され、各々が独立したローカルメモリを有し、少なくとも１つのアプリケーションプログラムの異なる部分をほぼ同時に動作し、単一のコンピュータでのみ動作するよう各々記述され、各ローカルメモリがアプリケーションプログラムの対応する部分によってだけアクセス可能である複数のコンピュータが開示される。

本発明の第３の態様によれば、単一のコンピュータでのみ動作するように各々記述された少なくとも１つのアプリケーションプログラムを同時に動作する方法であって、コンピュータが通信ネットワークによって相互接続されており、本方法が、（ｉ）コンピュータのうちの異なるコンピュータ上でアプリケーションプログラムの異なる部分を実行し、各部分に対して、対応するコンピュータにおいて同様の複数の実質的に同一のオブジェクトを各々作成し、該オブジェクトの各々に実質的に同一の名前を持たせる段階を含む方法が開示される。

本発明の第４の態様によれば、通信リンクを介して相互接続された複数のコンピュータの各々に単一のコンピュータでのみ動作するように記述されたアプリケーションプログラムをロードする方法であって、各コンピュータがアプリケーションプログラムの対応する部分によってのみアクセス可能な独立したローカルメモリを有し、アプリケーションプログラムの異なる部分が異なるコンピュータ上でほぼ同時に実行可能であり、本方法はロード前、ロード中、又はロード後で且つアプリケーションプログラムの関連部分の実行前にアプリケーションを修正する段階を含む方法が開示される。

本発明の第５の態様によれば、単一のコンピュータでのみ動作するよう各々記述された少なくとも１つのアプリケーションプログラムを通信リンクを介して全て相互接続された複数のコンピュータ上で同時に動作する方法であって、コンピュータの各々が少なくとも最小の事前設定されたローカルメモリ容量を有し、アプリケーションプログラムの異なる部分が、コンピュータの異なるコンピュータ上でほぼ同時に実行可能であると共に、各コンピュータのローカルメモリがアプリケーションプログラムの対応する部分によってのみアクセス可能であり、本方法が、（ｉ）実質的に同一の条件で各ローカルメモリを最初に提供する段階と、（ｉｉ）対応するローカルメモリから各アプリケーションプログラムにより生成された全てのメモリ読み取り及び書き込みを満たす段階と、（ｉｉｉ）複数のコンピュータの残り全てにローカルに行われる各コンピュータでの全メモリの書き込みを通信リンクを介して伝達する段階とを含み、これにより更新データ送信遅延の影響を受ける各コンピュータによって利用されるローカルメモリのコンテンツが、実質的に同一のままであることを特徴とする方法が開示される。

本発明の第６の態様によれば、単一のコンピュータでのみ動作するように各々記述されているが、通信リンクを介して相互接続された複数のコンピュータ上で同時に実行するようアプリケーションプログラムをコンパイル又は修正する方法であって、アプリケーションプログラムの異なる部分がコンピュータの異なるコンピュータ上でほぼ同時に実行され、コンピュータの各々がアプリケーションプログラムの対応する部分によってのみアクセス可能な独立したローカルメモリを有し、本方法が、（ｉ）コンピュータの１つを利用してメモリ記録を共有する命令を検出する段階と、（ｉｉ）このような共有メモリ記録全てをリストして、リストされた各メモリ記録に対して命名タグを付与する段階と、（ｉｉｉ）リストされたメモリ記録のいずれかに対する書き込み又は該リストされたメモリ記録のいずれかのコンテンツの操作を行う命令を検出する段階と、（ｉｖ）各検出された書き込み又は操作命令に従う更新プログラムルーチンを起動する段階と、を含み、更新プログラムルーチンが、再書き込み又は操作されたコンテンツ及び各再書き込み又は操作されたリストメモリ記録の命名タグをコンピュータのうちの残りに転送することを特徴とする方法が開示される。

本発明の第７の態様によれば、単一のコンピュータでのみ動作するように記述された単一のアプリケーションプログラムの個々のスレッドが、各々が対応するスレッドによってのみアクセス可能な独立したローカルメモリを有し且つ通信リンクを介して各々が相互接続された複数のコンピュータのうちの異なる対応するコンピュータ上で各々が同時に処理されるマルチスレッド処理コンピュータオペレーションにおいて、各スレッドを処理するコンピュータに物理的に関連付けられたローカルメモリのコンテンツ内の変更を通信リンクを介して他の各コンピュータのローカルメモリに伝達する段階を含む改良が開示される。

本発明の第８の態様によれば、上述の方法を実行することができるコンピュータプログラム製品が開示される。

本発明の実施形態を図面を参照しながら説明する。

本明細書は、説明された実施形態の種々の態様を実装する実際のプログラムフラグメントを提供する添付書Ａ及びＢを含む。

図５に関連して、本発明の好ましい実施形態によれば、単一のアプリケーションプログラム５０は、ネットワーク５３を介して通信する幾つかのマシーンＭ１、Ｍ２．．．Ｍｎ上で同時に動作することができる。以下に明らかになるように、マシーンＭ１、Ｍ２．．．Ｍｎの各々は、各マシーンＭ１、Ｍ２．．．Ｍｎ上で同じアプリケーションプログラム５０で動作し、従って、マシーンＭ１、Ｍ２．．．Ｍｎの全ては、同じアプリケーションコード及びデータ５０を有する。同様に、マシーンＭ１、Ｍ２．．．Ｍｎの各々は、各マシーンＭ１、Ｍ２．．．Ｍｎ上の同じ（又は実質的に同じ）モディファイアー(modifier,変更子)５１で動作し、従って、マシーンＭ１、Ｍ２．．．Ｍｎの全ては、５１／２で示されるマシーンＭ２のモディファイアーと同じ（又は実質的に同じ）モディファイアー５１を有する。更に、各マシーンＭ１、Ｍ２．．．Ｍｎ上でのアプリケーション５０のロード中、又は実行前に、各アプリケーション５０は、同じ規則（又は僅かな最適化変更が各モディファイアー５１／１．．．５１／ｎで許可されているので、実質的に同じ規則）に従って対応するモディファイアー５１で修正されている。

上述の構成の結果として、マシーンＭ１、Ｍ２．．．Ｍｎの各々が、例えば１０ＭＢの共有メモリ容量を有する場合には、各アプリケーション５０が利用可能な合計共有メモリは、予想されるように１０ｎＭＢではなくむしろ１０ＭＢだけである。しかしながら、これによって改良されたオペレーションがどのように生じるかは、以下で明らかになるであろう。当然、各マシーンＭ１、Ｍ２．．．Ｍｎは、非共有メモリ容量を有する。マシーンＭ１、Ｍ２．．．Ｍｎの非共有メモリ容量は、通常ほぼ等しいが、必須ではない。

図６に概略的に示されるように仮想マシーンを作成することによって、アプリケーションの特定の言語でマシーン（種々の製造業者の１つによって生産され、種々の異なる言語の１つで動作するオペレーティングシステムを有する）を動作させることは従来技術から公知である。図６の従来技術の構成は、Ｊａｖａ言語で記述されＪａｖａ仮想マシーン６１内で実行するアプリケーション５０の形式を取る。従って、アプリケーションの目的とする言語がＪＡＶＡ言語である場合、マシーン製造業者及びマシーンの内部の詳細に関わらず、ＪＡＶＡコードを操作できるＪＡＶＡ仮想マシーンが作成される。更なる詳細については、米国のＳｕｎＭｉｃｒｏｓｙｓｔｅｍｓＩｎｃ．のＴ．Ｌｉｎｄｈｏｌｍ及びＦ．Ｙｅｌｌｉｎによる「ＴｈｅＪＡＶＡＶｉｒｔｕａｌＭａｃｈｉｎｅＳｐｅｃｉｆｉｃａｔｉｏｎ」２ｎｄＥｄｉｔｉｏｎ（ＪＡＶＡ仮想マシーン仕様）」第２版を参照されたい。

図６のこの公知の従来技術の構成は、図７に見られるように「分散ランタイム」又はＤＲＴ７１と便宜上呼ばれる付加的な機能を提供することによって、本発明の好ましい実施形態に従って修正される。図７では、アプリケーション５０は、矢印７５によって示されるロード手順で分散ランタイムシステム７１を介してＪａｖａ仮想マシーン７２にロードされる。分散ランタイムシステムは、分散コンピューティング環境（ＤＣＥ）の名称でＯｐｅｎＳｏｆｔｗａｒｅＦｏｕｎｄａｔｉｏｎから利用可能である。特に、分散ランタイム７１は、最初にＪＡＶＡ仮想マシーン７２を作成するように、ＪＡＶＡアプリケーション５０の矢印７５によって示されるロード手順中に作動し始める。ロード中のオペレーションのシーケンスは、図９に関して以下に説明する。

図８は、各々が図７に示されるようにＪＡＶＡ仮想マシーンを用いる図５の構成の修正された形式を示す。同様に同じアプリケーション５０が各マシーンＭ１、Ｍ２．．．Ｍｎにロードされることは明らかであろう。しかしながら、矢印８３によって示されているがマシーンハードウェアからは物理的に経路指定されている各マシーンＭ１、Ｍ２．．．Ｍｎ間の通信は、各マシーン内の個々のＤＲＴ７１／１．．．７１／ｎによって制御される。従って、実際にはこれは、マシーンＭ１、Ｍ２．．．Ｍｎ自体ではなくネットワーク７３を介して互いに通信しているＤＲＴ７１／１．．．７１／ｎとして概念化することができる。

ここで図７及び９を参照すると、ローディング手順７５の間、各ＪＡＶＡ仮想マシーン７２を作成するためにロードされているプログラム５０が修正される。この修正は図９の９０で開始し、ロードされているアプリケーション５０において全メモリロケーション（ＪＡＶＡではフィールドと呼ばれるが、他の言語でも同等の用語が使用される）を検出する初期ステップ９１を包含する。このようなメモリロケーションは、ステップ９２及び９３での連続した処理において識別される必要がある。ローディング手順７５中のＤＲＴ７１は、メモリロケーション全てのリストを作成し、このようにしてオブジェクト及びクラスによってリストされるＪＡＶＡフィールドを識別する。揮発性フィールド及び同期フィールドの両方がリストされる。

修正手順の次のステップ（図９の９２で示される）は、全処理動作を特定するために実行可能なアプリケーションコードをサーチすることであり、該全処理動作では、ステップ９１で作成されたリストに対応するフィールド値を操作又は変更し、これによって対応するメモリロケーションでの値が変更されるようにフィールドに書き込む。フィールド値を変更するこのようなオペレーション（通常、ＪＡＶＡ言語におけるｐｕｔｓｔａｔｉｃ又はｐｕｔｆｉｅｌｄ）が検出された場合、フィールドの値が変わったことを全ての他のマシーンに確実に通知されるように、ステップ９３で「更新伝播ルーチン(updating propagating routine)」がプログラムのこの場所に挿入される。その後、ロード手順は、図９のステップ９４によって示される通常の方法で続行される。

ロード中の初期修正の他の形式が図１０に示されている。ここで開始及びリスティングステップ９０及び９１並びにサーチステップ９２は、図９と同じである。しかしながら、処理スレッドが更新を実行するステップ９３で「更新伝播ルーチン」を挿入するのではなく、「警報ルーチン(alert routine)」がステップ１０３で挿入される。「警報ルーチン」は、処理に使用されずＤＲＴに割り当てられる１つ又は複数のスレッドに対し必要な伝播を実行するよう指示を与える。このステップ１０３は、より低いオーバーヘッドを生じる簡単な代替手段である。

ロード手順中にこの初期修正が行われると、次いで、図１１及び１２に示されるマルチスレッド処理オペレーションのいずれか１つが行われる。図１１で分かるように、スレッド１１１／１．．．１１１／４からなるマシーン上のマルチスレッド処理１１０が行われ、第２スレッド１１１／２の処理（この実施例での）では、スレッド１１１／２がフィールド値の変更をステップ１１３で認識することになる。このステップで、スレッド１１１／２の通常の処理はステップ１１４で停止し、同じスレッド１１１／２は、ステップ１１３で行われた変更フィールドのアイデンティティ及び変更値をネットワーク５３を介して全ての他のマシーンＭ２．．．Ｍｎに通知する。次いでステップ１１５で、当該通信手順の最後において、スレッド１１１／２は、フィールド値の変更がある次のインスタンスまで処理を再開する。

図１２に示された他の構成では、ステップ１１３でスレッド１２１／２がフィールド値の変更を認識すると、スレッド１２１／２は、ＤＲＴ処理１２０に割り当てられた別のスレッド１２１／１がステップ１２８によりネットワーク５３を介しステップ１１３で検出された変更フィールドのアイデンティティ及び変更値を全ての他のマシーンＭ２．．．Ｍｎに伝播するようにＤＲＴ処理１２０（ステップ１２５及び矢印１２７によって示されるように）に指示する。これは、迅速に実行できるオペレーションであり、すなわち、スレッド１１１／２がステップ１１５で処理を再開する前に、該初期スレッド１１１／２の処理は、ステップ１２５で示されるように瞬間的に中断される。次いで、変更（矢印１２７によって示されるような）を通知された他のスレッド１２１／１は、その変更をステップ１２８で示されるようにネットワーク５３を介して他のマシーンＭ２．．．Ｍｎの各々に伝達する。

図１２のこの第２の構成は、種々のスレッド１１１／１．．．１１１／３及び１２１／１（これらは一般に均等要求の影響を受けない）の処理能力をうまく利用し、増大する「ｎ」のサイズと共に良好な拡張を与える（ｎは２以上の整数であって、ネットワーク５３に接続されアプリケーションプログラム５０を同時に実行するマシーンの総数を表す）。どの構成が使用されるかに関わらず、ステップ１１３で検出された変更フィールド及びアイデンティティ及び値は、ネットワーク上の他のマシーンＭ２．．．Ｍｎ全てに伝播される。

これは図１３に示され、ＤＲＴ７１／１及び図１２のスレッド１２１／１（図１３のステップ１２８によって表わされる）は、マシーンＭ１での処理によってネットワーク５３を介して図１２のステップ１１３で作成されたリストされたメモリロケーションのアイデンティティ及び変更値を他のマシーンＭ２．．．Ｍｎの各々に送信する。

他のマシーンＭ２．．．Ｍｎの各々は、ネットワーク５３からアイデンティティと値のペアを受信し且つ新しい値をローカルの対応するメモリロケーションに書き込むことにより、マシーンＭｎのための図１３のステップ１３５及び１３６によって示された動作を実行する。

分散型ソフトウェアを利用する図３の従来技術の構成では、１つのマシーンのソフトウェアから別のマシーンに物理的に位置付けられたメモリへのメモリアクセスは、マシーンを相互接続するネットワークによって許可される。しかしながら、このようなメモリアクセスは、マシーンの中央処理ユニットの１０⁶−１０⁷サイクルのオーダーの処理に遅延を生じる可能性がある。これは大部分が、複数の相互接続されたマシーンの性能の低下に起因する。

しかしながら、図８に関して上述された本構成では、全フィールドの現在の値は、メモリの読み取り要求を生成する処理を実行しているマシーン上に記憶されるので、データの全読み取りがローカルで達成されることを理解されたい。このようなローカル処理は、中央処理ユニットの１０²−１０³サイクル内で達成することができる。従って、実際には読み取りを伴うメモリアクセスを実質的には待機することはない。

しかしながら、ほとんどのアプリケーションソフトウェアは、メモリを頻繁に読み取るが、書き込みは比較的まれにしか行わない。この結果、メモリの書き込み又は再書き込みの速度は、メモリの読み取り速度に比べて比較的遅い。メモリの書き込み又は再書き込みに対するこの低速の要求に起因して、フィールドは、低価格製品ネットワーク５３を介した比較的低速で頻繁に更新することができ、更にこの低速では、メモリへ書き込むためのアプリケーションプログラムの要求を満たすのに十分である。この結果、図８の構成の性能は、図３の構成よりも極めて優れていることになる。

上記に関連した別の修正形態において、変更フィールドのアイデンティティ及び値をバッチにグループ分けし、種々のマシーンを相互接続するネットワーク５３の通信速度に対する要求を更に低減することができる。

フィールドを最初に記録する際に各ＤＲＴ７１によって作成されたテーブルでは、各フィールドに対してネットワーク全体で共通であり且つネットワークが認識する名前又はアイデンティティが存在することは当業者には明らかであろう。しかしながら、個々のマシーンでは、各マシーンが固有の内部プロセスに従って異なるロケーションで変更フィールド値を漸次記憶するので、所与の名前付きフィールドに対応するメモリロケーションは時間と共に変わることになる。従って、ＤＲＴの各々におけるテーブルは、一般には異なるメモリロケーションを有するが、各グローバル「フィールド名」は、異なるメモリロケーション内に記憶された同じ「フィールド値」を有することになる。

ロード中のアプリケーションプログラムの上述の修正は、以下の最大５つの方法で達成可能であることが当業者には明らかであろう。
（ｉ）ロード時の再コンパイル
（ｉｉ）プリコンパイルによるロード前の処理
（ｉｉｉ）ロード前のコンパイル
（ｉｖ）「実行時」（ＪＩＴ）コンパイル、
（ｖ）ロード後の再コンパイル（しかしながら、又は例えば、分散環境での関連した又は対応するアプリケーションコードを実行する前）

従来、用語「コンパイル」とは、例えばソースからオブジェクトコード、又は１つの言語から別の言語へのコード又は言語における変更を意味する。明確には、本明細書において用語「コンパイル」（及びその文法的に等価なもの）の使用は同じコード又は言語内に限定されず、修正形態を含む又は包含することができる。

第１の実施形態において、特定のマシーン、例えばマシーンＭ２は、それ自体にアプリケーションコードをロードし、これを修正し、次いで他のマシーンＭ１、Ｍ３．．．Ｍｎの各々に（順次又は同時に）修正コードをロードする。「マスタ／スレーブ」と呼ぶ場合があるこの構成では、マシーンＭ１、Ｍ３、．．．Ｍｎの各々が、マシーンＭ２によって与えられるものをロードする。

更に別の実施形態において、各マシーンはアプリケーションコードを受け取るが、これを修正し、修正コードをそのマシーンにロードする。これによって、各マシーンが行う修正をそのアーキテクチャ及びオペレーティングシステムに基づき僅かに異なるように最適化することができ、更に全ての他の類似の修正と整合を取ることができる。

別の構成では、特定のマシーン、例えばＭ１は修正されていないコードをロードし、全ての他のマシーンＭ２、Ｍ３．．．Ｍｎは、オリジナルのアプリケーションコードを削除し修正されたバージョンをロードするよう修正を行う。

全ての事例において、供給は、ブランチ（すなわち、Ｍ２がＭ１、Ｍ３、Ｍ４などの各々に直接提供する）又はカスケード或いはシーケンシャル（すなわち、Ｍ２はＭ１に供給し、次にＭ１がＭ３に供給し、次いで、Ｍ３がＭ４に供給する、以下同じ）とすることができる。

更に別の構成では、Ｍ１からＭｎまでのマシーンは追加のマシーン（図示せず）に全てのロード要求を送ることができ、該追加マシーンは、アプリケーションプログラムを実行しておらず、前述の方法のいずれかを介して修正を行い、修正ルーチンをマシーンＭ１からＭｎまでの各々に返し、次いで、マシーンＭ１からＭｎがこの修正ルーチンをローカルにロードする。この構成では、マシーンＭ１からＭｎは、修正ルーチンを各マシーンに返すこの追加のマシーンに全ロード要求を転送する。この追加のマシーンによって行われる修正は、本発明の範囲内で保護される修正形態の全てを含むことができる。

コンピュータ関連技術に熟練した人であれば、コンピュータコードで修正を作製する際に使用される少なくとも４つの技術を認識することになる。第１は、オリジナル（ソース）言語で修正を行うことである。第２は、オリジナルコード（例えばＪＡＶＡでの）を中間表現（又は中間言語）に変換することである。この変換を行うと、修正がなされ、次いで逆変換される。これは、修正されたＪＡＶＡコードの要求結果をもたらす。

第３の可能性は、マシーンコードに（直接又は前述の中間言語を介して）変換することである。次にマシーンコードは修正された後、ロードされ実行される。第４の可能性は、オリジナルコードを中間表現に変換することであり、この中間表現は次に修正され、その後マシーンコードに変換される。

本発明は、全ての４つの修正ルートと、更にこのようなルートの２つ、３つ、又は４つ全部の組み合わせを包含する。

ここで図１４−１６を参照すると、２つのラップトップコンピュータ１０１及び１０２が示されている。コンピュータ１０１及び１０２は、必ずしも同一でなくともよく、実際には、１つはＩＢＭ又はＩＢＭクローンで、他方がＡＰＰＬＥコンピュータとすることができる。コンピュータ１０１及び１０２は、２つのモニタ１０５、１１５及び２つのキーボード１０６、１１６と、単一のマウス１０７とを有する。２つのマシーン１０１、１０２は、単一の同軸ケーブル又はツイストペアケーブル３１４手段によって相互接続されている。

２つのシンプルアプリケーションプログラムは、マシーン１０１、１０２の各々にダウンロードされ、このプログラムは上述のようにロードされるときに修正される。この実施形態において、第１アプリケーションは、シンプル計算器プログラムであり、モニタ１０５上に表示される計算器１０８のイメージをもたらす。第２プログラムは、異なる色であり且つ矩形ボックス３１０内をランダムに動き回る４つのカラーブロック１０９を表示するグラフィックプログラムである。同様にロード後に、ボックス３１０はモニタ１０５上に表示される。各アプリケーションはブロック１０９がモニタ１０５上でランダムに移動しているように独立して動作すると同時に、計算器１０８内の数字は数学的演算子（加算又は乗算など）と共に（マウス１０７を用いて）選択され、計算器１０８が結果を表示することができるようになる。

マウス１０７を用いて、ボックス３１０を「把持」し、これを右方向にモニタ１０５を越えてモニタ１１５上に移動させ、図１５に示された状況に到るようにすることができる。この構成では、計算器アプリケーションがマシーン１０１上で処理されている間、ボックス３１０の表示をもたらすグラフィックアプリケーションはマシーン１０２上で処理されている。

しかしながら、図１６に示されるようにマウス１０７を用いることで、図１３に示されるように計算器１０８を右側にドラッグし、計算器１０８の一部をモニタ１０５、１１５の各々で表示させることができる。同様に、図１５に示されるボックス３１０は、マウス１０７を用いて左側にドラッグすることができ、その結果、ボックス３１０は図１６に示されるようにモニタ１０５、１１５の各々で部分的に表示されるようになる。この構成では、計算器オペレーションの部分は、マシーン１０１とマシーン１０２の一部上で実行されていると同時に、グラフィックアプリケーションの部分はマシーン１０１で実行されており、残りはマシーン１０２で実行されている。

上記は、本発明の幾つかの実施形態だけを説明しており、当業者であれば本発明の範囲から逸脱することなく本発明に対し修正を行うことができる点は明らかであろう。例えば、ＪＡＶＡへの言及は、ＪＡＶＡ言語と更にＪＡＶＡプラットフォーム及びアーキテクチャの両方を含む。

プログラミング技術に熟練した者であれば、付加的なコード又は命令が既存のコード又は命令セットに挿入されてこれを修正する場合、既存のコード又は命令セットは、オフセット、分岐、属性、マークアップ、及び同様のものが作成されるような追加の修正（例えば、シーケンシャル命令の再ナンバリングによって）を必要とする場合があることを認識するであろう。

同様に、ＪＡＶＡ言語でのメモリロケーションは、例えばフィールド及びアレイタイプの両方を含む。上記の説明は、フィールドを扱っており、アレイタイプに必要な変更は、本質的に同じ準用である。また本発明は、Ｍｉｃｒｏｓｏｆｔ．ＮＥＴプラットフォーム及びアーキテクチャ（ＶｉｓｕａｌＢａｓｉｃ、ＶｉｓｕａｌＣ／Ｃ⁺⁺、及びＣ＃）のＦＯＲＴＲＡＮ、Ｃ／Ｃ⁺⁺、ＣＯＢＯＬ、ＢＡＳＩＣなどを含むＪＡＶＡに類似したプログラミング言語（手続き、宣言、及びオブジェクト指向を含む）に対して等しく適用可能である。

フィールド値を更新するＪＡＶＡコードが修正された上述の構成は、各マシーンＭ１．．．Ｍｎのランタイムシステム（例えば、Ｃ及びＪＡＶＡで作成されたＪＡＶＡＨＯＴＳＰＯＴＶＩＲＴＵＡＬＭＡＣＨＩＮＥ）又はオペレーティングシステム（例えば、Ｃ及びアセンブラで記述されたＬＩＮＵＸ）のいずれかがローカルマシーン上で通常は更新され、他のどのような対応するマシーン上では更新しないといった仮定に基づく。フィールド値を更新するＪＡＶＡコードを未修正のままにし、その代わりにメモリをローカルに更新するＬＩＮＵＸ又はＨＯＴＳＰＯＴルーチンを修正することが可能であり、その結果他の全てのマシーン上のメモリも同様にこれに伴って更新するようになる。このような構成を包含するために、マシーンＭ１．．．Ｍｎ全てのメモリを基本的に同じものとして維持することと共に本明細書で使用される用語「更新伝播ルーチン」は、ＪＡＶＡ初期化ルーチンとメモリ更新を実施するＬＩＮＵＸ又はＨＯＴＳＰＯＴコードフラグメントの「組み合わせ」の両方をその範囲に含むことになると理解すべきである。

本明細書で使用される用語オブジェクト及びクラスは、ＪＡＶＡ環境から生じたものであり、ダイナミックリンクライブラリ（ＤＬＬ）、或いはオブジェクトコードパッケージ、或いは関数ユニット又はメモリロケーションのような異なる環境から派生した類似語を包含するものとする。

本明細書で使用される用語「備える」（及びその文法的変形形態）は、「有する」又は「含む」といった包括的な意味で使用され、「だけからなる」という排他的意味では使用されない。

添付書Ａ
以下は、ＪＡＶＡ言語でのプログラムリストである。
Ａ１．この第１の抜粋は、修正コードの一部である。これは、コードアレイをサーチし、ｐｕｔｓｔａｔｉｃ命令（ｏｐｃｏｄｅ１７８）を見つけると、修正を実行する。
// START
byte[] code = Code_attribute．code; //Bytecode of a given method in a
// given classfile．
int code_length = Code_attribute．code_length;
int DRT = 99; // Location of the CONSTANT_Methodref_info for the
// DRT．alert() method．
for (int i=0; i<code_length; i++){
if ((code[i] & 0xff) == 179){ // Putstatic instruction．
System．arraycopy(code, i+3, code, i+6, code_length-(i+3));
code[i+3] = (byte) 184; // Invokestatic instruction for the
// DRT．alert() method．
code[i+4] = (byte) ((DRT >>> 8) & 0xff);
code[i+5] = (byte) (DRT & 0xff);
}
}
// END

Ａ２．この第２の抜粋は、ＤＲＴ．ａｌｅｒｔ（）法の一部である。これは、呼び出されたときのＤＲＴ．ａｌｅｒｔ（）法の本体である。
// START
public static void alert(){
synchronized (ALERT_LOCK){
ALERT_LOCK．notify(); // Alerts a waiting DRT thread in the background．
}
}
// END

Ａ３．この第３の抜粋は、ＤＲＴ送信の一部である。このコードフラグメントは、別々のスレッドのＤＲＴを示しており、通知された後にネットワーク全体に値を送信する。
// START
MulticastSocket ms = DRT．getMulticastSocket(); // The multicast socket
// used by the DRT for
// communication．
byte nameTag = 33; // This is the “name tag” on the network for this
// field．
Field field = modifiedClass．getDeclaredField(“myField1”); // Stores
// the field
// from the
// modified
// class．
// In this example, the field is a byte field．
while (DRT．isRunning()){
synchronized (ALERT_LOCK){
ALERT_LOCK．wait(); // The DRT thread is waiting for the alert
// method to be called．
byte[] b = new byte[]{nameTag, field．getByte(null)}; // Stores
// the
// nameTag
// and the
// value
// of the
// field from
// the modified
// class in a
// buffer．
DatagramPacket dp = new DatagramPacket(b, 0, b．length);
ms．send(dp); // Send the buffer out across the network．
}
}
// END

Ａ４．第４の抜粋は、ＤＲＴ受信の一部である。これは、ネットワークを通じてＤＲＴ送信警報を受信するためのコードのフラグメントである。
// START
MulticastSocket ms = DRT．getMulticastSocket(); // The multicast socket
// used by the DRT for
// communication．
DatagramPacket dp = new DatagramPacket(new byte[2], 0, 2);
byte nameTag = 33; // This is the “name tag” on the network for this
// field．
Field field = modifiedClass．getDeclaredField(“myField1”); // Stores the
// field from
// the modified
// class．
// In this example, the field is a byte field．
while (DRT．isRunning){
ms．receive(dp); // Receive the previously sent buffer from the network．
byte[] b = dp．getData();
if (b[0] == nameTag){ // Check the nametags match．
field．setByte(null, b[1]); // Write the value from the network packet
// into the field location in memory．
}
}
// END

Ａ５．第５の抜粋は、修正が行われる前の例示的なアプリケーションである。
Method void setValues(int, int)
0 iload_1
1 putstatic #3 <Field int staticValue>
4 aload_0
5 iload_2
6 putfield #2 <Field int instanceValue>
9 return

Ａ６．第６の抜粋は、修正が実行された後の５と同様の例示的なアプリケーションである。修正は下線で強調されている。
Method void setValues(int, int)
0 iload_1
1 putstatic #3 <Field int staticValue>
4 ldc #4 <String “example”>
6 iconst_0
7 invokestatic #5 <Method void alert(java．lang．Object, int)>
10 aload_0
11 iload_2
12 putfield #2 <Field int instanceValue>
15 aload_0
16 iconst_1
17 invokestatic #5 <Method void alert(java．lang．Object, int)>
20 return

Ａ７．第７の抜粋は、抜粋５及び６で使用された例示的なアプリケーションのソースコードである。
import java．lang．*;
public class example{
/** Shared static field． */
public static int staticValue = 0;

/** Shared instance field． */
public int instanceValue = 0;

/** Example method that writes to memory (instance field)． */
public void setValues(int a, int b){
staticValue = a;
instanceValue = b;
}
}

Ａ８．第８の抜粋は、「分散ランタイム」をアラートし変更された値を伝播するＦｉｅｌｄＡｌｅｒｔのソースコードである。
import java．lang．*;
import java．util．*;
import java．net．*;
import java．io．*;
public class FieldAlert{
/** Table of alerts． */
public final static Hashtable alerts = new Hashtable();
/** Object handle． */
public Object reference = null;

/** Table of field alerts for this object． */
public boolean[] fieldAlerts = null;

/** Constructor． */
public FieldAlert(Object o, int initialFieldCount){
reference = o;
fieldAlerts = new boolean[initialFieldCount];
}

/** Called when an application modifies a value． (Both objects and
classes) */
public static void alert(Object o, int fieldID){
// Lock the alerts table．
synchronized (alerts){
FieldAlert alert = (FieldAlert) alerts．get(o);
if (alert == null){ // This object hasn't been alerted already,
// so add to alerts table．
alert = new FieldAlert(o, fieldID + 1);
alerts．put(o, alert);
}

if (fieldID >= alert．fieldAlerts．length){
// Ok, enlarge fieldAlerts array．
boolean[] b = new boolean[fieldID+1];
System．arraycopy(alert．fieldAlerts, 0, b, 0,
alert．fieldAlerts．length);
alert．fieldAlerts = b;
}

// Record the alert．
alert．fieldAlerts[fieldID] = true;

// Mark as pending．
FieldSend．pending = true; // Signal that there is one or more
// propagations waiting．

// Finally, notify the waiting FieldSend thread(s)
if (FieldSend．waiting){
FieldSend．waiting = false;
alerts．notify();
}
}
}
}

Ａ９．第９の抜粋は、ＦｉｅｌｄＡｌｅｒｔを介してアラートされた変更値を伝播するＦｉｅｌｄＳｅｎｄのソースコードである。
import java．lang．*;
import java．lang．reflect．*;
import java．util．*;
import java．net．*;
import java．io．*;

public class FieldSend implements Runnable{

/** Protocol specific values． */
public final static int CLOSE = -1;
public final static int NACK = 0;
public final static int ACK = 1;
public final static int PROPAGATE_OBJECT = 10;
public final static int PROPAGATE_CLASS = 20;

/** FieldAlert network values． */
public final static String group =
System．getProperty(“FieldAlert_network_group”);
public final static int port =
Integer．parseInt(System．getProperty(“FieldAlert_network_port”));

/** Table of global ID's for local objects． (hashcode-to-globalID
mappings) */
public final static Hashtable objectToGlobalID = new Hashtable();

/** Table of global ID's for local classnames． (classname-to-globalID
mappings) */
public final static Hashtable classNameToGlobalID = new Hashtable();

/** Pending． True if a propagation is pending． */
public static boolean pending = false;

/** Waiting． True if the FieldSend thread(s) are waiting． */
public static boolean waiting = false;

/** Background send thread． Propagates values as this thread is alerted
to their alteration． */
public void run(){

System．out．println(“FieldAlert_network_group=” + group);
System．out．println(“FieldAlert_network_port=” + port);

try{
// Create a DatagramSocket to send propagated field values．
DatagramSocket datagramSocket =
new DatagramSocket(port, InetAddress．getByName(group));

// Next, create the buffer and packet for all transmissions．
byte[] buffer = new byte[512]; // Working limit of 512 bytes
// per packet．
DatagramPacket datagramPacket =
new DatagramPacket(buffer, 0, buffer．length);

while (!Thread．interrupted()){
Object[] entries = null;

// Lock the alerts table．
synchronized (FieldAlert．alerts){
// Await for an alert to propagate something．
while (!pending){
waiting = true;
FieldAlert．alerts．wait();
waiting = false;
}
pending = false;
entries = FieldAlert．alerts．entrySet()．toArray();

// Clear alerts once we have copied them．
FieldAlert．alerts．clear();
}

// Process each object alert in turn．
for (int i=0; i<entries．length; i++){
FieldAlert alert = (FieldAlert) entries[i];
int index = 0;
datagramPacket．setLength(buffer．length);
Object reference = null;
if (alert．reference instanceof String){
// PROPAGATE_CLASS field operation．
buffer[index++] = (byte) ((PROPAGATE_CLASS >> 24) & 0xff);
buffer[index++] = (byte) ((PROPAGATE_CLASS >> 16) & 0xff);
buffer[index++] = (byte) ((PROPAGATE_CLASS >> 8) & 0xff);
buffer[index++] = (byte) ((PROPAGATE_CLASS >> 0) & 0xff);

String name = (String) alert．reference;
int length = name．length();
buffer[index++] = (byte) ((length >> 24) & 0xff);
buffer[index++] = (byte) ((length >> 16) & 0xff);
buffer[index++] = (byte) ((length >> 8) & 0xff);
buffer[index++] = (byte) ((length >> 0) & 0xff);
byte[] bytes = name．getBytes();
System．arraycopy(bytes, 0, buffer, index, length);
index += length;
}else{ // PROPAGATE_OBJECT field operation．
buffer[index++] =
(byte) ((PROPAGATE_OBJECT >> 24) & 0xff);
buffer[index++] =
(byte) ((PROPAGATE_OBJECT >> 16) & 0xff);
buffer[index++] = (byte) ((PROPAGATE_OBJECT >> 8) & 0xff);
buffer[index++] = (byte) ((PROPAGATE_OBJECT >> 0) & 0xff);

int globalID = ((Integer)
objectToGlobalID．get(alert．reference))．intValue();

buffer[index++] = (byte) ((globalID >> 24) & 0xff);
buffer[index++] = (byte) ((globalID >> 16) & 0xff);
buffer[index++] = (byte) ((globalID >> 8) & 0xff);
buffer[index++] = (byte) ((globalID >> 0) & 0xff);
reference = alert．reference;
}
// Use reflection to get a table of fields that correspond to
// the field indexes used internally．
Field[] fields = null;
if (reference == null){
fields = FieldLoader．loadClass((String)
alert．reference)．getDeclaredFields();
}else{
fields = alert．reference．getClass()．getDeclaredFields();
}
// Now encode in batch mode the fieldID/value pairs．
for (int j=0; j<alert．fieldAlerts．length; j++){
if (alert．fieldAlerts[j] == false)
continue;
buffer[index++] = (byte) ((j >> 24) & 0xff);
buffer[index++] = (byte) ((j >> 16) & 0xff);
buffer[index++] = (byte) ((j >> 8) & 0xff);
buffer[index++] = (byte) ((j >> 0) & 0xff);

// Encode value．
Class type = fields[j]．getType();
if (type == Boolean．TYPE){
buffer[index++] =(byte)
(fields[j]．getBoolean(reference)? 1 : 0);
}else if (type == Byte．TYPE){
buffer[index++] = fields[j]．getByte(reference);
}else if (type == Short．TYPE){
short v = fields[j]．getShort(reference);
buffer[index++] = (byte) ((v >> 8) & 0xff);
buffer[index++] = (byte) ((v >> 0) & 0xff);
}else if (type == Character．TYPE){
char v = fields[j]．getChar(reference);
buffer[index++] = (byte) ((v >> 8) & 0xff);
buffer[index++] = (byte) ((v >> 0) & 0xff);
}else if (type == Integer．TYPE){
int v = fields[j]．getInt(reference);
buffer[index++] = (byte) ((v >> 24) & 0xff);
buffer[index++] = (byte) ((v >> 16) & 0xff);
buffer[index++] = (byte) ((v >> 8) & 0xff);
buffer[index++] = (byte) ((v >> 0) & 0xff);
}else if (type == Float．TYPE){
int v = Float．floatToIntBits(
fields[j]．getFloat(reference));
buffer[index++] = (byte) ((v >> 24) & 0xff);
buffer[index++] = (byte) ((v >> 16) & 0xff);
buffer[index++] = (byte) ((v >> 8) & 0xff);
buffer[index++] = (byte) ((v >> 0) & 0xff);
}else if (type == Long．TYPE){
long v = fields[j]．getLong(reference);
buffer[index++] = (byte) ((v >> 56) & 0xff);
buffer[index++] = (byte) ((v >> 48) & 0xff);
buffer[index++] = (byte) ((v >> 40) & 0xff);
buffer[index++] = (byte) ((v >> 32) & 0xff);
buffer[index++] = (byte) ((v >> 24) & 0xff);
buffer[index++] = (byte) ((v >> 16) & 0xff);
buffer[index++] = (byte) ((v >> 8) & 0xff);
buffer[index++] = (byte) ((v >> 0) & 0xff);
}else if (type == Double．TYPE){
long v = Double．doubleToLongBits(
fields[j]．getDouble(reference));
buffer[index++] = (byte) ((v >> 56) & 0xff);
buffer[index++] = (byte) ((v >> 48) & 0xff);
buffer[index++] = (byte) ((v >> 40) & 0xff);
buffer[index++] = (byte) ((v >> 32) & 0xff);
buffer[index++] = (byte) ((v >> 24) & 0xff);
buffer[index++] = (byte) ((v >> 16) & 0xff);
buffer[index++] = (byte) ((v >> 8) & 0xff);
buffer[index++] = (byte) ((v >> 0) & 0xff);
}else{
throw new AssertionError(“Unsupported type．”);
}
}

// Now set the length of the datagrampacket．
datagramPacket．setLength(index);

// Now send the packet．
datagramSocket．send(datagramPacket);
}
}
}catch (Exception e){
throw new AssertionError(“Exception: ” + e．toString());
}
}
}

Ａ１０．第１０の抜粋は、ＦｉｅｌｄＳｅｎｄを介して送信される伝播された変更値を受信するＦｉｅｌｄＲｅｃｅｉｖｅのソースコードである。
import java．lang．*;
import java．lang．reflect．*;
import java．util．*;
import java．net．*;
import java．io．*;

public class FieldReceive implements Runnable{
/** Protocol specific values． */
public final static int CLOSE = -1;
public final static int NACK = 0;
public final static int ACK = 1;
public final static int PROPAGATE_OBJECT = 10;
public final static int PROPAGATE_CLASS = 20;

/** FieldAlert network values． */
public final static String group =
System．getProperty(“FieldAlert_network_group”);
public final static int port =
Integer．parseInt(System．getProperty(“FieldAlert_network_port”));

/** Table of global ID's for local objects． (globalID-to-hashcode
mappings) */
public final static Hashtable globalIDToObject = new Hashtable();

/** Table of global ID's for local classnames． (globalID-to-classname
mappings) */
public final static Hashtable globalIDToClassName = new Hashtable();

/** Called when an application is to acquire a lock． */
public void run(){
System．out．println(“FieldAlert_network_group=” + group);
System．out．println(“FieldAlert_network_port=” + port);
try{
// Create a DatagramSocket to send propagated field values from
MulticastSocket multicastSocket = new MulticastSocket(port);
multicastSocket．joinGroup(InetAddress．getByName(group));

// Next, create the buffer and packet for all transmissions．
byte[] buffer = new byte[512]; // Working limit of 512 bytes
// per packet．
DatagramPacket datagramPacket =
new DatagramPacket(buffer, 0, buffer．length);

while (!Thread．interrupted()){

// Make sure to reset length．
datagramPacket．setLength(buffer．length);

// Receive the next available packet．
multicastSocket．receive(datagramPacket);

int index = 0, length = datagramPacket．getLength();

// Decode the command．
int command = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));

if (command == PROPAGATE_OBJECT){ // Propagate operation for
// object fields．

// Decode global id．
int globalID = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));

// Now, need to resolve the object in question．
Object reference = globalIDToObject．get(
new Integer(globalID));

// Next, get the array of fields for this object．
Field[] fields = reference．getClass()．getDeclaredFields();

while (index < length){

// Decode the field id．
int fieldID = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));

// Determine value length based on corresponding field
// type．
Field field = fields[fieldID];
Class type = field．getType();
if (type == Boolean．TYPE){
boolean v = (buffer[index++] == 1 ? true : false);
field．setBoolean(reference, v);
}else if (type == Byte．TYPE){
byte v = buffer[index++];
field．setByte(reference, v);
}else if (type == Short．TYPE){
short v = (short) (((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setShort(reference, v);
}else if (type == Character．TYPE){
char v = (char) (((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setChar(reference, v);
}else if (type == Integer．TYPE){
int v = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setInt(reference, v);
}else if (type == Float．TYPE){
int v = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setFloat(reference, Float．intBitsToFloat(v));
}else if (type == Long．TYPE){
long v = (long) (((buffer[index++] & 0xff) << 56)
| ((buffer[index++] & 0xff) << 48)
| ((buffer[index++] & 0xff) << 40)
| ((buffer[index++] & 0xff) << 32)
| ((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setLong(reference, v);
}else if (type == Double．TYPE){
long v = (long) (((buffer[index++] & 0xff) << 56)
| ((buffer[index++] & 0xff) << 48)
| ((buffer[index++] & 0xff) << 40)
| ((buffer[index++] & 0xff) << 32)
| ((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setDouble(reference, Double．longBitsToDouble(v));
}else{
throw new AssertionError(“Unsupported type．”);
}
}

}else if (command == PROPAGATE_CLASS){ // Propagate an update
// to class fields．

// Decode the classname．
int nameLength = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
String name = new String(buffer, index, nameLength);
index += nameLength;

// Next, get the array of fields for this class．
Field[] fields =
FieldLoader．loadClass(name)．getDeclaredFields();

// Decode all batched fields included in this propagation
// packet．
while (index < length){

// Decode the field id．
int fieldID = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));

// Determine field type to determine value length．
Field field = fields[fieldID];
Class type = field．getType();
if (type == Boolean．TYPE){
boolean v = (buffer[index++] == 1 ? true : false);
field．setBoolean(null, v);
}else if (type == Byte．TYPE){
byte v = buffer[index++];
field．setByte(null, v);
}else if (type == Short．TYPE){
short v = (short) (((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setShort(null, v);
}else if (type == Character．TYPE){
char v = (char) (((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setChar(null, v);
}else if (type == Integer．TYPE){
int v = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setInt(null, v);
}else if (type == Float．TYPE){
int v = (int) (((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setFloat(null, Float．intBitsToFloat(v));
}else if (type == Long．TYPE){
long v = (long) (((buffer[index++] & 0xff) << 56)
| ((buffer[index++] & 0xff) << 48)
| ((buffer[index++] & 0xff) << 40)
| ((buffer[index++] & 0xff) << 32)
| ((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setLong(null, v);
}else if (type == Double．TYPE){
long v = (long) (((buffer[index++] & 0xff) << 56)
| ((buffer[index++] & 0xff) << 48)
| ((buffer[index++] & 0xff) << 40)
| ((buffer[index++] & 0xff) << 32)
| ((buffer[index++] & 0xff) << 24)
| ((buffer[index++] & 0xff) << 16)
| ((buffer[index++] & 0xff) << 8)
| (buffer[index++] & 0xff));
field．setDouble(null, Double．longBitsToDouble(v));
}else{ // Unsupported field type．
throw new AssertionError(“Unsupported type．”);
}
}
}
}
}catch (Exception e){
throw new AssertionError(“Exception: ” + e．toString());
}
}
}

Ａ１１．ＦｉｅｌｄＬｏａｄｅｒ．ｊａｖａ
この抜粋は、ロードされているときにアプリケーションを修正するＦｉｅｌｄＬｏａｄｅｒのソースコードである。
import java．lang．*;
import java．io．*;
import java．net．*;

public class FieldLoader extends URLClassLoader{
public FieldLoader(URL[] urls){
super(urls);
}

protected Class findClass(String name)
throws ClassNotFoundException{
ClassFile cf = null;
try{
BufferedInputStream in =
new BufferedInputStream(findResource(
name．replace('．', '/')．concat(“．class”))．openStream());

cf = new ClassFile(in);

}catch (Exception e){throw new ClassNotFoundException(e．toString());}

// Class-wide pointers to the ldc and alert index．
int ldcindex = -1;
int alertindex = -1;

for (int i=0; i<cf．methods_count; i++){
for (int j=0; j<cf．methods[i]．attributes_count; j++){
if (!(cf．methods[i]．attributes[j] instanceof Code_attribute))
continue;
Code_attribute ca = (Code_attribute) cf．methods[i]．attributes[j];
boolean changed = false;
for (int z=0; z<ca．code．length; z++){
if ((ca．code[z][0] & 0xff) == 179){ // Opcode for a PUTSTATIC
// instruction．
changed = true;

// The code below only supports fields in this class．
// Thus, first off, check that this field is local to this
// class．
CONSTANT_Fieldref_info fi = (CONSTANT_Fieldref_info)
cf．constant_pool[(int) (((ca．code[z][1] & 0xff) << 8) |
(ca．code[z][2] & 0xff))];
CONSTANT_Class_info ci = (CONSTANT_Class_info)
cf．constant_pool[fi．class_index];
String className =
cf．constant_pool[ci．name_index]．toString();
if (!name．equals(className)){
throw new AssertionError(“This code only supports fields”
“local to this class”);
}

// Ok, now search for the fields name and index．
int index = 0;
CONSTANT_NameAndType_info ni = (CONSTANT_NameAndType_info)
cf．constant_pool[fi．name_and_type_index];
String fieldName =
cf．constant_pool[ni．name_index]．toString();
for (int a=0; a<cf．fields_count; a++){
String fn = cf．constant_pool[
cf．fields[a]．name_index]．toString();
if (fieldName．equals(fn)){
index = a;
break;
}
}

// Next, realign the code array, making room for the
// insertions．
byte[][] code2 = new byte[ca．code．length+3][];
System．arraycopy(ca．code, 0, code2, 0, z+1);
System．arraycopy(ca．code, z+1, code2, z+4,
ca．code．length-(z+1));
ca．code = code2;

// Next, insert the LDC_W instruction．
if (ldcindex == -1){
CONSTANT_String_info csi =
new CONSTANT_String_info(ci．name_index);
cp_info[] cpi = new cp_info[cf．constant_pool．length+1];
System．arraycopy(cf．constant_pool, 0, cpi, 0,
cf．constant_pool．length);
cpi[cpi．length - 1] = csi;
ldcindex = cpi．length-1;
cf．constant_pool = cpi;
cf．constant_pool_count++;
}
ca．code[z+1] = new byte[3];
ca．code[z+1][0] = (byte) 19;
ca．code[z+1][1] = (byte) ((ldcindex >> 8) & 0xff);
ca．code[z+1][2] = (byte) (ldcindex & 0xff);

// Next, insert the SIPUSH instruction．
ca．code[z+2] = new byte[3];
ca．code[z+2][0] = (byte) 17;
ca．code[z+2][1] = (byte) ((index >> 8) & 0xff);
ca．code[z+2][2] = (byte) (index & 0xff);

// Finally, insert the INVOKESTATIC instruction．
if (alertindex == -1){
// This is the first time this class is encourtering the
// alert instruction, so have to add it to the constant
// pool．
cp_info[] cpi = new cp_info[cf．constant_pool．length+6];
System．arraycopy(cf．constant_pool, 0, cpi, 0,
cf．constant_pool．length);
cf．constant_pool = cpi;
cf．constant_pool_count += 6;

CONSTANT_Utf8_info u1 =
new CONSTANT_Utf8_info(“FieldAlert”);
cf．constant_pool[cf．constant_pool．length-6] = u1;

CONSTANT_Class_info c1 = new CONSTANT_Class_info(
cf．constant_pool_count-6);
cf．constant_pool[cf．constant_pool．length-5] = c1;

u1 = new CONSTANT_Utf8_info(“alert”);
cf．constant_pool[cf．constant_pool．length-4] = u1;

u1 = new CONSTANT_Utf8_info(“(Ljava/lang/Object;I)V”);
cf．constant_pool[cf．constant_pool．length-3] = u1;

CONSTANT_NameAndType_info n1 =
new CONSTANT_NameAndType_info(
cf．constant_pool．length-4, cf．constant_pool．length-3);
cf．constant_pool[cf．constant_pool．length-2] = n1;

CONSTANT_Methodref_info m1 = new CONSTANT_Methodref_info(
cf．constant_pool．length-5, cf．constant_pool．length-2);
cf．constant_pool[cf．constant_pool．length-1] = m1;
alertindex = cf．constant_pool．length-1;
}
ca．code[z+3] = new byte[3];
ca．code[z+3][0] = (byte) 184;
ca．code[z+3][1] = (byte) ((alertindex >> 8) & 0xff);
ca．code[z+3][2] = (byte) (alertindex & 0xff);

// And lastly, increase the CODE_LENGTH and ATTRIBUTE_LENGTH
// values．
ca．code_length += 9;
ca．attribute_length += 9;
}
}
// If we changed this method, then increase the stack size by one．
if (changed){
ca．max_stack++; // Just to make sure．
}
}
}
try{
ByteArrayOutputStream out = new ByteArrayOutputStream();
cf．serialize(out);
byte[] b = out．toByteArray();
return defineClass(name, b, 0, b．length);
}catch (Exception e){
throw new ClassNotFoundException(name);
}
}
}

Ａ１２．Ａｔｔｒｉｂｕｔｅ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のａｔｔｒｉｂｕｔｅ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** This abstract class represents all types of attribute_info
* that are used in the JVM specifications．
*
* All new attribute_info subclasses are to always inherit from this
* class．
*/
public abstract class attribute_info{

public int attribute_name_index;
public int attribute_length;

/** This is used by subclasses to register themselves
* to their parent classFile．
*/
attribute_info(ClassFile cf){}

/** Used during input serialization by ClassFile only． */
attribute_info(ClassFile cf, DataInputStream in)
throws IOException{
attribute_name_index = in．readChar();
attribute_length = in．readInt();
}

/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
out．writeChar(attribute_name_index);
out．writeInt(attribute_length);
}

/** This class represents an unknown attribute_info that
* this current version of classfile specification does
* not understand．
*/
public final static class Unknown extends attribute_info{

byte[] info;

/** Used during input serialization by ClassFile only． */
Unknown(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
info = new byte[attribute_length];
in．read(info, 0, attribute_length);
}

/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
super．serialize(out);
out．write(info, 0, attribute_length);
}
}
}

Ａ１３．ＣｌａｓｓＦｉｌｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;
import java．util．*;

/** The ClassFile follows verbatim from the JVM specification． */
public final class ClassFile {

public int magic;
public int minor_version;
public int major_version;
public int constant_pool_count;
public cp_info[] constant_pool;
public int access_flags;
public int this_class;
public int super_class;
public int interfaces_count;
public int[] interfaces;
public int fields_count;
public field_info[] fields;
public int methods_count;
public method_info[] methods;
public int attributes_count;
public attribute_info[] attributes;

/** Constructor． Takes in a byte stream representation and transforms
* each of the attributes in the ClassFile into objects to allow for
* easier manipulation．
*/
public ClassFile(InputStream ins)
throws IOException{
DataInputStream in = (ins instanceof DataInputStream ?
(DataInputStream) ins : new DataInputStream(ins));
magic = in．readInt();
minor_version = in．readChar();
major_version = in．readChar();
constant_pool_count = in．readChar();
constant_pool = new cp_info[constant_pool_count];
for (int i=1; i<constant_pool_count; i++){
in．mark(1);
int s = in．read();
in．reset();
switch (s){
case 1:
constant_pool[i] = new CONSTANT_Utf8_info(this, in);
break;
case 3:
constant_pool[i] = new CONSTANT_Integer_info(this, in);
break;
case 4:
constant_pool[i] = new CONSTANT_Float_info(this, in);
break;
case 5:
constant_pool[i] = new CONSTANT_Long_info(this, in);
i++;
break;
case 6:
constant_pool[i] = new CONSTANT_Double_info(this, in);
i++;
break;
case 7:
constant_pool[i] = new CONSTANT_Class_info(this, in);
break;
case 8:
constant_pool[i] = new CONSTANT_String_info(this, in);
break;
case 9:
constant_pool[i] = new CONSTANT_Fieldref_info(this, in);
break;
case 10:
constant_pool[i] = new CONSTANT_Methodref_info(this, in);
break;
case 11:
constant_pool[i] =
new CONSTANT_InterfaceMethodref_info(this, in);
break;
case 12:
constant_pool[i] = new CONSTANT_NameAndType_info(this, in);
break;
default:
throw new ClassFormatError(“Invalid ConstantPoolTag”);
}
}
access_flags = in．readChar();
this_class = in．readChar();
super_class = in．readChar();
interfaces_count = in．readChar();
interfaces = new int[interfaces_count];
for (int i=0; i<interfaces_count; i++)
interfaces[i] = in．readChar();
fields_count = in．readChar();
fields = new field_info[fields_count];
for (int i=0; i<fields_count; i++) {
fields[i] = new field_info(this, in);
}
methods_count = in．readChar();
methods = new method_info[methods_count];
for (int i=0; i<methods_count; i++) {
methods[i] = new method_info(this, in);
}
attributes_count = in．readChar();
attributes = new attribute_info[attributes_count];
for (int i=0; i<attributes_count; i++){
in．mark(2);
String s = constant_pool[in．readChar()]．toString();
in．reset();
if (s．equals(“SourceFile”))
attributes[i] = new SourceFile_attribute(this, in);
else if (s．equals(“Deprecated”))
attributes[i] = new Deprecated_attribute(this, in);
else if (s．equals(“InnerClasses”))
attributes[i] = new InnerClasses_attribute(this, in);
else
attributes[i] = new attribute_info．Unknown(this, in);
}
}

/** Serializes the ClassFile object into a byte stream． */
public void serialize(OutputStream o)
throws IOException{
DataOutputStream out = (o instanceof DataOutputStream ?
(DataOutputStream) o : new DataOutputStream(o));
out．writeInt(magic);
out．writeChar(minor_version);
out．writeChar(major_version);
out．writeChar(constant_pool_count);
for (int i=1; i<constant_pool_count; i++){
constant_pool[i]．serialize(out);
if (constant_pool[i] instanceof CONSTANT_Long_info ||
constant_pool[i] instanceof CONSTANT_Double_info)
i++;
}
out．writeChar(access_flags);
out．writeChar(this_class);
out．writeChar(super_class);
out．writeChar(interfaces_count);
for (int i=0; i<interfaces_count; i++)
out．writeChar(interfaces[i]);
out．writeChar(fields_count);
for (int i=0; i<fields_count; i++)
fields[i]．serialize(out);
out．writeChar(methods_count);
for (int i=0; i<methods_count; i++)
methods[i]．serialize(out);
out．writeChar(attributes_count);
for (int i=0; i<attributes_count; i++)
attributes[i]．serialize(out);
// Flush the outputstream just to make sure．
out．flush();
}
}

Ａ１４．Ｃｏｄｅ＿ａｔｔｒｉｂｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣｏｄｅ＿ａｔｔｒｉｂｕｔｅ構造を表わすためのコンビエンスクラス
import java．util．*;
import java．lang．*;
import java．io．*;

/**
* The code[] is stored as a 2D array． */
public final class Code_attribute extends attribute_info{

public int max_stack;
public int max_locals;
public int code_length;
public byte[][] code;
public int exception_table_length;
public exception_table[] exception_table;
public int attributes_count;
public attribute_info[] attributes;

/** Internal class that handles the exception table． */
public final static class exception_table{
public int start_pc;
public int end_pc;
public int handler_pc;
public int catch_type;
}

/** Constructor called only by method_info． */
Code_attribute(ClassFile cf, int ani, int al, int ms, int ml, int cl,
byte[][] cd, int etl, exception_table[] et, int ac,
attribute_info[] a){
super(cf);
attribute_name_index = ani;
attribute_length = al;
max_stack = ms;
max_locals = ml;
code_length = cl;
code = cd;
exception_table_length = etl;
exception_table = et;
attributes_count = ac;
attributes = a;
}

/** Used during input serialization by ClassFile only． */
Code_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
max_stack = in．readChar();
max_locals = in．readChar();
code_length = in．readInt();
code = new byte[code_length][];

int i = 0;
for (int pos=0; pos<code_length; i++){
in．mark(1);
int s = in．read();
in．reset();
switch (s){
case 16:
case 18:
case 21:
case 22:
case 23:
case 24:
case 25:
case 54:
case 55:
case 56:
case 57:
case 58:
case 169:
case 188:
case 196:
code[i] = new byte[2];
break;
case 17:
case 19:
case 20:
case 132:
case 153:
case 154:
case 155:
case 156:
case 157:
case 158:
case 159:
case 160:
case 161:
case 162:
case 163:
case 164:
case 165:
case 166:
case 167:
case 168:
case 178:
case 179:
case 180:
case 181:
case 182:
case 183:
case 184:
case 187:
case 189:
case 192:
case 193:
case 198:
case 199:
case 209:
code[i] = new byte[3];
break;
case 197:
code[i] = new byte[4];
break;
case 185:
case 200:
case 201:
code[i] = new byte[5];
break;
case 170:{
int pad = 3 - (pos % 4);
in．mark(pad+13); // highbyte
in．skipBytes(pad+5); // lowbyte
int low = in．readInt();
code[i] =
new byte[pad + 13 + ((in．readInt() - low + 1) * 4)];
in．reset();
break;
}case 171:{
int pad = 3 - (pos % 4);
in．mark(pad+9);
in．skipBytes(pad+5);
code[i] = new byte[pad + 9 + (in．readInt() * 8)];
in．reset();
break;
}default:
code[i] = new byte[1];
}
in．read(code[i], 0, code[i]．length);
pos += code[i]．length;
}

// adjust the array to the new size and store the size
byte[][] temp = new byte[i][];
System．arraycopy(code, 0, temp, 0, i);
code = temp;

exception_table_length = in．readChar();
exception_table =
new Code_attribute．exception_table[exception_table_length];
for (i=0; i<exception_table_length; i++){
exception_table[i] = new exception_table();
exception_table[i]．start_pc = in．readChar();
exception_table[i]．end_pc = in．readChar();
exception_table[i]．handler_pc = in．readChar();
exception_table[i]．catch_type = in．readChar();
}
attributes_count = in．readChar();
attributes = new attribute_info[attributes_count];
for (i=0; i<attributes_count; i++){
in．mark(2);
String s = cf．constant_pool[in．readChar()]．toString();
in．reset();
if (s．equals(“LineNumberTable”))
attributes[i] = new LineNumberTable_attribute(cf, in);
else if (s．equals(“LocalVariableTable”))
attributes[i] = new LocalVariableTable_attribute(cf, in);
else
attributes[i] = new attribute_info．Unknown(cf, in);
}
}

/** Used during output serialization by ClassFile only．
*/
void serialize(DataOutputStream out)
throws IOException{
attribute_length = 12 + code_length +
(exception_table_length * 8);
for (int i=0; i<attributes_count; i++)
attribute_length += attributes[i]．attribute_length + 6;
super．serialize(out);
out．writeChar(max_stack);
out．writeChar(max_locals);
out．writeInt(code_length);
for (int i=0, pos=0; pos<code_length; i++){
out．write(code[i], 0, code[i]．length);
pos += code[i]．length;
}
out．writeChar(exception_table_length);
for (int i=0; i<exception_table_length; i++){
out．writeChar(exception_table[i]．start_pc);
out．writeChar(exception_table[i]．end_pc);
out．writeChar(exception_table[i]．handler_pc);
out．writeChar(exception_table[i]．catch_type);
}
out．writeChar(attributes_count);
for (int i=0; i<attributes_count; i++)
attributes[i]．serialize(out);
}
}

Ａ１５．ＣＯＳＴＡＮＴ＿Ｃｌａｓｓ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＳＴＡＮＴ＿Ｃｌａｓｓ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Class subtype of a constant pool entry． */
public final class CONSTANT_Class_info extends cp_info{

/** The index to the name of this class． */
public int name_index = 0;

/** Convenience constructor．
*/
public CONSTANT_Class_info(int index) {
tag = 7;
name_index = index;
}

/** Used during input serialization by ClassFile only． */
CONSTANT_Class_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 7)
throw new ClassFormatError();
name_index = in．readChar();
}

/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeChar(name_index);
}
}

Ａ１６．ＣＯＮＳＴＡＮＴ＿Ｄｏｕｂｌｅ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿Ｄｏｕｂｌｅ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Double subtype of a constant pool entry． */
public final class CONSTANT_Double_info extends cp_info{

/** The actual value． */
public double bytes;
public CONSTANT_Double_info(double d){
tag = 6;
bytes = d;
}
/** Used during input serialization by ClassFile only． */
CONSTANT_Double_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 6)
throw new ClassFormatError();
bytes = in．readDouble();
}
/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeDouble(bytes);
long l = Double．doubleToLongBits(bytes);
}
}

Ａ１７．ＣＯＮＳＴＡＮＴ＿Ｆｉｅｌｄｒｅｆ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿Ｆｉｅｌｄｒｅｆ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Fieldref subtype of a constant pool entry． */
public final class CONSTANT_Fieldref_info extends cp_info{

/** The index to the class that this field is referencing to． */
public int class_index;

/** The name and type index this field if referencing to． */
public int name_and_type_index;

/** Convenience constructor． */
public CONSTANT_Fieldref_info(int class_index, int name_and_type_index) {
tag = 9;
this．class_index = class_index;
this．name_and_type_index = name_and_type_index;
}
/** Used during input serialization by ClassFile only． */
CONSTANT_Fieldref_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 9)
throw new ClassFormatError();
class_index = in．readChar();
name_and_type_index = in．readChar();
}
/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeChar(class_index);
out．writeChar(name_and_type_index);
}
}

Ａ１８．ＣＯＮＳＴＡＮＴ＿Ｆｌｏａｔ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿Ｆｌｏａｔ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Float subtype of a constant pool entry． */
public final class CONSTANT_Float_info extends cp_info{

/** The actual value． */
public float bytes;

public CONSTANT_Float_info(float f){
tag = 4;
bytes = f;
}
/** Used during input serialization by ClassFile only． */
CONSTANT_Float_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 4)
throw new ClassFormatError();
bytes = in．readFloat();
}
/** Used during output serialization by ClassFile only． */
public void serialize(DataOutputStream out)
throws IOException{
out．writeByte(4);
out．writeFloat(bytes);
}
}

Ａ１９．ＣＯＮＳＴＡＮＴ＿Ｉｎｔｅｇｅｒ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿Ｉｎｔｅｇｅｒ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Integer subtype of a constant pool entry． */
public final class CONSTANT_Integer_info extends cp_info{

/** The actual value． */
public int bytes;

public CONSTANT_Integer_info(int b) {
tag = 3;
bytes = b;
}
/** Used during input serialization by ClassFile only． */
CONSTANT_Integer_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 3)
throw new ClassFormatError();
bytes = in．readInt();
}
/** Used during output serialization by ClassFile only． */
public void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeInt(bytes);
}
}

Ａ２０．ＣＯＮＳＴＡＮＴ＿ＩｎｔｅｒｆａｃｅＭｅｔｈｏｄｒｅｆ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿ＩｎｔｅｒｆａｃｅＭｅｔｈｏｄｒｅｆ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** InterfaceMethodref subtype of a constant pool entry．
*/
public final class CONSTANT_InterfaceMethodref_info extends cp_info{

/** The index to the class that this field is referencing to． */
public int class_index;

/** The name and type index this field if referencing to． */
public int name_and_type_index;

public CONSTANT_InterfaceMethodref_info(int class_index,
int name_and_type_index) {
tag = 11;
this．class_index = class_index;
this．name_and_type_index = name_and_type_index;
}
/** Used during input serialization by ClassFile only． */
CONSTANT_InterfaceMethodref_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 11)
throw new ClassFormatError();
class_index = in．readChar();
name_and_type_index = in．readChar();
}
/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeChar(class_index);
out．writeChar(name_and_type_index);
}
}

Ａ２１．ＣＯＮＳＴＡＮＴ＿Ｌｏｎｇ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿Ｌｏｎｇ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Long subtype of a constant pool entry． */
public final class CONSTANT_Long_info extends cp_info{

/** The actual value． */
public long bytes;

public CONSTANT_Long_info(long b){
tag = 5;
bytes = b;
}
/** Used during input serialization by ClassFile only． */
CONSTANT_Long_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 5)
throw new ClassFormatError();
bytes = in．readLong();
}
/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeLong(bytes);
}
}

Ａ２２．ＣＯＮＳＴＡＮＴ＿Ｍｅｔｈｏｄｒｅｆ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿Ｍｅｔｈｏｄｒｅｆ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Methodref subtype of a constant pool entry．
*/
public final class CONSTANT_Methodref_info extends cp_info{

/** The index to the class that this field is referencing to． */
public int class_index;

/** The name and type index this field if referencing to． */
public int name_and_type_index;

public CONSTANT_Methodref_info(int class_index, int name_and_type_index) {
tag = 10;
this．class_index = class_index;
this．name_and_type_index = name_and_type_index;
}
/** Used during input serialization by ClassFile only． */
CONSTANT_Methodref_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 10)
throw new ClassFormatError();
class_index = in．readChar();
name_and_type_index = in．readChar();
}
/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeChar(class_index);
out．writeChar(name_and_type_index);
}
}

Ａ２３．ＣＯＮＳＴＡＮＴ＿ＮａｍｅＡｎｄＴｙｐｅ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿ＮａｍｅＡｎｄＴｙｐｅ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．io．*;
import java．lang．*;

/** NameAndType subtype of a constant pool entry．
*/
public final class CONSTANT_NameAndType_info extends cp_info{

/** The index to the Utf8 that contains the name． */
public int name_index;

/** The index fo the Utf8 that constains the signature． */
public int descriptor_index;

public CONSTANT_NameAndType_info(int name_index, int descriptor_index) {
tag = 12;
this．name_index = name_index;
this．descriptor_index = descriptor_index;
}
/** Used during input serialization by ClassFile only． */
CONSTANT_NameAndType_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 12)
throw new ClassFormatError();
name_index = in．readChar();
descriptor_index = in．readChar();
}
/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeChar(name_index);
out．writeChar(descriptor_index);
}
}

Ａ２４．ＣＯＮＳＴＡＮＴ＿Ｓｔｒｉｎｇ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿Ｓｔｒｉｎｇ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** String subtype of a constant pool entry．
*/
public final class CONSTANT_String_info extends cp_info{

/** The index to the actual value of the string． */
public int string_index;

public CONSTANT_String_info(int value) {
tag = 8;
string_index = value;
}
/** ONLY TO BE USED BY CLASSFILE! */
public CONSTANT_String_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 8)
throw new ClassFormatError();
string_index = in．readChar();
}
/** Output serialization, ONLY TO BE USED BY CLASSFILE! */
public void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeChar(string_index);
}
}

Ａ２５．ＣＯＮＳＴＡＮＴ＿Ｕｔｆ８＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣＯＮＳＴＡＮＴ＿Ｕｔｆ８＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．io．*;
import java．lang．*;

/** Utf8 subtype of a constant pool entry．
* We internally represent the Utf8 info byte array
* as a String．
*/
public final class CONSTANT_Utf8_info extends cp_info{

/** Length of the byte array． */
public int length;

/** The actual bytes, represented by a String． */
public String bytes;

/** This constructor should be used for the purpose
* of part creation． It does not set the parent
* ClassFile reference．
*/
public CONSTANT_Utf8_info(String s) {
tag = 1;
length = s．length();
bytes = s;
}
/** Used during input serialization by ClassFile only． */
public CONSTANT_Utf8_info(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
if (tag != 1)
throw new ClassFormatError();
length = in．readChar();
byte[] b = new byte[length];
in．read(b, 0, length);

// WARNING: String constructor is deprecated．
bytes = new String(b, 0, length);
}
/** Used during output serialization by ClassFile only． */
public void serialize(DataOutputStream out)
throws IOException{
out．writeByte(tag);
out．writeChar(length);

// WARNING: Handling of String coversion here might be problematic．
out．writeBytes(bytes);
}

public String toString(){
return bytes;
}
}

Ａ２６．ＣｏｎｓｔａｎｔＶａｌｕｅ＿ａｔｔｒｉｂｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＣｏｎｓｔａｎｔＶａｌｕｅ＿ａｔｔｒｉｂｕｔｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Attribute that allows for initialization of static variables in
* classes． This attribute will only reside in a field_info struct．
*/

public final class ConstantValue_attribute extends attribute_info{

public int constantvalue_index;

public ConstantValue_attribute(ClassFile cf, int ani, int al, int cvi){
super(cf);
attribute_name_index = ani;
attribute_length = al;
constantvalue_index = cvi;
}
public ConstantValue_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
constantvalue_index = in．readChar();
}
public void serialize(DataOutputStream out)
throws IOException{
attribute_length = 2;
super．serialize(out);
out．writeChar(constantvalue_index);
}
}

Ａ２７．ｃｐ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のｃｐ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Represents the common interface of all constant pool parts
* that all specific constant pool items must inherit from．
*
*/
public abstract class cp_info{

/** The type tag that signifies what kind of constant pool
* item it is */
public int tag;

/** Used for serialization of the object back into a bytestream． */
abstract void serialize(DataOutputStream out) throws IOException;

/** Default constructor． Simply does nothing． */
public cp_info() {}

/** Constructor simply takes in the ClassFile as a reference to
* it's parent
*/
public cp_info(ClassFile cf) {}

/** Used during input serialization by ClassFile only． */
cp_info(ClassFile cf, DataInputStream in)
throws IOException{
tag = in．readUnsignedByte();
}
}

Ａ２８．Ｄｅｐｒｅｃａｔｅｄ＿ａｔｔｒｂｉｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＤｅｐｒｅｃａｔｅｄ＿ａｔｔｒｂｉｕｔｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** A fix attributed that can be located either in the ClassFile,
* field_info or the method_info attribute． Mark deprecated to
* indicate that the method, class or field has been superceded．
*/
public final class Deprecated_attribute extends attribute_info{

public Deprecated_attribute(ClassFile cf, int ani, int al){
super(cf);
attribute_name_index = ani;
attribute_length = al;
}
/** Used during input serialization by ClassFile only． */
Deprecated_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
}
}

Ａ２９．Ｅｘｃｅｐｔｉｏｎｓ＿ａｔｔｒｉｂｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＥｘｃｅｐｔｉｏｎｓ＿ａｔｔｒｉｂｕｔｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** This is the struct where the exceptions table are located．
* 
* This attribute can only appear once in a method_info struct．
*/
public final class Exceptions_attribute extends attribute_info{

public int number_of_exceptions;
public int[] exception_index_table;

public Exceptions_attribute(ClassFile cf, int ani, int al, int noe,
int[] eit){
super(cf);
attribute_name_index = ani;
attribute_length = al;
number_of_exceptions = noe;
exception_index_table = eit;
}

/** Used during input serialization by ClassFile only． */
Exceptions_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
number_of_exceptions = in．readChar();
exception_index_table = new int[number_of_exceptions];
for (int i=0; i<number_of_exceptions; i++)
exception_index_table[i] = in．readChar();
}
/** Used during output serialization by ClassFile only． */
public void serialize(DataOutputStream out)
throws IOException{
attribute_length = 2 + (number_of_exceptions*2);
super．serialize(out);
out．writeChar(number_of_exceptions);
for (int i=0; i<number_of_exceptions; i++)
out．writeChar(exception_index_table[i]);
}
}

Ａ３０．ｆｉｅｌｄ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のｆｉｅｌｄ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Represents the field_info structure as specified in the JVM specification．
*/
public final class field_info{

public int access_flags;
public int name_index;
public int descriptor_index;
public int attributes_count;
public attribute_info[] attributes;

/** Convenience constructor． */
public field_info(ClassFile cf, int flags, int ni, int di){
access_flags = flags;
name_index = ni;
descriptor_index = di;
attributes_count = 0;
attributes = new attribute_info[0];
}

/** Constructor called only during the serialization process．
* 
* This is intentionally left as package protected as we
* should not normally call this constructor directly．
* 
* Warning: the handling of len is not correct (after String s =．．．)
*/
field_info(ClassFile cf, DataInputStream in)
throws IOException{
access_flags = in．readChar();
name_index = in．readChar();
descriptor_index = in．readChar();
attributes_count = in．readChar();
attributes = new attribute_info[attributes_count];
for (int i=0; i<attributes_count; i++){
in．mark(2);
String s = cf．constant_pool[in．readChar()]．toString();
in．reset();
if (s．equals(“ConstantValue”))
attributes[i] = new ConstantValue_attribute(cf, in);
else if (s．equals(“Synthetic”))
attributes[i] = new Synthetic_attribute(cf, in);
else if (s．equals(“Deprecated”))
attributes[i] = new Deprecated_attribute(cf, in);
else
attributes[i] = new attribute_info．Unknown(cf, in);
}
}

/** To serialize the contents into the output format．
*/
public void serialize(DataOutputStream out)
throws IOException{
out．writeChar(access_flags);
out．writeChar(name_index);
out．writeChar(descriptor_index);
out．writeChar(attributes_count);
for (int i=0; i<attributes_count; i++)
attributes[i]．serialize(out);
}
}

Ａ３１．ＩｎｎｅｒＣｌａｓｓｅｓ＿ａｔｔｒｉｂｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＩｎｎｅｒＣｌａｓｓｅｓ＿ａｔｔｒｉｂｕｔｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** A variable length structure that contains information about an
* inner class of this class．
*/
public final class InnerClasses_attribute extends attribute_info{

public int number_of_classes;
public classes[] classes;

public final static class classes{
int inner_class_info_index;
int outer_class_info_index;
int inner_name_index;
int inner_class_access_flags;
}

public InnerClasses_attribute(ClassFile cf, int ani, int al,
int noc, classes[] c){
super(cf);
attribute_name_index = ani;
attribute_length = al;
number_of_classes = noc;
classes = c;
}
/** Used during input serialization by ClassFile only． */
InnerClasses_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
number_of_classes = in．readChar();
classes = new InnerClasses_attribute．classes[number_of_classes];
for (int i=0; i<number_of_classes; i++){
classes[i] = new classes();
classes[i]．inner_class_info_index = in．readChar();
classes[i]．outer_class_info_index = in．readChar();
classes[i]．inner_name_index = in．readChar();
classes[i]．inner_class_access_flags = in．readChar();
}
}
/** Used during output serialization by ClassFile only． */
public void serialize(DataOutputStream out)
throws IOException{
attribute_length = 2 + (number_of_classes * 8);
super．serialize(out);
out．writeChar(number_of_classes);
for (int i=0; i<number_of_classes; i++){
out．writeChar(classes[i]．inner_class_info_index);
out．writeChar(classes[i]．outer_class_info_index);
out．writeChar(classes[i]．inner_name_index);
out．writeChar(classes[i]．inner_class_access_flags);
}
}
}

Ａ３２．ＬｉｎｅＮｕｍｂｅｒＴａｂｌｅ＿ａｔｔｒｉｂｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＬｉｎｅＮｕｍｂｅｒＴａｂｌｅ＿ａｔｔｒｉｂｕｔｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Determines which line of the binary code relates to the
* corresponding source code．
*/
public final class LineNumberTable_attribute extends attribute_info{

public int line_number_table_length;
public line_number_table[] line_number_table;

public final static class line_number_table{
int start_pc;
int line_number;
}

public LineNumberTable_attribute(ClassFile cf, int ani, int al, int lntl,
line_number_table[] lnt){
super(cf);
attribute_name_index = ani;
attribute_length = al;
line_number_table_length = lntl;
line_number_table = lnt;
}

/** Used during input serialization by ClassFile only． */
LineNumberTable_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
line_number_table_length = in．readChar();
line_number_table = new LineNumberTable_attribute．line_number_table[line_number_table_length];
for (int i=0; i<line_number_table_length; i++){
line_number_table[i] = new line_number_table();
line_number_table[i]．start_pc = in．readChar();
line_number_table[i]．line_number = in．readChar();
}
}

/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
attribute_length = 2 + (line_number_table_length * 4);
super．serialize(out);
out．writeChar(line_number_table_length);
for (int i=0; i<line_number_table_length; i++){
out．writeChar(line_number_table[i]．start_pc);
out．writeChar(line_number_table[i]．line_number);
}
}
}

Ａ３３．ＬｏｃａｌＶａｒｉａｂｌｅＴａｂｌｅ＿ａｔｔｒｉｂｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＬｏｃａｌＶａｒｉａｂｌｅＴａｂｌｅ＿ａｔｔｒｉｂｕｔｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** Used by debugger to find out how the source file line number is linked
* to the binary code． It has many to one correspondence and is found in
* the Code_attribute．
*/
public final class LocalVariableTable_attribute extends attribute_info{

public int local_variable_table_length;
public local_variable_table[] local_variable_table;

public final static class local_variable_table{
int start_pc;
int length;
int name_index;
int descriptor_index;
int index;
}

public LocalVariableTable_attribute(ClassFile cf, int ani, int al,
int lvtl, local_variable_table[] lvt){
super(cf);
attribute_name_index = ani;
attribute_length = al;
local_variable_table_length = lvtl;
local_variable_table = lvt;
}

/** Used during input serialization by ClassFile only． */
LocalVariableTable_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
local_variable_table_length = in．readChar();
local_variable_table = new LocalVariableTable_attribute．local_variable_table[local_variable_table_length];
for (int i=0; i<local_variable_table_length; i++){
local_variable_table[i] = new local_variable_table();
local_variable_table[i]．start_pc = in．readChar();
local_variable_table[i]．length = in．readChar();
local_variable_table[i]．name_index = in．readChar();
local_variable_table[i]．descriptor_index = in．readChar();
local_variable_table[i]．index = in．readChar();
}
}

/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
attribute_length = 2 + (local_variable_table_length * 10);
super．serialize(out);
out．writeChar(local_variable_table_length);
for (int i=0; i<local_variable_table_length; i++){
out．writeChar(local_variable_table[i]．start_pc);
out．writeChar(local_variable_table[i]．length);
out．writeChar(local_variable_table[i]．name_index);
out．writeChar(local_variable_table[i]．descriptor_index);
out．writeChar(local_variable_table[i]．index);
}
}
}

Ａ３４．ｍｅｔｈｏｄ＿ｉｎｆｏ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のｍｅｔｈｏｄ＿ｉｎｆｏ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** This follows the method_info in the JVM specification．
*/
public final class method_info {

public int access_flags;
public int name_index;
public int descriptor_index;
public int attributes_count;
public attribute_info[] attributes;

/** Constructor． Creates a method_info, initializes it with
* the flags set, and the name and descriptor indexes given．
* A new uninitialized code attribute is also created, and stored
* in the code variable．*/
public method_info(ClassFile cf, int flags, int ni, int di,
int ac, attribute_info[] a) {
access_flags = flags;
name_index = ni;
descriptor_index = di;
attributes_count = ac;
attributes = a;
}

/** This method creates a method_info from the current pointer in the
* data stream． Only called by during the serialization of a complete
* ClassFile from a bytestream, not normally invoked directly．
*/
method_info(ClassFile cf, DataInputStream in)
throws IOException{
access_flags = in．readChar();
name_index = in．readChar();
descriptor_index = in．readChar();
attributes_count = in．readChar();
attributes = new attribute_info[attributes_count];
for (int i=0; i<attributes_count; i++){
in．mark(2);
String s = cf．constant_pool[in．readChar()]．toString();
in．reset();
if (s．equals(“Code”))
attributes[i] = new Code_attribute(cf, in);
else if (s．equals(“Exceptions”))
attributes[i] = new Exceptions_attribute(cf, in);
else if (s．equals(“Synthetic”))
attributes[i] = new Synthetic_attribute(cf, in);
else if (s．equals(“Deprecated”))
attributes[i] = new Deprecated_attribute(cf, in);
else
attributes[i] = new attribute_info．Unknown(cf, in);
}
}

/** Output serialization of the method_info to a byte array．
* Not normally invoked directly．
*/
public void serialize(DataOutputStream out)
throws IOException{
out．writeChar(access_flags);
out．writeChar(name_index);
out．writeChar(descriptor_index);
out．writeChar(attributes_count);
for (int i=0; i<attributes_count; i++)
attributes[i]．serialize(out);
}
}

Ａ３５．ＳｏｕｒｃｅＦｉｌｅ＿ａｔｔｒｉｂｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＳｏｕｒｃｅＦｉｌｅ＿ａｔｔｒｉｂｕｔｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** A SourceFile attribute is an optional fixed_length attribute in
* the attributes table． Only located in the ClassFile struct only
* once．
*/
public final class SourceFile_attribute extends attribute_info{

public int sourcefile_index;

public SourceFile_attribute(ClassFile cf, int ani, int al, int sfi){
super(cf);
attribute_name_index = ani;
attribute_length = al;
sourcefile_index = sfi;
}

/** Used during input serialization by ClassFile only． */
SourceFile_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
sourcefile_index = in．readChar();
}

/** Used during output serialization by ClassFile only． */
void serialize(DataOutputStream out)
throws IOException{
attribute_length = 2;
super．serialize(out);
out．writeChar(sourcefile_index);
}
}

Ａ３６．Ｓｙｎｔｈｅｔｉｃ＿ａｔｔｒｉｂｕｔｅ．ｊａｖａ
ＣｌａｓｓＦｉｌｅｓ内のＳｙｎｔｈｅｔｉｃ＿ａｔｔｒｉｂｕｔｅ構造を表わすためのコンビエンスクラス
import java．lang．*;
import java．io．*;

/** A synthetic attribute indicates that this class does not have
* a generated code source． It is likely to imply that the code
* is generated by machine means rather than coded directly． This
* attribute can appear in the classfile, method_info or field_info．
* It is fixed length．
*/
public final class Synthetic_attribute extends attribute_info{

public Synthetic_attribute(ClassFile cf, int ani, int al){
super(cf);
attribute_name_index = ani;
attribute_length = al;
}

/** Used during output serialization by ClassFile only． */
Synthetic_attribute(ClassFile cf, DataInputStream in)
throws IOException{
super(cf, in);
}
}

従来のコンピュータの内部アーキテクチャを示す概略図である。公知の対称型多重プロセッサの内部アーキテクチャを示す概略図である。従来技術の分散コンピューティングを示す概略図である。クラスタを使用した従来技術のネットワークコンピューティングを示す概略図である。本発明の第１の実施形態に従って同じアプリケーションプログラムを実行する複数のマシーンを示す概略ブロック図である。ＪＡＶＡコードを動作させ、これによってＪＡＶＡ仮想マシーンを構成するように配置された従来技術のコンピュータを示す概略図である。図６に類似しているが、好ましい実施形態に従ってコードの初期ロードを示す図である。図５に類似しているが、図７に示された方式でＪＡＶＡコードを各々が実行する複数のコンピュータの相互接続を示す図である。ネットワーク内の各マシーンでの同じアプリケーションのロード中に行われる手順を示すフローチャートである。図９の手順に類似した修正された手順を示すフローチャートである。メモリ更新の第１の実施形態を利用して図８のマシーンで実行されるマルチスレッド処理を示す概略図である。図１１に類似した他の実施形態を示す概略図である。図８のコンピュータに対するマルチスレッドメモリ更新を示す図である。複数のアプリケーションを同時に実行するために相互接続され、両方とも単一のコンピュータ上で実行されるアプリケーションを備えた２つのラップトップコンピュータを示す概略図である。図１４に類似した図であり、各コンピュータで実行される１つのアプリケーションを備えた図１４の装置を示す図である。図１４及び１５に類似した図であり、両方のコンピュータ上で同時に実行される両方のアプリケーションを備えた図１４の装置を示す図である。

符号の説明

５０アプリケーション
５３ネットワーク
７１ＤＲＴ

Claims

単一のコンピュータでのみ動作するように各々記述されているが、通信ネットワークによって相互接続された複数のコンピュータ上で同時に実行される少なくとも１つのアプリケーションプログラムを有する多重コンピュータシステムであって、
前記アプリケーションプログラムの異なる部分が前記コンピュータのうちの異なるコンピュータ上でほぼ同時に実行され、前記各コンピュータが前記アプリケーションプログラムの対応する部分によってのみアクセス可能な独立したローカルメモリを有し、実質的に同一な複数のオブジェクトが前記対応するコンピュータに各々作成されることを特徴とする多重コンピュータシステム。
前記実質的に同一な複数のオブジェクトの各々が実質的に同一の名前を有することを特徴とする請求項１に記載のシステム。
各前記コンピュータが分散ランタイム手段を含み、前記各コンピュータの分散ランタイム手段が全ての他のコンピュータと通信可能であり、これによって前記コンピュータの１つの上で実行する前記アプリケーションプログラムの一部が当該コンピュータのオブジェクトのコンテンツを変更する場合には、前記オブジェクトに対するコンテンツの変更は前記１つのコンピュータの分散ランタイム手段によって他のコンピュータ全てに伝播されて、前記他のコンピュータの各々における対応するオブジェクトのコンテンツを変更することを特徴とする請求項２に記載のシステム。
更新伝播ルーチンを挿入してメモリに前記アプリケーションプログラムを書き込む各インスタンスを修正することにより、各前記アプリケーションプログラムがロード前、ロード中、ロード後に修正され、前記更新伝播ルーチンが１つのコンピュータによるあらゆるメモリへの書き込みを前記他のコンピュータ全てに伝播することを特徴とする請求項３に記載のシステム。
前記アプリケーションプログラムは、ロード時の再コンパイル、ロード前の事前コンパイル、ロード前のコンパイル、実行時コンパイル、及びロード後で且つアプリケーションプログラムの関連部分の実行前の再コンパイルからなる手順のグループから選択される手順に従って修正されることを特徴とする請求項４に記載のシステム。
前記修正アプリケーションプログラムは、マスタ／スレーブ転送、ブランチ転送、及びカスケード転送からなるグループから選択される手順に従って前記コンピュータの全てに転送されることを特徴とする請求項３に記載のシステム。
通信リンクを介して相互接続され、各々が独立したローカルメモリを有し、少なくとも１つのアプリケーションプログラムの異なる部分をほぼ同時に動作し、単一のコンピュータでのみ動作するよう各々記述され、前記各ローカルメモリが前記アプリケーションプログラムの対応する部分によってだけアクセス可能である複数のコンピュータ。
前記少なくとも１つのアプリケーションプログラムを動作中の各前記コンピュータは、各前記コンピュータに物理的に位置付けられたローカルメモリに対してだけ読み込み及び書き込みを行い、各前記コンピュータによって利用される前記ローカルメモリの各コンテンツは基本的に類似しているが、各瞬間では同一でなく、前記コンピュータの全てのコンピュータが、前記１つのコンピュータによって更新されたいずれかのメモリロケーションのコンテンツを他の前記コンピュータ全てに分散するための分散更新手段を有することを特徴とする請求項７に記載の複数のコンピュータ。
前記又は各前記アプリケーションプログラムに割り当てられたローカルメモリ容量が実質的に同一であり、前記又は各前記アプリケーションプログラムが利用可能な総メモリ容量が、前記割り当てられたメモリ容量であることを特徴とする請求項８に記載の複数のコンピュータ。
前記分散更新手段の全ては、前記ローカルメモリ読み取り速度よりも遅いデータ転送速度で前記通信リンクを介して伝達することを特徴とする請求項８に記載の複数のコンピュータ。
前記コンピュータの少なくとも幾つかは、種々の製造業者によって製造され、及び／又は種々のオペレーティングシステムを有することを特徴とする請求項７に記載の複数のコンピュータ。
単一のコンピュータでのみ動作するように各々記述された少なくとも１つのアプリケーションプログラムを同時に動作する方法であって、前記コンピュータが通信ネットワークによって相互接続されており、前記方法が、
（ｉ）前記コンピュータのうちの異なるコンピュータ上で前記アプリケーションプログラムの異なる部分を実行し、各前記部分に対して、前記対応するコンピュータにおいて実質的に同一な複数のオブジェクトを各々作成し、該オブジェクトの各々に実質的に同一の名前を持たせる段階と、
を含む方法。
（ｉｉ）前記実質的に同一な複数のオブジェクトの各々に実質的に同一の名前を付ける段階を更に含む請求項１２に記載の方法。
（ｉｉｉ）前記コンピュータの１つの上で実行される前記アプリケーションプログラムの一部が当該コンピュータにおいてオブジェクトのコンテンツを変更する場合には、前記オブジェクトのコンテンツの変更が前記通信ネットワークを介して他の前記コンピュータに伝播されて、他の前記コンピュータの各々において前記対応するオブジェクトのコンテンツを変更することを特徴とする請求項１３に記載の方法。
（ｉｖ）１つのコンピュータによる前記他のコンピュータの全てに対するあらゆるメモリ書き込みを伝播する更新プログラムルーチンを挿入して前記アプリケーションプログラムがメモリに書き込む各インスタンスを修正することによって、前記アプリケーションプログラムをロード前、ロード中、又はロード後に修正する段階を更に含む請求項１４に記載の方法。
（ｖ）ロード時の再コンパイル、ロード前の事前コンパイル、ロード前のコンパイル、実行時コンパイル、及びロード後で且つアプリケーションプログラムの関連部分の実行前の再コンパイルからなる手順のグループから選択される手順を利用して前記アプリケーションプログラムを修正する段階を更に含む請求項１４に記載の方法。
（ｖｉ）マスタ／スレーブ転送、ブランチ転送、及びカスケード転送からなるグループから選択される手順を利用して前記コンピュータの全てに前記修正アプリケーションプログラムを転送する段階を更に含む請求項１２に記載の方法。
通信リンクを介して相互接続された複数のコンピュータの各々に単一のコンピュータでのみ動作するように記述されたアプリケーションプログラムをロードする方法であって、
各コンピュータが前記アプリケーションプログラムの対応する部分によってのみアクセス可能な独立したローカルメモリを有し、前記アプリケーションプログラムの異なる部分が異なるコンピュータ上でほぼ同時に実行可能であり、
前記方法は、ロード前、ロード中、又はロード後で且つアプリケーションプログラムの関連部分の実行前に前記アプリケーションを修正する段階を含む方法。
前記アプリケーションの修正が異なるコンピュータ毎に異なることを特徴とする請求項１８に記載の方法。
前記修正段階が、
（ｉ）前記コンピュータの１つを利用したメモリ記録を共有する命令を検出する段階と、
（ｉｉ）このような前記共有メモリ記録全てをリストして、前記リストされた各メモリ記録に対して命名タグを付与する段階と、
（ｉｉｉ）前記リストされたメモリ記録のいずれかに対する書き込み又は該リストされたメモリ記録のいずれかのコンテンツの操作を行う命令を検出する段階と、
（ｉｖ）前記各検出された書き込み又は操作命令に対応する更新プログラムルーチンを生成する段階と、
を含み、
前記更新プログラムルーチンが、前記再書き込み又は操作されたコンテンツ及び前記各再書き込み又は操作されたリストメモリ記録の命名タグを前記コンピュータのうちの他のコンピュータの全てに転送することを特徴とする請求項１８に記載の方法。
単一のコンピュータでのみ動作するよう各々記述された少なくとも１つのアプリケーションプログラムを通信リンクを介して全て相互接続された複数のコンピュータ上で同時に動作する方法であって、前記コンピュータの各々が少なくとも最小の事前設定されたローカルメモリ容量を有し、前記アプリケーションプログラムの異なる部分が、前記コンピュータの異なるコンピュータ上でほぼ同時に実行可能であると共に、各コンピュータのローカルメモリが前記アプリケーションプログラムの対応する部分によってのみアクセス可能であり、
前記方法が、
（ｉ）実質的に同一の条件で各ローカルメモリを最初に提供する段階と、
（ｉｉ）前記対応するローカルメモリから各前記アプリケーションプログラムにより生成された全てのメモリ読み取り及び書き込みを満たす段階と、
（ｉｉｉ）前記複数のコンピュータの残り全てにローカルに行われる各前記コンピュータでの前記全メモリの書き込みを前記通信リンクを介して伝達する段階と、
を含み、
これにより更新データ送信遅延の影響を受ける各前記コンピュータによって利用される前記ローカルメモリのコンテンツが、実質的に同一のままであることを特徴とする方法。
（ｉｖ）前記ローカルメモリ読み取り速度よりも遅いデータ転送速度で更新データ送信を構成する前記ローカルメモリ書き込みを伝達する段階を更に含む請求項２１に記載の方法。
単一のコンピュータでのみ動作するように各々記述されているが、通信リンクを介して相互接続された複数のコンピュータ上で同時に実行するようアプリケーションプログラムをコンパイル又は修正する方法であって、前記アプリケーションプログラムの異なる部分が前記コンピュータの異なるコンピュータ上でほぼ同時に実行され、前記コンピュータの各々が前記アプリケーションプログラムの対応する部分によってのみアクセス可能な独立したローカルメモリを有し、
前記方法が、
（ｉ）前記コンピュータの１つを利用してメモリ記録を共有する命令を検出する段階と、
（ｉｉ）このような前記共有メモリ記録全てをリストして、前記リストされた各メモリ記録に対して命名タグを付与する段階と、
（ｉｉｉ）前記リストされたメモリ記録のいずれかに対する書き込み又は該リストされたメモリ記録のいずれかのコンテンツの操作を行う命令を検出する段階と、
（ｉｖ）前記各検出された書き込み又は操作命令に従う更新プログラムルーチンを起動する段階と、
を含み、
前記更新プログラムルーチンが、前記再書き込み又は操作されたコンテンツ及び前記各再書き込み又は操作されたリストメモリ記録の命名タグを前記コンピュータのうちの残りに転送することを特徴とする方法。
各前記コンピュータへの前記アプリケーションプログラムのロード前、ロード中、或いはロード後で且つ前記アプリケーションプログラムの関連部分の実行前に行われる請求項２３に記載の方法。
単一のコンピュータでのみ動作するように記述された単一のアプリケーションプログラムの個々のスレッドが、各々が対応するスレッドによってのみアクセス可能な独立したローカルメモリを有し且つ通信リンクを介して各々が相互接続された複数のコンピュータのうちの異なる対応するコンピュータ上で各々が同時に処理されるマルチスレッド処理コンピュータオペレーションにおいて、
各スレッドを処理する前記コンピュータに物理的に関連付けられたローカルメモリのコンテンツ内の変更を前記通信リンクを介して他の各前記コンピュータのローカルメモリに伝達する段階を含む改良方法。
１つの前記スレッドに関連付けられる前記メモリに対する変更が、前記１つのスレッドの前記コンピュータによって他の前記コンピュータ全てに伝達されることを特徴とする請求項２５に記載の改良方法。
１つの前記スレッドに関連付けられる前記メモリに対する変更が、別の前記スレッドに関連付けられたコンピュータに送信されることにより、前記他のコンピュータ全てに送信されることを特徴とする請求項２５に記載の改良方法。
記憶媒体内に記憶され、請求項１２又は１８又は２１又は２３に記載の方法の実行を複数のコンピュータに許可するように動作可能なプログラム命令のセットを含むコンピュータプログラム製品。
通信ネットワークを介して相互接続され、単一のコンピュータでのみ動作するよう記述されたアプリケーションプログラムの異なる部分をコンピュータのうちの対応する異なるコンピュータ上でほぼ同時に実行するよう各々が動作可能な複数のコンピュータであって、
前記コンピュータは、請求項１２又は１８又は２１又は２３に記載の方法を実行するようにプログラムされているか、或いは請求項２８に記載のコンピュータプログラム製品がロードされていることを特徴とする複数のコンピュータ。