(57)【要約】  本発明は、アプリケーションプログラム（５０）を複数のコンピュータ（Ｍ１、．．．Ｍｎ）上で同時に実行できるようにする修正されたコンピュータアーキテクチャ（５０、７１、７２）を開示する。各コンピュータにある共有メモリは、全てのメモリ読み取り要求がローカルで満たされるように修正及び／又は上書きによって更新される。初期プログラムロード（７５）又は類似のプログラムロード中、特定の資産（５０Ａ、５０Ｘ−５０Ｙ）（同期）上でロックを取得（又は解放）するアプリケーションプログラムを生じる命令が識別される。全てのコンピュータが更新される修正同期ルーチンをもたらす追加命令が挿入される（１６２、１６３）。【選択図】図８
2007534064.tif 000002
【特許請求の範囲】
【請求項１】
単一のコンピュータでのみ動作するように各々記述されているが、通信ネットワークによって相互接続された複数のコンピュータ上で同時に実行される少なくとも１つのアプリケーションプログラムを有する多重コンピュータシステムであって、
前記アプリケーションプログラムの異なる部分が前記コンピュータのうちの異なるコンピュータ上でほぼ同時に実行され、前記各部分において、実質的に同一な複数のオブジェクトが前記対応するコンピュータに各々作成され、各々が実質的に同一の名前を有し、前記システムは、前記コンピュータの全てに利用可能なロック手段を含み、コンピュータ内の名前を付けられたオブジェクトを利用したいと望んでいるあらゆるコンピュータが、前記ロック手段から許可ロックを取得し、前記許可ロックにより前記利用が許可され、前記許可ロックが放棄されるまで前記他のコンピュータ全てがこれらの対応する名前を付けられたオブジェクトを利用するのが阻止されることを特徴とする多重コンピュータシステム。
【請求項２】
前記ロック手段は、ロック取得ルーチンとロック解放ルーチンとを含み、前記ルーチンの両方は、前記全てのコンピュータ上で実行される前記アプリケーションプログラムになされた修正に含まれることを特徴とする請求項１に記載のシステム。
【請求項３】
前記ロック手段は、いずれかの前記コンピュータによって使用される前記名前を付けられたオブジェクト、前記各オブジェクトのロック状態、及びいずれかの未決のロック取得の待ち行列をリストする共有テーブルを更に含むことを特徴とする請求項２に記載のシステム。
【請求項４】
前記ロック手段は、前記アプリケーションプログラムを実行しておらず、前記通信ネットワークに接続されている追加のコンピュータ内に位置付けられることを特徴とする請求項３に記載のシステム。
【請求項５】
前記各アプリケーションプログラムは、前記ロック取得ルーチン及び前記ロック解放ルーチンを挿入して、前記アプリケーションプログラムがオブジェクトに対するロックをそれぞれ取得及び解放する各インスタンスを修正することによって、ロード前、ロード中、又はロード後に修正されることを特徴とする請求項２に記載のシステム。
【請求項６】
前記アプリケーションプログラムは、ロード時の再コンパイル、ロード前の事前コンパイル、ロード前のコンパイル、実行時コンパイル、及びロード後で且つアプリケーションプログラムの前記関連部分の実行前の再コンパイルからなる手順のグループから選択される手順に従って修正されることを特徴とする請求項３に記載のシステム。
【請求項７】
前記修正アプリケーションプログラムは、マスタ／スレーブ転送、ブランチ転送、及びカスケード転送からなるグループから選択される手順に従って前記コンピュータの全てに転送されることを特徴とする請求項２に記載のシステム。
【請求項８】
通信リンクを介して相互接続され、単一のコンピュータでのみ動作するように各々記述されている少なくとも１つのアプリケーションプログラムを同時に実行する複数のコンピュータであって、
前記各コンピュータが前記アプリケーションプログラムの異なる部分をほぼ同時に実行し、前記アプリケーションプログラム部分を動作中の前記各コンピュータは、前記各コンピュータに物理的に位置付けられたローカルメモリ内にあるオブジェクトだけを利用し、前記各コンピュータによって利用される前記ローカルメモリのコンテンツは、基本的に類似しているが、各瞬間では同一でなく、前記コンピュータの全てのコンピュータが、１つのコンピュータだけによる前記ローカルオブジェクトの利用を許可するロック取得ルーチン及びロック解放ルーチンを有し、前記複数のコンピュータの残りの各々は、これらの対応するオブジェクトの利用からロックアウトされることを特徴とする複数のコンピュータ。
【請求項９】
前記又は前記各アプリケーションプログラムに割り当てられたローカルメモリ容量が実質的に同一であり、前記又は前記各アプリケーションプログラムが利用可能な総メモリ容量が、前記割り当てられたメモリ容量であることを特徴とする請求項８に記載の複数のコンピュータ。
【請求項１０】
前記分散更新手段の全ては、前記ローカルメモリ読み取り速度よりも遅いデータ転送速度で前記通信リンクを介して伝達することを特徴とする請求項８に記載の複数のコンピュータ。
【請求項１１】
前記コンピュータの少なくとも幾つかは、種々の製造業者によって製造され、及び／又は種々のオペレーティングシステムを有することを特徴とする請求項８に記載の複数のコンピュータ。
【請求項１２】
単一のコンピュータでのみ動作するように各々記述されている少なくとも１つのアプリケーションプログラムを複数のコンピュータ上で同時に実行する方法であって、前記コンピュータは、通信ネットワークによって相互接続されており、前記方法が、
（ｉ）前記コンピュータのうちの異なるコンピュータ上で前記アプリケーションプログラムの異なる部分を実行し、前記各部分について前記対応するコンピュータ内に実質的に同一な複数のオブジェクトを各々作成し、各々に実質的に同一の名前を持たせる段階と、
（ｉｉ）コンピュータ内の名前を付けられたオブジェクトを利用することを意図する前記コンピュータのいずれにも、前記利用を許可し、前記許可ロックが放棄されるまで前記他のコンピュータの全てがこれらの対応する名前を付けられたオブジェクトの利用を阻止する許可ロックを取得するように要求する段階と、
を含む方法。
【請求項１３】
（ｉｉｉ）前記通信ネットワークを介して前記コンピュータ間で伝達するための分散ランタイム手段を前記各コンピュータに提供する段階を更に含む請求項１２に記載の方法。
【請求項１４】
（ｉｖ）前記各分散ランタイム手段によってアクセス可能であり、オブジェクトに現在アクセスする必要のあるあらゆるコンピュータのアイデンティティを前記オブジェクトのアイデンティティと共に記憶される共有テーブルを提供する段階を更に含む請求項１３に記載の方法。
【請求項１５】
前記オブジェクトへのアクセスを求める前記コンピュータの数のカウントを記憶するカウンタ手段を前記共有テーブルに関連付ける段階（ｖ）を更に含む請求項１４に記載の方法。
【請求項１６】
前記共有プログラムが実行されておらず、前記共有テーブル及びカウンタをホストする追加のコンピュータを提供する段階であって、該追加のコンピュータが前記通信ネットワークに接続されている提供段階（ｖｉ）を更に含む求項１５に記載の方法。
【請求項１７】
単一のコンピュータでのみ動作するように記述されているが、通信ネットワークを介して相互接続された複数のコンピュータの異なるコンピュータ上でその異なる部分が各々ほぼ同時に実行されることになるアプリケーションプログラムの矛盾のない同期を保証する方法であって、前記方法が、
（ｉ）ロード時、又はロード前、又はロード後に前記アプリケーションプログラムを精査して、同期ルーチンを定義する各プログラム段階を検出する段階と、
（ｉｉ）前記同期ルーチンを修正して１つだけのコンピュータによるオブジェクトの利用を保証し、前記残りのコンピュータ全てがこれらの対応するオブジェクトを同時に利用することを阻止する段階と、
を含む方法。
【請求項１８】
前記段階（ｉｉ）が、
（ｉｉｉ）前記コンピュータの１つで前記同期ルーチンをロードし実行する段階と、
（ｉｖ）前記１つのコンピュータによって前記同期ルーチンを修正する段階と、
（ｖ）前記修正された同期ルーチンを前記残りのコンピュータの各々に転送する段階と、
を含む請求項１７に記載の方法。
【請求項１９】
前記修正された同期ルーチンは、前記１つのコンピュータによって前記残りのコンピュータの各々に直接提供されることを特徴とする請求項１８に記載の方法。
【請求項２０】
前記修正された同期ルーチンは、前記１つのコンピュータから前記残りのコンピュータの各々に順次にカスケード方式で提供されることを特徴とする請求項１８に記載の方法。
【請求項２１】
前記段階（ｉｉ）が、
（ｖｉ）前記コンピュータの１つに前記同期ルーチンをロードし修正する段階と、
（ｖｉｉ）前記１つのコンピュータが前記残りのコンピュータの各々に前記未修正の同期ルーチンを送信する段階と、
（ｖｉｉｉ）前記残りのコンピュータの各々が前記同期ルーチンを受信した後に前記同期ルーチンを修正する段階と、
を含む請求項１７に記載の方法。
【請求項２２】
前記未修正の同期ルーチンは、前記１つのコンピュータによって前記残りのコンピュータの各々に直接提供されることを特徴とする請求項２１に記載の方法。
【請求項２３】
前記未修正の同期ルーチンは、前記１つのコンピュータから前記残りのコンピュータの各々に順次にカスケード方式で提供されることを特徴とする請求項２１に記載の方法。
【請求項２４】
（ｉｘ）ロード時の再コンパイル、ロード前の事前コンパイル、ロード前のコンパイル、実行時コンパイル、及びロード後で且つアプリケーションプログラムの関連部分の実行前の再コンパイルからなる手順のグループから選択される手順を利用して前記アプリケーションプログラムを修正する段階を更に含む請求項１７に記載の方法。
【請求項２５】
（ｘ）マスタ／スレーブ転送、ブランチ転送、及びカスケード転送からなるグループから選択される手順を利用して前記コンピュータの全てに前記修正アプリケーションプログラムを転送する段階を更に含む請求項１７に記載の方法。
【請求項２６】
単一のコンピュータ上でのみ動作するように記述された単一のアプリケーションプログラムの個々のスレッドが、通信リンクを介して相互接続された複数のコンピュータのうちの対応するコンピュータ上で各々同時に処理されるマルチスレッド処理コンピュータオペレーションにおいて、
各スレッドを処理する前記コンピュータに物理的に関連付けられたローカルメモリ内のオブジェクトは、他の前記各コンピュータのローカルメモリ内に対応するオブジェクトを有し、前記コンピュータの１つだけがオブジェクトを利用することを許可する段階と、前記残りのコンピュータの全てがこれらの対応するオブジェクトを同時に利用するのを阻止する段階とを含む改良方法。
【請求項２７】
１つの前記スレッドに関連付けられたメモリに常駐し且つ利用されることになるオブジェクトは、前記１つのスレッドのコンピュータによって他の前記コンピュータ全てがアクセス可能な共有テーブルに伝達されるアイデンティティを有することを特徴とする請求項２６に記載の改良方法。
【請求項２８】
１つの前記スレッドに関連付けられたメモリに常駐し且つ利用されることになるオブジェクトは、別の前記スレッドに関連付けられた前記コンピュータに送信されるアイデンティティを有し、これによって前記他のコンピュータ全てがアクセス可能な共有テーブルに転送されることを特徴とする請求項２６に記載の改良方法。
【請求項２９】
記憶媒体内に記憶され、請求項１２又は１７に記載される方法の実行を複数のコンピュータに許可するように動作可能なプログラム命令のセットを含むコンピュータプログラム製品。
【請求項３０】
通信ネットワークを介して相互接続された複数のコンピュータにおいて、単一のコンピュータでのみ動作するように各々記述されているが前記コンピュータ上で同時に実行されるアプリケーションプログラムの矛盾のない初期化を保証するよう動作可能な複数のコンピュータであって、前記コンピュータは、請求項１２又は１７に記載の方法を実行するようプログラムされており、或いは請求項２９に記載のコンピュータプログラム製品がロードされていることを特徴とする複数のコンピュータ。
【発明の詳細な説明】
【技術分野】
【０００１】
本発明は、コンピュータに関し、詳細には、通信ネットワークを介して相互接続された複数のコンピュータ上で同時にアプリケーションプログラムを動作することができる改良型マシーンアーキテクチャに関する。
【背景技術】
【０００２】
コンピュータ及びコンピュータ関係の利用が出現して以来、コンピュータのソフトウェアは、単一のマシーン上で実行するように記述されてきた。図１に示されるように、当該従来技術の単一マシーン１は、バス４を介してメモリ３に接続された中央処理ユニット又はＣＰＵ２から構成される。また、モニタ５、キーボード６、及びマウス７のような単一マシーン１の種々の他の機能ユニットもバス４に接続されている。
【０００３】
マシーン１の性能に対する基本的制限は、ＣＰＵ２によって操作されるデータ及びこれらの操作の結果をバス４によって移動する必要があることである。バス４は、バスへのアクセスを要望するユニットによって形成されるいわゆるバス「待ち行列」、コンテンション問題、及び同様のものを含む幾つかの問題の影響を受ける。これらの問題は、キャッシュメモリを含む種々の方策によってある程度までは軽減することができるが、このような方策は、マシーン１の管理オーバーヘッドを必然的に増大させる。
【０００４】
当然、何年もの間マシーン性能を向上させる種々の試みがなされてきた。１つの手法は、対称的マルチプロセッサを使用することである。この従来技術の手法は、いわゆる「スーパー」コンピュータで使用されており、図２に概略的に示されている。ここで複数のＣＰＵ１２は、グローバルメモリ１３に接続されている。同様に、ボトルネックは、ＣＰＵ１２とメモリ１３との間の通信で発生する。このプロセスは、「シングルシステムイメージ」と呼ばれている。１つだけのアプリケーションと、グローバルメモリにわたり分散されるアプリケーション用のメモリの１つの全体コピーが存在する。単一のアプリケーションは、完全にトランスペアレントにいずれかのメモリロケーションとの間で読み込み及び書き込み（すなわち共有）を行うことができる。
【０００５】
ネットワークを介して相互接続された幾つかのこのようなマシーンが存在する場合には、これは、単一のマシーン用に記述された単一のアプリケーションを採用し、必要とされるメモリ資源を小部分に分割することによって達成される。次いで、これらの小部分は、幾つかのコンピュータにわたって分散され、全てのＣＰＵ１２がアクセス可能なグローバルメモリ１３を形成する。この手順は、単一の実行中のアプリケーションプログラムからメモリパーティションをマスキング又は隠すことに依存する。１つのマシーンの１つのＣＰＵが、異なるマシーン内に物理的に位置付けられたメモリロケーションにアクセス（ネットワークを介して）する必要がある場合には、性能が低下する。
【０００６】
スーパーコンピュータは、高速の計算速度を達成する点においては技術的に成功しているが、これらが本質的に複雑であることによって、製造だけでなく管理に対しても極めて高価なものである点で商業的には成功していない。特に、シングルシステムイメージの概念は、「製品」である（すなわち大量生産された）コンピュータ及びネットワークを越えて拡張することは決してできない。特に、シングルシステムイメージの概念は、超高速（及び従って極めて高価）ネットワークによって相互接続された超高速（及び同様に極めて高価）コンピュータ上でのみ実用的なアプリケーションが見られた。
【０００７】
複数のマシーンを使用することで増大されたコンピュータパワーの別の可能性は、図３に概略的に示されている分散コンピューティングの従来技術の概念から生じる。この公知の構成では、単一のアプリケーションプログラム（Ａｐ）は、その作成者（又はアプリケーションプログラムについてよく理解している別のプログラマー）によって種々の離散的タスクに区分され、例えば図３のケースｎが整数３である３つのマシーン上で実行できるようにする。ここでの目的は、マシーンＭ１．．．Ｍ３の各々がアプリケーション全体のうちで異なる１／３を実行することであり、更に、種々のマシーンに加えられる負荷をほぼ等しくすることである。マシーンは、通信リンク、インターネット、イントラネット、ローカルエリアネットワーク、及び同様のものなどの種々の形式で提供することができるネットワーク１４を介して通信する。通常、このようなネットワーク１４のオペレーションの速度は、個々のマシーンＭ１、Ｍ２、その他の各々におけるバス４のオペレーション速度よりもかなり遅い。
【０００８】
分散コンピューティングには幾つかの欠点がある。第１に、アプリケーションを分割するジョブは困難であり、これはマニュアルで行わなければならない。第２に、ネットワーク１４を介したデータ、部分的な結果、結果、及び同様のものの通信は、管理上のオーバーヘッドである。第３に、分割が必要であることにより、例えば３つに分割されたアプリケーションが４つのマシーン上ではうまく動作しないので、より多くのマシーンを用いることによって機能を高めることが極めて困難になる。第４に、マシーンの１つを無効にする必要がある場合、システム全体の性能がかなり低下する。
【０００９】
別の従来技術の構成は、図４に概略的に示された「クラスタ」を介したネットワークコンピューティングとして公知である。この方法では、アプリケーション全体がマシーンＭ１、Ｍ２．．．Ｍｎの各々にロードされる。各マシーンは、共通のデータベースと通信するが、他のマシーンとは直接通信しない。各マシーンは同じアプリケーションを実行するが、異なる「ジョブ」を実行しており、固有のメモリだけを使用する。これは、その各々が列車のチケットを一般の人に販売する幾つかの窓口に幾分類似している。この方法は機能を実行し、拡張可能であるが、大抵はネットワークを管理するのが難しいといった欠点がある。
【００１０】
ＪＡＶＡ及びＭＩＣＴＰＳＯＦＴ．ＮＥＴなどのコンピュータ言語には、プログラマーが扱う構成体の２つの主要なタイプがある。ＪＡＶＡ言語では、これらはオブジェクト及びクラスとして知られる。あらゆるコンピュータ環境において、このような資産、資源、又は構造を利用することでアプリケーションプログラムの一部が同時に同じ資源を用いようとするのを防ぐことを可能にするロックを取得及び解放することが必要である。ＪＡＶＡ環境では、これは同期として知られる。これは、ＪＡＶＡでは「ｍｏｎｔｏｒ  ｅｎｔｅｒ」及び「ｍｏｎｉｔｏｒ  ｅｘｉｔ」命令又はルーチンにより実現される。他の言語は異なる項を使用するが、類似の概念を利用する。
【発明の開示】
【００１１】
本発明は、アプリケーションプログラムが複数のコンピュータ上で同時に動作するコンピューティング環境を開示する。このような環境では、「ｍｏｎｔｏｒ  ｅｎｔｅｒ」及び「ｍｏｎｉｔｏｒ  ｅｘｉｔ」がマシーンの全てにわたって矛盾のない方式で確実に動作することが必要である。これが本発明の起源である矛盾のない資源ロックの目標である。
【００１２】
本発明の第１の態様によれば、単一のコンピュータでのみ動作するように各々記述されているが、通信ネットワークによって相互接続された複数のコンピュータ上で同時に実行する少なくとも１つのアプリケーションプログラムを有する多重コンピュータシステムであって、アプリケーションプログラムの異なる部分がコンピュータのうちの異なるコンピュータ上でほぼ同時に実行され、各部分において、同様の複数の実質的に同一のオブジェクトが対応するコンピュータに各々作成され、各々が実質的に同一の名前を有し、本システムは、コンピュータの全てに利用可能なロック手段を含み、コンピュータ内の名前を付けられたオブジェクトを利用したいと望んでいるあらゆるコンピュータが、ロック手段から許可ロックを取得し、許可ロックにより利用が許可され、許可ロックが放棄されるまで他のコンピュータ全てがこれらの対応する名前を付けられたオブジェクトを利用するのが阻止されることを特徴とする多重コンピュータシステムが開示される。
【００１３】
本発明の第２の態様によれば、通信リンクを介して相互接続され、単一のコンピュータでのみ動作するように各々記述されている少なくとも１つのアプリケーションプログラムを同時に実行する複数のコンピュータであって、各コンピュータがアプリケーションプログラムの異なる部分をほぼ同時に実行し、アプリケーションプログラム部分を動作中の各コンピュータは、各コンピュータに物理的に位置付けられたローカルメモリ内にあるオブジェクトだけを利用し、各コンピュータによって利用されるローカルメモリのコンテンツは、基本的に類似しているが、各瞬間では同一でなく、コンピュータの全てのコンピュータが、１つのコンピュータだけによるローカルオブジェクトの利用を許可するロック取得ルーチン及びロック解放ルーチンを有し、複数のコンピュータの残りの各々は、これらの対応するオブジェクトの利用からロックアウトされることを特徴とする複数のコンピュータが開示される。
【００１４】
本発明の第３の態様によれば、単一のコンピュータでのみ動作するように各々記述されている少なくとも１つのアプリケーションプログラムを複数のコンピュータ上で同時に実行する方法であって、前記コンピュータは、通信ネットワークによって相互接続されており、本方法が、（ｉ）コンピュータのうちの異なるコンピュータ上でアプリケーションプログラムの異なる部分を実行し、各部分について対応するコンピュータ内に同様の複数の実質的に同一のオブジェクトを各々作成し、各々に実質的に同一の名前を持たせる段階と、（ｉｉ）コンピュータ内の名前を付けられたオブジェクトを利用することを意図するコンピュータのいずれにも、利用を許可し、許可ロックが放棄されるまで他のコンピュータの全てがこれらの対応する名前を付けられたオブジェクトの利用を阻止する許可ロックを取得するように要求する段階と、を含む方法が開示される。
【００１５】
本発明の第４の態様によれば、単一のコンピュータでのみ動作するように記述されているが、通信ネットワークを介して相互接続された複数のコンピュータの異なるコンピュータ上でその異なる部分が各々ほぼ同時に実行されることになるアプリケーションプログラムの矛盾のない同期を保証する方法であって、本方法が、（ｉ）ロード時、又はロード前、又はロード後にアプリケーションプログラムを精査して、同期ルーチンを定義する各プログラム段階を検出する段階と、（ｉｉ）同期ルーチンを修正して１つだけのコンピュータによるオブジェクトの利用を保証し、残りのコンピュータ全てがこれらの対応するオブジェクトを同時に利用することを阻止する段階と、を含む方法が開示される。
【００１６】
本発明の第５の態様によれば、単一のコンピュータ上でのみ動作するように記述された単一のアプリケーションプログラムの個々のスレッドが、通信リンクを介して相互接続された複数のコンピュータのうちの対応するコンピュータ上で各々同時に処理されるマルチスレッド処理コンピュータオペレーションにおいて、各スレッドを処理するコンピュータに物理的に関連付けられたローカルメモリ内のオブジェクトは、他の各コンピュータのローカルメモリ内に対応するオブジェクトを有し、コンピュータの１つだけがオブジェクトを利用することを許可する段階と、残りのコンピュータの全てがこれらの対応するオブジェクトを同時に利用するのを阻止する段階とを含む改良が開示される。
【００１７】
本発明の第６の態様によれば、記憶媒体内に記憶され、上述の方法の実行を複数のコンピュータに許可するように動作可能なプログラム命令のセットを含むコンピュータプログラム製品が開示される。
【発明を実施するための最良の形態】
【００１８】
本発明の実施形態を図面を参照しながら説明する。
【００１９】
本明細書は、説明された実施形態の種々の態様を実装する実際のプログラムフラグメントを提供する添付書Ａ及びＤを含む。添付書Ａはフィールドに関し、添付書Ｄは同期化に関する。
【００２０】
図５に関連して、本発明の好ましい実施形態によれば、単一のアプリケーションプログラム５０は、ネットワーク５３を介して通信する幾つかのマシーンＭ１、Ｍ２．．．Ｍｎ上で同時に動作することができる。以下に明らかになるように、マシーンＭ１、Ｍ２．．．Ｍｎの各々は、各マシーンＭ１、Ｍ２．．．Ｍｎ上で同じアプリケーションプログラム５０で動作し、従って、マシーンＭ１、Ｍ２．．．Ｍｎの全ては、同じアプリケーションコード及びデータ５０を有する。同様に、マシーンＭ１、Ｍ２．．．Ｍｎの各々は、各マシーンＭ１、Ｍ２．．．Ｍｎ上の同じ（又は実質的に同じ）モディファイアー(modifier,変更子)５１で動作し、従って、マシーンＭ１、Ｍ２．．．Ｍｎの全ては、５１／２で示されるマシーンＭ２のモディファイアーと同じ（又は実質的に同じ）モディファイアー５１を有する。更に、各マシーンＭ１、Ｍ２．．．Ｍｎ上でのアプリケーション５０のロード中、又は実行前に、各アプリケーション５０は、同じ規則（又は僅かな最適化変更が各モディファイアー５１／１．．．５１／ｎで許可されているので、実質的に同じ規則）に従って対応するモディファイアー５１で修正されている。
【００２１】
上述の構成の結果として、マシーンＭ１、Ｍ２．．．Ｍｎの各々が、例えば１０ＭＢの共有メモリ容量を有する場合には、各アプリケーション５０が利用可能な合計共有メモリは、予想されるように１０ｎＭＢではなくむしろ１０ＭＢだけである。しかしながら、これによって改良されたオペレーションがどのように生じるかは、以下で明らかになるであろう。当然、各マシーンＭ１、Ｍ２．．．Ｍｎは、非共有メモリ容量を有する。マシーンＭ１、Ｍ２．．．Ｍｎの非共有メモリ容量は、通常ほぼ等しいが、必須ではない。
【００２２】
図６に概略的に示されるように仮想マシーンを作成することによって、アプリケーションの特定の言語でマシーン（種々の製造業者の１つによって生産され、種々の異なる言語の１つで動作するオペレーティングシステムを有する）を動作させることは従来技術から公知である。図６の従来技術の構成は、Ｊａｖａ言語で記述されＪａｖａ仮想マシーン６１内で実行するアプリケーション５０の形式を取る。従って、アプリケーションの目的とする言語がＪＡＶＡ言語である場合、マシーン製造業者及びマシーンの内部の詳細に関わらず、ＪＡＶＡコードを操作できるＪＡＶＡ仮想マシーンが作成される。更なる詳細については、米国のＳｕｎ  Ｍｉｃｒｏｓｙｓｔｅｍｓ  Ｉｎｃ．のＴ．Ｌｉｎｄｈｏｌｍ及びＦ．Ｙｅｌｌｉｎによる「Ｔｈｅ  ＪＡＶＡ  Ｖｉｒｔｕａｌ  Ｍａｃｈｉｎｅ  Ｓｐｅｃｉｆｉｃａｔｉｏｎ”  ２ｎｄ  Ｅｄｉｔｉｏｎ（ＪＡＶＡ仮想マシーン仕様）」第２版を参照されたい。
【００２３】
図６のこの公知の従来技術の構成は、図７に見られるように「分散ランタイム」又はＤＲＴ７１と便宜上呼ばれる付加的な機能を提供することによって、本発明の好ましい実施形態に従って修正される。図７では、アプリケーション５０は、矢印７５によって示されるロード手順で分散ランタイムシステム７１を介してＪａｖａ仮想マシーン７２にロードされる。分散ランタイムシステムは、分散コンピューティング環境（ＤＣＥ）の名称でＯｐｅｎ  Ｓｏｆｔｗａｒｅ  Ｆｏｕｎｄａｔｉｏｎから利用可能である。特に、分散ランタイム７１は、最初にＪＡＶＡ仮想マシーン７２を作成するように、ＪＡＶＡアプリケーション５０の矢印７５によって示されるロード手順中に作動し始める。ロード中のオペレーションのシーケンスは、図９に関して以下に説明する。
【００２４】
図８は、各々が図７に示されるようにＪＡＶＡ仮想マシーンを用いる図５の構成の修正された形式を示す。同様に同じアプリケーション５０が各マシーンＭ１、Ｍ２．．．Ｍｎにロードされることは明らかであろう。しかしながら、矢印８３によって示されているがマシーンハードウェアからは物理的に経路指定されている各マシーンＭ１、Ｍ２．．．Ｍｎ間の通信は、各マシーン内の個々のＤＲＴ７１／１．．．７１／ｎによって制御される。従って、実際にはこれは、マシーンＭ１、Ｍ２．．．Ｍｎ自体ではなくネットワーク７３を介して互いに通信しているＤＲＴ７１／１．．．７１／ｎとして概念化することができる。
【００２５】
ここで図７及び９を参照すると、ローディング手順７５の間、各ＪＡＶＡ仮想マシーン７２を作成するためにロードされているプログラム５０が修正される。この修正は図９の９０で開始し、ロードされているアプリケーション５０において全メモリロケーション（ＪＡＶＡではフィールドと呼ばれるが、他の言語でも同等の用語が使用される）を検出する初期ステップ９１を包含する。このようなメモリロケーションは、ステップ９２及び９３での連続した処理において識別される必要がある。ローディング手順７５中のＤＲＴ７１は、メモリロケーション全てのリストを作成し、このようにしてオブジェクト及びクラスによってリストされるＪＡＶＡフィールドを識別する。揮発性フィールド及び同期フィールドの両方がリストされる。
【００２６】
修正手順の次のステップ（図９の９２で示される）は、全処理動作を特定するために実行可能なアプリケーションコードをサーチすることであり、該全処理動作では、ステップ９１で作成されたリストに対応するフィールド値を操作又は変更し、これによって対応するメモリロケーションでの値が変更されるようにフィールドに書き込む。フィールド値を変更するこのようなオペレーション（通常、ＪＡＶＡ言語におけるｐｕｔｓｔａｔｉｃ又はｐｕｔｆｉｅｌｄ）が検出された場合、フィールドの値が変わったことを全ての他のマシーンに確実に通知されるように、ステップ９３で「更新伝播ルーチン(updating propagating routine)」がプログラムのこの場所に挿入される。その後、ロード手順は、図９のステップ９４によって示される通常の方法で続行される。
【００２７】
ロード中の初期修正の他の形式が図１０に示されている。ここで開始及びリスティングステップ９０及び９１並びにサーチステップ９２は、図９と同じである。しかしながら、処理スレッドが更新を実行するステップ９３で「更新伝播ルーチン」を挿入するのではなく、「警報ルーチン(alert routine)」がステップ１０３で挿入される。「警報ルーチン」は、処理に使用されずＤＲＴに割り当てられる１つ又は複数のスレッドに対し必要な伝播を実行するよう指示を与える。このステップ１０３は、より低いオーバーヘッドを生じる簡単な代替手段である。
【００２８】
ロード手順中にこの初期修正が行われると、次いで、図１１及び１２に示されるマルチスレッド処理オペレーションのいずれか１つが行われる。図１１で分かるように、スレッド１１１／１．．．１１１／４からなるマシーン上のマルチスレッド処理１１０が行われ、第２スレッド１１１／２の処理（この実施例での）では、スレッド１１１／２がフィールド値の変更をステップ１１３で認識することになる。このステップで、スレッド１１１／２の通常の処理はステップ１１４で停止し、同じスレッド１１１／２は、ステップ１１３で行われた変更フィールドのアイデンティティ及び変更値をネットワーク５３を介して全ての他のマシーンＭ２．．．Ｍｎに通知する。次いでステップ１１５で、当該通信手順の最後において、スレッド１１１／２は、フィールド値の変更がある次のインスタンスまで処理を再開する。
【００２９】
図１２に示された他の構成では、ステップ１１３でスレッド１２１／２がフィールド値の変更を認識すると、スレッド１２１／２は、ＤＲＴ処理１２０に割り当てられた別のスレッド１２１／１がステップ１２８によりネットワーク５３を介しステップ１１３で検出された変更フィールドのアイデンティティ及び変更値を全ての他のマシーンＭ２．．．Ｍｎに伝播するようにＤＲＴ処理１２０（ステップ１２５及び矢印１２７によって示されるように）に指示する。これは、迅速に実行できるオペレーションであり、すなわち、スレッド１１１／２がステップ１１５で処理を再開する前に、該初期スレッド１１１／２の処理は、ステップ１２５で示されるように瞬間的に中断される。次いで、変更（矢印１２７によって示されるような）を通知された他のスレッド１２１／１は、その変更をステップ１２８で示されるようにネットワーク５３を介して他のマシーンＭ２．．．Ｍｎの各々に伝達する。
【００３０】
図１２のこの第２の構成は、種々のスレッド１１１／１．．．１１１／３及び１２１／１（これらは一般に均等要求の影響を受けない）の処理能力をうまく利用し、増大する「ｎ」のサイズと共に良好な拡張を与える（ｎは２以上の整数であって、ネットワーク５３に接続されアプリケーションプログラム５０を同時に実行するマシーンの総数を表す）。どの構成が使用されるかに関わらず、ステップ１１３で検出された変更フィールド及びアイデンティティ及び値は、ネットワーク上の他のマシーンＭ２．．．Ｍｎ全てに伝播される。
【００３１】
これは図１３に示され、ＤＲＴ７１／１及び図１２のスレッド１２１／１（図１３のステップ１２８によって表わされる）は、マシーンＭ１での処理によってネットワーク５３を介して図１２のステップ１１３で作成されたリストされたメモリロケーションのアイデンティティ及び変更値を他のマシーンＭ２．．．Ｍｎの各々に送信する。
【００３２】
他のマシーンＭ２．．．Ｍｎの各々は、ネットワーク５３からアイデンティティと値のペアを受信し且つ新しい値をローカルの対応するメモリロケーションに書き込むことにより、マシーンＭｎのための図１３のステップ１３５及び１３６によって示された動作を実行する。
【００３３】
分散型ソフトウェアを利用する図３の従来技術の構成では、１つのマシーンのソフトウェアから別のマシーンに物理的に位置付けられたメモリへのメモリアクセスは、マシーンを相互接続するネットワークによって許可される。しかしながら、このようなメモリアクセスは、マシーンの中央処理ユニットの１０6−１０7サイクルのオーダーの処理に遅延を生じる可能性がある。これは大部分が、複数の相互接続されたマシーンの性能の低下に起因する。
【００３４】
しかしながら、図８に関して上述された本構成では、全フィールドの現在の値は、メモリの読み取り要求を生成する処理を実行しているマシーン上に記憶されるので、データの全読み取りがローカルで達成されることを理解されたい。このようなローカル処理は、中央処理ユニットの１０2−１０3サイクル内で達成することができる。従って、実際には読み取りを伴うメモリアクセスを実質的には待機することはない。
【００３５】
しかしながら、ほとんどのアプリケーションソフトウェアは、メモリを頻繁に読み取るが、書き込みは比較的まれにしか行わない。この結果、メモリの書き込み又は再書き込みの速度は、メモリの読み取り速度に比べて比較的遅い。メモリの書き込み又は再書き込みに対するこの低速の要求に起因して、フィールドは、低価格製品ネットワーク５３を介した比較的低速で頻繁に更新することができ、更にこの低速では、メモリへ書き込むためのアプリケーションプログラムの要求を満たすのに十分である。この結果、図８の構成の性能は、図３の構成よりも極めて優れていることになる。
【００３６】
上記に関連した別の修正形態において、変更フィールドのアイデンティティ及び値をバッチにグループ分けし、種々のマシーンを相互接続するネットワーク５３の通信速度に対する要求を更に低減することができる。
【００３７】
フィールドを最初に記録する際に各ＤＲＴ７１によって作成されたテーブルでは、各フィールドに対してネットワーク全体で共通であり且つネットワークが認識する名前又はアイデンティティが存在することは当業者には明らかであろう。しかしながら、個々のマシーンでは、各マシーンが固有の内部プロセスに従って異なるロケーションで変更フィールド値を漸次記憶するので、所与の名前付きフィールドに対応するメモリロケーションは時間と共に変わることになる。従って、ＤＲＴの各々におけるテーブルは、一般には異なるメモリロケーションを有するが、各グローバル「フィールド名」は、異なるメモリロケーション内に記憶された同じ「フィールド値」を有することになる。
【００３８】
ロード中のアプリケーションプログラムの上述の修正は、以下の最大５つの方法で達成可能であることが当業者には明らかであろう。
（ｉ）ロード時の再コンパイル
（ｉｉ）プリコンパイルによるロード前の処理
（ｉｉｉ）ロード前のコンパイル
（ｉｖ）「実行時」（ＪＩＴ）コンパイル、
（ｖ）ロード後の再コンパイル（しかしながら、又は例えば、分散環境での関連した又は対応するアプリケーションコードを実行する前）
【００３９】
従来、用語「コンパイル」とは、例えばソースからオブジェクトコード、又は１つの言語から別の言語へのコード又は言語における変更を意味する。明確には、本明細書において用語「コンパイル」（及びその文法的に等価なもの）の使用は同じコード又は言語内に限定されず、修正形態を含む又は包含することができる。
【００４０】
第１の実施形態において、特定のマシーン、例えばマシーンＭ２は、それ自体にアプリケーションコードをロードし、これを修正し、次いで他のマシーンＭ１、Ｍ３．．．Ｍｎの各々に（順次又は同時に）修正コードをロードする。「マスタ／スレーブ」と呼ぶ場合があるこの構成では、マシーンＭ１、Ｍ３、．．．Ｍｎの各々が、マシーンＭ２によって与えられるものをロードする。
【００４１】
更に別の実施形態において、各マシーンはアプリケーションコードを受け取るが、これを修正し、修正コードをそのマシーンにロードする。これによって、各マシーンが行う修正をそのアーキテクチャ及びオペレーティングシステムに基づき僅かに異なるように最適化することができ、更に全ての他の類似の修正と整合を取ることができる。
【００４２】
別の構成では、特定のマシーン、例えばＭ１は修正されていないコードをロードし、全ての他のマシーンＭ２、Ｍ３．．．Ｍｎは、オリジナルのアプリケーションコードを削除し修正されたバージョンをロードするよう修正を行う。
【００４３】
全ての事例において、供給は、ブランチ（すなわち、Ｍ２がＭ１、Ｍ３、Ｍ４などの各々に直接提供する）又はカスケード或いはシーケンシャル（すなわち、Ｍ２はＭ１に供給し、次にＭ１がＭ３に供給し、次いで、Ｍ３がＭ４に供給する、以下同じ）とすることができる。
【００４４】
更に別の構成では、Ｍ１からＭｎまでのマシーンは追加のマシーン（図示せず）に全てのロード要求を送ることができ、該追加マシーンは、アプリケーションプログラムを実行しておらず、前述の方法のいずれかを介して修正を行い、修正ルーチンをマシーンＭ１からＭｎまでの各々に返し、次いで、マシーンＭ１からＭｎがこの修正ルーチンをローカルにロードする。この構成では、マシーンＭ１からＭｎは、修正ルーチンを各マシーンに返すこの追加のマシーンに全ロード要求を転送する。この追加のマシーンによって行われる修正は、本発明の範囲内で保護される修正形態の全てを含むことができる。
【００４５】
コンピュータ関連技術に熟練した人であれば、コンピュータコードで修正を作製する際に使用される少なくとも４つの技術を認識することになる。第１は、オリジナル（ソース）言語で修正を行うことである。第２は、オリジナルコード（例えばＪＡＶＡでの）を中間表現（又は中間言語）に変換することである。この変換を行うと、修正がなされ、次いで逆変換される。これは、修正されたＪＡＶＡコードの要求結果をもたらす。
【００４６】
第３の可能性は、マシーンコードに（直接又は前述の中間言語を介して）変換することである。次にマシーンコードは修正された後、ロードされ実行される。第４の可能性は、オリジナルコードを中間表現に変換することであり、この中間表現は次に修正され、その後マシーンコードに変換される。
【００４７】
本発明は、全ての４つの修正ルートと、更にこのようなルートの２つ、３つ、又は４つ全部の組み合わせを包含する。
【００４８】
ここで図１４を参照すると、ＪＡＶＡ仮想マシーンとして動作する単一の従来技術のコンピュータの概略図が示されている。このように、マシーン（種々の製造業者のいずれか１つによって生産され、種々の異なる言語のいずれか１つで動作するオペレーティングシステムを有する）は、アプリケーションプログラム５０の特定の言語、この場合はＪＡＶＡ言語で動作することができる。すなわち、ＪＡＶＡ仮想マシーン７２は、ＪＡＶＡ言語でコード５０を動作させることができ、マシーン製造業者及びマシーンの内部詳細に関係なくＪＡＶＡアーキテクチャを利用することができる。
【００４９】
更に、図１４の単一のマシーンは、プログラマーが同期ルーチンを利用することで指定されたときに特定のオブジェクト５０Ｘ−５０Ｚの同期を容易に行うことができる。各オブジェクトはローカルにだけ存在するので、該オブジェクトが図１４の単一のＪＡＶＡ仮想マシーンはプログラマーによって指定された通りに適切に同期され、従って任意の単一時点で実行可能コードの一部で利用されるのを保証することができる。実行可能コードの別の部分が同じオブジェクトを使用することを望む場合には、可能性のあるコンテンションがＪＡＶＡ仮想マシーン７２により解消され、アプリケーションプログラムの他の実行中の部分は、先の部分が終了するまで待機するようにされる。
【００５０】
同じ手順は、クラス５０Ａに対して準用される。特に、ＪＡＶＡ言語及びアーキテクチャを使用してプログラムを記述するコンピュータプログラマーは、この競合を回避するために同期ルーチンを使用するだけでよい。従って、単一のＪＡＶＡ仮想マシーンは、クラス及びオブジェクトの利用度を把握し、目立たない方式で必要に応じてあらゆる対応する問題を防ぐことができる。１つだけのオブジェクト又はクラスが排他的に使用されるプロセスが「同期」と呼ばれる。ＪＡＶＡ言語において、命令「ｍｏｎｉｔｏｒｅｎｔｅｒ」及び「ｍｏｎｉｔｏｒｅｘｉｔ」は、同期ルーチンの開始と終了を表し、資産が競合の対象とならないようにする「ロック」の取得と解放をそれぞれもたらす。
【００５１】
しかしながら、図８（及び図２０−２２）に示される構成では、複数の個々のコンピュータ又はマシーンＭ１、Ｍ２．．．．Ｍｎが備えられ、その各々は通信ネットワーク５３を介して相互接続されており、その各々はモディファイアー５１（図５に示され、図８のＤＲＴ７１によって実現される）を備え、共通アプリケーションプログラム５０がロードされる。本質的に、モディファイアー５１又はＤＲＴ７１は、マシーンの１つで実行されるアプリケーションプログラム５０の一部が、オブジェクト５０Ｘ−５０Ｚ又はクラス５０Ａなどの特定のローカル資産を排他的に（例えば同期によって）利用する場合に、他のマシーンＭ２．．．Ｍｎがそのローカルメモリ内の対応する資産を利用しないことを保証する。
【００５２】
特に、１つの特定のマシーン（例えば、Ｍ３）は、あるオブジェクト又はクラスを排他的に使用し、別のマシーン（例えば、Ｍ５）はまた、そのオブジェクト又はクラスを同時に排他的に使用するようコードによって指示することができる。従って、オブジェクト又はクラスが両方のマシーンによって排他的に使用される場合には、全体的にオブジェクト及びアプリケーションの動作は定義されず、すなわち、プログラマーによって明確に指定されたオブジェクトの適切な排他的使用がない場合、マシーンＭ５とマシーンＭ３との間の恒久的な矛盾が起こる可能性が高い。従って、同じアプリケーションプログラムの同時オペレーションに必要とされるマシーンＭ１、Ｍ２．．．Ｍｎの各々についての実質的に同一のメモリコンテンツの目標は達成されないことになる。
【００５３】
矛盾のない同期を保証するために、アプリケーションプログラムは、同期ルーチンを定義するプログラムステップを検出するために精査される。この精査は、ロード前、又はロード手順中のいずれか、或いはロード手順後（且つアプリケーションコードの関連の対応する部分の実行前）でも行うことができる。用語「コンパイル」が通常は、コード又は言語における変更、例えばソースからオブジェクトコード、或いは１つの言語から別の言語への変更を伴うことを理解した上で、これはコンパイル手順に形容することができる。しかしながら、本実施例では、用語「コンパイル」（及び、その文法的に等価なもの）は、同じコード又は言語内に限定されず、同じコード又は言語内の修正を含み包含することができる。
【００５４】
付随の添付書Ｄを参照する。添付書Ｄ１は、未修正の同期ルーチンからの一般的コードフラグメントであり、添付書Ｄ２は、修正された同期ルーチンに関する等価物である。
【００５５】
添付書Ｄ１及びＤ２はそれぞれ、同期ルーチンの前及び後の抜粋である。本方法に追加される修正コードは、下線で強調されている。添付書Ｄ１のオリジナルコードサンプルでは、コードは、同期命令文内の共有メモリロケーション（カウンタ）をインクリメントする。同期命令文の目的は、マルチスレッドアプリケーションにおけるインクリメントオペレーションのスレッドの安全性を保証することである。従って、分散型環境での同期を管理することなく、各マシーンが分離して同期を行い、よって場合によっては同時に共有カウンタをインクリメントし、潜在的な競合条件（又は複数の競合条件）及び矛盾したメモリを生じることになる。明らかに、これはアプリケーションプログラムのプログラマーが発生を予想したものではない。
【００５６】
そこで、ＤＲＴを利用することで、アプリケーションコードは、同期ルーチンを変更することによってマシーンにロードされるときに修正される。行われた変更（下線で強調されている）は、同期ルーチンが実行する初期命令及び終了命令である。これらの追加された命令は、分散型環境で全ての他のマシーンにわたって追加して同期を行うように機能し、これによって複数のマシーン全体でアプリケーションプログラムの同期動作を保全する。
【００５７】
ＤＲＴのａｃｑｕｉｒｅＬｏｃｋ（）法は、このオブジェクトの一意の識別子を表わす引数（添付書Ｄ２を参照のこと）、例えばオブジェクトの名前、当該オブジェクトへの参照、又は全ノードにわたってこのオブジェクトを表わす固有の数字を取り、指定されたオブジェクトのグローバルロックを取得するのに使用される。このように、ＤＲＴは、複数のオブジェクトのどれが既に同期されており、どれが同期されていないかに関して混同することなく、各オブジェクトの一意の識別子を使用して共有同期テーブルの正確な記録に照会することにより同時に複数のオブジェクトの同期をサポートすることができる。
【００５８】
ＤＲＴは、幾つかの方法でオブジェクトの同期状態を判定することができる。ＤＲＴは、このオブジェクトのローカルコピーが現在同期されているかどうかを各マシーンに尋ね、いずれかのマシーンが真を返信した場合には、当該オブジェクトが同期されなくなるまで待機し、そうでなければこのオブジェクトをローカルで同期する。或いは、ローカルマシーン上のＤＲＴは、共有記録テーブル（場合によっては別個のマシーン（例えばマシーンＸ）上、或いはローカルマシーン上の矛盾のない共有記録テーブル、又はデータベース）に照会して、このオブジェクトがいずれかの他のマシーンによって同期にマークされているかどうかを判定し、同期にマークされている場合、オブジェクトの状態が「非同期」に変更されるまで待機し、次いで、オブジェクトを同期としてマークすることでロックを取得し、同期にマークされていない場合には、このマシーンによって同期されたものとしてオブジェクトにマークを付けることによってロックを取得する。
【００５９】
ＤＲＴが、このオブジェクトに対するロックを現在他のマシーンが有していない（すなわち、このオブジェクトを同期している他のマシーンはない）と判定した場合、例えば同期状態の共有テーブルにおける対応する入口を修正すること、或いは現在のマシーンに加えて全ての他のマシーン上でロックを順次取得することによって、全ての他のマシーン上でこのオブジェクトに対するロックを取得する。このオブジェクトを現在同期している他のマシーンが存在しないことをこのマシーンが正常に確認し、これに応じてこのマシーンがローカルに同期したときにのみ、オリジナル同期コードブロックの実行を開始することができる。
【００６０】
他方、別のマシーンがこのオブジェクトを既に同期していることをＤＲＴが判定すると、このマシーンは、このオブジェクトに対する同期命令文を現在実行している他のマシーンがないこと、及びこのマシーンがこれに応じてローカルでオブジェクトを同期したことをＤＲＴが確認できるようになるまでオリジナルコードブロックの実行を延期することになる。このような場合、オリジナルコードブロックは、同期された命令文の並行実行により生じる競合条件、メモリの不整合性、及びその他に起因して、関与するマシーン全体でオブジェクトを損傷させる場合があるので、このオブジェクトに対する同期命令文を実行している他のマシーンがないことをこのマシーンが保証できるまで実行されることになるＮＯＴである。従って、このオブジェクトが現在「同期されている」とＤＲＴが判定した場合、ＤＲＴは、対応する「ｒｅｌｅａｓｅＬｏｃｋ（）」オペレーションがロックの現在の所有者によって実行されるようになるまで、「ａｃｑｕｉｒｅＬｏｃｋ（）」オペレーションの実行を停止することによってオリジナルコードブロックの実行を阻止する。
【００６１】
従って、「ｒｅｌｅａｓｅＬｏｃｋ（）」オペレーションの実行時に、現在ロックを「所有」している（すなわち、同期命令文を実行している）マシーンは、例えば、同期状態の共有テーブルで「非同期」としてこのオブジェクトをマークすることによって、或いは全ての他のマシーンで取得されたロックを順次解放することによって、その同期命令文のクローズを指示する。この時点で、対応する同期命令文の実行開始を待機しているあらゆる他のマシーンは、例えば同期状態の共有テーブルにおいてこのオブジェクトに対する同期命令文を実行するものとして自己マークすること、或いは他のマシーンの各々でローカルロックを順次取得することなど、延期された（すなわち遅延された）「ａｃｑｕｉｒｅＬｏｃｋ（）」オペレーションの実行を再開することによって、このオブジェクトのロックの所有権を請求することができる。
【００６２】
そこで、ＤＲＴを利用して、アプリケーションコードは、同期ルーチン（開始（ｍｏｎｉｔｏｒｅｎｔｅｒ）及び終了「ｍｏｎｉｔｏｒｅｘｉｔ」命令（又は複数の命令）からなる）を変更することでマシーンにロードされるときに修正される。行われる変更（下線で強調されている）は、同期ルーチンが実行する初期命令である。これらの追加される命令は、このロックが別のマシーンによって既に取得されているかどうかをチェックする。このロックが別のマシーンによって取得されていない場合、このマシーンのＤＲＴは、このマシーンがロックを取得したことを全ての他のマシーンに通知し、これによって他のマシーンがこのロックに対して同期ルーチンを実行するのを中止させる。
【００６３】
ＤＲＴは、多くの方法でマシーンのロック状態を記録することができる。例えば、
１．同期ルーチンへの入口に応じて、ＤＲＴは各マシーンに個々に照会し、このロックが既に取得されているかどうかを確かめる。取得されている場合、ＤＲＴは、全ての他のマシーンがこの資産又はオブジェクトのロックをもはや所有しなくなるまで同期ルーチンの実行を停止する。取得されていない場合、ＤＲＴは、この同期ルーチンを実行する。
或いは、
２．同期ルーチンへの入口に応じて、ＤＲＴは、いずれかのマシーンが現在このロックを「所有」しているかどうかを示す記録の共有テーブル（例えば、共有データベース、又はしているマシーンの各々の共有テーブルのコピー）に照会する。所有している場合、ＤＲＴは、全ての他のマシーンがこのオブジェクトのロックをもはや所有しなくなるまでこのマシーンでの同期ルーチンの実行を停止する。所有していない場合、ＤＲＴは、このロックの所有者として共有テーブル（又は、例えば複数のマシーンに複数の記録のテーブルがある場合には複数のテーブル）にこのマシーンを記録し、次いで同期ルーチンを実行する。
【００６４】
同様に、ロックが解放され、すなわち同期ルーチンの実行が終了すると、ＤＲＴは、多くの他の方法でマシーンのロック状態を「未記録」にすることができる。例えば、
１．同期ルーチンへの出口に応じて、ＤＲＴは、もはやロックを所有していないことを互いのマシーンに個々に通知する。
或いは、
２．同期ルーチンへの出口に応じて、ＤＲＴは、このマシーンがこのロックを所有しているものとして記録されないように記録の共有テーブルにおいてこのロックされた資産又はオブジェクトについての記録を更新する。
【００６５】
また更に、ＤＲＴは、複数の他の方法でロックされたオブジェクトを取得することを要求しているマシーンを待ち行列に入れることができる。
例えば、
１．同期ルーチンへの入口に応じて、ＤＲＴは、特定のマシーンが現在所有しているマシーンによる解放時にロックの取得を望んでいることをロックされたオブジェクトの現在の所有者に通知する。他に待機しているマシーンがない場合、指定されたマシーンは、指定されたマシーンの関心のある記録をテーブル内に記憶し、ロックされたオブジェクトの同期ルーチンの出口に従って、次いでこのロックされたオブジェクトを取得できる待機中のマシーンに通知し、よってその同期ルーチンの実行を開始する。
２．同期ルーチンへの入口に応じて、ＤＲＴは、特定のマシーン（例えば、マシーンＭ６）がそのマシーン（例えば、マシーンＭ４）による解放時にロックの取得を望んでいることをロックされたオブジェクトの現在の所有者に通知する。そのマシーンＭ４が、このロックされたオブジェクトについて待機中のマシーンのその記録を照会した後で見つけられた場合、１つ又はそれ以上の待機しているマシーンが既にあることを見つけ、次いでこのロックされたオブジェクトを取得しようとしているマシーンのリストの最後にマシーンＭ６を追加するか、或いはＭ６からの要求を、最初の待機中のマシーン、又はいずれかの他の待機中のマシーンに転送し、その後、記録のこれらのテーブル内にマシーンＭ６を記録する。
３．同期ルーチンへの入口に応じて、ＤＲＴは、記録の共有テーブル（例えば、全てのマシーンがアクセス可能な共有データベースに記憶されたテーブル、又は実質的に類似の複数の別個のテーブル）に自己記録する。
【００６６】
また更に、ＤＲＴは、以下の他の方法でこのマシーンによる同期ルーチンの出口に応じてこのロックを取得するよう待ち行列に並んだ他のマシーンに通知できる。例えば、
１．同期ルーチンの出口に対応して、ＤＲＴは、ロックが解放されることを待機しているマシーンの１つ（例えば、待機中のマシーンの待ち行列内のこの第１のマシーン）に通知する。
２．同期ルーチンの出口に対応して、ＤＲＴは、ロックが解放されたことを待機しているマシーンの１つ（例えば、待機中のマシーンの待ち行列の第１マシーン）に通知し、更に、マシーン（例えば、このロックを待機している第２マシーン及び次のマシーン）の全待ち行列のコピーを供給する。このようにして、第２マシーンは、第１マシーンから待機中のマシーンのリストを引き継ぎ、これによってリストの下にある各マシーンがロックを取得した後解放するように待機中のマシーンの待ち行列の連続性を保証する。
【００６７】
上述の精査の間、「ｍｏｎｉｔｏｒｅｎｔｅｒ」及び「ｍｏｎｉｔｏｒｅｘｉｔ」命令（又は方法）は、最初に探され、見つけられた場合、修正コードが挿入されて、修正された同期ルーチンをもたらす。この修正ルーチンは、ロックを取得し解放する。この修正及びロードを実行できる幾つかの異なるモードが存在する。
【００６８】
図１５で分かるように、図８の一般的構成に対する修正は、マシーンＭ１、Ｍ２．．．Ｍｎがこれまでと同じであり、全マシーンで同じアプリケーションプログラム５０を同時に実行するようにされる。しかしながら、以前の構成は、ハウスキーピング機能、例えば、特に構造、資産、及び資源の同期を好都合に供給できるサーバーマシーンＸを備えることによって修正される。このようなサーバーマシーンＸは、その計算負荷が低いため、ＰＣなどの低価格製品コンピュータとすることができる。図１５の破線で示されるように、２つのサーバーマシーンＸ及びＸ＋１は、システムの全体的な信頼性を高める冗長性の目的で設けられる。２つのこのようなサーバーマシーンＸ及びＸ＋１が設けられる場合、これらは、クラスタ形態の二重マシーンのように動作するのが好ましい。
【００６９】
計算負荷をマシーンＭ１、Ｍ２．．．Ｍｎ全体にわたって分散させることができるときには、サーバーマシーンＸを設ける必要はない。或いは、１つのマシーンで動作されるデータベース（マスタ／スレーブタイプオペレーション）は、ハウスキーピング機能に用いることができる。
【００７０】
図１６は、実行すべき好ましい一般的な手順を示している。ロード１６１の開始後、実行される命令が順番に考慮され、全同期ルーチンがステップ１６２で示されるように検出される。ＪＡＶＡ言語では、これらは、「ｍｏｎｉｔｏｒｅｎｔｅｒ」及び「ｍｏｎｉｔｏｒｅｘｉｔ」命令である。他の言語では異なる項を使用する。
【００７１】
同期ルーチンが検出された場合、通常は別の命令をルーチンに挿入することによって修正される。或いは、修正命令をルーチンの前に挿入することもできる。修正が完了すると、ロード手順に進む。修正は、ステップ１６３で示されるように、「全ての他のマシーンでのロック取得」オペレーション及び「全ての他のマシーンでのロック解放」修正の形式を取るのが好ましい。
【００７２】
図１７は、修正の特定の形式を示している。最初に、同期される構造、資産、又は資源（ＪＡＶＡでは例えば５０Ａ、５０Ｘ−５０Ｙなどのクラス又はオブジェクトと呼ばれる）は、ステップ１７２によって示されるように全てのマシーンによってグローバルに使用できる名前又はタグが既に割り当てられている。これは、クラス又はオブジェクトが最初に初期化されるときに行われるのが好ましい。これは、サーバーマシーンＸによって維持されているテーブルを介して非常に好都合に行われる。このテーブルはまた、クラス又はオブジェクトの同期状態を含む。好ましい実施形態において、このテーブルはまた、この資産の使用を要求しているマシーンのアイデンティティを記憶する待ち行列構成を含む。
【００７３】
図１７のステップ１７３で示されるように、次の「ロック取得」要求がマシーンＸに送信され、その後、送信マシーンは、ステップ１７４で示されるようにロック取得が確認されるのを待機する。従って、グローバル名が既にロックされている（すなわち、対応する資産が、ロックの取得を提案しているマシーン以外の別のマシーンによって使用中である）場合、これは、オブジェクト又はクラスが現在の所有者によってアンロックされるまで、オブジェクト又はクラスの提案された同期ルーチンを停止しなければならないことを意味する。
【００７４】
或いは、グローバル名がロックされていない場合、これは、他のマシーンがこのクラス又はオブジェクトを使用していないことを意味し、ロック取得の確認は直ちに受信される。ロック取得の確認を受信した後、ステップ１７５で示されるように、同期ルーチンの実行の続行が許可される。
【００７５】
図１８は、ロックを放棄することを意図するアプリケーションプログラム実行中のマシーンによって行われる手順を示している。初期ステップは、ステップ１８１で示される。この提案しているマシーンのオペレーションは、ステップ１８３、１８４によって一時的に中断され、その後、返信がステップ１８４に対応してマシーンＸから受信され、次いでステップ１８５で示されるように実行が再開される。任意選択的に、ステップ１８２で示されるように、マシーンが要求しているロックの解放は、マシーンＸに行われている要求に先行してこのロックに対する「グローバル名」をルックアップするために行われる。このように、複数のマシーンの複数のロックは、相互に干渉することなく取得し解放することができる。
【００７６】
図１９は、「ロック取得」問い合わせ（図１７）に応答して、マシーンＸによって行われる動作を示している。ステップ１９１で「ロック取得」要求を受け取った後、ステップ１９２及び１９３でロック状態が判定され、ノー、すなわち名付けられた資源がフリーでない場合、問い合わせしているマシーンのアイデンティティは、待機中の取得要求待ち行列（又は形式）にステップ１９４で追加される。或いは、答えがイエスであり、すなわち、名付けられた資源がフリーである場合、対応する返信がステップ１９７で送られる。次いで、待機している問い合わせ中のマシーンは、図１７のステップ１７５を実行することによってこれに応じて同期ルーチンを実行することができる。イエスの応答に加えて、共有テーブルは、グローバルに名付けられた資産の状態が「ロック」に変更されるようにステップ１９６で更新される。
【００７７】
図２０は、図１８の「ロック解放」要求に応答してマシーンＸによって行われる動作を示している。ステップ２０１で「ロック解放」要求を受け取った後、マシーンＸは、任意選択的に、及び好ましくは、ロックを解放するよう要求しているマシーンが、ステップ２０２で示されるように実際にはロックの現在の所有者であることを確認する。次に、ステップ２０３で待ち行列状態が判定され、このロックを取得するよう待機しているものがいない場合、マシーンＸは、ステップ２０７で示されるようにこのロックを共有テーブルで「未所有」としてマークし、任意選択的にステップ２０８によって示されるように、要求しているマシーンに解放の確認を返信する。これによって、要求しているマシーンが図１８のステップ１８５を実行できるようになる。
【００７８】
或いは、イエス、すなわち他のマシーンがこのロックの取得を待機している場合、マシーンＸは、ステップ２０４で示されるように待ち行列において次のマシーンによって現在取得されたものとしてこのロックをマークし、次にステップ２０５で、ロック取得の確認を待ち行列に並んだマシーンに送り、この結果、ステップ２０６で示されるように待機しているマシーンの待ち行列から新しいロック所有者を消去する。
【００７９】
同期ルーチンを修正する基本的概念が与えられると、この概念を実装することができる幾つかの種々の方法が存在する。
【００８０】
第１の実施形態において、特定のマシーン、例えばマシーンＭ２は、自己に同期ルーチンをロードし、これを修正し、次いで他のマシーンＭ１、Ｍ３．．．Ｍｎの各々に（順次に又は同時に）修正同期ルーチンをロードする。「マスタ／スレーブ」と呼ぶ場合があるこの構成では、マシーンＭ１、Ｍ３、．．．Ｍｎの各々が、マシーンＭ２によって与えられるものをロードする。
【００８１】
この「マスタ／スレーブ」構成の変形形態では、マシーンＭ２は、該マシーンＭ２に未修正の形式で同期ルーチンをロードし、次いで他のマシーンに同期ルーチン全体を削除して、修正コードをロードする。従ってこの場合、修正は、同期ルーチンのバイパスではなく、１つを除いた全てのマシーン上での同期ルーチンの削除である。
【００８２】
更に別の実施形態では、各マシーンは、同期ルーチンを受け取るが、これを修正し修正ルーチンをそのマシーンにロードする。これによって、各マシーンが行う修正をそのアーキテクチャ及びオペレーティングシステムに基づき僅かに異なるように最適化することができ、更に全ての他の類似の修正と整合を取ることができるようになる。
【００８３】
別の構成では、特定のマシーン、例えばＭ１は、未修正の同期ルーチンをロードし、全ての他のマシーンＭ２、Ｍ３．．．Ｍｎは、オリジナルの同期ルーチンを削除し修正されたバージョンをロードするよう修正を行う。
【００８４】
全ての事例において、供給は、ブランチ（すなわち、Ｍ２がＭ１、Ｍ３、Ｍ４などの各々に直接提供する）又はカスケード或いはシーケンシャル（すなわち、Ｍ２がＭ１に印加し、次にＭ１がＭ３に供給し、次いでＭ３がＭ４に供給する、以下同じ）とすることができる。
【００８５】
更に別の構成では、マシーンＭ１からＭｎは、全ロード要求を追加のマシーンＸ（図１５）に送ることができ、該追加マシーンＸは、前述の方法のいずれかを介して修正を行い、修正ルーチンをマシーンＭ１からＭｎの各々に返し、次いで修正ルーチンをローカルにロードする。この構成では、マシーンＭ１からＭｎは、全ロード要求をマシーンＸに転送し、マシーンＸは、修正ルーチンを各マシーンに返す。マシーンＸによって行われる修正は、本発明の範囲内で保護される修正の全てを含むことができる。
コンピュータ関連技術に熟練した人であれば、コンピュータコードで修正を作成する際に使用される４つの技術を認識することになる。第１は、オリジナル（ソース）言語で修正を行うことである。第２は、オリジナルコード（例えばＪＡＶＡでの）を中間表現（又は中間言語）に変換することである。この変換を行うと、修正がなされ、次いで逆変換される。これは、修正されたＪＡＶＡコードの要求結果をもたらす。
【００８６】
第３の可能性は、マシーンコードに（直接又は前述の中間言語を介して）変換することである。次にマシーンコードは修正された後、ロードされ実行される。第４の可能性は、オリジナルコードを中間表現に変換することであり、この中間表現は次に修正され、その後マシーンコードに変換される。
【００８７】
本発明は、全ての４つの修正ルートと、更にこのようなルートの２つ、３つ、又は４つ全部の組み合わせを包含する。
【００８８】
ここで図２１−２３を参照すると、２つのラップトップコンピュータ１０１及び１０２が示されている。コンピュータ１０１及び１０２は、必ずしも同一でなくともよく、実際には、１つはＩＢＭ又はＩＢＭクローンで、他方がＡＰＰＬＥコンピュータとすることができる。コンピュータ１０１及び１０２は、２つのモニタ１０５、１１５及び２つのキーボード１０６、１１６と、単一のマウス１０７とを有する。２つのマシーン１０１、１０２は、単一の同軸ケーブル又はツイストペアケーブル３１４手段によって相互接続されている。
【００８９】
２つのシンプルアプリケーションプログラムは、マシーン１０１、１０２の各々にダウンロードされ、このプログラムは上述のようにロードされるときに修正される。この実施形態において、第１アプリケーションは、シンプル計算器プログラムであり、モニタ１０５上に表示される計算器１０８のイメージをもたらす。第２プログラムは、異なる色であり且つ矩形ボックス３１０内をランダムに動き回る４つのカラーブロック１０９を表示するグラフィックプログラムである。同様にロード後に、ボックス３１０はモニタ１０５上に表示される。各アプリケーションはブロック１０９がモニタ１０５上でランダムに移動しているように独立して動作すると同時に、計算器１０８内の数字は数学的演算子（加算又は乗算など）と共に（マウス１０７を用いて）選択され、計算器１０８が結果を表示することができるようになる。
【００９０】
マウス１０７を用いて、ボックス３１０を「把持」し、これを右方向にモニタ１０５を越えてモニタ１１５上に移動させ、図２２に示された状況に到るようにすることができる。この構成では、計算器アプリケーションがマシーン１０１上で処理されている間、ボックス３１０の表示をもたらすグラフィックアプリケーションはマシーン１０２上で処理されている。
【００９１】
しかしながら、図２３に示されるようにマウス１０７を用いることで、図２２に示されるように計算器１０８を右側にドラッグし、計算器１０８の一部をモニタ１０５、１１５の各々で表示させることができる。同様に、図２２に示されるボックス３１０は、マウス１０７を用いて左側にドラッグすることができ、その結果、ボックス３１０は図２３に示されるようにモニタ１０５、１１５の各々で部分的に表示されるようになる。この構成では、計算器オペレーションの部分は、マシーン１０１とマシーン１０２の一部上で実行されていると同時に、グラフィックアプリケーションの部分はマシーン１０１で実行されており、残りはマシーン１０２で実行されている。
【００９２】
上記は、本発明の幾つかの実施形態だけを説明しており、当業者であれば本発明の範囲から逸脱することなく本発明に対し修正を行うことができる点は明らかであろう。例えば、ＪＡＶＡへの言及は、ＪＡＶＡ言語と更にＪＡＶＡプラットフォーム及びアーキテクチャの両方を含む。
【００９３】
プログラミング技術に熟練した者であれば、付加的なコード又は命令が既存のコード又は命令セットに挿入されてこれを修正する場合、既存のコード又は命令セットは、オフセット、分岐、属性、マークアップ、及び同様のものが作成されるような追加の修正（例えば、シーケンシャル命令の再ナンバリングによって）を必要とする場合があることを認識するであろう。
【００９４】
同様に、ＪＡＶＡ言語でのメモリロケーションは、例えばフィールド及びアレイタイプの両方を含む。上記の説明は、フィールドを扱っており、アレイタイプに必要な変更は、本質的に同じ準用である。また本発明は、Ｍｉｃｒｏｓｏｆｔ．ＮＥＴプラットフォーム及びアーキテクチャ（ＶｉｓｕａｌＢａｓｉｃ、ＶｉｓｕａｌＣ／Ｃ++、及びＣ＃）のＦＯＲＴＲＡＮ、Ｃ／Ｃ++、ＣＯＢＯＬ、ＢＡＳＩＣなどを含むＪＡＶＡに類似したプログラミング言語（手続き、宣言、及びオブジェクト指向を含む）に対して等しく適用可能である。
【００９５】
ＪＡＶＡ同期化ルーチンのコードが修正される上述の実施形態は、各マシーンＭ１．．．Ｍｎのランタイムシステム（例えば、Ｃ及びＪＡＶＡで記述されたＪＡＶＡ  ＨＯＴＳＰＯＴ  ＶＩＲＴＵＡＬ  ＭＡＣＨＩＮＥ）又はオペレーティングシステム（例えば、Ｃ及びアセンブラで記述されたＬＩＮＵＸ）のいずれかが、通常はローカルマシーン（例えばＭ２）でロックを取得し、他のあらゆるマシーン（Ｍ１．．．Ｍｎ）では取得されないことになる仮定に基づく。ＪＡＶＡ同期化ルーチンを未修正のままにし、その代わりにロックをローカルに取得するＬＩＮＵＸ又はＨＯＴＳＰＯＴルーチンを修正することが可能であり、その結果、これに伴い他の全てのマシーンでも同様にロックを取得するようになる。このような構成を包含するために、用語「同期化ルーチン」は、ＪＡＶＡ同期化ルーチン、並びにＪＡＶＡ同期化ルーチンとロックの取得及び解放を実行するＬＩＮＵＸ又はＨＯＴＳＰＯＴコードフラグメントとの「組み合わせ」の両方がその範囲に含まれることになると理解すべきである。
【００９６】
本明細書で使用される用語オブジェクト及びクラスは、ＪＡＶＡ環境から生じたものであり、ダイナミックリンクライブラリ（ＤＬＬ）、或いはオブジェクトコードパッケージ、或いは関数ユニット又はメモリロケーションのような異なる環境から派生した類似語を包含するものとする。
【００９７】
本明細書で使用される用語「備える」（及びその文法的変形形態）は、「有する」又は「含む」といった包括的な意味で使用され、「だけからなる」という排他的意味では使用されない。
【００９８】
著作権表示
本特許出願は、著作権保護の下にある資料を含む。著作権所有者（出願人）は、審査の目的で公的に利用可能な関連する特許庁ファイルからこの特許明細書又は関連資料を複製することに異議はないが、これ以外は如何なるものも無断転載が禁じられている。特に、種々の命令は、著作権所有者によって具体的に文書による承諾なしにコンピュータに入力されるべきではない。
【００９９】
添付書Ａ
以下は、ＪＡＶＡ言語でのプログラムリストである。
Ａ１．この第１の抜粋は、修正コードの一部である。これは、コードアレイをサーチし、ｐｕｔｓｔａｔｉｃ命令（ｏｐｃｏｄｅ１７８）を見つけると、修正を実行する。
// 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
【０１０１】
Ａ３．この第３の抜粋は、ＤＲＴ送信の一部である。このコードフラグメントは、別々のスレッドのＤＲＴを示しており、通知された後にネットワーク全体に値を送信する。
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.
*  <br><br>
*  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. 
*  <br><br> 
*  This is intentionally left as package protected as we
*  should not normally call this constructor directly.
*  <br><br>
*  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 <i>code</i> 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);
}
}
【０１３５】
添付書Ｄ１
Method void run()
0 getstatic #2 <Field java.lang.Object LOCK>
3 dup
4 astore_1
5 monitorenter
6 getstatic #3 <Field int counter>
9 iconst_1
10 iadd
11 putstatic #3 <Field int counter>
14 aload_1
15 monitorexit
16 return
【０１３６】
添付書Ｄ２
Method void run()
0 getstatic #2 <Field java.lang.Object LOCK>
3 dup
4 astore_1
5 dup
6 monitorenter
7 invokestatic #23 <Method void acquireLock(java.lang.Object)>
10 getstatic #3 <Field int counter>
13 iconst_1
14 iadd
15 putstatic #3 <Field int counter>
18 aload_1
19 dup
20 invokestatic #24 <Method void releaseLock(java.lang.Object)>
23 monitorexit
24 return
【０１３７】
添付書Ｄ３
import java.lang.*;
public class example{
/** Shared static field. */
public final static Object LOCK = new Object();
/** Shared static field. */
public static int counter = 0;
/** Example method using synchronization. This method serves to 
illustrate the use of synchronization to implement thread-safe 
modification of a shared memory location by potentially multiple 
threads. */
public void run(){
// First acquire the lock, otherwise any memory writes we do will be 
// prone to race-conditions.
synchronized (LOCK){
// Now that we have acquired the lock, we can safely modify memory 
// in a thread-safe manner.
counter++;
}
}
}
【０１３８】
添付書Ｄ４
import java.lang.*;
import java.util.*;
import java.net.*;
import java.io.*;
public class LockClient{
/** 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 ACQUIRE_LOCK = 10;
public final static int RELEASE_LOCK = 20;
/** LockServer network values. */
public final static String serverAddress =     
System.getProperty(“LockServer_network_address”);
public final static int serverPort = 
Integer.parseInt(System.getProperty(“LockServer_network_port”));
/** Table of global ID's for local objects. (hashcode-to-globalID 
mappings) */
public final static Hashtable hashCodeToGlobalID = new Hashtable();
/** Called when an application is to acquire a lock. */
public static void acquireLock(Object o){
// First of all, we need to resolve the globalID for object 'o'.
// To do this we use the hashCodeToGlobalID table.
int globalID = ((Integer) hashCodeToGlobalID.get(o)).intValue();
try{
// Next, we want to connect to the LockServer, which will grant us 
// the global lock.
Socket socket = new Socket(serverAddress, serverPort);
DataOutputStream out =
new DataOutputStream(socket.getOutputStream());
DataInputStream in = new DataInputStream(socket.getInputStream());
// Ok, now send the serialized request to the lock server.
out.writeInt(ACQUIRE_LOCK);
out.writeInt(globalID);
out.flush();
// Now wait for the reply.
int status = in.readInt();// This is a blocking call.  So we 
// will wait until the remote side 
// sends something.
if (status == NACK){
throw new AssertionError(
“Negative acknowledgement. Request failed.”);
}else if (status != ACK){
throw new AssertionError(“Unknown acknowledgement: ”
+ status + “. Request failed.”);
}
// Close down the connection.
out.writeInt(CLOSE);
out.flush();
out.close();
in.close();
socket.close();// Make sure to close the socket.
// This is a good acknowledgement, thus we can return now because 
// global lock is now acquired.
return;
}catch (IOException e){
throw new AssertionError(“Exception: ” + e.toString());
}
}
/** Called when an application is to release a lock. */
public static void releaseLock(Object o){
// First of all, we need to resolve the globalID for object 'o'.
// To do this we use the hashCodeToGlobalID table.
int globalID = ((Integer) hashCodeToGlobalID.get(o)).intValue();
try{
// Next, we want to connect to the LockServer, which records us as 
// the owner of the global lock for object 'o'.
Socket socket = new Socket(serverAddress, serverPort);
DataOutputStream out =
new DataOutputStream(socket.getOutputStream());
DataInputStream in = new DataInputStream(socket.getInputStream());
// Ok, now send the serialized request to the lock server.
out.writeInt(RELEASE_LOCK);
out.writeInt(globalID);
out.flush();
// Now wait for the reply.
int status = in.readInt();// This is a blocking call.  So we 
// will wait until the remote side 
// sends something.
if (status == NACK){
throw new AssertionError(
“Negative acknowledgement. Request failed.”);
}else if (status != ACK){
throw new AssertionError(“Unknown acknowledgement: ”
+ status + “. Request failed.”);
}
// Close down the connection.
out.writeInt(CLOSE);
out.flush();
out.close();
in.close();
socket.close();    // Make sure to close the socket.
// This is a good acknowledgement, return because global lock is 
// now released.
return;
}catch (IOException e){
throw new AssertionError(“Exception: ” + e.toString());
}
}
}
【０１３９】
添付書Ｄ５
import java.lang.*;
import java.util.*;
import java.net.*;
import java.io.*;
public class LockServer 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 ACQUIRE_LOCK = 10;
public final static int RELEASE_LOCK = 20;
/** LockServer network values. */
public final static int serverPort = 20001;
/** Table of lock records. */
public final static Hashtable locks = new Hashtable();
/** Linked list of waiting LockManager objects. */
public LockServer next = null;
/** Address of remote LockClient. */
public final String address;
/** Private input/output objects. */
private Socket socket = null;
private DataOutputStream outputStream;
private DataInputStream inputStream;
public static void main(String[] s)
throws Exception{
System.out.println(“LockServer_network_address=”
+ InetAddress.getLocalHost().getHostAddress());
System.out.println(“LockServer_network_port=” + serverPort);
// Create a serversocket to accept incoming lock operation 
// connections.
ServerSocket serverSocket = new ServerSocket(serverPort);
while (!Thread.interrupted()){
// Block until an incoming lock operation connection.
Socket socket = serverSocket.accept();
// Create a new instance of LockServer to manage this lock 
// operation connection.
new Thread(new LockServer(socket)).start();
}
}
/** Constructor. Initialise this new LockServer instance with necessary 
resources for operation. */
public LockServer(Socket s){
socket = s;
try{
outputStream = new DataOutputStream(s.getOutputStream());
inputStream = new DataInputStream(s.getInputStream());
address = s.getInetAddress().getHostAddress();
}catch (IOException e){
throw new AssertionError(“Exception: ” + e.toString());
}
}
/** Main code body. Decode incoming lock operation requests and execute 
accordingly. */
public void run(){
try{
// All commands are implemented as 32bit integers.
// Legal commands are listed in the “protocol specific values” 
// fields above.
int command = inputStream.readInt();
// Continue processing commands until a CLOSE operation.
while (command != CLOSE){
if (command == ACQUIRE_LOCK){       // This is an 
// ACQUIRE_LOCK 
// operation.
// Read in the globalID of the object to be locked.
int globalID = inputStream.readInt();
// Synchronize on the locks table in order to ensure thread-
// safety.
synchronized (locks){
// Check for an existing owner of this lock.
LockServer lock = (LockServer) locks.get(
new Integer(globalID));
if (lock == null){// No-one presently owns this lock, 
// so acquire it.
locks.put(new Integer(globalID), this);
acquireLock();  // Signal to the client the 
// successful acquisition of this 
// lock.
}else{               // Already owned. Append ourselves 
// to end of queue.
// Search for the end of the queue. (Implemented as 
// linked-list)
while (lock.next != null){
lock = lock.next;
}
lock.next = this;// Append this lock request at end.
}
}
}else if (command == RELEASE_LOCK){// This is a 
// RELEASE_LOCK 
// operation.
// Read in the globalID of the object to be locked.
int globalID = inputStream.readInt();
// Synchronize on the locks table in order to ensure thread-
// safety.
synchronized (locks){
// Check to make sure we are the owner of this lock.
LockServer lock = (LockServer) locks.get(
new Integer(globalID));
if (lock == null){
throw new AssertionError(“Unlocked. Release failed.”);
}else if (lock.address != this.address){
throw new AssertionError(“Trying to release a lock ”
+ “which this client doesn't own. Release ”
+ “failed.”);
}
lock = lock.next;
lock.acquireLock();// Signal to the client the 
// successful acquisition of this 
// lock.
// Shift the linked list of pending acquisitions forward 
// by one.
locks.put(new Integer(globalID), lock);
// Clear stale reference.
next = null;
}
releaseLock(); // Signal to the client the successful 
// release of this lock.
}else{             // Unknown command.
throw new AssertionError(
“Unknown command. Operation failed.”);
}
// Read in the next command.
command = inputStream.readInt();
}
}catch (Exception e){
throw new AssertionError(“Exception: ” + e.toString());
}finally{
try{
// Closing down. Cleanup this connection.
outputStream.flush();
outputStream.close();
inputStream.close();
socket.close();
}catch (Throwable t){
t.printStackTrace();
}
// Garbage these references.
outputStream = null;
inputStream = null;
socket = null;
}
}
/** Send a positive acknowledgement of an ACQUIRE_LOCK operation. */
public void acquireLock() throws IOException{
outputStream.writeInt(ACK);
outputStream.flush();
}
/** Send a positive acknowledgement of a RELEASE_LOCK operation. */
public void releaseLock() throws IOException{
outputStream.writeInt(ACK);
outputStream.flush();
}
}
【０１４０】
添付書Ｄ６
Lock Loader.java
この引用は、ロード時にアプリケーションを修正するLock Loaderのソースコードである。
import java.lang.*;
import java.io.*;
import java.net.*;
public class LockLoader extends URLClassLoader{
public LockLoader(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 enterindex and exitindex.
int enterindex = -1;
int exitindex = -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) == 194){     // Opcode for a 
// MONITORENTER 
// instruction.
changed = true;
// Next, realign the code array, making room for the 
// insertions.
byte[][] code2 = new byte[ca.code.length+2][];
System.arraycopy(ca.code, 0, code2, 0, z);
code2[z+1] = ca.code[z];
System.arraycopy(ca.code, z+1, code2, z+3,
ca.code.length-(z+1));
ca.code = code2;
// Next, insert the DUP instruction.
ca.code[z] = new byte[1];
ca.code[z][0] = (byte) 89;
// Finally, insert the INVOKESTATIC instruction.
if (enterindex == -1){
// This is the first time this class is encourtering the 
// acquirelock 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(“LockClient”);
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(“acquireLock”);
cf.constant_pool[cf.constant_pool.length-4] = u1;
u1 = new CONSTANT_Utf8_info(“(Ljava/lang/Object;)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;
enterindex = cf.constant_pool.length-1;
}
ca.code[z+2] = new byte[3];
ca.code[z+2][0] = (byte) 184;
ca.code[z+2][1] = (byte) ((enterindex >> 8) & 0xff);
ca.code[z+2][2] = (byte) (enterindex & 0xff);
// And lastly, increase the CODE_LENGTH and ATTRIBUTE_LENGTH 
// values.
ca.code_length += 4;
ca.attribute_length += 4;
z += 1;
}else if ((ca.code[z][0] & 0xff) == 195){// Opcode for a 
// MONITOREXIT 
// instruction.
changed = true;
// Next, realign the code array, making room for the 
// insertions.
byte[][] code2 = new byte[ca.code.length+2][];
System.arraycopy(ca.code, 0, code2, 0, z);
code2[z+1] = ca.code[z];
System.arraycopy(ca.code, z+1, code2, z+3,
ca.code.length-(z+1));
ca.code = code2;
// Next, insert the DUP instruction.
ca.code[z] = new byte[1];
ca.code[z][0] = (byte) 89;
// Finally, insert the INVOKESTATIC instruction.
if (exitindex == -1){
// This is the first time this class is encourtering the 
// acquirelock 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(“LockClient”);
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(“releaseLock”);
cf.constant_pool[cf.constant_pool.length-4] = u1;
u1 = new CONSTANT_Utf8_info(“(Ljava/lang/Object;)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;
exitindex = cf.constant_pool.length-1;
}
ca.code[z+2] = new byte[3];
ca.code[z+2][0] = (byte) 184;
ca.code[z+2][1] = (byte) ((exitindex >> 8) & 0xff);
ca.code[z+2][2] = (byte) (exitindex & 0xff);
// And lastly, increase the CODE_LENGTH and ATTRIBUTE_LENGTH 
// values.
ca.code_length += 4;
ca.attribute_length += 4;
z += 1;
}
}
// 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);
}
}
}
【図面の簡単な説明】
【０１４１】
【図１】従来のコンピュータの内部アーキテクチャを示す概略図である。
【図２】公知の対称型多重プロセッサの内部アーキテクチャを示す概略図である。
【図３】従来技術の分散コンピューティングを示す概略図である。
【図４】クラスタを使用した従来技術のネットワークコンピューティングを示す概略図である。
【図５】本発明の第１の実施形態に従って同じアプリケーションプログラムを実行する複数のマシーンを示す概略ブロック図である。
【図６】ＪＡＶＡコードを動作させ、これによってＪＡＶＡ仮想マシーンを構成するように配置された従来技術のコンピュータを示す概略図である。
【図７】図６に類似しているが、好ましい実施形態に従ってコードの初期ロードを示す図である。
【図８】図５に類似しているが、図７に示された方式でＪＡＶＡコードを各々が実行する複数のコンピュータの相互接続を示す図である。
【図９】ネットワーク内の各マシーンでの同じアプリケーションのロード中に行われる手順を示すフローチャートである。
【図１０】図９の手順に類似した修正された手順を示すフローチャートである。
【図１１】メモリ更新の第１の実施形態を利用して図８のマシーンで実行されるマルチスレッド処理を示す概略図である。
【図１２】図１１に類似した他の実施形態を示す概略図である。
【図１３】図８のコンピュータに対するマルチスレッドメモリ更新を示す図である。
【図１４】ＪＡＶＡコードで動作し、これによってＪＡＶＡ仮想マシーンを構成するように配置された従来技術のコンピュータを示す概略図である。
【図１５】アプリケーションプログラムを実行し、付加的なサーバーマシーンＸによってサービスされるｎ個のマシーンを示す概略図である。
【図１６】ｍｏｎｉｔｏｒｅｎｔｅｒ及びｅｘｉｔルーチンの修正を示すフローチャートである。
【図１７】ロックの取得要求におけるマシーンの処理に従うプロセスを示すフローチャートである。
【図１８】ロックの解放の要求を示すフローチャートである。
【図１９】図１７の要求に対するサーバーマシーンＸの応答のフローチャートである。
【図２０】図１８の要求に対するサーバーマシーンＸの応答を示すフローチャートである。
【図２１】複数のアプリケーションを同時に実行するために相互接続され、両方とも単一のコンピュータ上で実行されるアプリケーションを備えた２つのラップトップコンピュータを示す概略図である。
【図２２】図２１に類似した図であり、各コンピュータで実行される１つのアプリケーションを備えた図２１の装置を示す図である。
【図２３】図２１及び２２に類似した図であり、両方のコンピュータ上で同時に実行される両方のアプリケーションを備えた図２１の装置を示す図である。
【符号の説明】
【０１４２】
５０  アプリケーション
５３  ネットワーク
７１  ＤＲＴ
【図１】
2007534064.tif 000003
【図２】
2007534064.tif 000004
【図３】
2007534064.tif 000005
【図４】
2007534064.tif 000006
【図５】
2007534064.tif 000007
【図６】
2007534064.tif 000008
【図７】
2007534064.tif 000009
【図８】
2007534064.tif 000010
【図９】
2007534064.tif 000011
【図１０】
2007534064.tif 000012
【図１１】
2007534064.tif 000013
【図１２】
2007534064.tif 000014
【図１３】
2007534064.tif 000015
【図１４】
2007534064.tif 000016
【図１５】
2007534064.tif 000017
【図１６】
2007534064.tif 000018
【図１７】
2007534064.tif 000019
【図１８】
2007534064.tif 000020
【図１９】
2007534064.tif 000021
【図２０】
2007534064.tif 000022
【図２１】
2007534064.tif 000023
【図２２】
2007534064.tif 000024
【図２３】
2007534064.tif 000025
【国際調査報告】
2007534064.tif 000026
2007534064.tif 000027
2007534064.tif 000028