JP6223002B2 - METHOD, PROGRAM, AND SYSTEM FOR PROCESSING OBJECT IN COMPUTER - Google Patents

Description

  The present invention relates to an object processing technique in a computer, and more specifically, optimization of acquisition processing of an object stored in an associative array (map, Map) (Map.get processing, acquisition of an object by specifying a key). Related techniques.

  Conventionally, in large-scale software such as WebSphere (R) provided by International Business Machines Corporation, Map.get in which the value of Key is uniquely determined by Calling Context is frequently used. It has been processed.

  In particular, in an application for e-commerce, it is known that several percent of CPU power is spent for Map.get processing, and several tens of percent of the application context uniquely determines the value of Key.

  Such Map.get processing can optimize the processing to determine the value to be returned from the calling context. This processing is, for example, returning a specific value to a specific calling context, and so on.

  However, such optimization processing can not be handled by a compiler such as JIT. Because at the byte code level, Map semantics can not be recognized.

  Also, in a general JIT compiler, the object of optimization is method-based, and it can not cope with a call context in which a specific value can be derived from multi-step method calls. In general, the number of stages of method calls that can be inlined is limited in the JIT compiler. In the case of the above-mentioned application for e-commerce, it is necessary to inline ten or more stages of methods, and they are not inlined due to limitations.

  As a prior art related to this, Japanese Patent Laid-Open No. 2010-205170 discloses a technique for converting program code of a program operating on multithread into program code with less lock collision.

  JP 2011-253437 A prepares a Java class loader that generates and loads a Java interface class I (p) uniquely determined from PHP property name p, as needed, and a hierarchy of PHP classes By creating and caching Java classes in response to the above, the step of preparing the same class hierarchy on Java as the dynamically generated class hierarchy on PHP is executed, and the above interface class I (p) Steps to enable property access through the interface by declaring a Java class to implement and providing the property access code as an access to the Java field as an implementation of the methods provided in the interface Disclose.

  However, these conventional techniques can not be applied to optimization of Map.get processing. As background technology, http://www.ibm.com/developerworks/jp/java/library/j-jtp07233/ or http://docs.oracle.com/javase/jp/6/api/java/ There is a comment on ConcurrentHashMap in util / concurrent / ConcurrentHashMap.html.

Unexamined-Japanese-Patent No. 2010-205170 JP, 2011-253437, A

http://www.ibm.com/developerworks/jp/java/library/j-jtp07233/ http://docs.oracle.com/javase/jp/6/api/java/util/concurrent/ConcurrentHashMap.html

  An object of the present invention is to provide a technique for optimizing Map.get processing in which the value of a Key is uniquely determined by a call context within the range of an implementation such as a JVM.

The present invention addresses the above-mentioned problems,
(1) Identify the calling context origin method from the sampling result,
(2) Hold get return value information in the field of the specified method class,
(3) Add get return value information to the method argument in the calling context,
(4) Return the value after verifying the validity of get return value information in get processing in get processing of Map
The processing is automatically achieved by executing it in software.

  The method of specifying the origin class is to obtain a sample of stack trace for Map where get is called frequently, map nodes to values, map nodes to values, and have one-to-one correspondence Process to identify the target method as the starting point. When a plurality of nodes serve as starting points in one context, one is selected.

  In the get return value information, Map, Key, and Value are stored as Map.Entry. Map.Entry is an element that configures Map. In general Map.get processing, the value of Key in Map.Entry is compared to specify Map.Entry having the requested Key, and processing for returning that Value is performed.

  In the get processing, when the validity check of the get return value is successful, the Value of the get return value information is returned, and otherwise normal get processing is performed to initialize the get return value information.

  According to the present invention, a technique is provided to optimize Map.get processing in which the value of Key is uniquely determined by the call context.

