CN1438576A - Method for transfering Java line based on recovering of operation stack record - Google Patents

Abstract

With target byte codes being loaded, the inserted target byte codes are modified dynamically by use of interpreted loading byte codes dynamically. For the assigning operations, the isolation of the relevant code segment is used instead of the isolation of the content in the operation stack. For the operation of saving the content in the operation stack, each popping up or stacked operation is recorded by the the method of inserting the byte code. The operations are safe with high efficiency.

Description

Method based on the Java thread migration of the recovery of active stack record

Technical field

Method based on the Java thread migration of the recovery of active stack record belongs to the thread migration technical field, relates in particular to Java thread migration technology.

Background technology

Development along with distributed computing system (distributed computing) and portable computing system, the importance of thread migration technology more and more displays, and along with the generally use that needs the Java platform of heterogeneous system, Java thread migration strategy more and more is much accounted of, it is applied to fields such as fault-tolerant, load balance widely.

Java thread migration (Java Thread Migration) refers to, the thread (Thread) that will in our system, move, with thread (Thread) is least unit, suspend execution from the node (node) that is moving, the code (code) of this thread and data (data) are transferred in the system other moved node, continue the process of carrying out.Usually, our said transparent migration (transparent migration) refers to, and system does not have outside intervention in the process of the code of thread and data catching and recover, and this outside refers to the user.

At present, in the Java thread migration field,, can not offer the various states that external program makes its thread that is being moved because the java virtual machine does not have corresponding interface, comprising the content in PC (instruction pointer) and the active stack, generally acknowledged feasible method has two kinds:

First kind: directly revise virtual machine code, such disposal route is very direct, but the problem of bringing also is clearly, this opaque disposal route can produce very serious compatibility issue, as everyone knows, SUNMicrosystems (Sun Microsystems) company that has a Java Virtual Machine copyright is very sensitive and very strict its version of control to copyright problem.

Second kind: do not relate to any code of revising virtual machine, execution characteristics according to the Java code, in the code dynamic load, the dynamic code that needs execution of revising, in object code, increase needed code segment, write down the value that needed environmental variance comprises PC (instruction pointer), the debugging acid JPDA (Java Platform DebugArchitecture Java debug platform architecture) that utilizes Java to provide simultaneously extracts the content in the active stack in the java virtual machine.

The emphasis that we set forth will be placed on second kind of scheme, recovery at the PC in the Java thread (Thread) (Program Counter program pointer counter) value and Local Variables (local variable), there are some research institutions to propose the strategy of oneself at present, adopted Java thread sequence strategy as Belgian KULEUVEN research institute, Israel technical college has adopted the strategy of reequiping the Java compiler again.We have continued to use the numerical value that utilizes JPDA to catch PC and Local Variables, have adopted the Java thread sequenceization to preserve, and utilize the scheme that Byte Code (bytecode) recovers the state of these values of inserting.

Though a lot of research institutions are to seizure and the recovery of above-mentioned two kinds of PC and Local Varaiables, a lot of schemes are arranged, but seldom mention seizure and recovery to the Operand Stack (active stack) of Thread, and do not have research institution can deliver out clear and definite feasible scheme, this point is to mention without any family research in the document of our reference.

At emphasis in this thread migration and difficult point, we have proposed the feasible program of oneself, have realized the recovery of the Operand Stack (active stack) in the Java Thread thread, and our strategy can be realized very safely and effectively.

Summary of the invention:

The object of the present invention is to provide a kind of safely and effectively based on the Java thread migration method of the recovery of active stack record.The invention is characterized in: it makes the bytecode that is written into when being written into the target byte sign indicating number by dynamically explaining, dynamically revises the target byte sign indicating number that is written into; It carries out different processing to following different procedure operation:

(1). assign operation: corresponding code segment is isolated, carry out with box lunch and go to stop migration when these isolate code segment, replace the content in the active stack is isolated with this;

