JP2007086838A - Communication mediation device for zero garbage collection - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To prevent communication from being interrupted by the occurrence of garbage collection and being degraded in the real-time properties of a device for mediating service requests among a plurality of computers on a network, the device being implemented by an object-oriented programming language having garbage collection. <P>SOLUTION: The request mediation device has a means for reusing temporary objects created temporarily or repeatedly for each request, and a means for restricting communication patterns, and uses these means to prevent the occurrence of garbage collection so as to improve its real-time properties. <P>COPYRIGHT: (C)2007,JPO&INPIT

Description

  The present invention relates to a request mediating apparatus that performs request mediation by improving real-time property for remote requests between computers executed in an execution environment using a programming language equipped with garbage collection or hardware equipped with used memory management means More specifically, it is used to construct a system using distributed / parallel real-time application programs that operate between multiple computers on the network by suppressing the occurrence of garbage collection that starts when the work memory is insufficient. The present invention relates to an intermediary device that improves real-time performance in processing of communication middleware, programming language, operating system, and communication mediation hardware.

  In processing of a distributed / parallel application program (hereinafter abbreviated as an application) that operates between a plurality of computers on a network or a bus, communication is performed to request an object or service on a remote computer (remote) ( Call remote method). Since request processing in many parallel applications has commonality with distributed applications, they are collectively referred to as “distributed” below. In this case, manually designing communication processing in a distributed application is complicated and limited in interoperability. Therefore, it is common to use a request mediation apparatus that provides a request mediation function.

  The request mediating apparatus targeted by the present invention is an apparatus having advanced communication functions related to distributed processing and parallel processing, such as distributed objects, parallel objects, Web services, agent systems, P2P systems, and audio / video distribution apparatuses. As a form of the apparatus, there are many middleware, parallel / distributed operating system (hereinafter abbreviated as OS), parallel / distributed languages, and libraries, which are realized by software or hardware (FIG. 1). Examples of communication middleware include WEB services, CORBA, RMI, HORB, P2P systems, and the like. In the present invention, these are collectively referred to as “request mediation device” or “mediation device”.

  In this specification, the term “request” means a remote procedure call, a remote method call, a remote service call, or the like. The request mediating apparatus plays a role of mediating the request issued by the client computer to the server computer and notifying the response to the client computer, not the processing of the application that services the request itself. For example, in the case of a distributed object or a Web service, a program for reading a measured value of a sensor on a remote computer described in an application is based on a description such as “value = ref.getSensor ()” (FIG. 8). This one-line program piece calls the mediation device and automatically performs relatively complicated communication processing via the network.

  It does not include TCP or UDP level network libraries that only send data in packets without performing request-mediated communication processing, and configuration methods for distributed applications themselves. In the present invention, a computer broadly means not only a personal computer and a server but also a small microcomputer in an embedded device, a plurality of communicating components in the same system, and the like.

  In recent years, development of a distributed real-time application in which a machine is connected by a network and an advanced system is constructed has been developed. For example, a humanoid robot that operates in a group while synchronizing with a network, an information home appliance that provides a real-time video stream in a home, and a car that automatically operates while communicating with a road are typical examples. Such an intermediary device for a distributed real-time application must guarantee real-time performance such that communication with a certain response time and a periodic cycle is reliably performed during the mediation processing of a request. Even if it is not called real-time, there are many distributed applications that require high-speed response.

  However, an intermediary device developed in a modern programming language such as Java (registered trademark) has a problem that response time and periodicity cannot be guaranteed for the reasons described below, so real-time characteristics are required. In distributed real-time applications, traditional programming languages such as C and C ++ are often used.

  When a programming language such as C or C ++ is used, the programmer must explicitly describe the processing for performing operations such as memory allocation and memory return after using the memory in the program processing. If you forget to write an instruction to return after using the memory during program creation, for example, a memory leak may occur, causing the application to terminate abnormally due to insufficient memory. When verifying a created program, memory leaks in the processing of the program are difficult to find and are a factor that greatly impairs development efficiency and system safety.

  For this reason, in an execution environment of a modern programming language such as Java (registered trademark) language or C # language, a memory management method called garbage collection (GC) is adopted.

  In garbage collection (hereinafter abbreviated as GC), the “garbage collector” periodically checks all objects, and if the object is “not referenced by any reference type variable”, the object is deleted. As a result, the memory (heap memory) used by the object is released and can be used again. In a program process created by such a modern programming language, an object need only be generated at any time.

  Objects are created on heap memory. There is only a limited amount of heap memory. If heap memory is insufficient, program processing may end abnormally. However, GC automatically collects the memory occupied by objects that are no longer used and stores it in the heap memory. Since it is returned, the memory is reused. Thus, by releasing the programmer from memory management, the productivity of the programmer using the Java (registered trademark) language is greatly improved as compared to the case of using the C language or the C ++ language.

  However, this GC processing occurs at the discretion of a language runtime (for example, a Java virtual machine), and is executed by interrupting program execution. For this reason, unpredictable GC may occur in distributed real-time application processing, and unpredictable communication interruption may occur during communication processing, which is a serious accident. It may cause.

  In an intermediary device by Java, such as CORBA, J2EE, and Web service products, which are intermediary device products implemented in an existing object-oriented programming language, a considerable amount of temporary objects are generated for each request (remote method call). Therefore, GC frequently occurs. Here, the temporary object refers to all types of objects that are generated in the mediation apparatus in association with the request mediation processing. Specifically, server objects that provide remote services, large data such as communication buffers, and trivial data such as communication partner host names, user names, session identifiers, and request numbers are stored in the heap memory. Includes all objects that These are implemented using a character string object, a structural object, an array object, etc., and are generated for each session or for each request, and collected by the GC after use. If there is not enough memory when generating a temporary object, a GC occurs and communication is interrupted. A non-temporary object is an object that persists beyond the lifetime of a session or request. In a mediation device, for example, a table that records active server objects, it is created when the mediation device starts and persists until the end. To do.

For example, the following table shows the result of investigating the number of temporary objects generated during one request (remote method call) and the amount of temporary memory used in some Java mediating devices.

Further, the following table shows the results of examining the number of occurrences of GC per 2000 requests. Thus, it can be seen that many GCs are generated.

  Thus, since the generation of a temporary object in a request may cause a GC during the request and cause a communication interruption, a request mediating device developed in a programming language executed in an execution environment with a GC is real-time. This is a major factor that was not used in the necessary applications. Even when the mediation device is implemented by hardware, means for managing the used memory, that is, GC by hardware, is necessary, and includes similar problems.

  In contrast, several inventions have been proposed that attempt to solve this type of problem caused by GC. For example, Patent Document 13 proposes that by implementing a “recycle () method”, a class can be reused so that a GC process can determine whether an object can be reused. . This is a good mechanism for reusing objects to prevent object creation, but if the garbage collector does not find a recyclable object, a GC that spans the entire memory area occurs. End up. Therefore, the invention of Patent Document 13 is good for reducing the cost of object generation, but cannot prevent interruption of communication by GC.

  Patent Document 10 proposes an invention of a method for removing generation of fixed / constant objects from method calls. According to the invention of Patent Document 10, the problem of excessive use of memory in an iterative process can be partially solved. However, in most request mediation devices, requests are dynamic processes that handle various types, and most temporary objects in the process are neither fixed nor constant.

  More specifically, a streaming distribution system such as video provides QoS (Quality of Service) with respect to an application. The QoS mediating apparatus and the OS driver guarantee communication quality by preferentially allocating CPU time and bandwidth on the network. Regarding the memory allocation, the OS allocates the memory amount for the communication buffer of each stream according to the QoS level. The scope of application of this technique is limited to a buffer for communication data, and many small temporary objects generated during a request are not handled.

  In addition, real-time Java standards have been proposed by several organizations. Real-time Java counters this problem with a number of complex strategies. For example, an immortal memory (permanent memory), a scoped memory (ranged memory), a real-time thread, and the like can be given. Since GC also occurs in a real-time Java platform, as long as an object is created and discarded, it encounters a problem of communication interruption by GC in request mediation processing. In addition, there are many cases where it is desired to use a normal Java product that is not a real-time Java that is not widely used.

  Real-time GC and parallel GC techniques are another good way to solve the problem that the present invention is addressing. Real-time GC improves interrupt response performance by subdividing GC time on a single CPU. In the parallel GC, one CPU is assigned to the GC processing on the multi-CPU system so that the execution of other CPUs is not interrupted by the GC.

  In Non-Patent Document 1, in order to deal with the problem of lack of real-time performance due to GC in embedded Java applications, design guidelines centering on object pooling, GC-less AWT (Abstract Winding TOOLkit) drawing library, GC-less UDP (User) Datagram Protocol) packet server is being developed. There are basic techniques to prevent the occurrence of GC, such as pooling and reusing objects, using value types in objects for passing data, and using variable objects such as arrays instead of immutable objects such as String. Proposed.

  Although this proposal is a prior art of the present invention, it remains at a basic level such as reception of a basic drawing library and UDP packet, and a method for solving problems related to advanced communication processing such as distributed objects and Web services. Is not mentioned. Since a request mediating apparatus that mediates a request for a service is complicated, the problem cannot be solved by simply pooling an object.

