U.S. patent application number 11/259761 was filed with the patent office on 2006-11-23 for computer architecture and method of operation for multi-computer distributed processing with synchronization.
Invention is credited to John Matthew Holt.
Application Number | 20060265704 11/259761 |
Document ID | / |
Family ID | 37114615 |
Filed Date | 2006-11-23 |
United States Patent
Application |
20060265704 |
Kind Code |
A1 |
Holt; John Matthew |
November 23, 2006 |
Computer architecture and method of operation for multi-computer
distributed processing with synchronization
Abstract
The present invention discloses a modified computer architecture
(50, 71, 72) which enables an applications program (50) to be run
simultaneously on a plurality of computers (M1, . . . Mn). Shared
memory at each computer is updated with amendments and/or
overwrites so that all memory read requests are satisfied locally.
During initial program loading (75), or similar, instructions which
result in the application program (50) acquiring (or releasing) a
lock on a particular asset (50A, 50X-50Y) (synchronization) are
identified. Additional instructions are inserted (162, 163) to
result in a modified synchronization routine with which all
computers are updated.
Inventors: |
Holt; John Matthew;
(Lindfield, AU) |
Correspondence
Address: |
PERKINS COIE LLP
P.O. BOX 2168
MENLO PARK
CA
94026
US
|
Family ID: |
37114615 |
Appl. No.: |
11/259761 |
Filed: |
October 25, 2005 |
Current U.S.
Class: |
717/169 |
Current CPC
Class: |
G06F 8/456 20130101;
G06F 15/16 20130101 |
Class at
Publication: |
717/169 |
International
Class: |
G06F 9/44 20060101
G06F009/44 |
Foreign Application Data
Date |
Code |
Application Number |
Apr 21, 2005 |
AU |
2005 902 023 |
Apr 21, 2005 |
AU |
2005 902 024 |
Apr 21, 2005 |
AU |
2005 902 025 |
Apr 21, 2005 |
AU |
2005 902 026 |
Apr 21, 2005 |
AU |
2005 902 027 |
Apr 22, 2005 |
WO |
PCT/AU05/00582 |
Apr 22, 2005 |
WO |
PCT/AU05/00578 |
Apr 22, 2005 |
WO |
PCT/AU05/00581 |
Apr 22, 2005 |
WO |
PCT/AU05/00579 |
Apr 22, 2005 |
WO |
PCT/AU05/00580 |
Claims
1. A multiple computer system having at least one application
program each written to operate on only a single computer but
running simultaneously on a plurality of computers interconnected
by a communications network, wherein different portions of said
application program(s) execute substantially simultaneously on
different ones of said computers and for each portion a like
plurality of substantially identical objects are created, each in
the corresponding computer and each having a substantially
identical name, and said system including a lock means applicable
to all said computers wherein any computer wishing to utilize a
named object therein acquires an authorizing lock from said lock
means which permits said utilization and which prevents all the
other computers from utilizing their corresponding named object
until said authorizing lock is relinquished.
2. The system as claimed in claim 1 wherein said lock means
includes an acquire lock routine and a release lock routine, and
both said routines are included in modifications made to said
application program running on all said computers.
3. The system as claimed in claim 2 wherein said lock means further
includes a shared table listing said named objects in use by any
said computer, a lock status for each said object, and a queue of
any pending lock acquisitions.
4. The system as claimed in claim 3 wherein said lock means is
located within an additional computer not running said application
program and connected to said communications network.
5. The system as claimed in claim 2 wherein each said application
program is modified before, during, or after loading by inserting
said acquire lock routine and said release lock routine to modify
each instance at which said application program acquires and
releases respectively a lock on an object.
6. The system as claimed in claim 3 wherein the application program
is modified in accordance with a procedure selected from the group
of procedures consisting of re-compilation at loading,
pre-compilation prior to loading, compilation prior to loading,
just-in-time compilation, and re-compilation after loading and
before execution of the relevant portion of application
program.
7. The system as claimed in claim 2 wherein said modified
application program is transferred to all said computers in
accordance with a procedure selected from the group consisting of
master/slave transfer, branched transfer and cascaded transfer.
8. A plurality of computers interconnected via a communications
link and operating simultaneously at least one application program
each written to operate on only a single computer, wherein each
said computer substantially simultaneously executes a different
portion of said application program(s), each said computer in
operating its application program portion utilizes an object only
in local memory physically located in each said computer, the
contents of the local memory utilized by each said computer is
fundamentally similar but not, at each instant, identical, and
every one of said computers has an acquire lock routine and a
release lock routine which permit utilization of the local object
only by one computer and each of the remainder of said plurality of
computers is locked out of utilization of their corresponding
object.
9. The plurality of computers as claimed in claim 8 wherein the
local memory capacity allocated to the or each said application
program is substantially identical and the total memory capacity
available to the or each said application program is said allocated
memory capacity.
10. The plurality of computers as claimed in claim 8 wherein all
said distribution update means communicate via said communications
link at a data transfer rate which is substantially less than the
local memory read rate.
11. The plurality of computers as claimed in claim 8 wherein at
least some of said computers are manufactured by different
manufacturers and/or have different operating systems.
12. A method of running simultaneously on a plurality of computers
at least one application program each written to operate only on a
single computer, said computers being interconnected by means of a
communications network, said method comprising the steps of: (i)
executing different portions of said application program(s) on
different ones of said computers and for each said portion creating
a like plurality of substantially identical objects each in the
corresponding computer and each having a substantially identical
name, and (ii) requiring any of said computers wishing to utilize a
named object therein to acquire an authorizing lock which permits
said utilization and which prevents all the other computers from
utilizing their corresponding named object until said authorizing
lock is relinquished.
13. A method as claimed in claim 12 including the further step of:
(iii) providing each said computer with a distributed run time
means to communicate between said computers via said communications
network.
14. A method as claimed in claim 13 including the further step of:
(iv) providing a shared table accessible by each said distributed
run time means and in which is stored the identity of any computer
which currently has to access an object, together with the identity
of the object.
15. A method as claimed in claim 14 including the further step of:
(v) associating a counter means with said shared table, said
counter means storing a count of the number of said computers which
seek access to said object.
16. A method as claimed in claim 15 including the further step of:
(vi) providing an additional computer on which said shared program
does not run and which hosts said shared table and counter, said
additional computer being connected to said communications
network.
17. A method of ensuring consistent synchronization of an
application program written to operate only on a single computer
but different portions of which are to be executed substantially
simultaneously each on a different one of a plurality of computers
interconnected via a communications network, said method comprising
the steps of: (i) scrutinizing said application program at, or
prior to, or after loading to detect each program step defining an
synchronization routine, and (ii) modifying said synchronization
routine to ensure utilization of an object by only one computer and
preventing all the remaining computers from simultaneously
utilizing their corresponding objects.
18. The method claimed in claim 17 wherein step (ii) comprises the
steps of: (iii) loading and executing said synchronization routine
on one of said computers, (iv) modifying said synchronization
routine by said one computer, and (v) transferring said modified
synchronization routine to each of the remaining computers.
19. The method as claimed in claim 18 wherein said modified
synchronization routine is supplied by said one computer direct to
each of said remaining computers.
20. The method as claimed in claim 18 wherein said modified
synchronization routine is supplied in cascade fashion from said
one computer sequentially to each of said remaining computers.
21. The method claimed in claim 17 wherein step (ii) comprises the
steps of: (vi) loading and modifying said synchronization routine
on one of said computers, (vii) said one computer sending said
unmodified synchronization routine to each of the remaining
computers, and (viii) each of said remaining computers modifying
said synchronization routine after receipt of same.
22. The method claimed in claim 21 wherein said unmodified
synchronization routine is supplied by said one computer directly
to each of said remaining computers.
23. The method claimed in claim 21 wherein said unmodified
synchronization routine is supplied in cascade fashion from said
one computer sequentially to each of said remaining computers.
24. The method as claimed in claim 17 including the further step
of: (ix) modifying said application program utilizing a procedure
selected from the group of procedures consisting of re-compilation
at loading, pre-compilation prior to loading, compilation prior to
loading, just-in-time compilation, and re-compilation after loading
and before execution of the relevant portion of application
program.
25. The method as claimed in claim 17 including the further step
of: (x) transferring the modified application program to all said
computers utilizing a procedure selected from the group consisting
of master/slave transfer, branched transfer and cascaded
transfer.
26. In a multiple thread processing computer operation in which
individual threads of a single application program written to
operate only on a single computer are simultaneously being
processed each on a corresponding different one of a plurality of
computers interconnected via a communications link, and in which
objects in local memory physically associated with the computer
processing each thread have corresponding objects in the local
memory of each other said computer, the improvement comprising
permitting only one of said computers to utilize an object and
preventing all the remaining computers from simultaneously
utilizing their corresponding object.
27. The improvement as claimed in claim 26 wherein an object
residing in the memory associated with one said thread and to be
utilized has its identity communicated by the computer of said one
thread to a shared table accessible by all other said
computers.
28. The improvement as claimed in claim 26 wherein an object
residing in the memory associated with one said thread and to be
utilized has its identity transmitted to the computer associated
with another said thread and is transmitted thereby to a shared
table accessible by all said other computers.
29. A computer program product comprising a set of program
instructions stored in a storage medium and operable to permit a
plurality of computers to carry out the method as claimed in claim
12.
30. A plurality of computers interconnected via a communication
network and operable to ensure consistent initialization of an
application program written to operate only on a single computer
but running simultaneously of said computers, said computers being
programmed to carry out the method as claimed in claim 12.
31. A computer program product comprising a set of program
instructions stored in a storage medium and operable to permit a
plurality of computers to carry out the method as claimed in claim
17.
32. A plurality of computers interconnected via a communication
network and operable to ensure consistent initialization of an
application program written to operate only on a single computer
but running simultaneously of said computers, said computers being
programmed to carry out the method as claimed in claim 17.
33. A plurality of computers interconnected via a communication
network and operable to ensure consistent initialization of an
application program written to operate only on a single computer
but running simultaneously of said computers, said computers being
loaded with the computer program product as claimed in claim
29.
34. A plurality of computers interconnected via a communication
network and operable to ensure consistent initialization of an
application program written to operate only on a single computer
but running simultaneously of said computers, said computers being
loaded with the computer program product as claimed in claim 31.
Description
RELATED APPLICATIONS
[0001] This application claims the benefit of priority under ore or
more of 35 U.S.C. 119 and/or 35 U.S.C. 120 to the following
Australian Patent Applications, U.S. Utility patent applications
and PCT International Patent Applications, each of which is also a
related application and each is incorporated herein by reference in
its entirety:
[0002] U.S. patent application Ser. No. ______ filed 25 Oct. 2005
entitled "Computer Architecture And Method Of Operation For
Multi-Computer Distributed Processing With Replicated Memory";
[0003] U.S. patent application Ser. No. ______ filed 25 Oct. 2005
entitled "Computer Architecture And Method Of Operation For
Multi-Computer Distributed Processing With Initilization Of
Objects";
[0004] U.S. patent application Ser. No. ______ filed 25 Oct. 2005
entitled "Computer Architecture And Method Of Operation For
Multi-Computer Distributed Processing With Finalization Of
Objects";
[0005] U.S. patent application Ser. No. ______ filed 25 Oct. 2005
entitled "Computer Architecture And Method Of Operation For
Multi-Computer Distributed Processing With Synchronization";
[0006] U.S. patent application Ser. No. ______ filed 25 Oct. 2005
entitled "Computer Architecture And Method Of Operation For
Multi-Computer Distributed Processing And Coordinated Memory And
Asset Handling";
[0007] Australian Provisional Patent Application No. 2005 902 023
filed 21 Apr. 2005 entitled "Multiple Computer Architecture with
Replicated Memory Fields";
[0008] Australian Provisional Patent Application No. 2005 902 024
filed 21 Apr. 2005 entitled "Modified Computer Architecture with
Initialization of Objects";
[0009] Australian Provisional Patent Application No. 2005 902 025
filed 21 Apr. 2005 entitled "Modified Computer Architecture with
Finalization of Objects";
[0010] Australian Provisional Patent Application No. 2005 902 026
filed 21 Apr. 2005 entitled "Modified Computer Architecture with
Synchronization of Objects";
[0011] Australian Provisional Patent Application No. 2004 902 027
filed 21 Apr. 2005 entitled "Modified Computer Architecture with
Coordinated Objects";
[0012] U.S. patent application Ser. No. 11/111,757 filed 22 Apr.
2005 entitled "Multiple Computer Architecture with Replicated
Memory Fields";
[0013] U.S. patent application Ser. No. 11/111,781 filed 22 Apr.
2005 entitled "Modified Computer Architecture with Initialization
of Objects";
[0014] U.S. patent application Ser. No. 11/111,778 filed 22 Apr.
2005 entitled "Modified Computer Architecture with Finalization of
Objects";
[0015] U.S. patent application Ser. No. 11/111,779 filed 22 Apr.
2005 entitled "Modified Computer Architecture with Synchronization
of Objects";
[0016] U.S. patent application Ser. No. 11/111,946 filed 22 Apr.
2005 entitled "Modified Computer Architecture with Coordinated
Objects";
[0017] PCT International Application No. PCT/AU05/000/582 filed 22
Apr. 2005 entitled "Multiple Computer Architecture with Replicated
Memory Fields";
[0018] PCT International Application No. PCT/AU05/000/578 filed 22
Apr. 2005 entitled "Modified Computer Architecture with
Initialization of Objects";
[0019] PCT International Application No. PCT/AU05/000/581 filed 22
Apr. 2005 entitled "Modified Computer Architecture with
Finalization of Objects";
[0020] PCT International Application No. PCT/AU05/000/579 filed 22
Apr. 2005 entitled "Modified Computer Architecture with
Synchronization of Objects"; and
[0021] PCT International Application No. PCT/AU05/000/580 filed 22
Apr. 2005 entitled "Modified Computer Architecture with Coordinated
Objects".
[0022] A further related patent application that is hereby
incorporated by reference is U.S. patent application Ser. No.
10/830,042 filed 23 Apr. 2004 entitled "Modified Computer
Architecture".
FIELD OF THE INVENTION
[0023] The present invention relates to computers and other
computing machines and information appliances, in particular, to a
modified computer architecture and program structure which enables
the operation of an application program concurrently or
simultaneously on a plurality of computers interconnected via a
communications link using a distributed runtime and enables
improved performance to be achieved.
BACKGROUND OF THE INVENTION
[0024] Ever since the advent of computers, and computing, software
for computers has been written to be operated upon a single
machine. As indicated in FIG. 1, that single prior art machine 1 is
made up from a central processing unit, or CPU, 2 which is
connected to a memory 3 via a bus 4. Also connected to the bus 4
are various other functional units of the single machine 1 such as
a screen 5, keyboard 6 and mouse 7.
[0025] A fundamental limit to the performance of the machine 1 is
that the data to be manipulated by the CPU 2, and the results of
those manipulations, must be moved by the bus 4. The bus 4 suffers
from a number of problems including so called bus "queues" formed
by units wishing to gain an access to the bus, contention problems,
and the like. These problems can, to some extent, be alleviated by
various stratagems including cache memory, however, such stratagems
invariably increase the administrative overhead of the machine
1.
[0026] Naturally, over the years various attempts have been made to
increase machine performance. One approach is to use symmetric
multi-processors. This prior art approach has been used in so
called "super" computers and is schematically indicated in FIG. 2.
Here a plurality of CPU's 12 are connected to global memory 13.
Again, a bottleneck arises in the communications between the CPU's
12 and the memory 13. This process has been termed "Single System
Image". There is only one application and one whole copy of the
memory for the application which is distributed over the global
memory. The single application can read from and write to, (i.e.
share) any memory location completely transparently.
[0027] Where there are a number of such machines interconnected via
a network, this is achieved by taking the single application
written for a single machine and partitioning the required memory
resources into parts. These parts are then distributed across a
number of computers to form the global memory 13 accessible by all
CPU's 12. This procedure relies on masking, or hiding, the memory
partition from the single running application program. The
performance degrades when one CPU on one machine must access (via a
network) a memory location physically located in a different
machine.
[0028] Although super computers have been technically successful in
achieving high computational rates, they are not commercially
successful in that their inherent complexity makes them extremely
expensive not only to manufacture but to administer. In particular,
the single system image concept has never been able to scale over
"commodity" (or mass produced) computers and networks. In
particular, the Single System Image concept has only found
practical application on very fast (and hence very expensive)
computers interconnected by very fast (and similarly expensive)
networks.
[0029] A further possibility of increased computer power through
the use of a plural number of machines arises from the prior art
concept of distributed computing which is schematically illustrated
in FIG. 3. In this known arrangement, a single application program
(Ap) is partitioned by its author (or another programmer who has
become familiar with the application program) into various discrete
tasks so as to run upon, say, three machines in which case n in
FIG. 3 is the integer 3. The intention here is that each of the
machines M1 . . . M3 runs a different third of the entire
application and the intention is that the loads applied to the
various machines be approximately equal. The machines communicate
via a network 14 which can be provided in various forms such as a
communications link, the internet, intranets, local area networks,
and the like. Typically the speed of operation of such networks 14
is an order of magnitude slower than the speed of operation of the
bus 4 in each of the individual machines M1, M2, . . . , Mn.
[0030] Distributed computing suffers from a number of
disadvantages. Firstly, it is a difficult job to partition the
application and this must be done manually. Secondly, communicating
data, partial results, results and the like over the network 14 is
an administrative overhead. Thirdly, the need for partitioning
makes it extremely difficult to scale upwardly by utilising more
machines since the application having been partitioned into, say
three, does not run well upon four machines. Fourthly, in the event
that one of the machines should become disabled, the overall
performance of the entire system is substantially degraded.
[0031] A further prior art arrangement is known as network
computing via "clusters" as is schematically illustrated in FIG. 4.
In this approach, the entire application is loaded onto each of the
machines M1, M2, . . . , Mn. Each machine communicates with a
common database but does not communicate directly with the other
machines. Although each machine runs the same application, each
machine is doing a different "job" and uses only its own memory.
This is somewhat analogous to a number of windows each of which
sell train tickets to the public. This approach does operate, is
scalable and mainly suffers from the disadvantage that it is
difficult to administer the network.
[0032] In computer languages such as for example JAVA and
MICROSOFT.NET there are two major types of constructs with which
programmers deal. In the JAVA language these are known as objects
and classes. More generally they may be referred to as assets.
Every time an object (or other asset) is created there is an
initialization routine run known as an object initialization (e.g.,
"<init>") routine. Similarly, every time a class is loaded
there is a class initialization routine known as "<clinit>".
Other languages use different terms but utilize a similar concept.
In either case, however, there is no equivalent "clean up" or
deletion routine to delete an object or class (or other asset) once
it is no longer required. Instead, this "clean up" happens
unobtrusively in a background mode.
[0033] Furthermore, in any computer environment it is necessary to
acquire and release a lock to enable the use of such objects,
classes, assets, resources or structures to avoid different parts
of the application program from attempting to use the same objects,
classes, assets, resources or structures at the one time. In the
JAVA environment this is known as synchronization. Synchronization
more generally refers to the exclusive use of an object, class,
resource, structure, or other asset to avoid contention between and
among computers or machines. This is achieved in JAVA by the
"monitor enter" and "monitor exit" instructions or routines. Other
languages use different terms but utilize a similar concept.
[0034] Unfortunately, conventional computing systems,
architectures, and operating schemes do not provide for computing
environments and methods in which an application program can
operate simultaneously on an arbitrary plurality of computers where
the environment and operating scheme ensure that the abovementioned
memory management, initialization, clean up and synchronization
procedures operate in a consistent and coordinated fashion across
all the computing machines.
SUMMARY
[0035] The present invention discloses a computing environment in
which an application program operates simultaneously on a plurality
of computers. In such an environment it is advantageous to ensure
that the abovementioned asset initialization, clean-up and
synchronization procedures operate in a consistent and coordinated
fashion across all the machines.
[0036] In accordance with a first aspect of the present invention
there is disclosed a multiple computer system having at least one
application program each written to operate on only a single
computer but running simultaneously on a plurality of computers
interconnected by a communications network, wherein different
portions of said application program(s) execute substantially
simultaneously on different ones of said computers, wherein each
computer has an independent local memory accessible only by the
corresponding portion of said application program(s) and wherein
for each said portion a like plurality of substantially identical
objects are created, each in the corresponding computer.
[0037] In accordance with a second aspect of the present invention
there is disclosed A plurality of computers interconnected via a
communications link and each having an independent local memory and
substantially simultaneously operating a different portion at least
one application program each written to operate on only a single
computer, each local memory being accessible only by the
corresponding portion of said application program.
[0038] In accordance with a third aspect of the present invention
there is disclosed a method of running simultaneously on a
plurality of computers at least one application program each
written to operate on only a single computer, said computers being
interconnected by means of a communications network and each having
an independent local memory, said method comprising the step of:
(i) executing different portions of said application program(s) on
different ones of said computers and for each said portion creating
a like plurality of substantially identical objects each in the
corresponding computer and each accessible only by the
corresponding portion of said application program.
[0039] In accordance with a fourth aspect of the present invention
there is disclosed a method of loading an application program
written to operate only on a single computer onto each of a
plurality of computers, the computers being interconnected via a
communications link, and different portions of said application
program(s) being substantially simultaneously executable on
different computers with each computer having an independent local
memory accessible only by the corresponding portion of said
application program(s), the method comprising the step of modifying
the application before, during, or after loading and before
execution of the relevant portion of the application program.
[0040] In accordance with a fifth aspect of the present invention
there is disclosed a method of operating simultaneously on a
plurality of computers all interconnected via a communications link
at least one application program each written to operate on only a
single computer, each of said computers having at least a minimum
predetermined local memory capacity, different portions of said
application program(s) being substantially simultaneously executed
on different ones of said computers with the local memory of each
computer being only accessible by the corresponding portion of said
application program(s), said method comprising the steps of: (i)
initially providing each local memory in substantially identical
condition, (ii) satisfying all memory reads and writes generated by
each said application program portion from said corresponding local
memory, and (iii) communicating via said communications link all
said memory writes at each said computer which take place locally
to all the remainder of said plurality of computers whereby the
contents of the local memory utilised by each said computer,
subject to an updating data transmission delay, remains
substantially identical.
[0041] In accordance with a sixth aspect of the present invention
there is disclosed A method of compiling or modifying an
application program written to operate on only a single computer
but to run simultaneously on a plurality of computers
interconnected via a communications link, with different portions
of said application program(s) executing substantially
simultaneously on different ones of said computers each of which
has an independent local memory accessible only by the
corresponding portion of said application program, said method
comprising the steps of: (i) detecting instructions which share
memory records utilizing one of said computers, (ii) listing all
such shared memory records and providing a naming tag for each
listed memory record, (iii) detecting those instructions which
write to, or manipulate the contents of, any of said listed memory
records, and (iv) activating an updating propagation routine
following each said detected write or manipulate instruction, said
updating propagation routine forwarding the re-written or
manipulated contents and name tag of each said re-written or
manipulated listed memory record to the remainder of said
computers.
[0042] In accordance with a seventh aspect of the present invention
there is disclosed in a multiple thread processing computer
operation in which individual threads of a single application
program written to operate on only a single computer are
simultaneously being processed each on a different corresponding
one of a plurality of computers each having an independent local
memory accessible only by the corresponding thread and each being
interconnected via a communications link, the improvement
comprising communicating changes in the contents of local memory
physically associated with the computer processing each thread to
the local memory of each other said computer via said
communications link.
[0043] In accordance with a eighth aspect of the present invention
there is disclosed a multiple computer system having at least one
application program each written to operate on only a single
computer but running simultaneously on a plurality of computers
interconnected by a communications network, wherein different
portions of said application program(s) execute substantially
simultaneously on different ones of said computers and for each
portion a like plurality of substantially identical objects are
created, each in the corresponding computer and each having a
substantially identical name, and said system including a lock
mechanism or lock means applicable to all said computers wherein
any computer wishing to utilize a named object therein acquires an
authorizing lock from said lock means which permits said
utilization and which prevents all the other computers from
utilizing their corresponding named object until said authorizing
lock is relinquished.
[0044] In accordance with a ninth aspect of the present invention
there is disclosed a plurality of computers interconnected via a
communications link and operating simultaneously at least one
application program each written to operate on only a single
computer, wherein each said computer substantially simultaneously
executes a different portion of said application program(s), each
said computer in operating its application program portion utilizes
an object only in local memory physically located in each said
computer, the contents of the local memory utilized by each said
computer is fundamentally similar but not, at each instant,
identical, and every one of said computers has an acquire lock
routine and a release lock routine which permit utilization of the
local object only by one computer and each of the remainder of said
plurality of computers is locked out of utilization of their
corresponding object.
[0045] In accordance with a tenth aspect of the present invention
there is disclosed a method of running simultaneously on a
plurality of computers at least one application program each
written to operate only on a single computer, said computers being
interconnected by means of a communications network, said method
comprising the steps of: (i) executing different portions of said
application program(s) on different ones of said computers and for
each said portion creating a like plurality of substantially
identical objects each in the corresponding computer and each
having a substantially identical name, and (ii) requiring any of
said computers wishing to utilize a named object therein to acquire
an authorizing lock which permits said utilization and which
prevents all the other computers from utilizing their corresponding
named object until said authorizing lock is relinquished.
[0046] In accordance with a eleventh aspect of the present
invention there is disclosed a method of ensuring consistent
synchronization of an application program written to operate only
on a single computer but different portions of which are to be
executed substantially simultaneously each on a different one of a
plurality of computers interconnected via a communications network,
said method comprising the steps of: (i) scrutinizing said
application program at, or prior to, or after loading to detect
each program step defining an synchronization routine, and (ii)
modifying said synchronization routine to ensure utilization of an
object by only one computer and preventing all the remaining
computers from simultaneously utilizing their corresponding
objects.
[0047] In accordance with a twelvth aspect of the present invention
there is disclosed a multiple thread processing computer operation
in which individual threads of a single application program written
to operate only on a single computer are simultaneously being
processed each on a corresponding different one of a plurality of
computers interconnected via a communications link, and in which
objects in local memory physically associated with the computer
processing each thread have corresponding objects in the local
memory of each other said computer, the improvement comprising
permitting only one of said computers to utilize an object and
preventing all the remaining computers from simultaneously
utilizing their corresponding object.
[0048] In accordance with a thirteenth aspect of the present
invention there is disclosed a computer program product comprising
a set of program instructions stored in a storage medium and
operable to permit a plurality of computers to carry out the
abovementioned methods.
[0049] In accordance with a fourteenth aspect of the invention
there is disclosed a distributed run time and distributed run time
system adapted to enable communications between a plurality of
computers, computing machines, or information appliances.
[0050] In accordance with a fifteenth aspect of the invention there
is disclosed a modifier, modifier means, and modifier routine for
modifying an application program written to execute on a single
computer or computing machine at a time to execute simultaneously
on a plurality of networked computers or computing machines.
distributed run time and distributed run time system adapted to
enable communications between a plurality of computers, computing
machines, or information appliances.
[0051] In accordance with a sixteenth aspect of the present
invention there is disclosed a computer program and computer
program product written to operate on only a single computer but
product comprising a set of program instructions stored in a
storage medium and operable to permit a plurality of computers to
carry out the abovementioned procedures, routines, and methods.
BRIEF DESCRIPTION OF THE DRAWINGS
[0052] Embodiments of the present invention are now described with
reference to the drawings in which:
[0053] FIG. 1 is a schematic view of the internal architecture of a
conventional computer;
[0054] FIG. 2 is a schematic illustration showing the internal
architecture of known symmetric multiple processors;
[0055] FIG. 3 is a schematic representation of prior art
distributed computing;
[0056] FIG. 4 is a schematic representation of a prior art network
computing using clusters;
[0057] FIG. 5 is a schematic block diagram of a plurality of
machines operating the same application program in accordance with
a first embodiment of the present invention;
[0058] FIG. 6 is a schematic illustration of a prior art computer
arranged to operate JAVA code and thereby constitute a JAVA virtual
machine;
[0059] FIG. 7 is a drawing similar to FIG. 6 but illustrating the
initial loading of code in accordance with the preferred
embodiment;
[0060] FIG. 8 is a drawing similar to FIG. 5 but illustrating the
interconnection of a plurality of computers each operating JAVA
code in the manner illustrated in FIG. 7;
[0061] FIG. 9 is a flow chart of the procedure followed during
loading of the same application on each machine in the network;
[0062] FIG. 10 is a flow chart showing a modified procedure similar
to that of FIG. 9;
[0063] FIG. 11 is a schematic representation of multiple thread
processing carried out on the machines of FIG. 8 utilizing a first
embodiment of memory updating;
[0064] FIG. 12 is a schematic representation similar to FIG. 11 but
illustrating an alternative embodiment;
[0065] FIG. 13 illustrates multi-thread memory updating for the
computers of FIG. 8;
[0066] FIG. 14 is a schematic illustration of a prior art computer
arranged to operate in JAVA code and thereby constitute a JAVA
virtual machine;
[0067] FIG. 15 is a schematic representation of n machines running
the application program and serviced by an additional server
machine X;
[0068] FIG. 16 is a flow chart of illustrating the modification of
the monitor enter and exit routines;
[0069] FIG. 17 is a flow chart illustrating the process followed by
processing machine in requesting the acquisition of a lock;
[0070] FIG. 18 is a flow chart illustrating the requesting of the
release of a lock;
[0071] FIG. 19 is a flow chart of the response of the server
machine X to the request of FIG. 17;
[0072] FIG. 20 is a flow chart illustrating the response of the
server machine X to the request of FIG. 18;
[0073] FIG. 21 is a schematic representation of two laptop
computers interconnected to simultaneously run a plurality of
applications, with both applications running on a single
computer;
[0074] FIG. 22 is a view similar to FIG. 21 but showing the FIG. 21
apparatus with one application operating on each computer; and
[0075] FIG. 23 is a view similar to FIGS. 21 and 22 but showing the
FIG. 21 apparatus with both applications operating simultaneously
on both computers.
[0076] The specification includes Annexures A and D which provide
actual program fragments which implement various aspects of the
described embodiments. Annexure A relates to fields and Annexure D
to synchronization.
Reference to Annexes
[0077] Although the specification provides a complete and detailed
description of the several embodiments of the invention such that
the invention may be understood and implemented without reference
to other materials, the specification does includes Annexures A and
D which provide exemplary actual program or code fragments which
implement various aspects of the described embodiments. Although
aspects of the invention are described throughout the specification
including the Annexes, drawings, and claims, it may be appreciated
that Annexure A relates primarily to fields and Annexure D relates
primarily to synchronization.
[0078] It will be appreciated in light of the description provided
here that the categorization of the Annexures as well as the use of
other headings and subheadings in this description is intended as
an aid to the reader and is not to be used to limit the scope of
the invention in any way.
DETAILED DESCRIPTION OF EMBODIMENTS OF THE INVENTION
[0079] The present invention discloses a modified computer
architecture which enables an applications program to be run
simultaneously on a plurality of computers in a manner that
overcomes the limitations of the aforedescribed conventional
architectures, systems, methods, and computer programs.
[0080] In one aspect, shared memory at each computer may be updated
with amendments and/or overwrites so that all memory read requests
are satisfied locally. Before, during or after program loading, but
before execution of relevant portions of the program code are
executed, or similar, instructions which result in memory being
re-written or manipulated are identified. Additional instructions
are inserted into the program code (or other modification made) to
cause the equivalent memory locations at all computers to be
updated. While the invention is not limited to JAVA language or
virtual machines, exemplary embodiments are described relative to
the JAVA language and standards.
[0081] In another aspect, the initialization of JAVA language
classes and objects (or other assets) are provided for so all
memory locations for all computers are initialized in the same
manner. In another aspect, the finalization of JAVA language
classes and objects is also provide so finalization only occurs
when the last class or object present on all machines is no longer
required. In still another aspect, synchronization is provided such
that instructions which result in the application program acquiring
(or releasing) a lock on a particular asset (synchronization) are
identified. Additional instructions are inserted (or other code
modifications performed) to result in a modified synchronization
routine with which all computers are updated.
[0082] As will become more apparent in light of the further
description provided herein, one of the features of the invention
is to make it appear that one common application program or
application code and its executable version (with likely
modification) is simultaneously or concurrently executing across a
plurality of computers or machines M1, . . . , Mn. As will be
described in considerable detail hereinafter, the instant invention
achieves this by running the same application program (for example,
Microsoft Word or Adobe Photoshop CS2) on each machine, but
modifying the executable code of that application program on each
machine as necessary such that each executing instance (`copy`) on
each machine coordinates its local operations on any particular
machine with the operations of the respective instances on the
other machines such that they all function together in a
consistent, coherent and coordinated manner and give the appearance
of being one global instance of the application (i.e., a
"meta-application").
[0083] In accordance with embodiments of the present invention a
single application code 50 (sometimes more informally referred to
as the application or the application program) can be operated
simultaneously on a number of machines M1, M2 . . . Mn
interconnected via a communications network or other communications
link or path 53. The communications network or path may be any
electronic signaling, data, or digital communications network or
path and may advantageously be a relatively slow speed
communications path, such as a network connection over the Internet
or any common networking configurations known or available as of
the date or this applications, and extensions and improvements,
thereto.
[0084] By way of example but not limitation, one application code
or program 50 may be a single application on the machines, such as
Microsoft Word, as opposed to different applications on each
machine, such as Microsoft Word on machine M1, and Microsoft
PowerPoint on machine M2, and Netscape Navigator on machine M3 and
so forth. Therefore the terminology "one" application code or
program and a "common" application code or program is used to try
and capture this situation where all machines M1, . . . , Mn are
operating or executing the same program or code and not different
(and unrelated) programs. In other words copies or replicas of same
or substantially the same application code is loaded onto each of
the interoperating and connected machines or computers. As the
characteristics of each machine or computer may differ, the
application code 50 may be modified before loading, during the
loading process, and with some restrictions after the loading
process to provide a customization or modification of the code on
each machine. Some dissimilarity between the programs may be
permitted so long as the other requirements for interoperability,
consistency, and coherency as described herein can be maintain. As
it will become apparent hereafter, each of the machines M1, M2 . .
. Mn operates with the same application code 50 on each machine M1,
M2 . . . Mn and thus all of the machines M1, M2, . . . , Mn have
the same or substantially the same application code 50 usually with
a modification that may be machine specific.
[0085] Similarly, each of the machines M1, M2, . . . , Mn operates
with the same (or substantially the same or similar) modifier 51
(in some embodiments implemented as a distributed run time or DRT
71) on each machine M1, M2, . . . , Mn and thus all of the machines
M1, M2 . . . Mn have the same (or substantially the same or
similar) modifier 51 for each modification required. Different
modification for example may be required for memory management and
replication, initialization, finalization, and/or synchronization
(though not all of these modification types may be required for all
embodiments).
[0086] In addition, during the loading of, or at any time preceding
the execution of, the application code 50 (or relevant portion
thereof) on each machine M1, M2 . . . Mn, each application code 50
has been modified by the corresponding modifier 51 according to the
same rules (or substantially the same rules since minor optimizing
changes are permitted within each modifier 51/1, 51/2, . . . ,
51/n).
[0087] With reference to any synchronization modifier that may be
present, such synchronization modifier 51-S or DRT 71-S or other
code modifying means is responsible for ensuring that when a part
(such as a thread or process) of the modified application program
50 running on one or more of the machines exclusively utilizes
(e.g., by means of a synchronization routine or similar or
equivalent mutual exclusion operator or operation) a particular
local asset, such as an objects 50X-50Z or class 50A, no other
different and potentially concurrently executing part on machines
M2 . . . Mn exclusively utilizes the similar equivalent
corresponding asset in its local memory at once or at the same
time.
[0088] These structures and procedures when applied in combination
when required, maintain a computing environment where memory
locations, address ranges, objects, classes, assets, resources, or
any other procedural or structural aspect of a computer or
computing environment are where required created, maintained,
operated, and deactivated or deleted in a coordinated, coherent,
and consistent manner across the plurality of individual machines
M1, M2 . . . Mn.
[0089] Attention is now directed to the particulars of several
aspects of the invention that may be utilised alone or in any
combination.
[0090] In connection with FIG. 5, in accordance with a preferred
embodiment of the present invention a single application code 50
(sometimes more informally referred to as the application or the
application program) can be operated simultaneously on a number of
machines M1, M2 . . . Mn interconnected via a communications
network or other communications link or path 53. By way of example
but not limitation, one application code or program 50 would be a
single common application program on the machines, such as
Microsoft Word, as opposed to different applications on each
machine, such as Microsoft Word on machine M1, and Microsoft
PowerPoint on machine M2, and Netscape Navigator on machine M3 and
so forth. Therefore the terminology "one", "single", and "common"
application code or program is used to try and capture this
situation where all machines M1, . . . , Mn are operating or
executing the same program or code and not different (and
unrelated) programs. In other words copies or replicas of same or
substantially the same application code is loaded onto each of the
interoperating and connected machines or computers. As the
characteristics of each machine or computer may differ, the
application code 50 may be modified before loading, during the
loading process, or after the loading process to provide a
customization or modification of the code on each machine. Some
dissimilarity between the programs may be permitted so long as the
other requirements for interoperability, consistency, and coherency
as described herein can be maintain. As it will become apparent
hereafter, each of the machines M1, M2 . . . Mn operates with the
same application code 50 on each machine M1, M2 . . . Mn and thus
all of the machines M1, M2, . . . , Mn have the same or
substantially the same application code 50 usually with a
modification that may be machine specific.
[0091] Similarly, each of the machines M1, M2, . . . , Mn operates
with the same (or substantially the same or similar) modifier 51 on
each machine M1, M2, . . . , Mn and thus all of the machines M1, M2
. . . Mn have the same (or substantially the same or similar)
modifier 51 with the modifier of machine M1 being designated 51/1
and the modifier of machine M2 being designated 51/2, etc. In
addition, before or during the loading of, or preceding the
execution of, or even after execution has commenced, the
application code 50 on each machine M1, M2 . . . Mn is modified by
the corresponding modifier 51 according to the same rules (or
substantially the same rules since minor optimizing changes are
permitted within each modifier 51/1, 51/2, . . . , 51/n).
[0092] As will become more apparent in light of the further
description provided herein, one of the features of the invention
is to make it appear that one application program instance of
application code 50 is executing simultaneously across all of the
plurality of machines M1, M2, . . . , Mn. As will be described in
considerable detail hereinafter, the instant invention achieves
this by running the same application program code (for example,
Microsoft Word or Adobe Photoshop CS2) on each machine, but
modifying the executable code of that application program on each
machine such that each executing occurrence (or `local instance`)
on each one of the machines M1 . . . Mn coordinates its local
operations with the operations of the respective occurrences on
each one of the other machines such that each occurrence on each
one of the plurality of machines function together in a consistent,
coherent and coordinated manner so as to give the appearance of
being one global instance (or occurrence) of the application
program and program code (i.e., a "meta-application").
[0093] As a consequence of the above described arrangement, if each
of the machines M1, M2, . . . , Mn has, say, an internal memory
capability of 10 MB, then the total memory available to each
application code 50 is not necessarily, as one might expect the
number of machines (n) times 10 MB, or alternatively the additive
combination of the internal memory capability of all n machines,
but rather or still may only be 10 MB. In the situation where the
internal memory capacities of the machines are different, which is
permissible, then in the case where the internal memory in one
machine is smaller than the internal memory capability of at least
one other of the machines, then the size of the smallest memory of
any of the machines may be used as the maximum memory capacity of
the machines when such memory (or a portion thereof) is to be
treated as a `common` memory (i.e. similar equivalent memory on
each of the machines M1 . . . Mn) or otherwise used to execute the
common application code.
[0094] However, even though the manner that the internal memory of
each machine is treated may initially appear to be a possible
constraint on performance, how this results in improved operation
and performance will become apparent hereafter. Naturally, each
machine M1, M2 . . . Mn has an private (i.e. `non-common`) internal
memory capability. The private internal memory capability of the
machines M1, M2, . . . , Mn are normally approximately equal but
need not be. It may also be advantageous to select the amounts of
internal memory in each machine to achieve a desired performance
level in each machine and across a constellation or network of
connected or coupled plurality of machines, computers, or
information appliances M1, M2, . . . , Mn. Having described these
internal and common memory considerations, it will be apparent in
light of the description provided herein that the amount of memory
that can be common between machines is not a limitation of the
invention.
[0095] It is known from the prior art to operate a single computer
or machine (produced by one of various manufacturers and having an
operating system operating in one of various different languages)
in a particular language of the application, by creating a virtual
machine as schematically illustrated in FIG. 6. The code and data
and virtual machine configuration or arrangement of FIG. 6 takes
the form of the application code 50 written in the Java language
and executing within a Java Virtual Machine 61. Thus, where the
intended language of the application is the language JAVA, a JAVA
virtual machine is used which is able to operate code in JAVA
irrespective of the machine manufacturer and internal details of
the machine. For further details see "The JAVA Virtual Machine
Specification" 2.sup.nd Edition by T. Lindholm & F. Yellin of
Sun Microsystems Inc. of the USA, which is incorporated by
reference herein.
[0096] This conventional art arrangement of FIG. 6 is modified in
accordance with embodiments of the present invention by the
provision of an additional facility which is conveniently termed
"distributed run time" or "distributed run time system" DRT 71 and
as seen in FIG. 7.
[0097] In FIG. 7, the application code 50 is loaded onto the Java
Virtual Machine 72 in cooperation with the distributed runtime
system 71, through the loading procedure indicated by arrow 75. As
used herein the terms distributed runtime and the distributed run
time system are essentially synonymous, and by means of
illustration but not limitation are generally understood to include
library code and processes which support software written in a
particular language running on a particular platform. Additionally,
a distributed runtime system may also include library code and
processes which support software written in a particular language
running within a particular distributed computing environment. The
runtime system typically deals with the details of the interface
between the program and the operation system such as system calls,
program start-up and termination, and memory management. For
purposes of background, a conventional Distributed Computing
Environment (DCE) that does not provide the capabilities of the
inventive distributed run time or distributed run time system 71
required in the invention is available from the Open Software
Foundation. This Distributed Computing Environment (DCE) performs a
form of computer-to-computer communication for software running on
the machines, but among its many limitations, it is not able to
implement the modification or communication operations of this
invention. Among its functions and operations, the inventive DRT 71
coordinates the particular communications between the plurality of
machines M1, M2, . . . , Mn. Moreover, the inventive distributed
runtime 71 comes into operation during the loading procedure
indicated by arrow 75 of the JAVA application 50 on each JAVA
virtual machine 72 of machines JVM#1, JVM#2, . . . JVM#n. The
sequence of operations during loading will be described hereafter
in relation to FIG. 9. It will be appreciated in light of the
description provided herein that although many examples and
descriptions are provided relative to the JAVA language and JAVA
virtual machines so that the reader may get the benefit of specific
examples, the invention is not restricted to either the JAVA
language or JAVA virtual machines, or to any other language,
virtual machine, machine, or operating environment.
[0098] FIG. 8 shows in modified form the arrangement of FIG. 5
utilising JAVA virtual machines, each as illustrated in FIG. 7. It
will be apparent that again the same application code 50 is loaded
onto each machine M1, M2 . . . Mn. However, the communications
between each machine M1, M2, . . . , Mn, and indicated by arrows
83, although physically routed through the machine hardware, are
advantageously controlled by the individual DRT's 71/1 . . . 71/n
within each machine. Thus, in practice this may be conceptionalised
as the DRT's 71/1, . . . , 71/n communicating with each other via
the network or other communications link 73 rather than the
machines M1, M2, . . . , Mn communicating directly with themselves
or each other. Actually, the invention contemplates and included
either this direct communication between machines M1, M2, . . . ,
Mn or DRTs 71/1, 71/2, . . . , 71/n or a combination of such
communications. The inventive DRT 71 provides communication that is
transport, protocol, and link independent.
[0099] It will be appreciated in light of the description provided
herein that there are alternative implementations of the modifier
51 and the distributed run time 71. For example, the modifier 51
may be implemented as a component of or within the distributed run
time 71, and therefore the DRT 71 may implement the functions and
operations of the modifier 51. Alternatively, the function and
operation of the modifier 51 may be implemented outside of the
structure, software, firmware, or other means used to implement the
DRT 71. In one embodiment, the modifier 51 and DRT 71 are
implemented or written in a single piece of computer program code
that provides the functions of the DRT and modifier. The modifier
function and structure therefore maybe subsumed into the DRT and
considered to be an optional component. Independent of how
implemented, the modifier function and structure is responsible for
modifying the executable code of the application code program, and
the distributed run time function and structure is responsible for
implementing communications between and among the computers or
machines. The communications functionality in one embodiment is
implemented via an intermediary protocol layer within the computer
program code of the DRT on each machine. The DRT may for example
implement a communications stack in the JAVA language and use the
Transmission Control Protocol/Internet Protocol (TCP/IP) to provide
for communications or talking between the machines. Exactly how
these functions or operations are implemented or divided between
structural and/or procedural elements, or between computer program
code or data structures within the invention are less important
than that they are provided.
[0100] However, in the arrangement illustrated in FIG. 8, (and also
in FIGS. 31-32), a plurality of individual computers or machines
M1, M2, . . . , Mn are provided, each of which are interconnected
via a communications network 53 or other communications link and
each of which individual computers or machines provided with a
modifier 51 (See in FIG. 5) and realised by or in for example the
distributed run time (DRT) 71 (See FIG. 8) and loaded with a common
application code 50. The term common application program is to be
understood to mean an application program or application program
code written to operate on a single machine, and loaded and/or
executed in whole or in part on each one of the plurality of
computers or machines M1, M2 . . . Mn, or optionally on each one of
some subset of the plurality of computers or machines M1, M2 . . .
Mn. Put somewhat differently, there is a common application program
represented in application code 50, and this single copy or perhaps
a plurality of identical copies are modified to generate a modified
copy or version of the application program or program code, each
copy or instance prepared for execution on the plurality of
machines. At the point after they are modified they are common in
the sense that they perform similar operations and operate
consistently and coherently with each other. It will be appreciated
that a plurality of computers, machines, information appliances, or
the like implementing the features of the invention may optionally
be connected to or coupled with other computers, machines,
information appliances, or the like that do not implement the
features of the invention.
[0101] Essentially in at least one embodiment the modifier 51 or
DRT 71 or other code modifying means is responsible for modifying
the application code 50 so that it may execute memory manipulation
operations, such as memory putstatic and putfield instructions in
the JAVA language and virtual machine environment, in a
coordinated, consistent, and coherent manner across and between the
plurality of individual machines M1 . . . Mn. It follows therefore
that in such a computing environment it is necessary to ensure that
each of memory location is manipulated in a consistent fashion
(with respect to the others).
[0102] In some embodiments, some or all of the plurality of
individual computers or machines may be contained within a single
housing or chassis (such as so-called "blade servers" manufactured
by Hewlett-Packard Development Company, Intel Corporation, IBM
Corporation and others) or implemented on a single printed circuit
board or even within a single chip or chip set.
[0103] A machine (produced by any one of various manufacturers and
having an operating system operating in any one of various
different languages) can operate in the particular language of the
application program code 50, in this instance the JAVA language.
That is, a JAVA virtual machine 72 is able to operate application
code 50 in the JAVA language, and utilize the JAVA architecture
irrespective of the machine manufacturer and the internal details
of the machine.
[0104] When implemented in a non-JAVA language or application code
environment, the generalized platform, and/or virtual machine
and/or machine and/or runtime system is able to operate application
code 50 in the language(s) (possibly including for example, but not
limited to any one or more of source-code languages,
intermediate-code languages, object-code languages, machine-code
languages, and any other code languages) of that platform, and/or
virtual machine and/or machine and/or runtime system environment,
and utilize the platform, and/or virtual machine and/or machine
and/or runtime system and/or language architecture irrespective of
the machine manufacturer and the internal details of the machine.
It will also be appreciated in light of the description provided
herein that platform and/or runtime system may include virtual
machine and non-virtual machine software and/or firmware
architectures, as well as hardware and direct hardware coded
applications and implementations.
[0105] For a more general set of virtual machine or abstract
machine environments, and for current and future computers and/or
computing machines and/or information appliances or processing
systems, and that may not utilize or require utilization of either
classes and/or objects, the inventive structure, method, and
computer program and computer program product are still applicable.
Examples of computers and/or computing machines that do not utilize
either classes and/or objects include for example, the x86 computer
architecture manufactured by Intel Corporation and others, the
SPARC computer architecture manufactured by Sun Microsystems, Inc
and others, the PowerPC computer architecture manufactured by
International Business Machines Corporation and others, and the
personal computer products made by Apple Computer, Inc., and
others. For these types of computers, computing machines,
information appliances, and the virtual machine or virtual
computing environments implemented thereon that do not utilize the
idea of classes or objects, may be generalized for example to
include primitive data types (such as integer data types, floating
point data types, long data types, double data types, string data
types, character data types and Boolean data types), structured
data types (such as arrays and records) derived types, or other
code or data structures of procedural languages or other languages
and environments such as functions, pointers, components, modules,
structures, references and unions.
[0106] Turning now to FIGS. 7 and 9, during the loading procedure
75, the application code 50 being loaded onto or into each JAVA
virtual machine 72 is modified by DRT 71. This modification
commences at Step 90 in FIG. 9 and involves the initial step 91 of
preferably scrutinizing or analysing the code and detecting all
memory locations addressable by the application code 50, or
optionally some subset of all memory locations addressable by the
application code 50; such as for example named and unnamed memory
locations, variables (such as local variables, global variables,
and formal arguments to subroutines or functions), fields,
registers, or any other address space or range of addresses which
application code 50 may access. Such memory locations in some
instances need to be identified for subsequent processing at steps
92 and 93. In some embodiments, where a list of detected memory
locations is required for further processing, the DRT 71 during the
loading procedure 75 creates a list of all the memory locations
thus identified. In one embodiment, the memory locations in the
form of JAVA fields are listed by object and class, however, the
memory locations, fields, or the like may be listed or organized in
any manner so long as they comport with the architectural and
programming requirements of the system on which the program is to
be used and the principles of the invention described herein. This
detection is optional and not required in all embodiments of the
invention. It may be noted that the DRT is at least in part
fulfilling the roll of the modifier 51.
[0107] The next phase (designated Step 92 in FIG. 9) [Step 92] of
the modification procedure is to search through the application
code 50 in order to locate processing activity or activities that
manipulate or change values or contents of any listed memory
location (for example, but not limited to JAVA fields)
corresponding to the list generated at step 91 when required.
Preferably, all processing activities that manipulate or change any
one or more values or contents of any one or more listed memory
locations, are located.
[0108] When such a processing activity or operation (typically
"putstatic" or "putfield" in the JAVA language, or for example, a
memory assignment operation, or a memory write operation, or a
memory manipulation operation, or more generally operations that
otherwise manipulate or change value(s) or content(s) of memory or
other addressable areas), is detected which changes the value or
content of a listed or detected memory location, then an "updating
propagation routine" is inserted by step 93 in the application code
50 corresponding to the detected memory manipulation operation, to
communicate with all other machines in order to notify all other
machines of the identity of the manipulated memory location, and
the updated, manipulated or changed value(s) or content(s) of the
manipulated memory location. The inserted "updating propagation
routine" preferably takes the form of a method, function,
procedure, or similar subroutine call or operation to a network
communications library of DRT 71. Alternatively, the "updating
propagation routine" may take the optional form of a code-block (or
other inline code form) inserted into the application code
instruction stream at, after, before, or otherwise corresponding to
the detected manipulation instruction or operation. And preferably,
in a multi-tasking or parallel processing machine environment (and
in some embodiments inclusive or exclusive of operating system),
such as a machine environment capable of potentially simultaneous
or concurrent execution of multiple or different threads or
processes, the "updating propagation routine" may execute on the
same thread or process or processor as the detected memory
manipulation operation of step 92. Thereafter, the loading
procedure continues, by loading the modified application code 50 on
the machine 72 in place of the unmodified application code 50, as
indicated by step 94 in FIG. 9.
[0109] An alternative form of modification during loading is
illustrated in the illustration of FIG. 10. Here the start and
listing steps 90 and 91 and the searching step 92 are the same as
in FIG. 9. However, rather than insert the "updating propagation
routine" into the application code 50 corresponding to the detected
memory manipulation operation identified in step 92, as is
indicated in step 93, in which the application code 50, or network
communications library code 71 of the DRT executing on the same
thread or process or processor as the detected memory manipulation
operation, carries out the updating, instead an "alert routine" is
inserted corresponding to the detected memory manipulation
operation, at step 103. The "alert routine" instructs, notifies or
otherwise requests a different and potentially simultaneously or
concurrently executing thread or process or processor not used to
perform the memory manipulation operation (that is, a different
thread or process or processor than the thread or process or
processor which manipulated the memory location), such as a
different thread or process allocated to the DRT 71, to carry out
the notification, propagation, or communication of all other
machines of the identity of the manipulated memory location, and
the updated, manipulated or changed value(s) or content(s) of the
manipulated memory location.
[0110] Once this modification during the loading procedure has
taken place and execution begins of the modified application code
50, then either the steps of FIG. 11 or FIG. 12 take place. FIG. 11
(and the steps 112, 113, 114, and 115 therein) correspond to the
execution and operation of the modified application code 50 when
modified in accordance with the procedures set forth in and
described relative to FIG. 9. FIG. 12 on the other hand (and the
steps 112, 113, 125, 127, and 115 therein) set forth therein
correspond to the execution and operation of the modified
application code 50 when modified in accordance with FIG. 10.
[0111] This analysis or scrutiny of the application code 50 can may
take place either prior to loading the application program code 50,
or during the application program code 50 loading procedure, or
even after the application program code 50 loading procedure. It
may be likened to an instrumentation, program transformation,
translation, or compilation procedure in that the application code
may be instrumented with additional instructions, and/or otherwise
modified by meaning-preserving program manipulations, and/or
optionally translated from an input code language to a different
code language (such as for example from source-code language or
intermediate-code language to object-code language or machine-code
language), and with the understanding that the term compilation
normally or conventionally involves a change in code or language,
for example, from source code to object code or from one language
to another language. However, in the present instance the term
"compilation" (and its grammatical equivalents) is not so
restricted and can also include or embrace modifications within the
same code or language. For example, the compilation and its
equivalents are understood to encompass both ordinary compilation
(such as for example by way of illustration but not limitation,
from source-code to object-code), and compilation from source-code
to source-code, as well as compilation from object-code to
object-code, and any altered combinations therein. It is also
inclusive of so-called "intermediary-code languages" which are a
form of "pseudo object-code".
[0112] By way of illustration and not limitation, in one
embodiment, the analysis or scrutiny of the application code 50 may
take place during the loading of the application program code such
as by the operating system reading the application code from the
hard disk or other storage device or source and copying it into
memory and preparing to begin execution of the application program
code. In another embodiment, in a JAVA virtual machine, the
analysis or scrutiny may take place during the class loading
procedure of the java.lang.ClassLoader loadClass method (e.g.,
"java.lang.ClassLoader.loadClass( )").
[0113] Alternatively, the analysis or scrutiny of the application
code 50 may take place even after the application program code
loading procedure, such as after the operating system has loaded
the application code into memory, or optionally even after
execution of the relevant corresponding portion of the application
program code has started, such as for example after the JAVA
virtual machine has loaded the application code into the virtual
machine via the "java.lang.ClassLoader.loadClass( )" method and
optionally commenced execution.
[0114] As seen in FIG. 11, a multiple thread processing machine
environment 110, on each one of the machines M1, . . . , Mn and
consisting of threads 111/1 . . . 111/4 exists. The processing and
execution of the second thread 111/2 (in this example) results in
that thread 111/2 manipulating a memory location at step 113, by
writing to a listed memory location. In accordance with the
modifications made to the application code 50 in the steps 90-94 of
FIG. 9, the application code 50 is modified at a point
corresponding to the write to the memory location of step 113, so
that it propagates, notifies, or communicates the identity and
changed value of the manipulated memory location of step 113 to the
other machines M2, . . . , Mn via network 53 or other communication
link or path, as indicated at step 114. At this stage the
processing of the application code 50 of that thread 111/2 is or
may be altered and in some instances interrupted at step 114 by the
executing of the inserted "updating propagation routine", and the
same thread 111/2 notifies, or propagates, or communicates to all
other machines M2, . . . , Mn via the network 53 or other
communications link or path of the identity and changed value of
the manipulated memory location of step 113. At the end of that
notification, or propagation, or communication procedure 114, the
thread 111/2 then resumes or continues the processing or the
execution of the modified application code 50 at step 115.
[0115] In the alternative arrangement illustrated in FIG. 12, a
multiple thread processing machine environment 110 comprising or
consisting of threads 111/1, . . . , 111/3, and a simultaneously or
concurrently executing DRT processing environment 120 consisting of
the thread 121/1 as illustrated, or optionally a plurality of
threads, is executing on each one of the machines M1, . . . Mn. The
processing and execution of the modified application code 50 on
thread 111/2 results in a memory manipulation operation of step
113, which in this instance is a write to a listed memory location.
In accordance with the modifications made to the application code
50 in the steps 90, 91, 92, 103, and 94 of FIG. 9, the application
code 50 is modified at a point corresponding to the write to the
memory location of step 113, so that it requests or otherwise
notifies the threads of the DRT processing environment 120 to
notify, or propagate, or communicate to the other machines M2, . .
. Mn of the identity and changed value of the manipulated memory
location of step 113, as indicated at steps 125 and 128 and arrow
127. In accordance with this modification, the thread 111/2
processing and executing the modified application code 50 requests
a different and potentially simultaneously or concurrently
executing thread or process (such as thread 121/1) of the DRT
processing environment 120 to notify the machines M2, . . . Mn via
network 53 or other communications link or path of the identity and
changed value of the manipulated memory location of step 113, as
indicated in step 125 and arrow 127. In response to this request of
step 125 and arrow 127, a different and potentially simultaneously
or concurrently executing thread or process 121/1 of the DRT
processing environment 120 notifies the machines M2, . . . , Mn via
network 53 or other communications link or path of the identity and
changed value of the manipulated memory location of step 113, as
requested of it by the modified application code 50 executing on
thread 111/2 of step 125 and arrow 127.
[0116] When compared to the earlier described step 114 of thread
111/2 of FIG. 11, step 125 of thread 111/2 of FIG. 12 can be
carried out quickly, because step 114 of thread 111/2 must notify
and communicate with machines M2, . . . Mn via the relatively slow
network 53 (relatively slow for example when compared to the
internal memory bus 4 of FIG. 1 or the global memory 13 of FIG. 2)
of the identity and changed value of the manipulated memory
location of step 113, whereas step 125 of thread 111/2 does not
communicate with machines M2, . . . , Mn via the relatively slow
network 53. Instead, step 125 of thread 111/2 requests or otherwise
notifies a different and potentially simultaneously or concurrently
executing thread 121/1 of the DRT processing environment 120 to
perform the notification and communication with machines M2, . . .
, Mn via the relatively slow network 53 of the identify and changed
value of the manipulated memory location of step 113, as indicated
by arrow 127. Thus thread 111/2 carrying out step 125 is only
interrupted momentarily before the thread 111/2 resumes or
continues processing or execution of modified application code in
step 115. The other thread 121/1 of the DRT processing environment
120 then communicates the identity and changed value of the
manipulated memory location of step 113 to machines M2, . . . , Mn
via the relatively slow network 53 or other relatively slow
communications link or path.
[0117] This second arrangement of FIG. 12 makes better utilisation
of the processing power of the various threads 111/1 . . . 111/3
and 121/1 (which are not, in general, subject to equal demands).
Irrespective of which arrangement is used, the identity and change
value of the manipulated memory location(s) of step 113 is (are)
propagated to all the other machines M2 . . . Mn on the network 53
or other communications link or path.
[0118] This is illustrated in FIG. 13 where step 114 of FIG. 11, or
the DRT 71/1 (corresponding to the DRT processing environment 120
of FIG. 12) and its thread 121/1 of FIG. 12 (represented by step
128 in FIG. 13), send, via the network 53 or other communications
link or path, the identity and changed value of the manipulated
memory location of step 113 of FIGS. 11 and 12, to each of the
other machines M2, . . . , Mn.
[0119] With reference to FIG. 13, each of the other machines M2, .
. . , Mn carries out the action of receiving from the network 53
the identity and changed value of, for example, the manipulated
memory location of step 113 from machine M1, indicated by step 135,
and writes the value received at step 135 to the local memory
location corresponding to the identified memory location received
at step 135, indicated by step 136.
[0120] In the conventional arrangement in FIG. 3 utilising
distributed software, memory access from one machine's software to
memory physically located on another machine is permitted by the
network interconnecting the machines. However, because the read
and/or write memory access to memory physically located on another
computer require the use of the slow network 14, in these
configurations such memory accesses can result in substantial
delays in memory read/write processing operation, potentially of
the order of 10.sup.6-10.sup.7 cycles of the central processing
unit of the machine, but ultimately being dependent upon numerous
factors, such as for example, the speed, bandwidth, and/or latency
of the network 14. This in large part accounts for the diminished
performance of the multiple interconnected machines in the prior
art arrangement of FIG. 3.
[0121] However, in the present arrangement as described above in
connection with FIG. 8, it will be appreciated that all reading of
memory locations or data is satisfied locally because a current
value of all (or some subset of all) memory locations is stored on
the machine carrying out the processing which generates the demand
to read memory.
[0122] Similarly, in the present arrangement as described above in
connection with FIG. 8, it will be appreciated that all writing of
memory locations or data may be satisfied locally because a current
value of all (or some subset of all) memory locations is stored on
the machine carrying out the processing which generates the demand
to write to memory.
[0123] Such local memory read and write processing operation as
performed according to the invention can typically be satisfied
within 10.sup.2-10.sup.3 cycles of the central processing unit.
Thus, in practice, there is substantially less waiting for memory
accesses which involves reads than the arrangement shown and
described relative to FIG. 3. Additionally, in practice, there may
be less waiting for memory accesses which involve writes than the
arrangement shown and described relative to FIG. 3
[0124] It may be appreciated that most application software reads
memory frequently but writes to memory relatively infrequently. As
a consequence, the rate at which memory is being written or
re-written is relatively slow compared to the rate at which memory
is being read. Because of this slow demand for writing or
re-writing of memory, the memory locations or fields can be
continually updated at a relatively low speed via the possibly
relatively slow and inexpensive commodity network 53, yet this
possibly relatively slow speed is sufficient to meet the
application program's demand for writing to memory. The result is
that the performance of the FIG. 8 arrangement is superior to that
of FIG. 3. It may be appreciated in light of the description
provided herein that while a relatively slow network communication
link or path 53 may advantageously be used because it provides the
desired performance and low cost, the invention is not limited to a
relatively low speed network connection and may be used with any
communication link or path. The invention is transport, network,
and communications path independent, and does not depend on how the
communication between machines or DRTs takes place. In one
embodiment, even electronic mail (email) exchanges between machines
or DRTs may suffice for the communications.
[0125] In a further optional modification in relation to the above,
the identity and changed value pair of a manipulated memory
location sent over network 53, each pair typically sent as the sole
contents of a single packet, frame or cell for example, can be
grouped into batches of multiple pairs of identities and changed
values corresponding to multiple manipulated memory locations, and
sent together over network 53 or other communications link or path
in a single packet, frame, or cell. This further modification
further reduces the demands on the communication speed of the
network 53 or other communications link or path interconnecting the
various machines, as each packet, cell or frame may contain
multiple identity and changed value pairs, and therefore fewer
packets, frames, or cells require to be sent.
[0126] It may be apparent that in an environment where the
application program code writes repeatedly to a single memory
location, the embodiment illustrated of FIG. 11 of step 114 sends
an updating and propagation message to all machines corresponding
to every performed memory manipulation operation. In a still
further optimal modification in relation to the above, the DRT
thread 121/1 of FIG. 12 does not need to perform an updating and
propagation operation corresponding to every local memory
manipulation operation, but instead may send fewer updating and
propagation messages than memory manipulation operations, each
message containing the last or latest changed value or content of
the manipulated memory location, or optionally may only send a
single updating and propagation message corresponding to the last
memory manipulation operation. This further improvement reduces the
demands on the network 53 or other communications link or path, as
fewer packets, frames, or cells require to be sent.
[0127] It will also be apparent to those skilled in the art in
light of the detailed description provided herein that in a table
or list or other data structure created by each DRT 71 when
initially recording or creating the list of all, or some subset of
all, memory locations (or fields), for each such recorded memory
location on each machine M1, . . . , Mn there is a name or identity
which is common or similar on each of the machines M1, . . . , Mn.
However, in the individual machines the local memory location
corresponding to a given name or identity (listed for example,
during step 91 of FIG. 9) will or may vary over time since each
machine may and generally will store changed memory values or
contents at different memory locations according to its own
internal processes. Thus the table, or list, or other data
structure in each of the DRTs will have, in general, different
local memory locations corresponding to a single memory name or
identity, but each global "memory name" or identity will have the
same "memory value" stored in the different local memory
locations.
[0128] It will also be apparent to those skilled in the art in
light of the description provided herein that the abovementioned
modification of the application program code 50 during loading can
be accomplished in many ways or by a variety of means. These ways
or means include, but are not limited to at least the following
five ways and variations or combinations of these five, including
by:
(i) re-compilation at loading,
(ii) by a pre-compilation procedure prior to loading,
(iii) compilation prior to loading,
(iv) a "just-in-time" compilation, or
(v) re-compilation after loading (but, or for example, before
execution of the relevant or corresponding application code in a
distributed environment).
[0129] Traditionally the term "compilation" implies a change in
code or language, for example, from source to object code or one
language to another. Clearly the use of the term "compilation" (and
its grammatical equivalents) in the present specification is not so
restricted and can also include or embrace modifications within the
same code or language
[0130] Given the fundamental concept of modifying memory
manipulation operations to coordinate operation between and amongst
a plurality of machines M1 . . . Mn, there are several different
ways or embodiments in which this coordinated, coherent and
consistent memory state and manipulation operation concept, method,
and procedure may be carried out or implemented.
[0131] In the first embodiment, a particular machine, say machine
M2, loads the asset (such as class or object) inclusive of memory
manipulation operation(s), modifies it, and then loads each of the
other machines M1, M3, . . . , Mn (either sequentially or
simultaneously or according to any other order, routine or
procedure) with the modified object (or class or other asset or
resource) inclusive of the new modified memory manipulation
operation. Note that there may be one or a plurality of memory
manipulation operations corresponding to only one object in the
application code, or there may be a plurality of memory
manipulation operations corresponding to a plurality of objects in
the application code. Note that in one embodiment, the memory
manipulation operation(s) that is (are) loaded is binary executable
object code. Alternatively, the memory manipulation operation(s)
that is (are) loaded is executable intermediary code.
[0132] In this arrangement, which may be termed "master/slave" each
of the slave (or secondary) machines M1, M3 . . . , Mn loads the
modified object (or class), and inclusive of the new modified
memory manipulation operation(s), that was sent to it over the
computer communications network or other communications link or
path by the master (or primary) machine, such as machine M2, or
some other machine such as a machine X of FIG. 15. In a slight
variation of this "master/slave" or "primary/secondary"
arrangement, the computer communications network can be replaced by
a shared storage device such as a shared file system, or a shared
document/file repository such as a shared database.
[0133] Note that the modification performed on each machine or
computer need not and frequently will not be the same or identical.
What is required is that they are modified in a similar enough way
that in accordance with the inventive principles described herein,
each of the plurality of machines behaves consistently and
coherently relative to the other machines to accomplish the
operations and objectives described herein. Furthermore, it will be
appreciated in light of the description provided herein that there
are a myriad of ways to implement the modifications that may for
example depend on the particular hardware, architecture, operating
system, application program code, or the like or different factors.
It will also be appreciated that embodiments of the invention may
be implemented within an operating system, outside of or without
the benefit of any operating system, inside the virtual machine, in
an EPROM, in software, in firmware, or in any combination of
these.
[0134] In a still further embodiment, each machine M1, . . . , Mn
receives the unmodified asset (such as class or object) inclusive
of one or more memory manipulation operation(s), but modifies the
operations and then loads the asset (such as class or object)
consisting of the now modified operations. Although one machine,
such as the master or primary machine may customize or perform a
different modification to the memory manipulation operation(s) sent
to each machine, this embodiment more readily enables the
modification carried out by each machine to be slightly different
and to be enhanced, customized, and/or optimized based upon its
particular machine architecture, hardware, processor, memory,
configuration, operating system, or other factors, yet still
similar, coherent and consistent with other machines with all other
similar modifications and characteristics that may not need to be
similar or identical.
[0135] In all of the described instances or embodiments, the supply
or the communication of the asset code (such as class code or
object code) to the machines M1, . . . , Mn, and optionally
inclusive of a machine X of FIG. 15, can be branched, distributed
or communicated among and between the different machines in any
combination or permutation; such as by providing direct machine to
machine communication (for example, M2 supplies each of M1, M3, M4,
etc. directly), or by providing or using cascaded or sequential
communication (for example, M2 supplies M1 which then supplies M3
which then supplies M4, and so on), or a combination of the direct
and cascaded and/or sequential.
[0136] Reference is made to the accompanying Annexure A in which:
Annexure A5 is a typical code fragment from a memory manipulation
operation prior to modification (e.g., an exemplary unmodified
routine with a memory manipulation operation), and Annexure A6 is
the same routine with a memory manipulation operation after
modification (e.g., an exemplary modified routine with a memory
manipulation operation). These code fragments are exemplary only
and identify one software code means for performing the
modification in an exemplary language. It will be appreciated that
other software/firmware or computer program code may be used to
accomplish the same or analogous function or operation without
departing from the invention.
[0137] Annexures A5 and A6 (also reproduced in part in Table VI and
Table VII below) are exemplary code listings that set forth the
conventional or unmodified computer program software code (such as
may be used in a single machine or computer environment) of a
routine with a memory manipulation operation of application program
code 50 and a post-modification excerpt of the same routine such as
may be used in embodiments of the present invention having multiple
machines. The modified code that is added to the routine is
highlighted in bold text. TABLE-US-00001 TABLE I Summary Listing of
Contents of Annexure A Annexure A includes exemplary program
listings in the JAVA language to further illustrate features,
aspects, methods, and procedures of described in the detailed
description A1. This first excerpt is part of an illustration of
the modification code of the modifier 51 in accordance with steps
92 and 103 of FIG. 10. It searches through the code array of the
application program code 50, and when it detects a memory
manipulation instruction (i.e. a putstatic instruction (opcode 178)
in the JAVA language and virtual machine environment) it modifies
the application program code by the insertion of an "alert"
routine. A2. This second excerpt is part of the DRT.alert( ) method
and implements the step of 125 and arrow of 127 of FIG. 12. This
DRT.alert( ) method requests one or more threads of the DRT
processing environment of FIG. 12 to update and propagate the value
and identity of the changed memory location corresponding to the
operation of Annexure A1. A3. This third excerpt is part of the DRT
71, and corresponds to step 128 of FIG. 12. This code fragment
shows the DRT in a separate thread, such as thread 121/1 of FIG.
12, after being notified or requested by step 125 and array 127,
and sending the changed value and changed value location/identity
across the network 53 to the other of the plurality of machines M1
. . . Mn. A4. The fourth excerpt is part of the DRT 71, and
corresponds to steps 135 and 136 of FIG. 13. This is a fragment of
code to receive a propagated identity and value pair sent by
another DRT 71 over the network, and write the changed value to the
identified memory location. A5. The fifth excerpt is an
disassembled compiled form of the example.java application of
Annexure A7, which performs a memory manipulation operation
(putstatic and putfield). A6. The sixth excerpt is the disassembled
compiled form of the same example application in Annexure A5 after
modification has been performed by FieldLoader.java of Annexure
A11, in accordance with FIG. 9 of this invention. The modifications
are highlighted in bold. A7. The seventh excerpt is the source-code
of the example.java application used in excerpt A5 and A6. This
example application has two memory locations (staticValue and
instanceValue) and performs two memory manipulation operations. A8.
The eighth excerpt is the source-code of FieldAlert.java which
corresponds to step 125 and arrow 127 of FIG. 12, and which
requests a thread 121/1 executing FieldSend.java of the
"distributed run-time" 71 to propagate a changed value and identity
pair to the other machines M1 . . . Mn. A9. The ninth excerpt is
the source-code of FieldSend.java which corresponds to step 128 of
FIG. 12, and waits for a request/notification generated by
FieldAlert.java of A8 corresponding to step 125 and arrow 127, and
which propagates a changed value/identity pair requested of it by
FieldAlert.java, via network 53. A10. The tenth excerpt is the
source-code of FieldReceive.java, which corresponds to steps 135
and 136 of FIG. 13, and which receives a propagated changed value
and identity pair sent to it over the network 53 via FieldSend.java
of annexure A9. A11. FieldLoader.java. This excerpt is the
source-code of FieldLoader.java, which modifies an application
program code, such as the example.java application code of Annexure
A7, as it is being loaded into a JAVA virtual machine in accordance
with steps 90, 91, 92, 103, and 94 of FIG. 10. FieldLoader.java
makes use of the convenience classes of Annexures A12 through to
A36 during the modification of a compiled JAVA A12.
Attribute_info.java Convience class for representing attribute_info
structures within ClassFiles. A13. ClassFile.java Convience class
for representing ClassFile structures. A14. Code_attribute.java
Convience class for representing Code_attribute structures within
ClassFiles. A15. CONSTANT_Class_info.java Convience class for
representing CONSTANT_Class_info structures within ClassFiles. A16.
CONSTANT_Double_info.java Convience class for representing
CONSTANT_Double_info structures within ClassFiles. A17.
CONSTANT_Fieldref_info.java Convience class for representing
CONSTANT_Fieldref_info structures within ClassFiles. A18.
CONSTANT_Float_info.java Convience class for representing
CONSTANT_Float_info structures within ClassFiles. A19.
CONSTANT_Integer_info.java Convience class for representing
CONSTANT_Integer_info structures within ClassFiles. A20.
CONSTANT_InterfaceMethodref_info.java Convience class for
representing CONSTANT_InterfaceMethodref_info structures within
ClassFiles. A21. CONSTANT_Long_info.java Convience class for
representing CONSTANT_Long_info structures within ClassFiles. A22.
CONSTANT_Methodref_info.java Convience class for representing
CONSTANT_Methodref_info structures within ClassFiles. A23.
CONSTANT_NameAndType_info.java Convience class for representing
CONSTANT_NameAndType_info structures within ClassFiles. A24.
CONSTANT_String_info.java Convience class for representing
CONSTANT_String_info structures within ClassFiles. A25.
CONSTANT_Utf8_info.java Convience class for representing
CONSTANT_Utf8_info structures within ClassFiles. A26.
ConstantValue_attribute.java Convience class for representing
ConstantValue_attribute structures within ClassFiles. A27.
cp_info.java Convience class for representing cp_info structures
within ClassFiles. A28. Deprecated_attribute.java Convience class
for representing Deprecated_attribute structures within ClassFiles.
A29. Exceptions_attribute.java Convience class for representing
Exceptions_attribute structures within ClassFiles. A30.
field_info.java Convience class for representing field_info
structures within ClassFiles. A31. InnerClasses_attribute.java
Convience class for representing InnerClasses_attribute structures
within ClassFiles. A32. LineNumberTable_attribute.java Convience
class for representing LineNumberTable_attribute structures within
ClassFiles. A33. LocalVariableTable_attribute.java Convience class
for representing LocalVariableTable_attribute structures within
ClassFiles. A34. method_info.java Convience class for representing
method_info structures within ClassFiles. A35.
SourceFile_attribute.java Convience class for representing
SourceFile_attribute structures within ClassFiles. A36.
Synthetic_attribute.java Convience class for representing
Synthetic_attribute structures within ClassFiles.
[0138] TABLE-US-00002 TABLE II Exemplary code listing showing
embodiment of modified code. A1. This first excerpt is part of an
illustration of the modification code of the modifier 51 in
accordance with steps 92 and 103 of FIG. 10. It searches through
the code array of the application program code 50, and when it
detects a memory manipulation instruction (i.e. a putstatic
instruction (opcode 178) in the JAVA language and virtual machine
environment) it modifies the application program code by the
insertion of an "alert" routine. // START byte[ ] code =
Code_attribute.code; // Bytecode of a given method in a // given
classfile. int code_length = Code_attribute.code_length; int DRT =
99; // Location of the CONSTANT_Methodref_info for the //
DRT.alert( ) method. for (int i=0; i<code_length; i++){ if
((code[i] & 0xff) == 179){ // Putstatic instruction.
System.arraycopy(code, i+3, code, i+6, code_length-(i+3));
code[i+3] = (byte) 184; // Invokestatic instruction for the //
DRT.alert( ) method. code[i+4] = (byte) ((DRT >>> 8) &
0xff); code[i+5] = (byte) (DRT & 0xff); } } // END
[0139] TABLE-US-00003 TABLE III Exemplary code listing showing
embodiment of code for alert method A2. This second excerpt is part
of the DRT.alert( ) method and implements the step of 125 and arrow
of 127 of FIG. 12. This DRT.alert( ) method requests one or more
threads of the DRT processing environment of FIG. 12 to update and
propagate the value and identity of the changed memory location
corresponding to the operation of Annexure A1. // START public
static void alert( ){ synchronized (ALERT_LOCK){ ALERT_LOCK.notify(
); // Alerts a waiting DRT thread in the background. } } // END
[0140] TABLE-US-00004 TABLE IV Exemplary code listing showing
embodiment of code for DRT A3. This third excerpt is part of the
DRT 71, and corresponds to step 128 of FIG. 12. This code fragment
shows the DRT in a separate thread, such as thread 121/1 of FIG.
12, after being notified or requested by step 125 and array 127,
and sending the changed value and changed value location/identity
across the network 53 to the other of the plurality of machines
M1...Mn. // START MulticastSocket ms = DRT.getMulticastSocket( );
// The multicast socket // used by the DRT for // communication.
byte nameTag = 33; // This is the "name tag" on the network for
this // field. Field field =
modifiedClass.getDeclaredField("myField1"); // Stores // the field
// from the // modified // class. // In this example, the field is
a byte field. while (DRT.isRunning( )){ synchronized (ALERT_LOCK){
ALERT_LOCK.wait( ); // The DRT thread is waiting for the alert //
method to be called. byte[ ] b = new byte[ ]{nameTag,
field.getByte(null)}; // Stores // the // nameTag // and the //
value // of the // field from // the // modified // class in a
buffer. DatagramPacket dp = new DatagramPacket(b, 0, b.length);
ms.send(dp); // Send the buffer out across the network. } } //
END
[0141] TABLE-US-00005 TABLE V Exemplary code listing showing
embodiment of code for DRT receiving. A4. The fourth excerpt is
part of the DRT 71, and corresponds to steps 135 and 136 of FIG.
13. This is a fragment of code to receive a propagated identity and
value pair sent by another DRT 71 over the network, and write the
changed value to the identified memory location. // 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
[0142] TABLE-US-00006 TABLE VI Exemplary code listing showing
embodiment of application before modification is made. A5. The
fifth excerpt is an disassembled compiled form of the example.java
application of Annexure A7, which performs a memory manipulation
operation (putstatic and putfield). 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
[0143] TABLE-US-00007 TABLE VII Exemplary code listing showing
embodiment of application after modification is made. A6. The sixth
excerpt is the disassembled compiled form of the same example
application in Annexure A5 after modification has been performed by
FieldLoader.java of Annexure A11, in accordance with FIG. 9 of this
invention. The modifications are highlighted in bold. 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
[0144] TABLE-US-00008 TABLE VIII Exemplary code listing showing
embodiment of source-code of the example application. A7. The
seventh excerpt is the source-code of the example.java application
used in excerpt A5 and A6. This example application has two memory
locations (staticValue and instanceValue) and performs two memory
manipulation operations. 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; }
}
[0145] TABLE-US-00009 TABLE IX Exemplary code listing showing
embodiment of the source-code of FieldAlert. A8. The eighth excerpt
is the source-code of FieldAlert.java which corresponds to step 125
and arrow 127 of FIG. 12, and which requests a thread 121/1
executing FieldSend.java of the "distributed run-time" 71 to
propagate a changed value and identity pair to the other machines
M1...Mn. 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( ); } } } }
[0146] It is noted that the compiled code in the annexure and
portion repeated in the table is taken from the source-code of the
file "example.java" which is included in the Annexure A7 (Table
VIII). In the procedure of Annexure A5 and Table VI, the procedure
name "Method void setValues(int, int)" of Step 001 is the name of
the displayed disassembled output of the setValues method of the
compiled application code of "example.java". The name "Method void
setValues(int, int)" is arbitrary and selected for this example to
indicate a typical JAVA method inclusive of a memory manipulation
operation. Overall the method is responsible for writing two values
to two different memory locations through the use of an memory
manipulation assignment statement (being "putstatic" and "puffield"
in this example) and the steps to accomplish this are described in
turn.
[0147] First (Step 002), the Java Virtual Machine instruction
"iload.sub.--1" causes the Java Virtual Machine to load the integer
value in the local variable array at index 1 of the current method
frame and store this item on the top of the stack of the current
method frame and results in the integer value passed to this method
as the first argument and stored in the local variable array at
index 1 being pushed onto the stack.
[0148] The Java Virtual Machine instruction "putstatic #3 <Field
int staticValue>" (Step 003) causes the Java Virtual Machine to
pop the topmost value off the stack of the current method frame and
store the value in the static field indicated by the
CONSTANT_Fieldref_info constant-pool item stored in the 3.sup.rd
index of the classfile structure of the application program
containing this example setvalues( ) method and results in the
topmost integer value of the stack of the current method frame
being stored in the integer field named "staticValue".
[0149] The Java Virtual Machine instruction "aload.sub.--0" (Step
004) causes the Java Virtual Machine to load the item in the local
variable array at index 0 of the current method frame and store
this item on the top of the stack of the current method frame and
results in the `this` object reference stored in the local variable
array at index 0 being pushed onto the stack.
[0150] First (Step 005), the Java Virtual Machine instruction
"iload.sub.--2" causes the Java Virtual Machine to load the integer
value in the local variable array at index 2 of the current method
frame and store this item on the top of the stack of the current
method frame and results in the integer value passed to this method
as the first argument and stored in the local variable array at
index 2 being pushed onto the stack.
[0151] The Java Virtual Machine instruction "putfield #2 <Field
int instanceValue>" (Step 006) causes the Java Virtual Machine
to pop the two topmost values off the stack of the current method
frame and store the topmost value in the object instance field of
the second popped value, indicated by the CONSTANT_Fieldref_info
constant-pool item stored in the 2.sup.nd index of the classfile
structure of the application program containing this example
setValues method and results in the integer value on the top of the
stack of the current method frame being stored in the instance
field named "instanceValue" of the object reference below the
integer value on the stack.
[0152] Finally, the JAVA virtual machine instruction "return" (Step
007) causes the JAVA virtual machine to cease executing this
setValues( ) method by returning control to the previous method
frame and results in termination of execution of this setValues( )
method.
[0153] As a result of these steps operating on a single machine of
the conventional configurations in FIG. 1 and FIG. 2, the JAVA
virtual machine manipulates (i.e. writes to) the staticValue and
instanceValue memory locations, and in executing the setValues( )
method containing the memory manipulation operation(s) is able to
ensure that memory is and remains consistent between multiple
threads of a single application instance, and therefore ensure that
unwanted behaviour, such as for example inconsistent or incoherent
memory between multiple threads of a single application instance
(such inconsistent or incoherent memory being for example incorrect
or different values or contents with respect to a single memory
location) does not occur. Were these steps to be carried out on the
plurality of machines of the configurations of FIG. 5 and FIG. 8 by
concurrently executing the application program code 50 on each one
of the plurality of machines M1 . . . Mn, the memory manipulation
operations of each concurrently executing application program
occurrence on each one of the machines would be performed without
coordination between any other machine(s), such coordination being
for example updating of corresponding memory locations on each
machine such that they each report a same content or value. Given
the goal of consistent, coordinated and coherent memory state and
manipulation and updating operation across a plurality of a
machines, this prior art arrangement would fail to perform such
consistent, coherent, and coordinated memory state and manipulation
and updating operation across the plurality of machines, as each
machine performs memory manipulation only locally and without any
attempt to coordinate or update their local memory state and
manipulation operation with any other similar memory state on any
one or more other machines. Such an arrangement would therefore be
susceptible to inconsistent and incoherent memory state amongst
machines M1 . . . Mn due to uncoordinated, inconsistent and/or
incoherent memory manipulation and updating operation. Therefore it
is the goal of the present invention to overcome this limitation of
the prior art arrangement.
[0154] In the exemplary code in Table VII (Annexure A6), the code
has been modified so that it solves the problem of consistent,
coordinated memory manipulation and updating operation for a
plurality of machines M1 . . . Mn, that was not solved in the code
example from Table VI (Annexure A5). In this modified setValues( )
method code, an "ldc #4 <String "example">" instruction is
inserted after the "putstatic #3" instruction in order to be the
first instruction following the execution of the "putstatic #3"
instruction. This causes the JAVA virtual machine to load the
String value "example" onto the stack of the current method frame
and results in the String value of "example" loaded onto the top of
the stack of the current method frame. This change is significant
because it modifies the setValues( ) method to load a String
identifier corresponding to the classname of the class containing
the static field location written to by the "putstatic #3"
instruction onto the stack.
[0155] Furthermore, the JAVA virtual machine instruction
"iconst.sub.--0" is inserted after the "ldc #4" instruction so that
the JAVA virtual machine loads an integer value of "0" onto the
stack of the current method frame and results in the integer value
of "0" loaded onto the top of the stack of the current method
frame. This change is significant because it modifies the
setValues( ) method to load an integer value, which in this example
is "0", which represents the identity of the memory location
(field) manipulated by the preceding "putstatic #3" operation. It
is to be noted that the choice or particular form of the memory
identifier used for the implementation of this invention is for
illustration purposes only. In this example, the integer value of
"0" is the identifier used of the manipulated memory location, and
corresponds to the "staticValue" field as the first field of the
"example.java" application, as shown in Annexure A7. Therefore,
corresponding to the "putstatic #3" instruction, the
"iconst.sub.--0" instruction loads the integer value "0"
corresponding to the index of the manipulated field of the
"putstatic #3" instruction, and which in this case is the first
field of "example.java" hence the "0" integer index value, onto the
stack.
[0156] Additionally, the JAVA virtual machine instruction
"invokestatic #5 <Method boolean alert(java.lang.Object,
int)>" is inserted after the "iconst.sub.--0" instruction so
that the JAVA virtual machine pops the two topmost items off the
stack of the current method frame (which in accordance with the
preceding "ldc #4" instruction is a reference to the String object
with the value "example" corresponding to the name of the class to
which manipulated field belongs, and the integer "0" corresponding
to the index of the manipulated field in the example java
application) and invokes the "alert" method, passing the two
topmost items popped off the stack to the new method frame as its
first two arguments. This change is significant because it modifies
the setvalues( ) method to execute the "alert" method and
associated operations, corresponding to the preceding memory
manipulation operation (that is, the "putstatic #3" instruction) of
the setValues( ) method.
[0157] Likewise, in this modified setValues( ) method code, an
"aload.sub.--0" instruction is inserted after the "putfield #2"
instruction in order to be the first instruction following the
execution of the "putfield #2" instruction. This causes the JAVA
virtual machine to load the instance object of the example class to
which the manipulated field of the preceding "putfield #2"
instruction belongs, onto the stack of the current method frame and
results in the object reference corresponding to the instance field
written to by the "putfield #2" instruction, loaded onto the top of
the stack of the current method frame. This change is significant
because it modifies the setValues( ) method to load a reference to
the object corresponding to the manipulated field onto the
stack.
[0158] Furthermore, the JAVA virtual machine instruction
"iconst.sub.--1" is inserted after the "aload.sub.--0" instruction
so that the JAVA virtual machine loads an integer value of "1" onto
the stack of the current method frame and results in the integer
value of "1" loaded onto the top of the stack of the current method
frame. This change is significant because it modifies the
setValues( ) method to load an integer value, which in this example
is "1", which represents the identity of the memory location
(field) manipulated by the preceding "putfield #2" operation. It is
to be noted that the choice or particular form of the identifier
used for the implementation of this invention is for illustration
purposes only. In this example, the integer value of "1"
corresponds to the "instanceValue" field as the second field of the
"example.java" application, as shown in Annexure A7. Therefore,
corresponding to the "putfield #2" instruction, the
"iconst.sub.--1" instruction loads the integer value "1"
corresponding to the index of the manipulated field of the
"putfield #2" instruction, and which in this case is the second
field of "example.java" hence the "1" integer index value, onto the
stack.
[0159] Additionally, the JAVA virtual machine instruction
"invokestatic #5 <Method boolean alert(java.lang.Object,
int)>" is inserted after the "iconst.sub.--1" instruction so
that the JAVA virtual machine pops the two topmost item off the
stack of the current method frame (which in accordance with the
preceding "aload.sub.--0" instruction is a reference to the object
corresponding to the object to which the manipulated instance field
belongs, and the integer "1" corresponding to the index of the
manipulated field in the example.java application) and invokes the
"alert" method, passing the two topmost items popped off the stack
to the new method frame as its first two arguments. This change is
significant because it modifies the setValues( ) method to execute
the "alert" method and associated operations, corresponding to the
preceding memory manipulation operation (that is, the "putfield #2"
instruction) of the setValues( ) method.
[0160] The method void alert(java.lang.Object, int), part of the
FieldAlert code of Annexure A8 and part of the distributed runtime
system (DRT) 71, requests or otherwise notifies a DRT thread 121/1
executing the FieldSend.java code of Annexure A9 to update and
propagate the changed identity and value of the manipulated memory
location to the plurality of machines M1 . . . Mn.
[0161] It will be appreciated that the modified code permits, in a
distributed computing environment having a plurality of computers
or computing machines, the coordinated operation of memory
manipulation operations so that the problems associated with the
operation of the unmodified code or procedure on a plurality of
machines M1 . . . Mn (such as for example inconsistent and
incoherent memory state and manipulation and updating operation)
does not occur when applying the modified code or procedure.
[0162] Turning to FIG. 14, there is illustrated a schematic
representation of a single prior art computer operated as a JAVA
virtual machine. In this way, a machine (produced by any one of
various manufacturers and having an operating system operating in
any one of various different languages) can operate in the
particular language of the application program code 50, in this
instance the JAVA language. That is, a JAVA virtual machine 72 is
able to operate application code 50 in the JAVA language, and
utilize the JAVA architecture irrespective of the machine
manufacturer and the internal details of the machine.
[0163] When implemented in a non-JAVA language or application code
environment, the generalized platform, and/or virtual machine
and/or machine and/or runtime system is able to operate application
code 50 in the language(s) (possibly including for example, but not
limited to any one or more of source-code languages,
intermediate-code languages, object-code languages, machine-code
languages, and any other code languages) of that platform, and/or
virtual machine and/or machine and/or runtime system environment,
and utilize the platform, and/or virtual machine and/or machine
and/or runtime system and/or language architecture irrespective of
the machine manufacturer and the internal details of the machine.
It will also be appreciated in light of the description provided
herein that platform and/or runtime system may include virtual
machine and non-virtual machine software and/or firmware
architectures, as well as hardware and direct hardware coded
applications and implementations.
[0164] Furthermore, the single machine (not a plurality of
connected or coupled machines) of FIG. 14, or a more general
virtual machine or abstract machine environment such as for example
but not limited to an object-oriented virtual machine, is able to
readily ensure that multiple different and potentially concurrent
uses of specific objects 50X-50Z do not conflict or cause unwanted
interactions, when specified by the use of mutual exclusion (e.g.
"mutex") operators or operations (inclusive for example of locks,
semaphores, monitors, barriers, and the like), such as for example
by the programmer's use of a synchronizing or synchronization
routine in a computer program written in the JAVA language. As each
object exists singularly and only locally (that is locally within
the machine within which execution is occurring) in this example,
the single JAVA virtual machine 72 of FIG. 14 executing within this
single machine is able to ensure that an object (or several
objects) is (are) properly synchronized as defined by the JAVA
Virtual Machine and Language Specifications existent at least as of
the date of the filing of this patent application, when specified
to do so by the application program (or programmer), and thus the
object or objects to be synchronized are only utilized by one
executing part of potentially multiple executing parts and
potentially concurrently executing parts of the executable
application code 50 at once or at the same time, such as for
example potentially concurrently executing threads or processes. If
another executing part and potentially concurrently executing part
(such as for example but not limited to a potentially concurrently
executing thread or process) of the executable application code 50
wishes to exclusively use the same object whilst that object is the
subject of a mutual exclusion operation by a first executing part
(e.g. a first thread or process), such as when a second executing
part (e.g. a second thread or process) of a multiple part
processing machine of FIG. 14 attempts to synchronize on a same
object already synchronized by a first executing part, then the
possible conflict is resolved by the JAVA virtual machine 72 such
that the second and additional executing parts and potentially
concurrently executing part or parts of the application program 50
have to wait until the first executing part has finished the
execution of its synchronization routine or other mutual exclusion
operation. It may be appreciated that in a conventional situation,
a second or multiple executing part(s) (i.e. a second or multiple
thread(s)) of the application program or program code may want to
use the same object in a multiple-thread processing machine of FIG.
14.
[0165] For a more general set of virtual machine or abstract
machine environments, and for current and future computers and/or
computing machines and/or information appliances or processing
systems, and that may not utilize or require utilization of either
classes and/or objects, the inventive structure, method, and
computer program and computer program product are still applicable.
Examples of computers and/or computing machines that do not utilize
either classes and/or objects include for example, the x86 computer
architecture manufactured by Intel Corporation and others, the
SPARC computer architecture manufactured by Sun Microsystems, Inc
and others, the PowerPC computer architecture manufactured by
International Business Machines Corporation and others, and the
personal computer products made by Apple Computer, Inc., and
others. For these types of computers, computing machines,
information appliances, and the virtual machine or virtual
computing environments implemented thereon that do not utilize the
idea of classes or objects, the terms `class` and `object` may be
generalized for example to include primitive data types (such as
integer data types, floating point data types, long data types,
double data types, string data types, character data types and
Boolean data types), structured data types (such as arrays and
records) derived types, or other code or data structures of
procedural languages or other languages and environments such as
functions, pointers, components, modules, structures, references
and unions.
[0166] A similar procedure applies mutatis mutandis (that is, with
suitable or necessary alterations) for classes 50A. In particular,
the computer programmer (or if and when applicable, an automated or
nonautomated computer program generator or generation means) when
writing or generating a program using the JAVA language and
architecture in a single machine, need only use a synchronization
routine or routines in order to provide for this avoidance of
conflict or unwanted interaction. Thus a single JAVA virtual
machine can keep track of exclusive utilization of the classes and
objects (or other asset) and avoid corresponding problems (such as
conflict, race condition, unwanted interaction, or other anomalous
behaviour due to unexpected critical dependence on the relative
timing of events) as necessary in an unobtrusive fashion. The
process whereby only one object or class is exclusively used is
termed "synchronization" in the JAVA language. In the JAVA
language, synchronization may usually be operationalized or
implemented in one of three ways or means. The first way or means
is through the use of a synchronization method description that is
included in the source-code of an application program written in
the JAVA language. The second way or means is by the inclusion of a
`synchronization descriptor` in the method descriptor of a compiled
application program of the JAVA virtual machine. And the third way
or means for performing synchronization are by the use of the
instructions monitor enter (e.g., "monitorenter") and monitor exit
(e.g., "monitorexit") of the JAVA virtual machine which signify
respectively the beginning and ending of a synchronization routine
which results in the acquiring or execution of a "lock" (or other
mutual exclusion operator or operation), and the releasing or
termination of a "lock" (or other mutual exclusion operator or
operation) respectively which prevents an asset being the subject
of conflict (or race condition, or unwanted interaction, or other
anomalous behaviour due to unexpected critical dependence on the
relative timing of events) between multiple and potentially
concurrent uses. An asset may for example include a class or an
object, as well as any other
software/language/runtime/platform/architecture or machine
resource. Such resources may include for example, but are not
limited to, software programs (such as for example executable
software. modules, subprograms, sub-modules, application program
interfaces (API), software libraries, dynamically linkable
libraries) and data (such as for example data types, data
structures, variables, arrays, lists, structures, unions), and
memory locations (such as for example named memory locations,
memory ranges, address space(s), registers) and input/output (I/O)
ports and/or interfaces, or other machine, computer, or information
appliance resource or asset.
[0167] However, in the arrangement illustrated in FIG. 8, (and also
in FIGS. 21-23), a plurality of individual computers or machines
M1, M2 . . . , Mn are provided, each of which are interconnected
via a communications network 53 or other communications link and
each of which individual computers or machines is provided with a
modifier 51 (See in FIG. 5) and realised by or in for example the
distributed run time (DRT) 71 (See FIG. 8) and loaded with a common
application code 50. The term common application program is to be
understood to mean an application program or application program
code written to operate on a single machine, and loaded and/or
executed in whole or in part on each one of the plurality of
computers or machines M1, M2 . . . Mn, or optionally on each one of
some subset of the plurality of computers or machines M1, M2 . . .
Mn. Put somewhat differently, there is a common application program
represented in application code 50, and this single copy or perhaps
a plurality of identical copies are modified to generate a modified
copy or version of the application program, each copy or instance
prepared for execution on the plurality of machines. At the point
after they are modified they are common in the sense that they
perform similar operations and operate consistently and coherently
with each other. It will be appreciated that a plurality of
computers, machines, information appliances, or the like
implementing the features of the invention may optionally be
connected to or coupled with other computers, machines, information
appliances, or the like that do not implement the features of the
invention.
[0168] In some embodiments, some or all of the plurality of
individual computers or machines may be contained within a single
housing or chassis (such as so-called "blade servers" manufactured
by Hewlett-Packard Development Company, Intel Corporation, IBM
Corporation and others) or implemented on a single printed circuit
board or even within a single chip or chip set.
[0169] Essentially the modifier 51 or DRT 71 ensures that when an
executing part (such as a thread or process) of the modified
application program 50 running on one or more of the machines
exclusively utilizes (e.g., by means of a synchronization routine
or similar or equivalent mutual exclusion operator or operation) a
particular local asset, such as an objects 50X-50Z or class 50A, no
other executing part and potentially concurrently executing part on
machines M2 . . . Mn exclusively utilizes the similar equivalent
corresponding asset in its local memory at once or at the same
time.
[0170] It will be appreciated in light of the description provided
herein that there are alternative implementations of the modifier
51 and the distributed runtime system 71. For example, the modifier
51 may be implemented as a component of or within the distributed
run time 71, and therefore the DRT 71 may implement the functions
and operations of the modifier 51. Alternatively, the function and
operation of the modifier 51 may be implemented outside of the
structure, software, firmware, or other means used to implement the
DRT 71. In one embodiment, the modifier 51 and DRT 71 are
implemented or written in a single piece of computer program code
that provides the functions of the DRT and modifier. The modifier
function and structure therefore maybe subsumed into the DRT and
considered to be an optional component. Independent of how
implemented, the modifier function and structure is responsible for
modifying the executable code of the application code program, and
the distributed run time function and structure is responsible for
implementing communications between and among the computers or
machines. The communications functionality in one embodiment is
implemented via an intermediary protocol layer within the computer
program code of the DRT on each machine. The DRT may for example
implement a communications stack in the JAVA language and use the
Transmission Control Protocol/Internet Protocol (TCP/IP) to provide
for communications or talking between the machines. Exactly how
these functions or operations are implemented or divided between
structural and/or procedural elements, or between computer program
code or data structures within the invention are less important
than that they are provided.
[0171] It will therefore be understood in light of the description
provided here that the invention further includes any means of
implementing thread-safety, regardless of whether it is through the
use of locks (lock/unlock), synchronizations, monitors,
semphafores, mutexes, or other mechanisms.
[0172] It will be appreciated that synchronization means or implies
"exclusive use" or "mutual exclusion" of an asset or resource.
Conventional structures and methods for implementations of single
computers or machines have developed some methods for
synchronization on such single computer or machine configurations.
However, these conventional structures and methods have not
provided solutions for synchronization between and among a
plurality of computers, machines, or information appliances.
[0173] In particular, whilst one particular machine (say, for
example machine M3) is exclusively using an object or class (or any
other asset or resource), another machine (say, for example machine
M5) may also be instructed by the code it is executing to
exclusively use the local similar equivalent object or class
corresponding to the similar equivalent object or class on machine
M3 at the same time or an overlapping time period. Thus if the same
corresponding local similar equivalent objects or classes on each
machine M3 and M5 were to be exclusively used by both machines,
then the behaviour of the object and application as a whole is
undefined--that is, in the absence of proper exclusive use of an
object (or class) when explicitly specified by the computer program
(programmer), conflict, race conditions, unwanted interactions,
anomalous behaviour due to unexpected dependence on the relative
timing of events, or permanent inconsistency between the similar
equivalent objects on machines M5 and M3 is likely to result. Thus
a goal of achieving or providing consistent, coordinated, and
coherent operation of synchronization routines (or other mutual
exclusion operations) between and amongst a plurality of machines,
as required for the simultaneous and coordinated operation of the
same application program code on each of the plurality of machines
M1, M2 . . . Mn, would not be achieved.
[0174] In order to ensure consistent synchronization between and
amongst machines M1, M2 . . . Mn the application code 50 is
analysed or scrutinized by searching through the executable
application code 50 in order to detect program steps (such as
particular instructions or instruction types) in the application
code 50 which define or constitute or otherwise represent a
synchronization routine (or other mutual exclusion operation). In
the JAVA language, such program steps may for example comprise or
consist of an opening monitor enter (e.g. "monitorenter")
instruction and one or more closing monitor exit (e.g.
"monitorexit") instructions. In one embodiment, a synchronization
routine may start with the execution of a "monitorenter"
instruction and close with a paired execution of a "monitorexit"
instruction.
[0175] This analysis or scrutiny of the application code 50 may
take place either prior to loading the application program code 50,
or during the application program code 50 loading procedure, or
even after the application program code 50 loading procedure. It
may be likened to an instrumentation, program transformation,
translation, or compilation procedure in that the application code
may be instrumented with additional instructions, and/or otherwise
modified by meaning-preserving program manipulations, and/or
optionally translated from an input code language to a different
code language (such as for example from source-code language or
intermediate-code language to object-code language or machine-code
language), and with the understanding that the term compilation
normally or conventionally involves a change in code or language,
for example, from source code to object code or from one language
to another language. However, in the present instance the term
"compilation" (and its grammatical equivalents) is not so
restricted and can also include or embrace modifications within the
same code or language. For example, the compilation and its
equivalents are understood to encompass both ordinary compilation
(such as for example by way of illustration but not limitation,
from source-code to object-code), and compilation from source-code
to source-code, as well as compilation from object-code to
object-code, and any altered combinations therein. It is also
inclusive of so-called "intermediary languages" which are a form of
"pseudo object-code".
[0176] By way of illustration and not limitation, in one
embodiment, the analysis or scrutiny of the application code 50 may
take place during the loading of the application program code such
as by the operating system reading the application code from the
hard disk or other storage device or source and copying it into
memory and preparing to begin execution of the application program
code. In another embodiment, in a JAVA virtual machine, the
analysis or scrutiny may take place during the class loading
procedure of the java.lang.ClassLoader loadClass method (e.g.,
"java.lang.ClassLoader.loadClass( )").
[0177] Alternatively, the analysis or scrutiny of the application
code 50 may take place even after the application program code
loading procedure, such as after the operating system has loaded
the application code into memory, or optionally even after
execution of the application program code has started, such as for
example after the JAVA virtual machine has loaded the application
code into the virtual machine via the
"java.lang.ClassLoader.loadClass( )" method and optionally
commenced execution.
[0178] Reference is made to the accompanying Annexure D in which:
Annexure D1 is a typical code fragment from a synchronization
routine prior to modification (e.g., an exemplary unmodified
synchronization routine), and Annexure D2 is the same
synchronization routine after modification (e.g., an exemplary
modified synchronization routine). These code fragments are
exemplary only and identify one software code means for performing
the modification in an exemplary language. It will be appreciated
that other software/firmware or computer program code may be used
to accomplish the same or analogous function or operation without
departing from the invention.
[0179] Annexures D1 and D2 (also reproduced in part in Tables XX
and XXI below) are exemplary code listings that set forth the
conventional or unmodified computer program software code (such as
may be used in a single machine or computer environment) of a
synchronization routine of application program 50 and a
post-modification excerpt of the same synchronization routine such
as may be used in embodiments of the present invention having
multiple machines. The modified code that is added to the
synchronization method is highlighted in bold text. Other
embodiments of the invention may provide for code or statements or
instructions to be added, amended, removed, moved or reorganized,
or otherwise altered.
[0180] It is noted that the compiled code in the Annexure and
portion repeated in the table is taken from the source-code of the
file "example.java" which is included in the Annexure D3. The
disassembled compiled code that is listed in the Annexure and Table
is taken from compiled source code of the file "EXAMPLE.JAVA". In
the procedure of Annexure D1 and Table XXX, the procedure name
"Method void run( )" of Step 001 is the name of the displayed
disassembled output of the run method of the compiled application
code of "example.java". The name "Method void run( )" is arbitrary
and selected for this example to indicate a typical JAVA method
inclusive of a synchronization operation. Overall the method is
responsible for incrementing a memory location ("counter") in a
thread-safe manner through the use of a synchronization statement
and the steps to accomplish this are described in turn.
[0181] First (Step 002), the Java Virtual Machine instruction
"getstatic #2 <Field java.lang.Object LOCK>" causes the Java
Virtual Machine to retrieve the object reference of the static
field indicated by the CONSTANT_Fieldref_info constant-pool item
stored in the 2.sup.nd index of the classfile structure of the
application program containing this example run( ) method and
results in a reference to the object (hereafter referred to as
LOCK) in the field to be placed (pushed) on the stack of the
current method frame of the currently executing thread.
[0182] Next (Step 003), the Java Virtual Machine instruction "dup"
causes the Java Virtual Machine to duplicate the topmost item of
the stack and push the duplicated item onto the topmost position of
the stack of the current method frame and results in the reference
to the LOCK object at the top of the stack being duplicated and
pushed onto the stack.
[0183] Next (Step 004), the Java Virtual Machine instruction
"astore.sub.--1" causes the Java Virtual Machine to remove the
topmost item of the stack of the current method frame and store the
item into the local variable array at index 1 of the current method
frame and results in the topmost LOCK object reference of the stack
being stored in the local variable index 1.
[0184] Then (Step 005), the Java Virtual Machine instruction
"monitorenter" causes the Java Virtual Machine to pop the topmost
object off the stack of the current method frame and acquire an
exclusive lock on said popped object and results in a lock being
acquired on the LOCK object.
[0185] The Java Virtual Machine instruction "getstatic #3 <Field
int counter>" (Step 006) causes the Java Virtual Machine to
retrieve the integer value of the static field indicated by the
CONSTANT_Fieldref_info constant-pool item stored in the 3rd index
of the classfile structure of the application program containing
this example run( ) method and results in the integer value of said
field being placed (pushed) on the stack of the current method
frame of the currently executing thread.
[0186] The Java Virtual Machine instruction "iconst.sub.--1" (Step
007) causes the Java Virtual Machine to load an integer value of
"1" onto the stack of the current method frame and results in the
integer value of 1 loaded onto the top of the stack of the current
method frame.
[0187] The Java Virtual Machine instruction "iadd" (Step 008)
causes the Java Virtual Machine to perform an integer addition of
the two topmost integer values of the stack of the current method
frame and results in the resulting integer value of the addition
operation being placed on the top of the stack of the current
method frame.
[0188] The Java Virtual Machine instruction "putstatic #3 <Field
int counter>" (Step 009) causes the Java Virtual Machine to pop
the topmost value off the stack of the current method frame and
store the value in the static field indicated by the
CONSTANT_Fieldref_info constant-pool item stored in the 3.sup.rd
index of the classfile structure of the application program
containing this example run( ) method and results in the topmost
integer value of the stack of the current method frame being stored
in the integer field named "counter".
[0189] The Java Virtual Machine instruction "aload.sub.--1" (Step
010) causes the Java Virtual Machine to load the item in the local
variable array at index 1 of the current method frame and store
this item on the top of the stack of the current method frame and
results in the object reference stored in the local variable array
at index 1 being pushed onto the stack.
[0190] The Java Virtual Machine instruction "monitorexit" (Step
011) causes the Java Virtual Machine to pop the topmost object off
the stack of the current method frame and release the exclusive
lock on said popped object and results in the LOCK being released
on the LOCK object.
[0191] Finally, the Java Virtual Machine instruction "return" (Step
012) causes the Java Virtual Machine to cease executing this run( )
method by returning control to the previous method frame and
results in termination of execution of this run( ) method.
[0192] As a result of these steps operating on a single machine of
the conventional configurations in FIG. 1 and FIG. 2, the
synchronization statement enclosing the increment operation of the
"counter" memory location ensures that no two or more concurrently
execution instances of this run( ) method will conflict, or
otherwise result in unwanted interactions such as a race-condition
or other anomalous behaviour due to unexpected critical dependence
on the relative timing of the incrementing events performed of the
one "counter" memory location. Were these steps to be carried out
on the plurality of machines of the configurations of FIG. 5 and
FIG. 8 with the memory update and propagation replication means of
FIGS. 9, 10, 11, 12 and 13, and concurrently executing two or more
instances or occurrences of the run( ) method each on a different
one of the plurality of machines M1, M2 . . . Mn, the mutual
exclusion operations of each concurrently executing instance of the
run( ) method would be performed on each corresponding one of the
machines without coordination between those machines.
[0193] Given the goal of consistent coordinated synchronization
operation across a plurality of machines, this prior art
arrangement would fail to perform such consistent coordinated
synchronization operation across the plurality of machines, as each
machine performs synchronization only locally and without any
attempt to coordinate their local synchronization operation with
any other similar synchronization operation on any one or more
other machines. Such an arrangement would therefore be susceptible
to conflict or other unwanted interactions (such as race-conditions
or other anomalous behaviour due to unexpected critical dependence
on the relative timing of the "counter" increment events on each
machine) between the machines M1, M2, . . . , Mn. Therefore it is
the goal of the present invention to overcome this limitation of
the prior art arrangement.
[0194] In the exemplary code in Table XXI (Annexure D2), the code
has been modified so that it solves the problem of consistent
coordinated synchronization operation for a plurality of machines
M1, M2, . . . , Mn, that was not solved in the code example from
Table XX (Annexure D1). In this modified run( ) method code, a
"dup" instruction is inserted between the "4 astore.sub.--1" and "6
monitorenter" instructions. This causes the Java Virtual Machine to
duplicate the topmost item of the stack and push said duplicated
item onto the topmost position of the stack of the current method
frame and results in the reference to the LOCK object at the top of
the stack being duplicated and pushed onto the stack.
[0195] Furthermore, the Java Virtual Machine instruction
"invokestatic #23 <Method void
acquireLock(java.lang.Object)>" is inserted after the "6
monitorenter" and before the "10 getstatic #3 <Field int
counter>" statements so that the Java Virtual Machine pops the
topmost item off the stack of the current method frame and invokes
the "acquireLock" method, passing the popped item to the new method
frame as its first argument. This change is particularly
significant because it modifies the run( ) method to execute the
"acquireLock" method and associated operations, corresponding to
the "monitorenter" instruction preceding it. Annexure D1 is a
before-modification excerpt of the disassembled compiled form of
the synchronization operation of example.java of Annexure D3,
consisting of an starting "monitorenter" instruction and ending
"monitorexit" instruction. Annexure D2 is an after-modification
form of Annexure D1, modified by LockLoader.java of Annexure D6 in
accordance with the steps of FIG. 16. The modifications are
highlighted in bold. TABLE-US-00010 TABLE X Annexure D1 Step
Annexure D1 001 Method void run( ) 002 0 getstatic #2 <Field
java.lang.Object LOCK> 003 3 dup 004 4 astore_1 005 5
monitorenter 006 6 getstatic #3 <Field int counter> 007 9
iconst_1 008 10 iadd 009 11 putstatic #3 <Field int counter>
010 14 aload_1 011 15 monitorexit 012 16 return
[0196] TABLE-US-00011 TABLE XXI Annexure D2 Step Annexure D2 001
Method void run( ) 002 0 getstatic #2 <Field java.lang.Object
LOCK> 003 3 dup 004 4 astore_1 004A 5 dup 005 6 monitorenter
005A 7 invokestatic #23 <Method void
acquireLock(java.lang.Object)> 006 10 getstatic #3 <Field int
counter> 007 13 iconst_1 008 14 iadd 009 15 putstatic #3
<Field int counter> 010 18 aload_1 010A 19 dup 010B 20
invokestatic #24 <Method void releaseLock(java.lang.Object)>
011 23 monitorexit 24 return
[0197] The method void acquireLock(java.lang.Object), part of the
LockClient code of Annexure D4 and part of the distributed runtime
system (DRT) 71, performs the communications operations between
machines M1, . . . , Mn to coordinate the execution of the
preceding "monitorenter" synchronization operation amongst the
machines M1 . . . Mn. The acquireLock method of this example
communicates with the LockServer code of Annexure D5 executing on a
machine X of FIG. 15, by means of sending an `acquire lock request`
to machine X corresponding to the object being `locked` (i.e., the
object corresponding to the "monitorenter" instruction), which in
the context of Table XXI and Annexure D2 is the `LOCK` object. With
reference to FIG. 19, Machine X receives the `acquire lock request`
corresponding to the LOCK object, and consults a table of locks to
determine the lock status corresponding to the plurality of similar
equivalent objects on each of the machines, which in the case of
Annexure D2 is the plurality of similar equivalent LOCK
objects.
[0198] If all of the plurality of similar equivalent objects on
each of the plurality of machines M1 . . . Mn is presently not
locked by any other machine M1 . . . Mn, then Machine X will record
the object as now locked and inform the requesting machine of the
successful acquisition of the lock. Alternatively, if a similar
equivalent object is presently locked by another one of the
machines M1 . . . Mn, then Machine X will append this requesting
machine to a queue of machines waiting to lock this plurality of
similar equivalent objects, until such a time as machine X
determines this requesting machine can acquire the lock.
Corresponding to the successful acquisition of a lock by a
requesting machine, a reply is generated and sent to the successful
requesting machine informing that machine of the successful
acquisition of the lock. Following a receipt of such a message from
Machine X confirming the successful acquisition of a requested
lock, the acquireLock method and operations terminate execution and
return control to the previous method frame, which is the context
of Annexure D2 is the executing method frame of the run( ) method.
Until such a time as the requesting machine receives a reply from
machine X confirming the successful acquisition of the requested
lock, the operation of the acquireLock method and run( ) method are
suspended until such a confirmatory reply is received. Following
this return operation, the execution of the run( ) method then
resumes. Exemplary source-code for an embodiment of the acquireLock
method is provided in Annexure D4. Annexure D4 also provides
additional detail concerning DRT 71 functionality.
[0199] Later, the two statements "dup" and "invokestatic #24
<Method void releaseLock(java.lang.Object)>" are inserted
into the code stream after the "18 aload.sub.--1" statement and
before the "23 monitorexit" statement. These two statements cause
the Java Virtual Machine to duplicate the item on the stack and
then invoke the releaseLock method with the topmost item of the
stack as an argument to the method call and result in the
modification of the run( ) method to execute the "releaseLock"
method and associated operations, corresponding to the following
"monitorexit" instruction, before the procedure exits and
returns.
[0200] The method void releaseLock(java.lang.Object), part of the
LockClient code of Annexure D4 and part of the distributed runtime
system (DRT) 71, performs the communications operations between
machines M1 . . . Mn to coordinate the execution of the following
"monitorexit" synchronization operation amongst the machines M1 . .
. Mn. The releaseLock method of this example communications with
LockServer code of Annexure D5 executing on a machine X of FIG. 15,
by means of sending a "release lock request" to machine X
corresponding to the object being "unlocked" (i.e., the object
corresponding to the "monitorexit" instruction), which in the
context of Table XXI and Annexure D2 is the `LOCK` object.
Corresponding to FIG. 20, machine X receives the "release lock
request" corresponding to the LOCK object, and updates the table of
locks to indicate the lock status corresponding to the plurality of
similar equivalent `LOCK` objects as now "unlocked". Additionally,
if there are other machines awaiting acquisition of this lock, then
machine X is able to select one of the awaiting machines to be the
new owner of the lock by updating the table of locks to indicate
this selected one awaiting machine as the new lock owner, and
informing the successful one of the awaiting machines of its
successful acquisition of the lock by means of a confirmatory
reply. The successful one of the awaiting machines then resumes
execution of its synchronization routine. Following the
notification to machine X of lock release, the releaseLock method
terminates execution and returns control to the previous method
frame, which in this instance is the method frame of the run( )
method. Following this return operation, the execution of the run(
) method resumes.
[0201] It will be appreciated that the modified code permits, in a
distributed computing environment having a plurality of computers
or computing machines, the coordinated operation of synchronization
routines or other mutual exclusion operations between and amongst
machines M1 . . . Mn so that the problems associated with the
operation of the unmodified code or procedure on a plurality of
machines M1 . . . Mn (such as conflicts, unwanted interactions,
race-conditions, or anomalous behaviour due to unexpected critical
dependence on the relative time of events) does not occur when
applying the modified code or procedure.
[0202] In the unmodified code sample of Annexure D1, the
application program code includes instructions or operations that
increment a memory location in local memory (used for a counter)
within an enclosing synchronization routine. The purpose of the
synchronization routine is to ensure thread-safety of the counter
memory increment operation in multi-threaded and multi-processing
applications and computer systems. The terms thread-safe or
thread-safety refer to code that is either re-entrant or protected
from multiple simultaneous execution by some form of mutual
exclusion. Multi-threaded applications in the context of the
invention may, for example, include applications operating two or
more threads of execution concurrently each on a different machine.
Thus, without the management of coordinated synchronization in
environments comprising or consisting of a plurality of machines,
each running concurrently executing part of a same application
program, and with a memory updating and propagation replication
means of FIGS. 9, 10, 11, 12, and 13, each computer or computing
machine would perform synchronization in isolation, thus
potentially incrementing the shared counter at the same time,
leading to potential conflicts or unwanted interactions such as
race condition(s) and incoherent memory between the machines M1 . .
. Mn. It will be appreciated that although this embodiment is
described using a shared counter, the use or provision of such
shared counter or memory location is optional and not required for
the synchronization aspects of the invention. What is advantageous
is that the synchronization routine behaves in a manner as the
programming language, runtime system, or machine architecture (or
any combination thereof) guarantees--that is, stop two parts (for
example, two threads) of the application program from executing the
same synchronization routine or same mutual exclusion operation or
operator concurrently. Clearly consistent, coherent and coordinated
synchronization behaviour is what the programmer or user of the
application program code 50 expects to happen.
[0203] So, taking advantage of the DRT 71, the application code 50
is modified as it is loaded into the machine by changing the
synchronization routine. It will be appreciated in light of the
description provided here that the modifications made on each
machine may generally be similar in-so-far as they should
advantageously achieve a consistent end result of coordinated
synchronization operation amongst all the machines; however, given
the broad applicability of the inventive synchronization method and
associated procedures, the nature of the modifications may
generally vary without altering the effect produced. For example,
in a simple variation, one or more additional instructions or
statements may be inserted, such as for example a "no-operation"
(nop) type instruction into the application will mean the
modifications made are technically different, but the modified code
still conforms to the invention. Embodiments of the invention may
for example, implement the changes by means of program
transformation, translation, various forms of compilation,
instrumentation, or by other means described herein or known in the
art. The changes made (highlighted in bold text) are the starting
or initial instructions and the ending instructions that the
synchronization routine executes, and which correspond to the entry
(start) and exit (finish) of the synchronization routine
respectively. These added instructions (or modified instruction
stream) act to coordinate the execution of the synchronization
routine amongst the multiple concurrently executing instances or
occurrences of the modified run method executing on each one of, or
some subset of, the plurality of machines M1 . . . Mn, by invoking
the acquireLock method corresponding to the start of execution of
the synchronization routine, and by invoking the releaseLock method
corresponding to the finish of execution of the synchronization
routine, thereby providing consistent coordinated operation of the
synchronization routine (or other mutual exclusion operation or
operator) as required for the simultaneous operation of the
modified application program code that is running on or across the
plurality of machines M1, M2, . . . , Mn. This also advantageously
provides for operation of the one application program in a
coordinated manner across the machines.
[0204] The acquire lock (e.g. "acquireLock( )") method of the DRT
71 takes an argument "(java.lang.Object)" which represents a
reference to (or some other unique identifier for) the particular
local object for which the global lock is desired (See Annexure D2
and Table XXI), and is to be used in acquiring a global lock across
the plurality of similar equivalent objects on the other machines
corresponding to the specified local object. The unique identifier
may, for example be the name of the object, a reference to the
object in question, or a unique number representing the plurality
of similar equivalent objects across all nodes. By using a globally
unique identifier across all connected machines to represent the
plurality of similar equivalent objects on the plurality of
machines, the DRT can support the synchronization of multiple
objects at the same time without becoming confused as to which of
the multiple objects are already synchronized and which are not as
might be the case if object (or class) identifiers were not unique,
by using the unique identifier of each object to consult the
correct record in the shared synchronization table.
[0205] A further advantage of using a global identifier here is as
a form of `meta-name` for all the similar equivalent local objects
on each one of the machines. For example, rather than having to
keep track of each unique local name of each similar equivalent
local object on each machine, one may instead define a global name
(e.g., "globalname7787") which each local machine in turn maps to a
local object (e.g., "globalname7787" points to object
"localobject456" on machine M1, and "globalname7787" points to
object "localobject885" on machine M2, and "globalname7787" points
to object "localobject111" on machine M3, and so forth). It
thereafter is easier to simply say "acquire lock for
globalname7787" which is then translated on machine 1 (M1) to mean
"acquire lock for localobject456", and is translated on machine 2
(M2) to mean "acquire lock for localobject885", and so on.
[0206] The shared synchronization table that may optionally be used
is a table, other storage means, or any other data structure that
stores an object (and/or class or other asset) identifier and the
synchronization status (or locked or unlocked status) of each
object (and/or class or other asset). The table or other storage
means operates to relate an object (and/or class or other asset, or
a plurality of similar equivalent objects or classes or assets) to
a status of either locked or unlocked or some other physical or
logical indication of a locked state and an unlocked state. For
example: the table (or any other data structure one cares to
employ) may advantageously include a named object identifier and a
record indicating if a named object (i.e., "globalname7787") is
locked or unlocked. In one embodiment, the table or other storage
means stores a flag or memory bit, wherein when the flag or memory
bit stores a "0" the object is unlocked and when the flag or memory
bit stores a "1" the object is locked. Clearly, multiple bit or
byte storage may be used and different logic sense or indicators
may be used without departing from the invention.
[0207] The DRT 71 can determine the synchronization state of the
object in any one of a number of ways. Recall, for example that the
invention may include any means of implementing thread-safety,
regardless of whether it is through the use of locks (lock/unlock),
synchronizations, monitors, semphafores, mutexes, or other
mechanisms. These means stop or limit concurrently executing parts
of a single application program in order to guarantee consistency
according to the rules of synchronization, locks, or the like.
Preferably, it can ask each machine in turn if their local similar
equivalent object (or class or other asset or resource)
corresponding to the object being sought to be locked is presently
synchronized, and if any machine replies true, then to pause
execution of the synchronization routine and wait until that
presently synchronized similar equivalent object on the other
machine is unsynchronised, otherwise synchronize this object
locally and resume execution of the synchronization routine. Each
machine may implement synchronization (or mutual exclusion
operations or operators) in its own way and this may be different
in the different machines. Therefore, although some exemplary
implementation details are provided, ultimately how synchronization
(or mutual exclusion operations) is (are) implemented, or precisely
how synchronization or mutual exclusion status (or locked/unlocked
status) is recorded in memory or other storage means, is not
critical to the invention. By unsynchronized we generally mean
unlocked or otherwise not subject to a mutual exclusion operation,
and by synchronized we generally mean locked and subject to a
mutual exclusion operation.
[0208] Alternatively, the DRT 71 on each local machine can consult
a shared record table (perhaps on a separate machine (for example,
on machine X which is different from machines M1, M2, . . . , Mn)),
or can consult a coherent shared record table on each one of the
local machines, or a shared database established in a memory or
other storage, to determine if this object has been marked or
identified as synchronized (or "locked") by any machine and if so,
then wait until the status of the object is changed to "unlocked"
and then acquire the lock on this machine, otherwise acquire the
lock by marking the object as locked (optionally by this machine)
in the shared lock table.
[0209] In the situation where the shared record table is consulted,
this may be considered as a variation of a shared database or data
structure, where each machine has a local copy of a shared table
(that is a replica of a shared table) with is updated to maintain
coherency across the plurality of machines M1, . . . , Mn.
[0210] In one embodiment, the shared record table refers to a
shared table accessible by all machines M1, . . . , Mn, that may
for example be defined or stored in a commonly accessibly database
such that any machine M1, . . . , Mn can consult or read this
shared database table for the locked or unlocked status of an
object. A further alternative arrangement is to implement a shared
record table as a table in the memory of an additional machine
(which we call "machine X") which stores each object identification
name and its lock status, and serves as the central repository
which all other machines M1, . . . , Mn consult to determine locked
status of similar equivalent objects.
[0211] In any of these different alternative implementations, the
manner in which a one of, or a plurality of, similar equivalent
objects is marked or identified as being synchronized (or locked)
or unsynchronized (or unlocked) is relatively unimportant, and
various stored memory bits or bytes or flags may be utilized as are
known in the art to identify either one of the two possible logic
states. It will also be appreciated that in the present embodiment,
that synchronized is largely synonymous with locked and
unsynchronized is largely synonymous with unlocked. These same
considerations apply for classes as well as for other assets or
resources.
[0212] Recall that the DRT 71 is responsible for determining the
locked status for an object (or class, or other asset,
corresponding to a plurality of similar equivalent objects or
classes or assets) seeking to be locked before allowing the
synchronization routine corresponding to the acquisition of that
lock to proceed. In the exemplary embodiment described here, the
DRT consults the shared synchronization record table which in one
embodiment resides on an special "machine X", and therefore the DRT
needs to communicate via the network or other communications link
or path with this machine X to enquire as to and determine the
locked (or unlocked) status of the object (or class or other asset
corresponding to a plurality of similar equivalent objects or
classes or assets).
[0213] If the DRT on the local machine that is trying to execute a
synchronization routine or other mutual exclusion operation
determines that no other machine currently has a lock for this
object (i.e., no other machine has synchronized this object) or any
other one of a plurality of similar equivalent objects, then to
acquire the lock for this object corresponding to the plurality of
similar equivalent objects on all other machines, for example by
means of modifying the corresponding entry in a shared table of
locked states for the object sought to be locked or alternatively,
sequentially acquiring the lock on all other similar equivalent
objects on all other machines in addition to the current machine.
Note that the intent of this procedure is to lock the plurality of
similar equivalent objects (or classes or assets) on all the other
machines M1, . . . , Mn so that simultaneous or concurrent use of
any similar equivalent objects by two or more machines is
prevented, and any available approach may be utilized to accomplish
this coordinated locking. For example, it does not matter if
machine M1 instructs M2 to lock its similar equivalent local
object, then instructs M3 to lock its similar equivalent local
object, and then instructs M4 and so on; or if M1 instructs M2 to
lock its similar equivalent local object, and then M2 instructs M3
to lock its similar equivalent local object, and then M3 instructs
M4 to lock its similar equivalent local object, and so forth, what
is being sought is the locking of the similar equivalent objects on
all other machines so that simultaneous or concurrent use any
similar equivalent objects by two or more machines is prevented.
Only once this machine has successfully confirmed that no other
machine has currently locked a similar equivalent object, and this
machine has correspondingly locked its locally similar equivalent
object, can the execution of the synchronization routine or
code-block begin.
[0214] On the other hand, if the DRT 71 within the machine about to
execute a synchronization routine (such as machine M1) determines
that another machine, such as machine M4 has already synchronized a
similar equivalent object, then this machine M1 is to postpone
continued execution of the synchronization routine (or code-block)
until such a time as the DRT on machine M1 can confirm than no
other machine (such as one of machines M2, M3, M4, or M5, . . . ,
Mn) is presently executing a synchronize routine on a corresponding
similar equivalent local object, and that this machine M1 has
correspondingly synchronized its similar equivalent object locally.
Recall that local synchronization refers to prior art conventional
synchronization on a single machine, whereas global or coordinated
synchronization refers to coordinated synchronization of, across
and/or between similar equivalent local objects each on a one of
the plurality of machines M1 . . . Mn. In such a case, the
synchronization routine (or code-block) is not to continue
execution until this machine M1 can guarantee that no other machine
M2, M3, M4, . . . , Mn is executing a synchronization routine
corresponding to the local similar equivalent object being sought
to be locked, as it will potentially corrupt the object across the
participating machines M1, M2, M3, . . . , Mn due to susceptibility
to conflicts or other unwanted interactions such as
race-conditions, and the like problems resulting from the
concurrent execution of synchronization routines. Thus, when the
DRT determines that this object, or a similar equivalent object on
another machine, is presently "locked", say by machine M4 (relative
to all other machines), the DRT on machine M1 pauses execution of
the synchronization routine by pausing the execution of the acquire
lock (e.g., "acquireLock( )") operation until such a time as a
corresponding release lock (e.g., "releaseLock( )") operation is
executed by the present owner of the lock (e.g., machine M4).
[0215] Thus, on execution of a release lock (e.g. "releaseLock( )")
operation, the machine M4 which presently "owns" or holds a lock
(i.e., is executing a synchronization routine) indicates the close
of its synchronization routine, for example by marking this object
as "unlocked" in the shared table of locked states, or
alternatively, sequentially releasing locks acquired on all other
machines. At this point, a different machine waiting to begin
execution of a paused synchronization statement can then claim
ownership of this now released lock by resuming execution of its
postponed (i.e. delayed) "acquireLock( )" operation, for example,
by marking itself as executing a lock for this similar equivalent
object in the shared table of synchronization states, or
alternatively, sequentially acquiring local locks of similar
equivalent objects on each of the other machines. It is to be
understood that the resumed execution of the acquire lock (e.g.,
"acquireLock") operation is to be inclusive of the optional
resumption of execution of the acquire lock (e.g., "acquireLock")
method at the point that execution was paused, as well as the
alternative optional arrangement wherein the execution of the
acquire lock (e.g., "acquireLock") operation is repeated so as to
re-request the lock. Again, these same considerations also apply
for classes and more generally to any asset or resource.
[0216] So, according to at least one embodiment and taking
advantage of the operation of the DRT 71, the application code 50
is modified as it is loaded into the machine by changing the
synchronization routine (consisting of at least a beginning
"acquire lock" type instruction (such as a JAVA "monitorenter"
instruction) and an ending "release lock" type instruction (such as
a JAVA "monitorexit" instruction). "Acquire lock" type instructions
commence operation or execution of a mutual exclusion operation,
generally corresponding to a particular asset such as a particular
memory location or machine resource, and result in the asset
corresponding to the mutual exclusion operation being locked with
respect to some or all modes of simultaneous or concurrent use,
execution or operation. "Release lock" type instructions terminate
or otherwise discontinue operation or execution of a mutual
exclusion operation, generally corresponding to a particular asset
such as a particular memory location or machine resource, and
result in the asset corresponding to the mutual exclusion operation
being unlocked with respect to some or all modes of simultaneous or
concurrent use, execution or operation. The changes made
(highlighted in bold) are the modified instructions that the
synchronization routine executes. These added instructions for
example check if this lock has already been acquired by another
machine. If this lock has not been acquired by another machine,
then the DRT of this machine notifies all other machines that this
machine has acquired the specified lock, and thereby stopping the
other machines from executing synchronization routines
corresponding to this lock.
[0217] The DRT 71 can determine and record the lock status of
similar equivalent objects, or other corresponding memory location
or machine or software resource on a plurality of machines, in many
ways, such as for example, by way of illustration but not
limitation:
[0218] 1. Corresponding to the entry to a synchronization routine
by Machine M1, the DRT of machine M1 individually consults or
communicates with each machine to ascertain if this global lock is
already acquired by any other Machine M2, . . . , Mn different from
itself. If this global lock corresponding to this asset or object
is or has already been acquired by another one of the machines M2,
. . . , Mn then the DRT of Machine M1 pauses execution of the
synchronization routine on machine M1 until all other machines no
longer own a global lock on this asset or object (that is to say
that none of the other machines any longer own a global lock
corresponding to this asset or object), at which point machine M1
can successfully acquire the global lock such that all other
machines M2, . . . , Mn must now wait for machine M1 to release the
global lock before a different machine can in turn acquire it.
Otherwise, when it is determined that this global lock
corresponding to this asset or object has not already been acquired
by another machine M2, . . . , Mn the DRT continues execution of
the synchronization routine, and such that all other machines M2, .
. . , Mn must now wait for machine M1 to release the global lock
before a different machine can in turn acquire it.
[0219] Alternatively, 2. Corresponding to the entry to a
synchronization routine, the DRT consults a shared table of records
(for example a shared database, or a copy of a shared table on each
of the participating machines) which indicate if any machine
currently "owns" this global lock. If so, the DRT then pauses
execution of the synchronization routine on this machine until no
machine owns a global lock on a similar equivalent object.
Otherwise the DRT records this machine in the shared table (or
tables, if there are multiple tables of records, e.g., on multiple
machines) as the owner of this global lock, and then continues
executing the synchronization routine.
[0220] Similarly, when a global lock is released, that is to say,
when the execution of a synchronization routine is to end, the DRT
can "un-record", alter the status indicator, and/or reset the
global lock status of machines in many alternative ways, for
example by way of illustration but not limitation:
[0221] 1. Corresponding to the exit to a synchronization routine,
the DRT individually notifies each other machine that it no longer
owns the global lock.
[0222] Alternatively,
[0223] 2. Corresponding to the exit to a synchronization routine,
the DRT updates the record for this globally locked asset or object
(such as for example a plurality of similar equivalent objects or
assets) in the shared table(s) of records such that this machine is
no longer recorded as owning this global lock.
[0224] Still further, the DRT can provide an acquire global lock
queue to queue machines needing to acquire a global lock in
multiple alternative ways, for example by way of illustration but
not limitation:
[0225] 1. Corresponding to the entry to a synchronization routine
by Machine M1 say, the DRT of machine M1 notifies the present
owning machine (say Machine M4) of the global lock that machine M1
would like to or needs to acquire the corresponding global lock
upon release by the current owning machine in order to perform an
operation. The specified machine M4, if there are no other waiting
machines, then stores a record of the requesting machine's (i.e.,
machine M1) interest or request in a table or list, such that
machine M4 may know subsequent to releasing the corresponding
global lock that the machine M1 recorded in the table or list is
waiting to acquire the same global lock, which, following the exit
of the synchronization routine corresponding to the global lock
held by machine M4, then notifies the waiting machine (i.e. machine
M1) specified in the record of waiting machines, that the global
lock can be acquired, and thus machine M1 can proceed to acquire
the global lock and continue executing its own synchronization
routine.
[0226] 2. Corresponding to the entry to a synchronization routine
by machine M1 say, the DRT notifies the present owner of the global
lock, say machine M4, that a specific machine (say machine M1)
would like to acquire the lock upon release by that machine (i.e.,
machine M4). That machine M4, if it finds after consulting its
records of waiting machines for this locked object, finds that
there are already one or more other machines (say machines M2 and
M7) waiting, then either appends machine M1 to the end of the list
of machines M2 and M7 wanting to acquire this locked object, or
alternatively, forwards the request from M1 to the first waiting
machine (i.e., machine M2), or any other machine waiting (i.e.,
machine M7), which then, in turn, records machine M1 in their table
or records of waiting machines.
[0227] In the example above, for example, the records may be kept
on Machine M4 and store a queue or other ordered or indexed list of
machines waiting to acquire the lock after Machine M4 releases the
lock it holds. This list or queue may then be used or referenced by
M4 so that M4 can pass the lock on to other machines in accordance
with the order of request or any other prioritization scheme.
Alternatively, the list may be unordered, and machine M4 may pass
the global lock on to any machine in the list or record.
[0228] 3. Corresponding to the entry to a synchronization routine,
the DRT records itself in a shared table(s) of records (for
example, a table stored in a shared database accessible by all
machines, or multiple separate tables which are substantially
similar).
[0229] Still further or in the alternative, the DRT 71 can notify
other machines queued to acquire this global lock corresponding to
the exit of a synchronization routine by this machine in the
following alternative ways, for example:
1. Corresponding to the exit of a synchronization routine, the DRT
notifies one of the awaiting machines (for example, this first
machine in the queue of waiting machines) that the global lock is
released,
[0230] 2. Corresponding to the exit of a synchronization routine,
the DRT notifies one of the awaiting machines (for example, the
first machine in the queue of waiting machines) that the global
lock is released, and additionally, provides a copy of the entire
queue of machines (for example, the second machine and subsequent
machines awaiting for this global lock). This way, the second
machine inherits the list of waiting machines from the first
machine, and thereby ensures the continuity of the queue of waiting
machines as each machine in turn down the list acquires and
subsequently releases the same global lock.
[0231] During the abovementioned scrutiny, "monitorenter" and
"monitorexit" instructions (or methods) are initially looked for
and, when found, a modifying code is inserted so as to give rise to
a modified synchronization routine. This modified routine
additionally acquires and releases the global lock. There are
several different modes whereby this modification and loading can
be carried out.
[0232] As seen in FIG. 15 a modification to the general arrangement
of FIG. 8 is provided in that machines M1, M2 . . . Mn are as
before and run the same application code 50 (or codes) on all
machines M1 . . . Mn simultaneously or concurrently. However, the
previous arrangement is modified by the provision of a server
machine X which is conveniently able to supply housekeeping
functions, for example, and especially the synchronization of
structures, assets, and resources. Such a server machine X can be a
low value commodity computer such as a PC since its computational
load is low. As indicated by broken lines in FIG. 15, two server
machines X and X+1 can be provided for redundancy purposes to
increase the overall reliability of the system. Where two such
server machines X and X+1 are provided, they are preferably but
optionally operated as redundant machines in a failover
arrangement.
[0233] It is not necessary to provide a server machine X as its
computational load can be distributed over machines M1, M2 . . .
Mn. Alternatively, a database operated by one machine (in a
master/slave type operation) can be used for the housekeeping
function(s).
[0234] FIG. 16 shows a preferred general procedure to be followed.
After loading 161 has been commenced, the instructions to be
executed are considered in sequence and all synchronization
routines are detected as indicated in step 162. In the JAVA
language these are the "monitorenter" and "monitorexit"
instructions, and methods marked as synchronized in the method
descriptor. Other languages use different terms.
[0235] Where a synchronization routine is detected 162, it is
modified in step 163 in order to perform consistent, coordinated,
and coherent synchronization operation (or other mutual exclusion
operation) across the plurality of machines M1 . . . Mn, typically
by inserting further instructions into the synchronization (or
other mutual exclusion) routine to, for example, coordinate the
operation of the synchronization routine amongst and between
similar equivalent synchronization or other mutual exclusion
operations on other one or more of the plurality of machines M1 . .
. Mn, so that no two or more machines execute a similar equivalent
synchronization or other mutual exclusion operation at once or
overlapping. Alternatively, the modifying instructions may be
inserted prior to the routine, such as for example prior to the
instruction(s) or operation(s) related to a synchronization
routine. Once the modification step 163 has been completed the
loading procedure continues by loading the modified application
code in place of the unmodified application code, as indicated in
step 164. The modifications preferably take the form of an "acquire
lock on all other machines" operation and a "release lock on all
other machines" modification as indicated at step 163.
[0236] FIG. 17 illustrates a particular form of modification.
Firstly, the structures, assets or resources (in JAVA termed
classes or objects eg 50A, 50X-50Y) or more generally "locks" to be
synchronized have already been allocated a name or tag (for example
a global name or tag) which can be used to identify corresponding
similar equivalent local objects, or assets, or resources, or locks
on each of the machines M1 . . . Mn, as indicated by step 172. This
preferably happens when the classes or objects are originally
initialized. This is most conveniently done via a table maintained
by server machine X. This table also includes the synchronization
status of the class or object or lock. It will be understood that
this table or other data structure may store only the
synchronization status, or it may store other status or information
as well. In the preferred embodiment, this table also includes a
queue arrangement which stores the identities of machines which
have requested use of this asset or lock.
[0237] As indicated in step 173 of FIG. 17, next an "acquire lock"
request is sent to machine X, after which, the sending machine
awaits for confirmation of lock acquisition as shown in step 174.
Thus, if the global name is already locked (i.e. a corresponding
similar local asset is in exclusive use by another machine other
than the machine proposing to acquire the lock) then this means
that the proposed synchronization routine of the corresponding
object or class or asset or lock should be paused until the
corresponding object or class or asset or lock is unlocked by the
current owner.
[0238] Alternatively, if the global name is not locked, this means
that no other machine is exclusively using a similar equivalent
class, object, asset or lock, and confirmation of lock acquisition
is received straight away. After receipt of confirmation of lock
acquisition, execution of the synchronization routine is allowed to
continue, as shown in step 175.
[0239] FIG. 18 shows the procedures followed by the application
program executing machine which wishes to relinquish a lock. The
initial step is indicated at step 181. The operation of this
proposing machine is temporarily interrupted by steps 183, 184
until the reply is received from machine X, corresponding to step
184, and execution then resumes as indicated in step 185.
Optionally, and as indicated in step 182, the machine requesting
release of a lock is made to lookup the "global name" for this lock
preceding a request being made to machine X. This way, multiple
locks on multiple machines may be acquired and released without
interfering with one another.
[0240] FIG. 19 shows the activity carried out by machine X in
response to an "acquire lock" enquiry (of FIG. 17). After receiving
an "acquire lock" request at step 191, the lock status is
determined at steps 192 and 193 and, if no--the named resource is
not free or otherwise "locked", the identity of the enquiring
machine is added at step 194 to (or forms) the queue of awaiting
acquisition requests. Alternatively, if the answer is yes--the
named resource is free and "unlocked"--the corresponding reply is
sent at step 197. The waiting enquiring machine is then able to
execute the synchronization routine accordingly by carrying out
step 175 of FIG. 17. In addition to the yes response, the shared
table is updated at step 196 so that the status of the globally
named asset is changed to "locked".
[0241] FIG. 10 shows the activity carried out by machine X in
response to a "release lock" request of FIG. 18. After receiving a
"release lock" request at step 201, machine X optionally, and
preferably, confirms that the machine requesting to release the
global lock is indeed the current owner of the lock, as indicated
in step 202. Next, the queue status is determined at step 203 and,
if no-one is waiting to acquire this lock, machine X marks this
lock as "unowned" (or "unlocked") in the shared table, as shown in
step 207, and optionally sends a confirmation of release back to
the requesting machine, as indicated by step 208. This enables the
requesting machine to execute step 185 of FIG. 18.
[0242] Alternatively, if yes--that is, other machines are waiting
to acquire this lock--machine X marks this lock as now acquired by
the next machine in the queue, as shown in step 204, and then sends
a confirmation of lock acquisition to the queued machine at step
205, and consequently removes the new lock owner from the queue of
waiting machines, as indicated in step 206.
[0243] Given the fundamental concept of modifying the
synchronization routines (or other mutual exclusion operations or
operators) to coordinate operation between and amongst a plurality
of machines M1 . . . Mn, there are several different ways or
embodiments in which this coordinated, coherent and consistent
synchronization (or other mutual exclusion) operation concept,
method, and procedure may be carried out or implemented.
[0244] In the first embodiment, a particular machine, say machine
M2, loads the asset (for example a class or object) inclusive of a
synchronization routine(s), modifies it, and then loads each of the
other machines M1, M3 . . . Mn (either sequentially, or
simultaneously or according to any other order, routine, or
procedure) with the modified asset (or class or object) inclusive
of the new modified synchronization routine(s). Note that there may
be one or a plurality of routine(s) corresponding to only one
object in the application code, or there may be a plurality of
routines corresponding to a plurality of objects in the application
code. Note that in one embodiment, the synchronization routine(s)
that is (are) loaded is binary executable object code.
Alternatively, the synchronization routine(s) that is (are) loaded
is executable intermediate code.
[0245] In this arrangement, which may be termed "master/slave" each
of the slave (or secondary) machines M1, M3, . . . , Mn loads the
modified object (or class), and inclusive of the new modified
synchronization routine(s), that was sent to it over the computer
communications network or other communications link or path by the
master (or primary) machine, such as machine M2, or some other
machine such as a machine X of FIG. 15. In a slight variation of
this "master/slave" or "primary/secondary" arrangement, the
computer communications network can be replaced by a shared storage
device such as a shared file system, or a shared document/file
repository such as a shared database.
[0246] Note that the modification performed on each machine or
computer need not and frequently will not be the same or identical.
What is required is that they are modified in a similar enough way
that in accordance with the inventive principles described herein,
each of the plurality of machines behaves consistently and
coherently relative to the other machines to accomplish the
operations and objectives described herein. Furthermore, it will be
appreciated in light of the description provided herein that there
are a myriad of ways to implement the modifications that may for
example depend on the particular hardware, architecture, operating
system, application program code, or the like or different factors.
It will also be appreciated that embodiments of the invention may
be implemented within an operating system, outside of or without
the benefit of any operating system, inside the virtual machine, in
an EPROM, in software, in firmware, or in any combination of
these.
[0247] In a further variation of this "master/slave" or
"primary/secondary" arrangement, machine M2 loads asset (such as
class or object) inclusive of an (or even one or more)
synchronization routine in unmodified form on machine M2, and then
(for example, machine M2 or each local machine) modifies the class
(or object or asset) by deleting the synchronization routine in
whole or part from the asset (or class or object) and loads by
means of a computer communications network or other communications
link or path the modified code for the asset with the now modified
or deleted synchronization routine on the other machines. Thus in
this instance the modification is not a transformation,
instrumentation, translation or compilation of the asset
synchronization routine but a deletion of the synchronization
routine on all machines except one.
[0248] The process of deleting the synchronization routine in its
entirety can either be performed by the "master" machine (such as
machine M2 or some other machine such as machine X of FIG. 15) or
alternatively by each other machine M1, M3, . . . , Mn upon receipt
of the unmodified asset. An additional variation of this
"master/slave" or "primary/secondary" arrangement is to use a
shared storage device such as a shared file system, or a shared
document/file repository such as a shared database as means of
exchanging the code (including for example, the modified code) for
the asset, class or object between machines M1, M2, . . . , Mn and
optionally a machine X of FIG. 15.
[0249] In a still further embodiment, each machine M1, . . . , Mn
receives the unmodified asset (such as class or object) inclusive
of one or more synchronization routines, but modifies the routines
and then loads the asset (such as class or object) consisting of
the now modified routines. Although one machine, such as the master
or primary machine may customize or perform a different
modification to the synchronization routine sent to each machine,
this embodiment more readily enables the modification carried out
by each machine to be slightly different and to be enhanced,
customized, and/or optimized based upon its particular machine
architecture, hardware, processor, memory, configuration, operating
system, or other factors, yet still similar, coherent and
consistent with other machines with all other similar modifications
and characteristics that may not need to be similar or
identical.
[0250] In a further arrangement, a particular machine, say M1,
loads the unmodified asset (such as class or object) inclusive of
one or more synchronization routines and all other machines M2, M3,
. . . , Mn perform a modification to delete the synchronization
routine(s) of the asset (such as class or object) and load the
modified version.
[0251] In all of the described instances or embodiments, the supply
or the communication of the asset code (such as class code or
object code) to the machines M1, . . . , Mn, and optionally
inclusive of a machine X of FIG. 15, can be branched, distributed
or communicated among and between the different machines in any
combination or permutation; such as by providing direct machine to
machine communication (for example, M2 supplies each of M1, M3, M4,
etc. directly), or by providing or using cascaded or sequential
communication (for example, M2 supplies M1 which then supplies M3
which then supplies M4, and so on), or a combination of the direct
and cascaded and/or sequential.
[0252] In a still further arrangement, the machines M1 to Mn, may
send some or all load requests to an additional machine X (see for
example the embodiment of FIG. 15), which performs the modification
to the application code 50 inclusive of an (and possibly a
plurality of) synchronization routine(s) via any of the afore
mentioned methods, and returns the modified application code
inclusive of the now modified synchronization routine(s) to each of
the machines M1 to Mn, and these machines in turn load the modified
application code inclusive of the modified routines locally. In
this arrangement, machines M1 to Mn forward all load requests to
machine X, which returns a modified application program code 50
inclusive of modified synchronization routine(s) to each machine.
The modifications performed by machine X can include any of the
modifications covered under the scope of the present invention.
This arrangement may of course be applied to some of the machines
and other arrangements described herein before applied to other of
the machines.
[0253] Persons skilled in the computing arts will be aware of
various possible techniques that may be used in the modification of
computer code, including but not limited to instrumentation,
program transformation, translation, or compilation means.
[0254] One such technique is to make the modification(s) to the
application code, without a preceding or consequential change of
the language of the application code. Another such technique is to
convert the original code (for example, JAVA language source-code)
into an intermediate representation (or intermediate-code language,
or pseudo code), such as JAVA byte code. Once this conversion takes
place the modification is made to the byte code and then the
conversion may be reversed. This gives the desired result of
modified JAVA code.
[0255] A further possible technique is to convert the application
program to machine code, either directly from source-code or via
the abovementioned intermediate language or through some other
intermediate means. Then the machine code is modified before being
loaded and executed. A still further such technique is to convert
the original code to an intermediate representation, which is thus
modified and subsequently converted into machine code.
[0256] The present invention encompasses all such modification
routes and also a combination of two, three or even more, of such
routes.
[0257] Having now described aspects of the memory management and
replication and synchronization, attention is now directed to an
exemplary operational scenario illustrating the manner in which
application programs on two computers may simultaneously execute
the same application program in a consistent, coherent manner.
[0258] In this regard, attention is directed to FIGS. 31-33, two
laptop computers 101 and 102 are illustrated. The computers 101 and
102 are not necessarily identical and indeed, one can be an IBM or
IBM-clone and the other can be an APPLE computer. The computers 101
and 102 have two screens 105, 115 two keyboards 106, 116 but a
single mouse 107. The two machines 101, 102 are interconnected by a
means of a single coaxial cable or twisted pair cable 314.
[0259] Two simple application programs are downloaded onto each of
the machines 101, 102, the programs being modified as they are
being loaded as described above. In this embodiment the first
application is a simple calculator program and results in the image
of a calculator 108 being displayed on the screen 105. The second
program is a graphics program which displays four coloured blocks
109 which are of different colours and which move about at random
within a rectangular box 310. Again, after loading, the box 310 is
displayed on the screen 105. Each application operates
independently so that the blocks 109 are in random motion on the
screen 105 whilst numerals within the calculator 108 can be
selected (with the mouse 107) together with a mathematical operator
(such as addition or multiplication) so that the calculator 108
displays the result.
[0260] The mouse 107 can be used to "grab" the box 310 and move
same to the right across the screen 105 and onto the screen 115 so
as to arrive at the situation illustrated in FIG. 23. In this
arrangement, the calculator application is being conducted on
machine 101 whilst the graphics application resulting in display of
box 310 is being conducted on machine 102.
[0261] However, as illustrated in FIG. 23, it is possible by means
of the mouse 107 to drag the calculator 108 to the right as seen in
FIG. 22 so as to have a part of the calculator 108 displayed by
each of the screens 105, 115. Similarly, the box 310 can be dragged
by means of the mouse 107 to the left as seen in FIG. 22 so that
the box 310 is partially displayed by each of the screens 105, 115
as indicated FIG. 23. In this configuration, part of the calculator
operation is being performed on machine 101 and part on machine 102
whilst part of the graphics application is being carried out the
machine 101 and the remainder is carried out on machine 102.
Further Description
[0262] The foregoing describes only some embodiments of the present
invention and modifications, obvious to those skilled in the art,
can be made thereto without departing from the scope of the present
invention. For example, reference to JAVA includes both the JAVA
language and also JAVA platform and architecture.
[0263] In all described instances of modification, where the
application code 50 is modified before, or during loading, or even
after loading but before execution of the unmodified application
code has commenced, it is to be understood that the modified
application code is loaded in place of, and executed in place of,
the unmodified application code subsequently to the modifications
being performed.
[0264] Alternatively, in the instances where modification takes
place after loading and after execution of the unmodified
application code has commenced, it is to be understood that the
unmodified application code may either be replaced with the
modified application code in whole, corresponding to the
modifications being performed, or alternatively, the unmodified
application code may be replaced in part or incrementally as the
modifications are performed incrementally on the executing
unmodified application code. Regardless of which such modification
routes are used, the modifications subsequent to being performed
execute in place of the unmodified application code.
[0265] An advantage of using a global identifier in the invention
described is as a form of `meta-name` or `meta-identity` for all
the similar equivalent local objects (or classes, or assets or
resources or the like) on each one of the plurality of machines M1,
. . . , Mn. For example, rather than having to keep track of each
unique local name or identity of each similar equivalent local
object on each machine of the plurality of similar equivalent
objects, one may instead define or use a global name corresponding
to the plurality of similar equivalent objects on each machine
(e.g., "globalname7787"), and with the understanding that each
machine relates the global name to a specific local name or object
(e.g., "globalname7787" corresponds to object "localobject456" on
machine M1, and "globalname7787" corresponds to object
"localobject885" on machine M2, and "globalname7787" corresponds to
object "localobject111" on machine M3, and so forth).
[0266] Those skilled in the programming arts will be aware that
when additional code or instructions is/are inserted into an
existing code or instruction set to modify same, the existing code
or instruction set may well require further modification (such as
for example, by renumbering of sequential instructions) so that
offsets, branching, attributes, mark up and the like are catered
for.
[0267] Similarly, in the JAVA language memory locations include,
for example, both fields and array types. The above description
deals with fields and the changes required for array types are
essentially the same mutatis mutandis. Also the present invention
is equally applicable to similar programming languages (including
procedural, declarative and object orientated) to JAVA including
Micrsoft.NET platform and architecture (Visual Basic, Visual
C/C.sup.++, and C#) FORTRAN, C/C.sup.++, COBOL, BASIC etc.
[0268] The abovementioned arrangement, in which the JAVA code which
updates memory locations or field values is modified, is based on
the assumption that either the runtime system (say, JAVA HOTSPOT
VIRTUAL MACHINE written in C and Java) or the operating system
(LINUX written in C and Assembler, for example) of each machine M1
. . . Mn will ordinarily update memory on the local machine (say
M2) but not on any corresponding other machines (M1, M3 . . . Mn).
It is possible to leave the JAVA code which updates memory
locations or field values unamended and instead amend the LINUX or
HOTSPOT routine which updates memory locally, so that it
correspondingly updates memory on all other machines as well. In
order to embrace such an arrangement the term "updating propagation
routine" used herein in conjunction with maintaining the memory of
all machines M1 . . . Mn essentially the same, is to be understood
to include within its scope both the JAVA putfield and putstatic
instructions and related operations and the "combination" of the
JAVA putfield and putstatic operations and the LINUX or HOTSPOT
code fragments which perform memory updating.
[0269] The abovementioned embodiment in which the code of the JAVA
synchronization routine is modified, is based upon the assumption
that either the run time system (say, JAVA HOTSPOT VIRTUAL MACHINE
written in C and JAVA) or the operating system (LINUX written in C
and Assembler, for example) of each machine M1 . . . Mn will
normally acquire the lock on the local machine (say M2) but not on
any other machines (M1, M3 . . . Mn). It is possible to leave the
JAVA synchronization routine unamended and instead amend the LINUX
or HOTSPOT routine which acquires the lock locally, so that it
correspondingly acquires the lock on all other machines as well. In
order to embrace such an arrangement the term "synchronization
routine" is to be understood to include within its scope both the
JAVA synchronization routine and the "combination" of the JAVA
synchronization routine and the LINUX or HOTSPOT code fragments
which perform lock acquisition and release.
[0270] The terms object and class used herein are derived from the
JAVA environment and are intended to embrace similar terms derived
from different environments such as dynamically linked libraries
(DLL), or object code packages, or function unit or memory
locations.
[0271] Various means are described relative to embodiments of the
invention, including for example but not limited to lock means,
distributed run time means, modifier or modifying means,
propagation means, distribution update means, counter means,
synchronization means, and the like. In at least one embodiment of
the invention, any one or each of these various means may be
implemented by computer program code statements or instructions
(possibly including by a plurality of computer program code
statements or instructions) that execute within computer logic
circuits, processors, ASICs, microprocessors, microcontrollers, or
other logic to modify the operation of such logic or circuits to
accomplish the recited operation or function. In another
embodiment, any one or each of these various means may be
implemented in firmware and in other embodiments such may be
implemented in hardware. Furthermore, in at least one embodiment of
the invention, any one or each of these various means may be
implemented by an combination of computer program software,
firmware, and/or hardware.
[0272] Any and each of the aforedescribed methods, procedures,
and/or routines may advantageously be implemented as a computer
program and/or computer program product stored on any tangible
media or existing in electronic, signal, or digital form. Such
computer program or computer program products comprising
instructions separately and/or organized as modules, programs,
subroutines, or in any other way for execution in processing logic
such as in a processor or microprocessor of a computer, computing
machine, or information appliance; the computer program or computer
program products modifying the operation of the computer on which
it executes or on a computer coupled with, connected to, or
otherwise in signal communications with the computer on which the
computer program or computer program product is present or
executing. Such computer program or computer program product
modifying the operation and architectural structure of the
computer, computing machine, and/or information appliance to alter
the technical operation of the computer and realize the technical
effects described herein.
[0273] The invention may therefore includes a computer program
product comprising a set of program instructions stored in a
storage medium or exiting electronically in any form and operable
to permit a plurality of computers to carry out any of the methods,
procedures, routines, or the like as described herein including in
any of the claims.
[0274] Furthermore, the invention may include a plurality of
computers interconnected via a communication network or other
communications ink or path and each operable to substantially
simultaneously or concurrently execute the same or a different
portion of an application program code written to operate on only a
single computer on a corresponding different one of computers,
wherein the computers being programmed to carry out any of the
methods, procedures, or routines described in the specification or
set forth in any of the claims, or being loaded with a computer
program product.
[0275] The term "comprising" (and its grammatical variations) as
used herein is used in the inclusive sense of "having" or
"including" and not in the exclusive sense of "consisting only
of".
Copyright Notice
[0276] This patent specification and the Annexures which form a
part thereof contains material which is subject to copyright
protection. The copyright owner (which is the applicant) has no
objection to the reproduction of this patent specification or
related materials from publicly available associated Patent Office
files for the purposes of review, but otherwise reserves all
copyright whatsoever. In particular, the various instructions are
not to be entered into a computer without the specific written
approval of the copyright owner.
Annexures A and D
Annexure A
[0277] The following are program listings in the JAVA language:
[0278] A1. This first excerpt is part of an illustration of the
modification code of the modifier 51 in accordance with steps 92
and 103 of FIG. 10. It searches through the code array of the
application program code 50, and when it detects a memory
manipulation instruction (i.e. a putstatic instruction (opcode 178)
in the JAVA language and virtual machine environment) it modifies
the application program code by the insertion of an "alert"
routine. TABLE-US-00012 // 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
[0279] A2. This second excerpt is part of the DRT.alert( ) method
and implements the step of 125 and arrow of 127 of FIG. 12. This
DRT.alert( ) method requests one or more threads of the DRT
processing environment of FIG. 12 to update and propagate the value
and identity of the changed memory location corresponding to the
operation of Annexure A1. TABLE-US-00013 // START public static
void alert( ){ synchronized (ALERT_LOCK){ ALERT_LOCK.notify( ); //
Alerts a waiting DRT thread in the background. } } // END
[0280] A3. This third excerpt is part of the DRT 71, and
corresponds to step 128 of FIG. 12. This code fragment shows the
DRT in a separate thread, such as thread 121/1 of FIG. 12, after
being notified or requested by step 125 and array 127, and sending
the changed value and changed value location/identity across the
network 53 to the other of the plulality of machines M1 . . . Mn.
TABLE-US-00014 // START MulticastSocket ms =
DRT.getMulticastSocket( ); // The multicast socket // used by the
DRT for // communication. byte nameTag = 33; // This is the "name
tag" on the network for this // field. Field field =
modifiedClass.getDeclaredField("myField1"); // Stores // the field
// from the // modified // class. // In this example, the field is
a byte field. while (DRT.isRunning( )){ synchronized (ALERT_LOCK){
ALERT_LOCK.wait( ); // The DRT thread is waiting for the alert //
method to be called. byte[ ] b = new byte[ ]{nameTag,
field.getByte(null)}; // Stores // the // nameTag // and the //
value // of the // field from // the // modified // class in a
buffer. DatagramPacket dp = new DatagramPacket(b, 0, b.length);
ms.send(dp); // Send the buffer out across the network. } } //
END
[0281] A4. The fourth excerpt is part of the DRT 71, and
corresponds to steps 135 and 136 of FIG. 13. This is a fragment of
code to receive a propagated identity and value pair sent by
another DRT 71 over the network, and write the changed value to the
idenitified memory location. TABLE-US-00015 // 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
[0282] A5. The fifth excerpt is an dissassembled compiled form of
the example.java application of Annexure A7, which performs a
memory manipulation operation (putstatic and putfield).
TABLE-US-00016 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
[0283] A6. The sixth excerpt is the dissassembled compiled form of
the same example application in Annexure A5 after modification has
been performed by FieldLoader.java of Annexure A11, in accordance
with FIG. 9 of this invention. The modifications are highlighted in
bold. TABLE-US-00017 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
[0284] A7. The seventh excerpt is the source-code of the
example.java application used in excerpt A5 and A6. This example
application has two memory locations (staticValue and
instanceValue) and performs two memory manipulation operations.
TABLE-US-00018 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; }
}
[0285] A8. The eighth excerpt is the source-code of FieldAlert.java
which corresponds to step 125 and arrow 127 of FIG. 12, and which
requests a thread 121/1 executing FieldSend.java of the
"distributed run-time" 71 to propagate a changed value and identity
pair to the other machines M1 . . . Mn. TABLE-US-00019 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( ); } } } }
[0286] A9. The ninth excerpt is the source-code of FieldSend.java
which corresponds to step 128 of FIG. 12, and waits for a
request/notification generated by FieldAlert.java of A8
corresponding to step 125 and arrow 127, and which propagates a
changed value/identity pair requested of it by FieldAlert.java, via
network 53. TABLE-US-00020 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(
)); } } }
[0287] A10. The tenth excerpt is the source-code of
FieldReceive.java, which corresponds to steps 135 and 136 of FIG.
13, and which receives a propagated changed value and identity pair
sent to it over the network 53 via FieldSend.java of annexure A9.
TABLE-US-00021 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( )); } } }
A11. FieldLoader.java
[0288] This excerpt is the source-code of FieldLoader.java, which
modifies an application program code, such as the example.java
application code of Annexure A7, as it is being loaded into a JAVA
virtual machine in accordance with steps 90, 91, 92, 103, and 94 of
FIG. 10. FieldLoader.java makes use of the convenience classes of
Annexures A12 through to A36 during the modification of a compiled
JAVA classfile. TABLE-US-00022 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); } } }
A12. Attribute_info.java
[0289] Convience class for representing attribute_info structures
within ClassFiles. TABLE-US-00023 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); } }
}
A13. ClassFile.java
[0290] Convience class for representing ClassFile structures.
TABLE-US-00024 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( ); } }
A14. Code_attribute.java
[0291] Convience class for representing Code_attribute structures
within ClassFiles. TABLE-US-00025 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); } }
A15. CONSTANT_Class_info.java
[0292] Convience class for representing CONSTANT_Class_info
structures within
[0293] ClassFiles. TABLE-US-00026 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); } }
A16. CONSTANT_Double_info.java
[0294] Convience class for representing CONSTANT_Double_info
structures within
[0295] ClassFiles. TABLE-US-00027 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); } }
A17. CONSTANT_Fieldref_info.java
[0296] Convience class for representing CONSTANT_Fieldref_info
structures within
[0297] ClassFiles. TABLE-US-00028 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); }
}
A18. CONSTANT_Float_info.java
[0298] Convience class for representing CONSTANT_Float_info
structures within ClassFiles. TABLE-US-00029 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); } }
A19. CONSTANT_Integer_info.java
[0299] Convience class for representing CONSTANT_Integer_info
structures within ClassFiles. TABLE-US-00030 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); } }
A20. CONSTANT_InterfaceMethodref_info.java
[0300] Convience class for representing
CONSTANT_InterfaceMethodref_info structures within ClassFiles.
TABLE-US-00031 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); }
}
A21. CONSTANT_Long_info.java
[0301] Convience class for representing CONSTANT_Long_info
structures within ClassFiles. TABLE-US-00032 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); } }
A22. CONSTANT_Methodref_info.java
[0302] Convience class for representing CONSTANT_Methodref_info
structures within ClassFiles. TABLE-US-00033 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); }
}
A23. CONSTANT_NameAndType_info.java
[0303] Convience class for representing CONSTANT_NameAndType_info
structures within ClassFiles. TABLE-US-00034 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); } }
A24. CONSTANT_String_info.java
[0304] Convience class for representing CONSTANT_String_info
structures within ClassFiles. TABLE-US-00035 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); } }
A25. CONSTANT_Utf8_info.java
[0305] Convience class for representing CONSTANT_Utf8_info
structures within ClassFiles. TABLE-US-00036 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; } }
A26. ConstantValue_attribute.java
[0306] Convience class for representing ConstantValue_attribute
structures within ClassFiles. TABLE-US-00037 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); } }
A27. cp_info.java
[0307] Convience class for representing cp_info structures within
ClassFiles. TABLE-US-00038 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(
); } }
A28. Deprecated_attribute.java
[0308] Convience class for representing Deprecated_attribute
structures within ClassFiles. TABLE-US-00039 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); } }
A29. Exceptions_attribute.java
[0309] Convience class for representing Exceptions_attribute
structures within ClassFiles. TABLE-US-00040 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]); } }
A30. field_info.java
[0310] Convience class for representing field_info structures
within ClassFiles. TABLE-US-00041 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); } }
A31. InnerClasses_attribute.java
[0311] Convience class for representing InnerClasses_attribute
structures within ClassFiles. TABLE-US-00042 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); } } }
A32. LineNumberTable_attribute.java
[0312] Convience class for representing LineNumberTable_attribute
structures within ClassFiles. TABLE-US-00043 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); } } }
A33. LocalVariableTable_attribute.java
[0313] Convience class for representing
LocalVariableTable_attribute structures within ClassFiles.
TABLE-US-00044 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); } } }
A34. method_info.java
[0314] Convience class for representing method_info structures
within ClassFiles. TABLE-US-00045 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); } }
A35. SourceFile_attribute.java
[0315] Convience class for representing SourceFile_attribute
structures within ClassFiles. TABLE-US-00046 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); } }
A36. Synthetic_attribute.java
[0316] Convience class for representing Synthetic_attribute
structures within ClassFiles. TABLE-US-00047 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); } }
Annexure D1
[0317] Annexure D1 is a before-modification excerpt of the
dissassembled compiled form of the synchronization operation of
example.java of Annexure D3, consisting of an starting
"monitorenter" instruction and ending "monitorexit" instruction.
Annexure D2 is an after-modification form of Annexure D1, modified
by LockLoader.java of Annexure D6 in accordance with the steps of
FIG. 26. The modifications are highlighted in bold. TABLE-US-00048
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
Annexure D2
[0318] TABLE-US-00049 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
Annexure D3
[0319] This excerpt is the source-code of the example.java
application used in before/after modification excerpts D1 and D2.
This example application has a single synchronization operation
routine, consisting of a starting "monitorenter" instruction and an
ending "monitorexit" instruction, which is modified in accordance
with this invention by LockLoader of Annexure D6. TABLE-US-00050
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++; } } }
Annexure D4
[0320] This excerpt is the source-code of LockClient.java, which
corresponds to steps 171B, 172B, 173B, 174B, and 175B of FIG. 27,
and steps 181B, 182B, 183B, 184B, and 185B of FIG. 28, and which
queries an "synchronization server", such as a machine X of FIG.
15, executing LockServer.java of Annexure D5, in order to
synchronize (i.e. by means of an acquire lock and release a lock
request pair) the relevant class or object seeking to be
synchronized (i.e. seeking to be "locked"). TABLE-US-00051 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( )); } }
}
Annexure D5
[0321] This excerpt is the source-code of LockServer.java, which
corresponds to steps 191B, 192B, 193B, 194B, 195B, 196B, 197B, and
198B of FIG. 29, and steps 201, 202, 203, 204, 205, 206, 206, 207,
and 208 of FIG. 30, and which operates on a "synchronization
server" such as a machine X of FIG. 15, and receives an `acquire
lock request` or a `release lock request` for a specified object or
class of a plurality of similar equivalent objects or classes on
the plurality of machines M1 . . . Mn, from network 53 and sent by
a machine executing LockClient.java of Annexure D4, and in response
returns the corresponding confirmation of ownership of an `acqure
lock request`, or optionally confirmation of a `release lock
request`, of the specified class or object. TABLE-US-00052 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( ); } }
Annexure D6
LockLoader.java
[0322] This excerpt is the source-code of LockLoader.java, which
modifies an application program code, such as the example.java
application code of Annexure D3, as it is being loaded into a JAVA
virtual machine in accordance with steps 161B, 162B, 163B, and 164B
of FIG. 26. LockLoader.java makes use of the convenience classes of
Annexures A12 through to A36 during the modification of a compiled
JAVA classfile. TABLE-US-00053 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); } } }
End of Annexures
* * * * *