(2). the operation that the active stack content is preserved: in the process that is written into the target byte sign indicating number, insert the corresponding code of handling,, all use the method for inserting corresponding bytecode to write down corresponding operation in time to the stacked operation of popping each time.

Use proof: it has guaranteed the correctness of thread migration and the efficient of Java thread migration simultaneously.

Description of drawings

Fig. 1 is based on the program flow chart of the Java thread migration method of the recovery of active stack record.

Embodiment

The method that the present invention adopts is Java Virtual Machine not to be carried out any modification, and starts with from object code.Java is a kind of indicative language, the bytecode that it is written into by dynamic explanation (Byte Code), make us when being written into the target byte sign indicating number, the dynamic strategy that inserts the target byte sign indicating number of revising becomes possibility, so, Java Virtual Machine (JVM) is explained has been exactly the code crossed through our routine processes.

Java is a kind of language towards storehouse in essence, this characteristics have determined, the Java any operation relevant with numerical value in the inside is such as assignment, the calculating of expression formula all need be finished by stack, and our purpose is will be when object code calculates, record and preserve content in the active stack so that migration of programs can the recovery operation stack in other the destination node content.

We have carried out different processing at different procedure operation.First kind of assign operation, our strategy are that corresponding code segment is isolated, and when carrying out these isolation code segments, do not move, and so also just need not isolate the content in the active stack.Second kind of situation is that we need carry out the preservation of active stack content, in the process that is written into the target byte sign indicating number, if run into following statement assignment, expression solution (shape such as following expression formula code segment): the x=y+z of type like this; We will insert corresponding processing code.

Below, we provide two simple example A at these two kinds of different processing procedures) processing of assign operation:

。。。。。。。

X=100; The value of //X variable is arranged to 100

。。。。。。。

The result of common compilation is:

0:bipush 100 // constant 100 enters active stack (0perand stack)

2:istore_1 // will operate the numerical value ejection of stack top and variable X is set

Our code isolation mark is all inserted in our processing in the front and back of this code segment, show that to system this code segment cannot interrupt, and only is finished and just can moves.

The result's who handles code is:

The code distance piece of 0:iconst_1 // insertion begins the part sign

The code distance piece of 1:istore_2 // insertion begins the part sign

The code segment of 2:bipush 100//originally

The code segment of 4:istore_1 // originally

The code distance piece latter end end mark of 5:iconst 0 // insertion

The code distance piece latter end sign B of 6:istore_2 // insertion) processing of expression formula operation:

。。。。。。。

*=y+z; // with y, z phase adduction is given X with assignment as a result

The result of common compilation is:

8:iload_2 // with the value push operation stack of variable y

9:iload_3 // with the value push operation stack of variable z

Two value phase adductions of 10:iadd // will operate stack top are put into stack top with the result

11:istore_1 // will operate the numerical value ejection of stack top and variable X is set

Our processing is at the stack-incoming operation of popping each time, all uses the corresponding byte code of insertion to write down corresponding operation,

Just be processed into following result at top the 8th statement:

The code distance piece of 26:iconst_1 // insertion begins the part sign

The code distance piece of 27:istore %4 // insertion begins the part sign

The code segment of 29:iload_2 // originally

Content counter+1 in 30:iinc %5-1 // recording operation stack

The content of 33:dup // replicate run stack top

The content of 34:istore %6 // ejection and preservation operation stack top is in the variable of new insertion

The code distance piece latter end sign of 36:iconst_0 // insertion

The code distance piece latter end sign of 37:istore %4 // insertion

Through the similar processing at every statement, result's code is as follows:

// to the modification of the 8th statement iload_2

The code distance piece of 26:iconst_1 // insertion begins the part sign

The code distance piece of 27:istore %4 // insertion begins the part sign

The code segment of 29:iload_2 // originally

Content counter+1 in 30:iinc %5-1 // recording operation stack (active stack is 1 value)

The content of 33:dup // replicate run stack top