Other inventions of Patent Documents 1 to 16 cited as references in this specification relate to memory management means or real-time processing in a computer system. However, they are not intended to solve the GC problem described here. In view of the trends in the prior art, we think it is well worth supplying an improved method for this problem.
JP-A-63-93055 JP 2001-188704 A JP 2001-202284 A US Pat. No. 6,678,697 US Pat. No. 5,950,231 US Pat. No. 6,272,674 US Pat. No. 6,055,492 US Pat. No. 6,754,796 US Pat. No. 6,751,790 US Pat. No. 6,701,520 US Pat. No. 6,430,564 US Pat. No. 6,748,555 US Pat. No. 6,138,127 US Pat. No. 6,611,898 US Pat. No. 6,629,948 US Pat. No. 6,381,735 Embedded Java Practical Consortium, Embedded Technology 2004 Lecture Report Embedded Java Real-time Performance Assurance and Application Guidelines-GUI / Network GC-less Library Implementation-Lecture Materials http://www.ejpc.org/et2004/et2004.htmlhttp:// www.ejpc.org/et2004/et2004p2.pdf Real-timePlatform SIG, Realtime CORBA, white paper, Object Management Group, Dec. 1996, Editor: Judy McGoogan, Lucent Technologies. Ray Clark, E. Douglas Jensen, Doug Wells, Andy Wellings, The distributed Real-time Specification for Java: A Status Report, Embedded Systems Conference, March 2002. JSR 50: Distributed Real-Time Specification

  By the way, in a mediation apparatus such as a distributed object or a web service developed using an object-oriented programming language equipped with GC, GC is generated for many temporary objects generated during repetitive request mediation processing. When GC occurs, the processing of the program is interrupted, and communication is also interrupted during that time.

  If no object is generated, GC does not occur. If no GC occurs, communication is not interrupted. However, in general, the content of communication varies, and the amount of memory used varies greatly depending on the content. Also, depending on the application, the type of request and the type of data to be transferred increase as the application is improved. Although it is easy to suppress GC with a low-level one such as a simple TCP packet library, it is difficult because various objects are generated in a mediation device that makes sense for communication contents such as distributed objects and Web services. .

  The present invention has been made in order to solve such problems, and a first object of the present invention is to provide a request for a distributed real-time application that requires response communication within a predetermined time and periodic communication. There is a need to provide a request mediation device that can guarantee that communication interruption does not occur during request mediation processing for any communication pattern within the range assumed at the time of design in the mediation device. Such a system configuration of the request mediating apparatus is referred to as a hard zero GC system.

  A second problem of the present invention is a request mediating apparatus that reduces communication interruption even for an application having a communication pattern that deviates from a range assumed at the time of design, or an application that cannot assume a clear range at the time of design. Is to provide. According to such a request mediation apparatus, communication interruption does not occur due to processing characteristics in the application as well as processing characteristics in the request mediation apparatus, or some communication interruption occurs depending on application characteristics. This is a request mediating apparatus that can perform request mediation processing for a good application. Such a system configuration of the request mediating apparatus is referred to as a soft zero GC system.

  A third problem of the present invention is to provide a mediation device that can operate in a mode that suppresses communication interruption and a mode that does not use a communication interruption suppression function in one request mediation device. This is because real-time performance is not always required even within one application. When a single distributed application uses both real-time communications and communications that do not require real-time communication, computing resources and development costs are doubled, but an intermediary device that can reduce the increase in computational resources and development costs is provided. Is done.

  Therefore, an object of the present invention to solve the above-described problems is to suppress the occurrence of garbage collection for mediating remote requests between computers executed in an execution environment of an object-oriented programming language having garbage collection, or An object of the present invention is to provide an intermediary device for zero garbage collection communication which performs request mediation by improving real-time performance without generating garbage collection.

  In order to achieve the above object, the present invention provides, as a first aspect, an intermediary device for zero garbage collection communication according to the present invention comprising: a remote request between computers implemented by an object-oriented programming language having a garbage collection function; An intermediary device that suppresses garbage collection, a temporary object storage unit that holds a used temporary object among temporary objects temporarily used for the mediation processing, and the used A temporary object management means for initializing a temporary object for reuse, a request type limit value setting means for setting a request type limit value, and a request for limiting the request type by the request type limit value Type restriction means and transfer data count control Transfer data number limit value setting means for setting a value, transfer data number limit means for limiting the type and number of data and objects transferred by a request according to the limit value of the transfer data number, and limit value for the number of simultaneous and parallel use And a concurrent and concurrent use number limit setting means for limiting the concurrent and concurrent use number of requests by the limit value of the concurrent and concurrent use number. .

  In the intermediary apparatus of this aspect, the first problem is solved by using the locality of the communication pattern specific to the application and artificially limiting the communication pattern.

  In some applications, depending on the field, when one computer establishes a communication session with another computer and starts communication, it may tend to repeat similar requests. In particular, communication between embedded devices such as communication between machines, for example, communication between components inside a robot or an automobile, often involves monotonous repetition of a small number of requests such as acquisition of sensor data.

  For such communication, use of the characteristic that there is a predetermined pattern makes it possible to optimize memory use. In other words, if the same request is repeated, instead of generating the necessary temporary object for each request, the temporary object generated before communication or the first time is not discarded after use, but after the next time. Also, the occurrence of GC can be suppressed by reusing it. Hereinafter, this is referred to as “zero GC”.

  Communication patterns vary greatly depending on the application. If communication occurs when there are too many objects to be transferred, or unexpected communication such as simultaneous communication from more client computers than expected, the number of temporary objects generated increases and the heap memory is exhausted. Accordingly, by determining the range of communication patterns assumed for each application, a large number of temporary objects are prevented from being generated.

  For example, the range of communication patterns to be restricted includes whether communication can be accepted (the number of simultaneous sessions is not too many), what type of request communication is performed, the type and number of data transferred by communication, It is sufficient to limit As a result, the field of applications to which the present invention can be applied is also limited. However, in many applications, communication processing therein is regular, and this is often sufficient.

  In this way, by suppressing the number of temporary objects generated so that the heap memory is not exhausted, the method of suppressing the occurrence of GC and further preventing the occurrence of GC is 1) Assumption It is a solution (hard zero GC system) that can keep the zero GC state forever for all the request patterns in the above, or depending on the application, the hard solution is too restrictive to use In some cases, it is either 2) a less restrictive method (soft zero GC system).

  Therefore, the mediation device (“zero GC communication mediation device”) according to the present invention is provided as a first aspect in a system that mediates communication implemented in an object-oriented programming language having a GC mechanism. The following processing is performed by processing elements (each processing means).

  When it is necessary to create a temporary object, the temporary object storage means is searched by the object management means, and if a temporary object that has been used with the same type is stored, it is taken out and reused. Store again in the storage means. When an object of the same type as the temporary object does not exist in the temporary object storage means, the temporary object management means generates a new object and uses it. The newly generated temporary object is stored in the temporary object storage means after use. In the case of a hard zero GC system, the memory usage cannot exceed the heap memory allocation given to the system.

  Therefore, in order to prevent an excessive increase in the number of temporary objects generated due to an unexpected communication pattern, the request type is restricted by the request type restriction means, and the data transferred as an argument or a return value by the data transfer number restriction means and The number and type of objects are limited, and the number of simultaneous sessions is limited by means of limiting the number of concurrent and concurrent use. As described later, the restriction by these restriction means includes a form performed at the time of execution and a form performed at the time of development. Requests restricted at runtime are postponed or notified to clients as exceptions or errors. These limit values are set using the request type limit value setting means for the request type limit value, and the transfer data number limit value setting means for the transfer data number limit value setting means. Are respectively set by the simultaneous parallel use number limit value setting means.

  As a result, in the mediation apparatus according to the present invention, the generation opportunity of the temporary object is managed, and if the request mediation process is performed, the communication interruption due to the GC is interrupted as long as the mediation process of the request is performed. Does not occur. Unexpected communication patterns are excluded. For this reason, it becomes a hard zero GC state, and communication with high real-time property is attained.

  According to a second aspect of the present invention, there is provided an intermediary device for zero garbage collection communication according to the present invention, wherein the request type is restricted by the request type restriction means, and the transfer data The number restriction means restricts the type and number of data and objects transferred by the request, or the concurrent and parallel use number restriction means restricts the number of simultaneous and concurrent requests. In the case where the request cannot be started, it is configured to include request postponing means for postponing the start of request processing within a time window time range.

  According to this, the request postponing means is provided, and the request processing start can be postponed within the next time range when the request cannot be accepted by the limiting means as described above. By deferring the request by the request deferral means, it is possible to reduce the chance that the service cannot be used due to the rejection of the reception while ensuring the real time property. Since the degree of real-time property varies depending on the application, it becomes possible to cope with various real-time properties by making it possible to adjust the time range (time window) that can be postponed.

  According to a third aspect of the present invention, there is provided a mediating apparatus for zero garbage collection communication according to the present invention, wherein the mediating apparatus further comprises a stub generating means for generating a stub code using the temporary object managing means. It may be configured to have.

  By providing such a stub code generation means, in an intermediary device that implements a remote service using a stub code (also called a proxy, skeleton, or surrogate), GC occurs using a temporary object management means. By generating a code that does not have, there is no occurrence of GC.

  According to a fourth aspect of the present invention, there is provided an intermediary device for zero garbage collection communication according to the present invention, in which the intermediary device is further configured to temporarily execute a request mediation process that requires a temporary object. An object is generated and configured to be pre-positioned in the temporary object storage means.

  As a result, in the mediation apparatus, the temporary object management means preliminarily arranges the temporary object in the temporary object storage means, so that the runtime object arrangement cost can be reduced. All temporary objects are generated and stored in advance or during the first request by using the method of pre-arranging the temporary objects in the temporary object storage means, and no temporary objects are generated in subsequent requests. Therefore, the GC during the request mediation process does not occur.

  According to a fifth aspect of the present invention, there is provided an intermediary device for zero garbage collection communication according to the present invention, wherein in the intermediary device, the concurrent concurrent use number limiting means is the number of clients or the number of sessions used simultaneously. The concurrent concurrent use number limit value is determined based on the above, and the maximum number of temporary objects to be pre-arranged in the temporary object storage means is determined.

  Thereby, in the mediation device, the number of temporary objects required for the zero GC operation can be determined by the number of communication partners, that is, the number of users to be used simultaneously and the number of other parties to be simultaneously communicated, It is possible to cope with an environment having a plurality of users and a plurality of communication partners. As the amount of heap memory, the product of the amount of memory used in one session and the number of simultaneous sessions is required at a minimum.

  According to a sixth aspect of the present invention, there is provided an intermediary device for zero garbage collection communication according to the present invention, wherein in the intermediary device, a request type limit value limited by a request type limiter and a transfer data number limit The limit value of the type and number of data and objects transferred by the request limited by the means, the limit value of the simultaneous and parallel use number of the request limited by the simultaneous and parallel use number limiting means, and the temporary object storage means are arranged in advance. The limit parameter for the type and number of temporary objects must be at least one of source code, interface definition, service definition, program meta information, command line option specification, setting screen, setting file, and compiled program. Configure to get by parsing It is.

  With such a configuration, it is possible to determine each limit value in each limiting means based on information about the temporary object to be used, and to pre-position how many types of objects in the temporary object storage means You can decide what to do. Information about temporary objects used is obtained by analyzing source code, interface definition, service definition, program meta information, command line option specification, setting screen, setting file or compiled program at the time of development or early execution. can get. Information about the server object to which the request is sent, the temporary object used in the parameters passed by the request, and the type and number of the temporary objects used in the mediation apparatus are obtained.

  According to a seventh aspect of the present invention, there is provided a mediating apparatus for zero garbage collection communication according to the present invention, wherein in the mediating apparatus, the temporary object management means is configured such that when a temporary object is an immutable object, Configured to replace temporary objects with variable objects. With such a configuration, the intermediary device according to the present invention provides a variable object in place of an immutable object so that the variable object can be reused.

  There are two types of object variability in object-oriented programming languages. One is a variable object that can change the contents of the field once set, and the other is an immutable object that cannot change the contents of the field once set. Examples of Java invariant objects include a String object and an Integer object. A StringBuffer object is provided as a variable version of the String object. An immutable object cannot be reused because its state cannot be changed. For this reason, it is effective not to use an immutable object if zero GC is used when designing the mediating apparatus.

  However, since the application specifies an immutable object in the request argument or return value, the mediation device may need to generate an immutable object. In order to prevent the generation, in the mediation apparatus according to the present invention, in order to provide a variable object in place of the immutable object, the temporary object management means can change the temporary object when the temporary object is an immutable object. The variable object is reused by replacing it with an object.

  In addition, as an eighth aspect of the present invention, the intermediary device for zero garbage collection communication according to the present invention further switches an operation mode switching between a mode in which garbage collection suppression processing is performed and a mode in which garbage collection suppression processing is not performed. Means for operating mode switching means for use / non-use of temporary object management means, limit value set in request type limit value setting means, and transfer data number limit value setting means in accordance with each operation mode. It is configured to set each set value of the limit value to be set and the limit value to be set in the simultaneous and parallel use number limit value setting means.

  With such a configuration, the intermediary device according to the present invention can switch between the mode in which the garbage collection suppression process is performed and the mode in which the garbage collection suppression process is not performed, by the operation mode switching unit. Depending on the application, it may be necessary to perform communication without performing zero GC processing within the same application, and it is wasteful that one application includes both the zero GC communication mediating apparatus and the normal mediating apparatus. For this purpose, the zero GC communication mediating apparatus switches between a mode in which zero GC communication is performed and a mode in which zero GC processing is not performed, so that an operation mode suitable for an application can be selected.

  By the way, in the mediating apparatus according to the present invention, some limiting means such as limiting the type of request is provided, and for example, it is ensured that no GC occurs in the mediation processing of communication. If restrictions are imposed by means, the system may not be realized. For this reason, a wider range of applications can be covered by using only one or two restricting means instead of all three restricting means as required.

  Accordingly, as a ninth aspect of the present invention, the mediation apparatus for zero garbage collection communication according to the present invention is configured to perform the mediation processing of remote requests between computers implemented by an object-oriented programming language having a garbage collection function. A temporary object storage means for holding a used temporary object among the objects used for the brokering process, and an initial for reuse of the used temporary object. A temporary object managing means for converting the request, and a request restricting means for restricting a request accepted in the mediation process. The request restricting means includes a request type restricting means for restricting a request type, a data and an object transferred by the request. Transfer data speed limiting means for limiting the of Type and number, or be configured to be either concurrent use number limiting means for limiting the concurrent use number of requests. With such a configuration, a wider range of applications can be covered.

  According to the tenth aspect of the present invention, as a tenth aspect, the intermediary device for zero garbage collection communication according to the present invention performs the intermediary processing of remote requests between computers implemented by an object-oriented programming language having a garbage collection function. A temporary object storage means for holding a used temporary object among the objects used for the brokering process, and an initial for reuse of the used temporary object. A temporary object management means for converting the request, and a request restriction means for restricting a request accepted in the mediation process, wherein the request restriction means includes a request type restriction means for restricting a request type, data and an object transferred by the request Transfer data speed limiting means limits the type and number, or be configured to be two or concurrent use number limiting means for limiting the concurrent use number of requests. With such a configuration, a wider range of applications can be covered.

  As an eleventh aspect of the present invention, there is provided a memory allocation method so that the mediation device for zero garbage collection communication according to the present invention can appropriately manage the memory usage in the mediation device. A memory allocation method according to the present invention for this purpose is a memory allocation method in an intermediary device that performs intermediary processing of remote requests between computers implemented by an object-oriented programming language having a garbage collection function while suppressing garbage collection. The maximum heap memory amount that the intermediary device should have is the maximum memory amount of data transferred as an argument and return value in one request in addition to the memory amount that the intermediary device itself needs in the initial state. Memory obtained by multiplying the amount of memory added for each type of request included in the limit value by the amount of memory required by the mediation device itself for each session, and the limit value for the number of concurrent concurrent use Assign an amount.

  As a result, the maximum heap memory amount to be provided in the mediation device according to the present invention can be obtained by the calculation formula, and the memory usage in the mediation device can be appropriately managed. The mediation apparatus according to the present invention may be implemented not only by software but also by hardware.

  According to the mediating apparatus of the present invention, communication middleware and programming language used for building a distributed real-time application that operates between a plurality of computers on a network by suppressing the occurrence of garbage collection that starts when a memory shortage occurs. The real-time property in the processing of the operating system can be improved.

  Hereinafter, specific embodiments of the present invention will be described with reference to the drawings. In order to facilitate understanding, Java (registered trademark) programming language is used for the description. However, the mediation apparatus according to the present invention can be applied to other object-oriented programming languages including GC such as C # language.

  The present invention is mainly used in distributed real-time applications where communication interruption must be avoided, non-real-time distributed applications where communication interruption is not desirable, and distributed applications where it is desirable to avoid GC to improve processing speed and response speed. Applied to middleware, communication library, language, or OS.

  FIG. 1 is a diagram illustrating the positioning of an intermediary device for zero garbage collection communication according to the present invention. It shows the position of the intermediary device in the distributed application. As shown in FIG. 1, a client computer 110 and a server computer 120 are connected by a communication medium 130, and data communication is performed between the two computers. Communication is performed between two or more computers, or between a plurality of communication elements in one computer. Communication information itself is transmitted via the communication medium 130. As the communication medium 130, for example, a network is used for communication between a plurality of computers, and a data bus is used for communication between a plurality of communication elements in one computer.

  Here, for the sake of explanation, the two computers are divided into a client computer 110 that issues a request and a server computer 120 that receives and services a request for convenience. The application includes an application (client program) 111 operating on the client side and an application (server program) 121 operating on the server side. Communication processing performed in the application is mediated by the client-side mediating device 112 and the server-side mediating device 122. For example, in CORBA, the client-side mediating device 112 is composed of a client-side stub and a client-side communication runtime, the server-side mediating device 122 is composed of a server-side stub and a server-side runtime, and the application (client program) 111 includes An application that calls a server-side stub, and an application (server program) 121 includes a server object that executes a service. A Web service and a video server have the same configuration.

  FIG. 2 is a diagram for explaining the system configuration of an intermediary device for zero garbage collection communication according to the present invention. The example of a structure on one computer carrying the zero GC communication mediation apparatus is shown. In FIG. 2, reference numeral 200 denotes one computer on the server side or client side, and 220 is a language runtime used by the zero GC communication mediating apparatus 230.

  Examples of the language runtime 220 include “Java virtual machine”, “.NET CLR”, “GNU Mono runtime”, and the like. The intermediate code execution method, the compile-time native code conversion method, and the runtime native code conversion method may be used. The language runtime 220 includes a garbage collector 222 and is implemented in software or hardware. When implemented in software, it is executed by the OS or in a memory management system on hardware. During the execution of application 250, during that time, language runtime 220 creates a new object on heap memory 212. The garbage collector 222 performs a memory collection operation (trash collection) at the discretion of the language runtime 220.

  The zero GC communication mediating apparatus 230 includes at least one temporary object storage unit 232 and at least one temporary object management unit 234 in order to suppress the occurrence of GC during communication in the processing of the application 250. These may be configured to include a plurality of temporary object storage means 232 and a plurality of temporary object management means 234.

  The temporary object storage unit 232 holds a temporary object that is required in the execution of the zero GC communication mediating apparatus 230 in order to avoid generation of a temporary object every time. The temporary object storage means 232 is implemented as long as the object can be held, and is not particularly limited. The collection class, the container class, the hash table, the singleton object pattern, the cache, the array, the pool, the inline cache, and the field in the object are used. Means such as holding can be used.

  The temporary object management unit 234 manages the temporary object stored in the temporary object storage unit 232. In the temporary object management process, when a temporary object is required in the mediation process, the temporary object storage means 232 is searched to find a usable temporary object, and the work is reinitialized to be reused. The work of generating a new temporary object and the work of returning the temporary object which becomes unnecessary after use to the temporary object storage means 232 are performed.

  As a method of mounting the temporary object management means 234, a method of providing an object or a component dedicated to this work, a method of describing processing directly inline in the mediating apparatus, a method of integrating with the temporary object storage means 232 (for example, The cache has a search function and a storage function). Note that the temporary object in use does not necessarily need to be removed from the temporary object management unit 234 and may be stored in the temporary object management unit 234 as long as there is no conflict with other users.

  The number and association of the temporary object management means 234 and the temporary object storage means 232 can be arbitrarily combined depending on the mounting convenience. These temporary object storage means 232 and temporary object management means 234 can provide a temporary object reuse function not only for an intermediary apparatus but also for an application that uses the intermediary apparatus, and can suppress GC throughout the application. .

  In the system configuration as shown in FIG. 2, the zero GC communication mediating apparatus 230 takes an embodiment as middleware, and operates in an intermediate layer between the language runtime 220 and the application 250. Since the embodiment of the present invention is not necessarily implemented as middleware, in another case, it is incorporated into the language runtime 220 as a part of the language function, or incorporated into a part of the OS function. Is done.

  In the case of a Web service, XML parsing is performed and an object tree representing the parsing result is constructed. Each element object in the tree is also reused using the temporary object management means.

  The zero GC communication mediating apparatus 230 is provided with a request type limiting unit 236, a transfer data number limiting unit 237, and a simultaneous and parallel use number limiting unit 238. These request type restriction means 236, transfer data number restriction means 237, and concurrent and parallel use number restriction means 238 respectively include the request type, the type and number of data and objects transferred by the request, and the number of concurrent parallel sessions used. Is a restricting means for restricting to be within an assumed range. Limit the intermediary requests by comparing each set limit value with the actual number of uses. The request type limit value is set by the request type limit value setting means 240, the limit value of the transfer data number is set by the transfer data number limit value setting means 241, and the limit value of the simultaneous and parallel use number of requests is calculated by the simultaneous and parallel use number. Each is set by the limit value setting means 242. The limit value is set by a setting file, a setting window, or analysis of source code as will be described later.

  FIG. 3 is a diagram for explaining how the temporary object storage means and the temporary object management means cooperate with the garbage collection means and the language runtime as a more preferred embodiment. The garbage collector 322, which is a garbage collection means, provides the temporary object storage means 332 and the temporary object management means 334, or the garbage collector 322 operates in cooperation with the temporary object storage means 332 and the temporary object management means 334. Thereby, suppression of GC more efficiently becomes possible.

  As shown in FIG. 3, the language runtime 320 cooperates with the temporary object management unit 334 when generating a temporary object, and uses the object stored in the temporary object storage unit 332 when generating a new temporary object. To work. When generating a temporary object, the language runtime 320 does not generate a new temporary object, but searches the temporary object storage means 332 and reuses an object of the same type if it is already stored. The garbage collector 322 can selectively recover some of the temporary objects in the temporary object storage means 332 when the heap memory 312 is tight and the heap memory is still insufficient even when GC is performed. A weak reference can be used for the implementation.

  Next, the procedure of the request mediation process will be described with reference to FIGS. 4, 8, and 9, taking the client computer 110 on the request issuing side as an example. The same applies to the server computer 120 on the server side. FIG. 4 shows a flowchart for explaining a process for mediating a connection request to a service, FIG. 8 shows an example of an application (client program), and FIG. 9 shows a service request mediation. 3 is a flowchart illustrating processing for managing a temporary object in processing.

  Assume that in the client computer 110, the application (client program) 111 issues a request (step 901) in the processing of the program shown in FIG. The process of step 901 is a connection to a remote service, and a reference is obtained as a return value of this process. In this process, session information for a series of remote sessions is created. The remote service is requested by the processing of the next step 902 and step 903. If an argument is passed, the remote service performs some computation and returns a return value. Then, the session is closed by the processing in step 904.

  In the remote service connection process (step 901), a service connection request process 400 as shown in FIG. 4 is started. When the service connection request processing 400 is started, first, the concurrent concurrent usage number limiting means 238 checks whether the concurrent concurrent usage number (number of sessions) exceeds the limit value (step 401). If not, after increasing the number of simultaneous sessions (step 402), an object is generated as normal processing, and session information creation, user information creation, and user authentication encryption data are processed as object processing. , Creation of a reference identifier, creation of a communication data buffer, creation of a connection for communication, etc. (some of them are omitted because there are many). In this case, it is determined whether or not there is an object of the same type of session information (step 410). If there is an object, the internal state of the object is reinitialized (step 411), the object is reused, If there is no object, an object of the same type is generated, initialized and used (step 412). A similar process is performed for each object (step 420 to step 422, step 430 to step 432), and then connection to a remote service is performed (step 480), and a process of returning a reference to the caller as a result of the process. Perform (step 495).

  That is, in the processing of this object, as shown in FIG. 4, when creating such data and information as an object, the temporary object management means is inquired of “Is there a session information object of the same type?” (Step 410). ), The temporary object management means searches the temporary object storage means, and returns it if there is. In the connection process, the session information object is reinitialized and used (step 411). Here, the re-initialization is an operation for re-creating the initial state of the object so as to match the content of the request. Give the temporary object a reinitialization method and call it, or set the state using reflection. If there is no temporary object of the same type in the temporary object storage means, a new object is generated (step 412). Such processing is repeated for all necessary temporary objects. In the process at the end of the session (step 904 in FIG. 8), the previously used temporary object is stored in the temporary object storage means. If the number of simultaneous sessions exceeds the limit value in the determination process of step 401, the mediation apparatus 112 returns a failure to the client program 111 (step 490).

  The processing according to the flowchart of FIG. 4 and the example of the program shown in FIG. 8 describe one embodiment for explanation, and the present invention is applied to an intermediary device having a different temporary object configuration. FIG. 4 shows a different flowchart. However, the essence of the present invention of suppressing GC by changing the temporary object while limiting the communication pattern does not change.

  FIG. 9 is a flowchart showing a process for mediating the request issuance process (steps 902 and 903). The request mediation process 1000 of FIG. 9 is called by the process of step 902 in the example program of FIG. When the mediation process 1000 is started, it is confirmed whether the type of request called by the request type restriction unit 236 is assumed (not exceeding the limit number) or not assumed (step) 1001). In an intermediary device that can dynamically expand the types of requests, such as CORBA, this is a process necessary to prevent the types of requests from expanding unexpectedly and increasing the types of temporary objects. In addition, static CORBA requests that generate a stub for a request in advance, and systems such as RMI and HORB are not required at the time of execution because they are restricted at the time of compilation (access the specified method type). Only stubs to generate).

  Next, similarly, the transfer data number limiting means 237 confirms whether the argument type and number of requests are within the assumption (whether the limit number is exceeded) (step 1002). For example, when a request is made using an array of objects as an argument, the number of temporary objects will increase too much if the number of elements in the array is larger than expected, so this must be avoided. The types of argument objects can vary in polymorphism. Again, accepting any type would increase the number of temporary objects, so you need to limit the number of types. In a system that does not transfer objects, such as a video distribution system, a part can be omitted. After the confirmation, processing for securing a data buffer for transmission (step 1020 to step 1022), processing for securing a data buffer for reception (step 1030 to step 1032), and the like are performed. These processes are also executed by generating an object or reusing the object.

  These are also performed using temporary object management means and temporary object storage means, but the type of temporary object actually required differs depending on the system. Processing by such an object is performed, and in step 1080, the request is transmitted to the remote computer and the result is received. If a temporary object is generated for the return value, it is reused in the same manner, and the result is returned to the called client program (step 1095). At the end of the session, the previously used temporary object must be stored in the temporary object storage means.

  When the program of FIG. 8 is executed for the first time, while the processing of FIG. 4 or FIG. 9 is executed, if a temporary object is not stored in the temporary object storage means, a new temporary object is frequently generated. However, when the program of FIG. 8 is executed for the second time or later, sufficient temporary objects are stored in the temporary object storage means, and a reuse path is selected instead of new generation. Become more. As the processing continues in this way and the processing of the distributed application progresses, the opportunity to newly generate a temporary object decreases, and a stable state in which generation of a temporary object does not occur is reached. This is the zero GC state.

  When the state becomes the zero GC state in this way, no GC is generated during the process in which the mediation device mediates the request. In the processing of the application (client program) 111 and the application (server program) 121 using the zero GC communication mediating apparatus, attention should be paid to object generation, and explicit GC operation should be performed as necessary. Is desirable. It is also desirable to record the memory usage and report if the memory usage exceeds a certain amount, which will be useful for setting the next limit value. The amount of heap memory that the system should have will be described later.

  In the intermediary device having such a configuration, the memory usage increases for a while after the system starts to operate, but after the communication reaches the expected pattern, no GC is generated and the state becomes a zero GC state. Therefore, no communication delay due to GC occurs. This makes it possible to develop a system that was impossible with conventional technology. For example, it is possible to mount an application that performs communication processing that requires real-time property in an object-oriented programming language that includes a GC with high development efficiency and high safety. Compared with the problem solving method using real-time GC or parallel GC, the solution method according to the present invention has an advantage that it can be implemented on a language runtime that does not have a prevailing real-time GC / parallel GC.

  Further, in the object pooling library for GC-less operation of Non-Patent Document 1, when the number of objects increases and the size of the pool is insufficient, a method of expanding the pool within the GC possible time is taken. In an intermediary device implemented in an oriented programming language, the GC possible time is unknown to the intermediary device, so that method cannot cope with the problem of guaranteeing zero GC for any communication pattern that is assumed. . In the mediation apparatus according to the present invention, such a problem can be solved by imposing a limit on the opportunity of generating a temporary object by utilizing the characteristic that communication is regular.

  Next, another embodiment of the mediation apparatus according to the present invention will be described. As described above, when the request cannot be accepted by each restriction unit, the request is suspended by the request deferment unit so that the start of request processing can be deferred within the next time range. As a result, it is possible to reduce the chance that the service cannot be used due to refusal of reception while securing the real-time property. Since the degree of real-time property varies depending on the application, it becomes possible to cope with various real-time properties by making it possible to adjust the time range (time window) that can be postponed.

  FIG. 14 is a flowchart for explaining an intermediary process including a postponement process performed when a request exceeds a limit value. With reference to FIG. 14, the operation by the request postponing means will be described taking the connection request processing to the service as an example. In the request mediation process, when the service connection request process 1600 is started, it is confirmed by a certain restricting means whether or not the limit value is exceeded (step 1601). In this process, the number of simultaneous sessions is confirmed. If the number of simultaneous sessions exceeds the limit number, it waits for a certain time (within the time window) (step 1602), and determines whether the limit value is satisfied within the time window (step 1603). If not satisfied, that is, if timed out, a failure is returned (step 1606). If the limit value is satisfied by the termination of another session within the time window time, subsequent processing is performed (steps 1604, 1605, 1607).

  As described above, the mediation processing including the request deferral processing can be used both in the service connection request processing and in the mediation processing of each request. In this case, the request deferral process can be performed by a form in which the postponement is performed before the request mediation process and a form in which a queue is provided for each temporary object. The time window value is set in advance according to the real-time property required by the application or the mediation device.

  In this way, when request intermediation processing is performed, if the request cannot be received by the restriction means, the start of request processing is postponed within the time range that satisfies the real-time property required by the application. It is possible to reduce the chance that the service cannot be used due to the rejection of the reception while ensuring the real-time property necessary for the service.

  Next, FIG. 13 is a diagram for explaining another embodiment of an intermediary device for zero garbage collection communication according to the present invention, and shows the position of the intermediary device in a distributed application. The mediating apparatus of this embodiment is configured to include stub generation means for generating stub code (also called proxy, skeleton, surrogate) that uses temporary object management means. In FIG. 13, the stub code generation means is a client-side stub code 1512 that is executed on the client side and marshalls the API of the server object, and a server-side stub code 1512 that is executed on the server side to unmarshall communication contents and call the server object Server side stub code 1522 is generated.

  When generating a stub code, instead of the conventional method of generating a temporary object in the stub code, the temporary object is reused by using the temporary object management means, and a code that does not generate GC is generated. Prevent interruption. Each of the generated stub codes (1512, 1522) calls the client-side mediating device 1513 and the server-side mediating device 1523 to perform communication. The stub code may exist in both the client and the server or only one of them, and there are a form that is generated during development and a form that is dynamically generated during execution.

  With reference to the flowcharts of FIGS. 5 and 6, another embodiment of the mediation apparatus according to the present invention will be described. When the processing of the application is started and then the initialization of the mediation apparatus is started (step 501), a number of temporary objects within a range assumed in advance are generated and stored in the temporary object management means. (Step 502). At that time, if it is found that the amount of allocated heap memory is insufficient (step 503), an abnormality is reported to the application (step 505) so that measures can be taken at an early stage. To do. If there is a sufficient amount of heap memory, initialization of the mediation device is normally completed (step 504). Subsequently, a service connection request process (step 510) shown in FIG. 6 is started.

  After performing the processing as shown in FIG. 5, at the stage of performing the connection request to the service and the mediation processing to the service shown in FIG. 6, as described above, if the number of simultaneous sessions does not exceed the limit number, The number of sessions is increased and processing is executed (steps 511 to 516). Normally, as described with reference to FIGS. 4 and 9, a temporary object is newly created as necessary. In this case, since the necessary temporary object already exists in the temporary object storage means, FIG. Even when the connection request processing 510 to the indicated service is started, the session information object here is acquired and reused (step 513), the user information object is acquired and reused (step 514), and the data buffer object Is acquired and reused (step 515), etc., the object stored in the temporary object storage means is reused and the process proceeds, and the process is performed without generating a new temporary object. . Thereby, generation | occurrence | production of GC is suppressed and it is further ensured that GC does not generate | occur | produce.

  In this way, by generating temporary objects when the system is started and storing them in the temporary object storage means in advance, there is no need to generate them at runtime, which has the effect of improving the speed at runtime. There will be something.

  Since the object pooling library for GC-less operation of Non-Patent Document 1 of the prior art does not have means for generating objects in advance and storing them in the object pool, there may occur a situation where heap memory is insufficient during execution. Although heap memory can be expanded, if the OS memory runs out, the system must be in error. On the other hand, according to the mediation apparatus according to the present invention, there is an effect that even if there is a mistake that the amount of memory allocated to the system is too small, it is discovered at the initial stage of execution.

  Next, a process for setting the limit value of the limiter in the mediation apparatus according to the present invention will be described. FIG. 7 is a flowchart for explaining processing for obtaining information about a temporary object and determining a limit value. The process shown in FIG. 7 is executed as a preprocess when a request mediation process service is started. By executing this process, the limit value of the request type, the limit value of the type and number of data and objects transferred by the request, the limit value of the number of concurrent concurrent requests, and the type of temporary object to be pre-arranged Get limit value parameters such as number.

  At the time of development or at the start of operation, the process 800 shown in FIG. 7 is performed as a pre-process before starting the service connection request process 400 (FIG. 4) and the request mediation process 1000 (FIG. 9). In this process 800, first, one or more of application source code, interface definition, service definition, program meta information, command line option specification, setting screen, setting file, and compiled program are analyzed (step 801). . As a result of the analysis, the type R of the request to be serviced remotely is extracted from the obtained information (step 802), the type and number P of the data and objects transferred by the request are extracted (step 803), and the user is used The number and the number S of simultaneous sessions are extracted (step 804). The parameter of the limit value obtained by these becomes the limit value set in each limiting means (step 805). If the intermediary device takes into account the temporary objects T1 and T2 used internally for each session, the type and number of necessary temporary objects can be determined. Further, the maximum range of the temporary object to be pre-placed (step 502 in FIG. 5) and the maximum memory amount Mmax are determined (step 806). The meaning of these codes will be described later.

  In this way, it is sufficient to know how many types of temporary objects an application uses, how many and how many clients and how many peers it should serve at the same time. Memory can be allocated. For this reason, it is possible to prevent the memory usage amount from exceeding the memory allocation amount given to the system and the occurrence of GC.

  Now, when an application generates an immutable object, as described above, the immutable object cannot change its state, and therefore this object cannot be reused. Therefore, in order to obtain a zero GC system when designing the mediating apparatus, it is effective to use a process that does not use an immutable object.

  However, depending on the application, since the application specifies an immutable object in the argument or return value of the request, the mediation device may have to generate the immutable object. For example, in the program example shown in FIG. 10, the remote method 1201 takes an object of “ImmutableData” (1203) class as an argument.

  When executing the application program, the server-side mediating device 122 (FIG. 1) passes a copy of the object as an argument and processes the server method entity in the application (server program) 121. There must be. Making a copy of the object creates a new temporary object. In order to prevent the new creation of the object, the server-side mediating apparatus 122 reuses the variable object by synthesizing and passing the variable object MutableData (1204), which is a subclass of ImmutableData (1203), by executing the method 1202. can do.

  That the object 1203 is an immutable object is detected by the presence of the final field. An object 1204 is a version obtained by removing final from the final field of the object 1203, and is synthesized at the time of development or execution. The same applies to the case where the return value is an immutable object as in the method 1202. If a compatible subclass cannot be synthesized, such as the String class, which is the final class, the application developer may be required to use a variable object such as the StringBuffer type.

  In a language whose basic type (for example, int) is not an object, the basic type does not use heap memory. On the other hand, many object-oriented programming languages provide a wrapper object (for example, Java.lang.Integrer) that makes it possible to handle a basic type as an object for design flexibility. In some languages, wrapper objects are immutable objects. When it is necessary to transfer the wrapper object in the request, in order to avoid the use of heap memory, the operation of replacing the basic type wrapper object with the basic type is performed. Application developers may be required to use basic types rather than wrapper objects in requests.

  Replacing an immutable object with a variable object enables reuse of the object and contributes to suppressing the occurrence of GC.

  In addition, the application of the present invention can be applied by reading the source code of an existing intermediary device that does not use the present invention, detecting a temporary object, converting it into a code that reuses a temporary object, converting an immutable object into a variable object, etc A conversion system that performs is useful.

  Now, depending on the application, some types of requests are restricted by a plurality of restricting means as in the intermediary device according to the present invention, and communication that performs zero GC processing and communication that does not perform zero GC processing are mixed. I want to use it. The intermediary device of the present invention may be configured so that whether to perform the zero GC process can be switched for each session, for each request, for each communication partner, the importance of communication contents, or for the entire intermediary device. With such a configuration, the mediation apparatus of the present invention can meet various application development requirements.

  FIG. 12 is a flowchart for explaining a switching process between a mode in which zero GC processing is performed and a mode in which zero GC processing is not performed in request mediation processing. In the request mediation process, the operation mode can be switched in this way, and the mediation process in each operation mode can be performed. In this case, the application sets a state variable indicating whether or not the zero GC process is necessary for the request brokering process. When request mediation processing starts, it is determined whether or not zero GC processing is necessary using the state variable (step 1401). If so, request mediation is performed in the mode with zero GC processing as described above. Processing is performed (step 1402). If not necessary, request mediation processing is performed in a mode in which zero GC processing is not performed (step 1403). The request mediation process in the mode in which the zero GC process is not performed is a request mediation process by a conventional method.

  The implementation that enables switching of the operation mode is the simplest implementation in which the mode switching is performed in the entire intermediary device, but the operation mode may be switched for each session. When performing processing in which different modes are mixed for each session, the mode in which zero GC processing is not performed consumes heap memory. Therefore, heap memory is allocated to each mode, and heap memory is used by using real-time GC or parallel GC. It is desirable to prevent saturation.

  In the mediating apparatus according to the present invention, the zero GC communication mediating apparatus includes a mode switching means that switches between a mode in which the zero GC processing is performed and a mode in which the zero GC processing is not performed, thereby mixing the zero GC processing within the same application. Thus, it is possible to switch between communication with high real-time characteristics and communication with which the service is not rejected (by the limiting means). With such a configuration, it is not necessary to provide both a zero GC communication mediation device and a normal mediation device in a single application, which has the effect of reducing computational resources and development costs.

  As described above, in the request mediation process, the method that does not generate the GC is a method (hard zero GC system) that can maintain the zero GC state forever for any request pattern, or depending on the application. However, a hard solution that restricts requests by the restricting means may be too restrictive and cannot be used. Therefore, a configuration with a less restrictive method (soft zero GC system) may be used.

  In the request mediation process shown in FIG. 11, some limiting means are removed, and the request is limited only by the type and number of arguments (step 1301). As described above, the mediation apparatus according to the present invention can be applied even in a system in which the number of requests cannot be limited by loosening the restrictions imposed on the types of requests, the types of objects to be transferred, and the number of simultaneous sessions. Is possible.