It is a block diagram of an example hardware configuration for carrying out the present invention. FIG. 5 is a diagram illustrating an example software configuration hierarchy for implementing the present invention. It is a figure which shows the flowchart of a process of this invention. It is a figure which shows the call of Map.get between several programs. It is a figure which shows the hierarchy of a call of Map.get. It is a figure which shows the call of Map.get between several programs corrected by this invention.

  Hereinafter, embodiments of the present invention will be described with reference to the drawings. It is to be understood that these examples are intended to illustrate preferred embodiments of the present invention and are not intended to limit the scope of the invention to what is set forth herein. Further, throughout the following drawings, the same reference numerals indicate the same objects unless otherwise specified.

  Referring to FIG. 1, a block diagram of computer hardware for implementing the system configuration and processing according to one embodiment of the present invention is shown. In FIG. 1, a CPU 104, a main storage (RAM) 106, a hard disk drive (HDD) 108, a keyboard 110, a mouse 112, and a display 114 are connected to the system bus 102. The CPU 104 is preferably based on a 32-bit or 64-bit architecture, for example, Intel's CoreTM i3, CoreTM i5, CoreTM i7, Xeon®, AMD. Athlon (TM), Phenom (TM), Sempron (TM) etc. can be used. The main memory 106 preferably has a capacity of 8 GB or more, more preferably 32 GB or more.

  The hard disk drive 108 stores an operating system (OS). The operating system may be anything that is compatible with CPU 104, such as Linux (TM), Microsoft's Windows (TM) 7, Windows (TM) 2008 server, and the like. The operating system (OS) is indicated by reference numeral 202 in FIG. 2 described below.

  The hard disk drive 108 further stores a Java (R) Runtime Environment program for realizing the Java (R) virtual machine (JVM) 204 (FIG. 2).

  The hard disk drive 108 further incorporates WebSphere (R) Commerce, which is middleware provided by International Business Machines Corporation, which runs on the JVM. The middleware is indicated by reference numeral 206 in FIG. 2 described later.

  The hard disk drive 108 further includes a program group 208 operating on middleware. The program group includes a conversion program for changing the program at the byte code level according to the present invention. The conversion program is indicated by reference numeral 210 in FIG. 2 described later.

  The hard disk drive 108 also stores programs for operating the system as a Web server, such as Apache.

  The keyboard 110 and the mouse 112 are used to operate graphic objects such as an icon, a task bar, and a text box displayed on the display 114 according to a graphic user interface provided by the operating system.

  The display 114 is preferably, but not limited to, a 32-bit true color LCD monitor with a resolution of 1024 × 768 or higher. The display 114 is used, for example, to display the result of an operation by an application program running on the JVM.

  The communication interface 116 is preferably connected to the network by the Ethernet (R) protocol. The communication interface 116 receives a processing request according to a communication protocol such as TCP / IP by the function provided by Apache from a client computer (not shown), and returns the processing result to the client computer (not shown).

  Referring now to FIG. 2, the hierarchy of software for practicing the invention will be described. In FIG. 2, a program group in which a JVM 204 operates on an operating system 202, middleware 206 which is a WebSphere (R) commerce operates on the JVM 204, and includes Map.get processing under the management of the middleware 206. 208 is located, and the conversion program 210 executes processing for optimizing Map.get processing of the program group 208 at the byte code level according to the feature of the present invention.

  Next, processing of the conversion program 210 will be described with reference to FIG. In FIG. 3, in step 302, the conversion program 210 identifies a caller program that frequently calls Map's get method using a profiler tool such as jprof or IBM (R) Health Center. . FIG. 4 shows an example of a calling relationship between a plurality of programs.

Once the calling program is identified, the conversion program 210 inserts code for sampling Key, Value, Stack Trace (StackTrace) in step 304 after calling the calling program. The code is, for example, as follows. This code may be inserted at the source code level or at the byte code level.
String value = map.get (key);
try {
throw new Exception ();
} catch (Exception ex) {
StackTraceElement [] cc = ex.getStackTrace ();
profile (cc, key, value);
}

Some examples of such sampled results are shown below.
X.m0->A.m1->B.m2-> Cache.get: "AAA", "VA"
Y.m0 → C.m1 → B.m2 → Cache.get: “CCC”, “CA”
X.m0 → A.m1 → B.m2 → Cache.get: “AAA”, “VA”
AA.m1 → B.m2 → Cache.get: “AAA”, “VA”
X.m0 → A.m1 → B.m2 → Cache.get: “AAA”, “VA”
X.m0 → A.m1 → B.m2 → Cache.get: “AAA”, “VA”
AA.m1 → B.m2 → Cache.get “AAA”, “VA”
Y.m0 → C.m1 → B.m2 → Cache.get: “CCC”, “CA”

Next, at step 306, the conversion program 210 identifies the same sample from the sampled result. It is as follows.
X.m0->A.m1->B.m2-> Cache.get: "AAA", "VA"
AA.m1 → B.m2 → Cache.get: “AAA”, “VA”
Y.m0 → C.m1 → B.m2 → Cache.get: “CCC”, “CA”

Next, at step 308, the conversion program 210 associates each method with the value acquired by that method. It looks like the following table.

Next, at step 310, the conversion program 210 specifies a one-to-one corresponding method. It is the shaded part of the table below.

  Next, in step 312, the conversion program 210 specifies the class of the method closest to the Map get among the specified methods as the class holding the get return value information. It is a class surrounded by a thick line in the example of FIG. Note that the hierarchical relationship of such classes can be known by obtaining the call context from the stack trace and using the call context.

Next, at step 314, the conversion program 210 generates a method added with get return value information as an argument for all methods from the specified method to the get. This is, for example, taking Mem as an argument,
B.m2 (A.class.GetName (), ...);
B. m2 (A.class.GetName (), ..., mem);

  Next, at step 316, the conversion program 210 modifies the specified method to get to call a method added with get return value information as an argument. FIG. 6 shows the calling of the modified code.