The content of 34:istore %6 // ejection and preservation operation stack top is in the variable of new insertion

The code distance piece latter end sign of 36:iconst_0 // insertion

The code distance piece latter end sign of 37:istore %4 // insertion

// to the modification of the 9th statement iload_3

The code distance piece of 39:iconst_1 // insertion begins the part sign

The code distance piece of 40:istore %4 // insertion begins the part sign

The code segment of 42:iload_3 // originally

Content counter+1 in 43:iinc %5-1 // recording operation stack (active stack is 2 values)

The content of 46:dup // replicate run stack top

47:istore %7 // ejection is also preserved the variable of the content of operation stack top to new insertion

The code distance piece latter end sign of 49:iconst_0 // insertion

The code distance piece latter end sign of 50:istore %4 // insertion

// to the modification of the 10th statement iadd

The code distance piece of 52:iconst_1 // insertion begins the part sign

The code distance piece of 53:istore %4 // insertion begins the part sign

The code segment of 55:iadd // originally

Content counter-1 in 56:iinc %5 1 // recording operation stack (this moment, the active stack number was 1)

The content of 59:dup // replicate run stack top

60:istore %6 // ejection is also preserved the variable of the content of operation stack top to new insertion

The code distance piece latter end sign of 62:iconst_0 // insertion

The code distance piece latter end sign of 63:istore %4 // insertion

// to the modification of Sub_clause 11 statement istore_1

The code distance piece of 65:iconst_1 // insertion begins the part sign

The code distance piece of 66:istore %4 // insertion begins the part sign

The code segment of 68:istore_1 // originally

Content counter-1 in 69:iinc %5 1 // recording operation stack (this moment, active stack was empty)

The code distance piece latter end sign of 72:iconst_0 // insertion

The code distance piece latter end sign of 73:istore %4 // insertion

In sum, at our target, stack in the process of assurance Java thread migration can be by correct recovery, consider the efficiency in the transition process simultaneously, the strategy that we adopt is the type of evaluating objects code, adopted and utilized the issued transaction (transention) in the similar database to isolate, that is to say the object code of assignment expression is regarded as an integral body, carried out atomic operation assignment expression.And simultaneously at the operation of the expression formula in the Java thread, we have then adopted method described above, have also showed above simultaneously by before our strategy modification and the object code after revising.

Through test, our strategy can guarantee the Java thread the transition process stack can be correct recovery, thereby guaranteed the correctness of thread migration, our strategy has also guaranteed the efficient of Java thread migration simultaneously.

Corresponding general program flow chart is seen Fig. 1.

At first, what it may be noted that and illustrate is, the mechanism that algorithm herein adopts is to transparent algorithm, here transparent implication is meant, set forth in the flow process above this paper, needed in the process at the customer referral program migration, catch the program pointer of user program, the content of the numerical value of the variable of program and user program active stack, and after object code is moved to object code, at the user program pointer, the resuming work of the content of the numerical value of the variable of program and user program active stack, all top work, all be under the situation of user transparent, to carry out, that is to say that the user does not need top all work of setting forth is participated in and operates, these work all be by, the thread migration module in first computing system is finished.

Therefore, in view of top elaboration, have in first computing system of algorithm of described thread migration herein, the migrated users task of submitting to is to destination node if desired, and the user need not to make extra action.

Claims (1)

1. based on the method for the Java thread migration of the recovery of active stack record, it is characterized in that: it makes the bytecode that is written into when being written into the target byte sign indicating number by dynamically explaining, dynamically revises the target byte sign indicating number that is written into; It carries out different processing to following different procedure operation:

(1). assign operation: corresponding code segment is isolated, carry out with box lunch and go to stop migration when these isolate code segment, replace the content in the active stack is isolated with this;

(2). the operation that the active stack content is preserved: in the process that is written into the target byte sign indicating number, insert the corresponding code of handling,, all use the method for inserting corresponding bytecode to write down corresponding operation in time to the stacked operation of popping each time.