Depending on the application, even if the intermediary device consumes memory step by step, the application itself may explicitly perform GC at an appropriate timing, so that zero GC may be maintained during request processing. Further, the OS may be requested to add a memory. In such an application, it is said that it does not service more sessions than expected in advance, dynamically increases the number of methods, or does not limit the types and number of objects transferred in the request. It becomes possible to give flexibility.

  Now, a method for calculating the amount of heap memory to be allocated to the mediating device in order to realize the hard zero GC will be described. That heap memory amount is the amount of memory required by the mediation device to ensure that no GC occurs. R is the set of request types, P is the amount of memory occupied by the maximum value of the type and number of arguments and return values and transferred data and objects in a request, and the amount of memory required by the mediation device per session Is T1, the amount of memory required by the mediation device itself in the initial state is T2, and the maximum limit value of the number of concurrent concurrent sessions is S, the heap memory amount Mmax that the mediation device should have at least is expressed by the equation of FIG. Is done.

  The amount of heap memory used does not exceed the allocated amount by allocating the amount of heap memory calculated by the formula for calculating the maximum amount of heap memory and imposing a limit by the limiting means such as the mediation device of the first aspect. Is guaranteed. Conversely, by using the formula of FIG. 15, it is possible to obtain the maximum number of sessions allowed from the allocated heap memory amount.

  However, the maximum amount of heap memory is used only under extreme load conditions where all clients issue all requests simultaneously. Many systems are unlikely to reach extreme load conditions, so it may not be necessary to provide the maximum amount of heap memory. There is a trade-off relationship between providing a memory close to the maximum heap memory amount in order to guarantee the hard zero GC more strongly and allowing the hard zero GC to be broken and reducing the heap memory amount. It is also one preferred embodiment to grasp the trade-off relationship suitable for the system and to provide an appropriate amount of heap memory in accordance with the hard zero GC guarantee level sufficient in terms of specifications.

  The mediation device according to the invention can also be implemented using hardware. When implementing an intermediary device with hardware, an important point is how to efficiently manage objects that are dynamically created and disappeared (as hardware, a small area on a memory) with hardware. Components and architecture for hardware implementation are similar to the system configuration shown in FIG. However, it does not matter whether or not an object-oriented language is used. Due to recent advances in hardware / software co-design tools, it is not difficult to describe part or all of the present invention, such as temporary object storage means and temporary object management means, in a hardware description language and convert it to hardware. .

  By performing the memory management by applying the present invention, it is possible to reduce the hardware for collecting the free area of the memory on a large scale. It is also possible to suppress communication interruption for memory management.

  As described above, the intermediary device according to the present invention greatly improves the real-time property in a request mediation device implemented in a programming language equipped with GC or a request mediation device implemented in hardware equipped with memory management. It can be widely used in industrial equipment, robots, communication devices, space equipment, automobiles, and the like that communicate on a network.