Especially in FIG. 6, in class ConcurrentHashMap <K, V> {.
Object m = mem.validate (map, key, mem);
return m! = null? m: mem.initialize (map.getEntry (key));
The following code checks the validity of the get return value mem with validate (map, key, mem), returns m if it is correct, and otherwise indicates initialization of get return value information.

The following shows a more concrete implementation example of the code of ConcurrentHashMap.get.
public V get (Object key, Mem <K, V> memo) {
HashEntry <K, V> memoEntry =
memo.validate (this, key);
if (memoEntry! = null)
return memoEntry.value;
int hash = hash (key);
HashEntry <K, V> ret =
segmentFor (hash) .getEntry (key, hash);
memo.initialize (ret);
if (ret == null)
return null;
else
return ret. value;
}

Also, an example of code of class Mem used in the above code of ConcurrentHashMap.get is shown. Also shown here is the implementation of the initialize () and validate () methods.
public static class Mem <K, V> {
ConcurrentHashMap.HashEntry <K, V>value;
V initialize (HashEntry <K, V> value) {
this.value = value;
return value.value;
}
V validate (
ConcurrentHashMap <K, V> map,
Object key) {
HashEntry <K, V> memoEntry = value;
if (memoEntry! = null //
// 1. HashEntry.delete is volatile
&&! memoEntry.delete
// 2. HashEntry.parent is final
&& memoEntry.parent == map
// 3. HashEntry.key is final
&& key.equals (memoEntry.key))
return memoEntry.value;
else
return null;
}
}

  The present invention has been described above in the example of implementing Map.get on WebSphere (R) Commerce, which is middleware introduced on the JVM, but such a configuration is only an example, and the implementation of Map.get is It should be understood that the present invention can be practiced in any configuration that makes it possible.

104 CPU
106 RAM
108 Hard Disk Drive 202 OS
204 JVM
206 middleware 210 conversion program

Claims (12)

A method of processing an object returned in a method by a process of retrieving data from a map (hereinafter referred to as get) according to a calling context by computer processing,
Identifying an origin method of the invocation context;
Holding a get return value in a field of the specified origin method class and information necessary for validation of the get return value;
Adding a get return value to the method argument in the calling context;
Verifying the validity of Map's get return value information;
Returning the map's get return value in response to determining that the map's get return value information is valid;
Updating the get return value of the map to the latest in response to the determination that the get return value information of the map is not valid;
Method. The step of identifying the origin method is
Getting a sample of map's get return value,
Taking a method in context as a node based on a sample of a return value of the Map, mapping the node to a value that can be returned by the Map get via each node;
In the mapping, comprising the step of identifying a method corresponding to the node that is the return value and the one-to-one correspondence get the Map originating method,
The method of claim 1.   The method of claim 1, wherein the sequence of steps is performed on a JVM.   The method according to claim 3, wherein the step of verifying the validity of get return value information of the Map is implemented in a class of ConcurrentHashMap. A program for processing an object returned in a method by a process of retrieving data from a map (hereinafter referred to as "get") according to a calling context by computer processing,
On the computer
Identifying an origin method of the invocation context;
Holding a get return value in a field of the specified origin method class and information necessary for validation of the get return value;
Adding a get return value to the method argument in the calling context;
Verifying the validity of Map's get return value information;
Returning the map's get return value in response to determining that the map's get return value information is valid;
Causing the step of updating the get return value of the map to be updated in response to the determination that the get return value information of the map is not valid;
program. The step of identifying the origin method is
Getting a sample of map's get return value,
Taking a method in context as a node based on a sample of a return value of the Map, mapping the node to a value that can be returned by the Map get via each node;
In the mapping, comprising the step of identifying a method corresponding to the node that is the return value and the one-to-one correspondence get the Map originating method,
The program according to claim 5.   The program according to claim 5, wherein the series of steps are executed on a JVM.   The program according to claim 7, wherein the step of verifying the validity of the get return value information of the Map is implemented by a class of ConcurrentHashMap. A system for processing an object returned in a method by a process of retrieving data from a map (hereinafter referred to as "get") according to a calling context by computer processing,
Means for identifying an origin method of the invocation context;
A means for holding a get return value in a field of the specified source method class and information necessary for validation of the get return value;
Means for adding a get return value to a method argument in said calling context;
A means for verifying the validity of Map's get return value information;
A means for returning the get return value of the map in response to the determination that the get return value information of the map is valid;
Having means for updating the Map return value to the latest in response to the determination that the Map return value information is not valid;
system. The means for identifying the origin method is
Process to get a sample of Map's get return value,
A process of setting a method in a context as a node based on a sample of a get return value of the Map, and mapping the node to a value that can be returned by the Map get via each node;
In the mapping, processing is performed to specify a method corresponding to a node that has a one-to-one correspondence with the return value of get of Map as an origin method.
The system of claim 9.   The system of claim 9, wherein the system is implemented on a JVM and middleware.   The system according to claim 11, wherein the means for verifying the validity of the get return value information of the Map is implemented in a class of ConcurrentHashMap.

Images