It is a figure explaining the positioning of the mediation apparatus for the zero garbage collection communication by this invention. It is a figure explaining the system configuration | structure of the mediation apparatus for the zero garbage collection communication by this invention. It is a figure showing a mode that a temporary object storage means and a temporary object management means cooperate with a garbage collection means and a language runtime. It is a flowchart explaining the process which mediates the connection request to a service. It is a 1st flowchart explaining the step which performs prior arrangement and reuse of a temporary object in a system with prior arrangement. It is a 2nd flowchart explaining the step which performs prior arrangement and reuse of a temporary object in a system with prior arrangement. It is a flowchart explaining the process which acquires the information about a temporary object and determines a limit value. It is a figure which shows an example of an application (client program). It is a flowchart which shows the process which manages the temporary object in the mediation process of a service request. It is a figure explaining the usage example of an immutable object. It is a flowchart explaining the step of the request mediation process which eased restrictions. It is a flowchart explaining the switching process of the mode which performs zero GC process in the request mediation process, and the mode which is not performed. It is a figure showing the positioning of a stub code and a stub code generation means. It is a flowchart explaining the mediation process including the postponement process performed when a request exceeds a limit value. It is a figure which shows the type | formula which calculates the maximum heap memory amount to be used.

Explanation of symbols

110 Client computer 111 Application (client program)
112 Client-side Mediation Device 120 Server Computer 121 Application (Server Program)
122 server side mediating device 130 communication medium 200 computer 212 heap memory 220 language runtime 222 garbage collector 230 zero GC communication mediating device 232 temporary object storage means 234 temporary object management means 235 request deferment means 236 request type restriction means 237 transfer data number restriction means 237 238 Concurrent use limit unit 239 Operation mode switching unit 240 Request type limit value setting unit 241 Transfer data number limit value setting unit 242 Concurrent use number limit value setting unit 250 Application 312 Heap memory 320 Language runtime 322 Garbage collector 330 Zero GC Communication mediation device 332 Temporary object storage means 334 Temporary object management means 340 Application 1510 Client compilation Over data 1511 application (client program)
1512 Client-side stub code 1513 Client-side mediating device 1520 Server computer 1521 Application (server program)
1522 Server-side stub code 1523 Server-side mediating device 1530 Communication medium

Claims (14)

An intermediary device that performs intermediary processing of remote requests between computers implemented by an object-oriented programming language having a garbage collection function while suppressing garbage collection,
A temporary object storage means for holding a used temporary object among temporary objects temporarily used for the mediation process;
Temporary object management means for initializing the used temporary object for reuse;
A request type limit value setting means for setting a request type limit value;
Request type limiting means for limiting the type of request by the limit value of the type of request;
Transfer data number limit value setting means for setting the transfer data number limit value;
Transfer data number limiting means for limiting the type and number of data and objects transferred by a request according to the limit value of the transfer data number;
Concurrent concurrent usage limit setting means for setting the concurrent concurrent usage limit, and
Concurrent concurrent usage limit means for limiting the concurrent concurrent usage number of requests by the concurrent concurrent usage limit value;
An intermediary device comprising: The mediation device according to claim 1, further comprising:
The request type limiting means limits the type of request,
The type and number of data and objects transferred by the request are limited by the transfer data number limiting means, or the simultaneous and parallel use number of requests is limited by the simultaneous parallel use number limiting means,
An intermediary apparatus comprising: a request postponing unit that postpones the start of request processing within a time window when a request cannot be started. The mediation device according to claim 1, further comprising:
An intermediary apparatus comprising stub generation means for generating a stub code that uses the temporary object management means. The mediation device according to claim 1, further comprising:
Before a request mediation process that requires a temporary object is started, a temporary object is generated and pre-positioned in the temporary object storage means.
An intermediary device characterized by that. The intermediary device according to claim 1,
The concurrent and concurrent usage limit means determines a concurrent and concurrent usage limit value based on the number of clients or the number of sessions used simultaneously, and determines the maximum number of temporary objects to be pre-arranged in the temporary object storage means To
An intermediary device characterized by that. The intermediary device according to claim 1,
The request type restriction means restricts the request type restriction value, the transfer data number restriction means restricts the type and number of data and objects transferred by the request restriction, and the concurrent and parallel use number restriction means restricts it. The limit value of the number of concurrent requests used and the type and number of temporary objects to be pre-arranged in the temporary object storage means include source code, interface definition, service definition, program meta information, command line option specification, setting screen, An intermediary device obtained by analyzing at least one of a setting file and a compiled program. The intermediary device according to claim 1,
The intermediary apparatus characterized in that the temporary object management means replaces a temporary object with a variable object when the temporary object is an immutable object. The mediation device according to claim 1, further comprising:
An operation mode switching means for switching between a mode for performing garbage collection suppression processing and a mode for not performing garbage collection suppression processing;
The operation mode switching means uses or does not use the temporary object management means according to each operation mode, a limit value set in the request type limit value setting means, and a limit value set in the transfer data number limit value setting means And an intermediary device that sets each set value of the limit value to be set in the simultaneous parallel use number limit value setting means. An intermediary device that performs intermediary processing of remote requests between computers implemented by an object-oriented programming language having a garbage collection function while suppressing garbage collection,
A temporary object storage means for holding a used temporary object among temporary objects temporarily used for the mediation process;
Temporary object management means for initializing the used temporary object for reuse;
Request limiting means for limiting requests accepted in the mediation process,
The request limiting means includes
Request type restriction means to limit the type of request,
Transfer data number limiting means to limit the type and number of data and objects transferred by the request, or concurrent parallel usage limit means to limit the number of concurrent and concurrent requests,
An intermediary device characterized by being any one of the above. An intermediary device that performs intermediary processing of remote requests between computers implemented by an object-oriented programming language having a garbage collection function while suppressing garbage collection,
A temporary object storage means for holding a used temporary object among temporary objects temporarily used for the mediation process;
Temporary object management means for initializing the used temporary object for reuse;
Request limiting means for limiting requests accepted in the mediation process,
The request limiting means includes
Request type restriction means to limit the type of request,
Transfer data number limiting means for limiting the type and number of data and objects transferred by the request, or concurrent parallel usage limit means for limiting the number of concurrent and concurrent requests,
Any one of the two. A method of allocating memory in an intermediary device that performs intermediary processing of remote requests between computers implemented by an object-oriented programming language having a garbage collection function while suppressing garbage collection,
The maximum amount of heap memory that the mediation device should have is:
In addition to the amount of memory required by the mediation device itself in the initial state, the maximum amount of data transferred as an argument and return value in one request is added to each request type included in the request type limit value The amount of memory obtained by multiplying the amount of memory plus the amount of memory required by the intermediary device itself for each session by the limit value of the number of concurrent concurrent uses is allocated.
A memory allocation method in an intermediary device. An intermediary device that performs mediation processing of remote requests between computers while suppressing garbage collection,
A temporary object storage means for holding a used temporary object among temporary objects temporarily used for the mediation process;
Temporary object management means for initializing the used temporary object for reuse;
A request type limit value setting means for setting a request type limit value;
Request type limiting means for limiting the type of request by the limit value of the type of request;
Transfer data number limit value setting means for setting the transfer data number limit value;
Transfer data number limiting means for limiting the type and number of data and objects transferred by a request according to the limit value of the transfer data number;
Concurrent concurrent usage limit setting means for setting the concurrent concurrent usage limit, and
Concurrent concurrent usage limit means for limiting the concurrent concurrent usage number of requests by the concurrent concurrent usage limit value;
An intermediary device comprising: An intermediary device that performs mediation processing of remote requests between computers while suppressing garbage collection,
A temporary object storage means for holding a used temporary object among temporary objects temporarily used for the mediation process;
Temporary object management means for initializing the used temporary object for reuse;
Request limiting means for limiting requests accepted in the mediation process,
The request limiting means includes
Request type restriction means to limit the type of request,
Transfer data number limiting means to limit the type and number of data and objects transferred by the request, or concurrent parallel usage limit means to limit the number of concurrent and concurrent requests,
An intermediary device characterized by being any one of the above. An intermediary device that performs mediation processing of remote requests between computers while suppressing garbage collection,
A temporary object storage means for holding a used temporary object among temporary objects temporarily used for the mediation process;
Temporary object management means for initializing the used temporary object for reuse;
Request limiting means for limiting requests accepted in the mediation process,
The request limiting means includes
Request type restriction means to limit the type of request,
Transfer data number limiting means to limit the type and number of data and objects transferred by the request, or concurrent parallel usage limit means to limit the number of concurrent and concurrent requests,
Any one of the two.

Images