JP5357989B2 - Memory management device, memory management method, and memory management program - Google Patents

Description

  The present invention relates to a technique for managing a memory used by a bundle based on an OSGi standard specification.

[About OSGi]
OSGi (Open Services Gateway interactive) is a software modularization technology. A software module based on the OSGi standard specification is called a bundle.

  As shown in FIG. 16, JavaVM (Java (registered trademark) Virtual Machine) operates as one process on the operating terminal OS (Operating System), and the bundle is executed on the JavaVM. OSGiFW (OSGi Framework), which is an environment, operates. A plurality of bundles can be operated on the OSGiFW. OSGiFW and bundles are Java programs.

  To run a Java program on JavaVM, first, source code written in the Java language is compiled into a class file that is a binary file that can be interpreted by JavaVM. JavaVM interprets the class file and executes the program.

  A bundle is a set of files necessary for executing a program such as a class file or an image file. The OSGi specification defines a mechanism in which a plurality of bundles cooperate, that is, a mechanism in which another bundle can call a class file provided by a bundle.

  One of them is cooperation by OSGi service. Specifically, as shown in FIG. 17, the bundle A provides an implementation class of the service S defined by the Java interface, and registers the generated object as an OSGi service in the OSGiFW service registry. The bundle B can acquire the OSGi service registered in the service registry and call the service S method of the object.

  In addition, there is cooperation by Import / Export of packages.

[Providing and using functions]
In many OSGi services, as shown in FIG. 18, the bundle C in which the OSGi service is registered provides a function for the bundle D through the service S.

  For example, in the HTTP Service defined by the OSGi specification, the bundle C provides an HTTP Service implementation class and performs service registration, thereby providing a Java Servlet registration function to an HTTP server to other bundles. The bundle D obtains and calls the HttpService to use the HttpService function of the class provided by the bundle C.

  On the other hand, in the case of a callback type call, the provision and use of functions are reversed. As an example, as shown in FIG. 19, there is an event notification when there is a bundle E that manages certain information and a bundle F that is desired to be notified when the information is changed.

  In this case, the bundle F provides the OSGi service implementation class that becomes the event listener L, registers the service in the service registry, and when the bundle E is to notify the event, obtains the registered OSGi service and calls it. Back.

  That is, a function called event notification is provided by a bundle E that performs a call, and a bundle F that provides a class uses the function.

  The relationship between the provision and use of such functions also exists in bundles and OSGiFW, bundles and JavaVM, etc., in addition to cooperation between bundles.

[About JavaVM]
In the conventional technology, the memory required for the bundle, OSGiFW, and JavaVM itself to operate is secured by the JavaVM from one heap memory (heap area) allocated from the OS. Specifically, for example, a memory used (secured / consumed) by a bundle called by a certain thread is secured from one heap area. Hereinafter, it may be described by the expression of memory allocation.

  Further, in a thread operating on JavaVM, memory allocation always occurs in the top stack (TOPSTACK) of each thread as shown in FIG. In the JavaVM specification, a specific structure is not defined for an object. Bundles, OSGiFW, and JavaVM, which are system entities, share one heap area.

  If the memory amount necessary for memory allocation cannot be secured, GC (Garbage Collection) is performed, and the memory area of the object that is not referenced at that time is released. If the required amount of memory cannot be secured even after GC, an OOM (Out Of Memory) error occurs. If an OOM error is caught and handled, the entity may fail to operate if it is not appropriate for each entity.

  In the present invention, “the case where the necessary amount of memory cannot be secured” refers to the case where the necessary amount of memory cannot be secured even when GC is performed.

  As shown in FIG. 21, the JavaVM stack structure is generally (1) triggered by a call from the caller stack, and (2) memory allocation is performed in the processing in the class providing stack.

"The Java Virtual Machine Specification, 3.5.3 Heap, 4.1 The ClassFile Structure", [Online], searched February 8, 2012, <URL: http://java.sun.com/docs/books/jvms/ second_edition / html / VMSpecTOC.doc.html> "OSGi Alliance", [Online], searched February 8, 2012, <URL: http://www.osgi.org/Specifications/HomePage>

  In the conventional technology, the bundle, OSGiFW, and JavaVM share the heap area. If an OOM error occurs at a certain entity and the memory is not released, other entities can also secure new memory after that point. As a result, all the systems may stop.

  A particular problem arises when a plurality of business operators share a single system and provide services simultaneously using conventional technology.

  For example, a platform provider (hereinafter referred to as a “PF provider”) provides a platform system part such as JavaVM and OSGiFW as a platform system, and a service provider (hereinafter referred to as “Service Provider” provider). It is assumed that the service provider provides a service by operating a bundle developed by the user on a platform system provided by the PF provider.

  At this time, if a bundle created by a certain SP provider consumes more memory than expected due to a bug, other entities such as JavaVM, OSGiFW, and other bundles that should have been able to operate normally without the bug. It becomes impossible to operate until. In other words, all the entities (systems provided by PF providers and SP provider bundles) that operate on JavaVM that should be operating normally become inoperable due to a bug in one SP provider bundle. It happens.

  As described above, in OSGi, components such as a bundle and OSGiFW are linked. The definition of whether the memory consumed when linking is counted as “caller” or “provided by class” is not defined in the specifications of OSGi or Java (Non-Patent Document 1, Non-Patent Document 1, Patent Document 2). Since the definition is not fixed, the memory consumption of the bundle cannot be measured.

  The present invention has been made in view of the above problems, and an object of the present invention is to limit memory consumption in an arbitrary unit.

A memory management device according to a first aspect of the present invention is a memory management device that manages memory used by a bundle operating on a software platform, and creates a group in memory management units, and the amount of memory that can be used for each group set the limit, when installing the bundle, and setting means for setting the group to the class loader object of the bundle, when the class loader object of the bundle or the software platform requests a memory, the memory selection means for selecting a group set to the class loader object of the bundle or the software platform which requested as a count which the request memory amount, a total value of memory already assigned to the group selected by the selecting unit An estimated integrated value obtained by adding the requested memory amount to the integrated memory consumption value and a limit value set for the group. If the estimated integrated value is equal to or less than the limit value, Allocates the amount of memory, adds the requested memory amount to the memory consumption integrated value of the group, updates the memory consumption integrated value, and generates an error if the expected integrated value exceeds the limit value And assigning means.

A memory management method according to a second aspect of the present invention is a memory management method for managing a memory used by a bundle operating on a software platform, wherein a group is created by a memory management unit by a computer and used for each group. Setting a limit value of the amount of memory that can be created; setting the group in the class loader object of the bundle when installing the bundle; and the class loader object of the bundle or the software platform requested memory Occasionally, the step of selecting the bundle or group set to the class loader object of the software platform which requested the memory as the count which the request amount of memory, glue selected in said selecting step Comparing a predicted integrated value obtained by adding the requested memory amount to a memory consumption integrated value that is a total value of memory already allocated to the limit value set for the group, and the predicted integrated value is the limit value If less than the value, allocating the required memory amount from the heap area, adding the required memory amount to the memory consumption integrated value of the group, and updating the memory consumption integrated value; and A step of generating an error when the integrated value exceeds the limit value.

In the memory management method, when a class loader object of the bundle or the software platform requests a memory, the bundle or software platform that is the first caller is traced by calling the bundle or software platform that requested the memory. A group to which the platform belongs is selected as a count destination of the requested memory amount .

In the memory management method described above, when the class loader object of the bundle or the software platform requests a memory, the bundle or the software platform that requested the memory is traced, and the bundle called by the software platform belongs. A group is selected as a count destination of the requested memory amount .

In the memory management method, when the function providing flag or the function use flag is set in the bundle, and the class loader object of the bundle or the software platform requests the memory, the bundle or the software platform that requested the memory And the group to which the bundle called by the software platform belongs or the group to which the bundle for which the function use flag is set belongs is selected as the requested memory amount count destination .

In the memory management method, when the bundle or the software platform sets up a thread, a group to which the bundle or the software platform that sets up the thread belongs is set to the thread, and the class loader of the bundle or the software platform is set. When an object requests a memory, a group set to a thread to which the bundle or the software platform to which the memory is requested belongs is selected as a count destination of the requested memory amount .

  In the above memory management method, a step of assigning a group ID for identifying a group selected as a counting destination of consumption of the memory to an object generated when the memory is requested, and a specified group ID are given And summing up the sizes of the objects to obtain the memory consumption of the group indicated by the group ID.

  A memory management program according to a third aspect of the present invention causes a computer to execute each step of the memory management method.

  According to the present invention, the memory consumption can be limited in an arbitrary unit.

It is a figure which shows the structure of the memory management apparatus in this Embodiment. It is a table | surface which shows the calling relationship of the quadrants ad. It is a figure which shows the example of the stack referred at the time of group selection algorithm description. It is a flowchart which shows operation | movement of a 1st group selection algorithm. It is a figure which shows the allocation condition of the resource consumption of each stack at the time of 1st group selection algorithm execution. It is a flowchart which shows operation | movement of a 2nd group selection algorithm. It is a figure which shows the allocation condition of the resource consumption of each stack at the time of 2nd group selection algorithm execution. It is a flowchart which shows operation | movement of a 3rd group selection algorithm. It is a table | surface which shows the call destination of quadrant ad, and the count destination of memory consumption. It is a figure which shows the allocation condition of the resource consumption of each stack at the time of 3rd group selection algorithm execution. It is a flowchart which shows operation | movement of a 4th group selection algorithm. It is a table | surface which shows the call destination of quadrant ad, and the count destination of memory consumption. It is a figure which shows the allocation condition of the resource consumption of each stack at the time of 4th group selection algorithm execution. It is a figure which shows an example of the calling function of PF set. It is a flowchart which shows operation | movement of a 5th group selection algorithm. It is a figure which shows the system architecture of OSGi. It is a figure which shows the cooperation between bundles by an OSGi service. It is a figure which shows provision and utilization of a bundle function. It is a figure which shows utilization and provision of a bundle function. It is a figure explaining memory allocation. It is a figure explaining the stack structure of JavaVM.

  Hereinafter, an embodiment for carrying out the present invention will be described with reference to the drawings. However, the present invention can be implemented in many different modes and should not be construed as being limited to the description of the present embodiment.

[Configuration of memory management device]
First, the configuration of the memory management device 1 in the present embodiment will be described.

  FIG. 1 is a diagram illustrating a configuration of the memory management device 1. The memory management device 1 is configured by a computer including an arithmetic processing device, a storage device, and the like, and the processing of each unit is executed by a program. This program is stored in a storage device included in the memory management device 1, and can be recorded on a recording medium such as a magnetic disk, an optical disk, or a semiconductor memory, or provided through a network.

  The memory management device 1 according to the present embodiment includes a Java VM 10 that operates on the OS, an OSGiFW 11 that provides a bundle execution environment on the Java VM 10, and a resource management bundle 12a that operates as a Java program on the OSGiFW 11, and the Java VM 10 And a resource that is used (secured / consumed) by a bundle operating on a software platform configured with OSGiFW11.

  A bundle created by the PF company is referred to as an owner bundle 12, and a bundle created by the SP company for providing a service is referred to as an SP bundle 131. In addition, a bundle group composed of one or more bundles is used as a bundle set, a bundle set created by an SP provider is created as an SP bundle set 13, and a Java VM 10, OSGiFW 11, and owner bundle 12 are created as a platform system by a PF provider. The PF set 14 is assumed. There is one PF set 14 in the present embodiment, and a plurality of SP bundle sets 13 can be considered.

  The Java VM 10 operates software such as the OSGiFW 11, the owner bundle 12, and the SP bundle 131 using resources received from the OS. The Java VM 10 according to the present embodiment has a unique remodeling unit, and when operating the software, creates a group that is a unit for managing resources, assigns a group ID, and sets a memory consumption limit value for each group. Set to manage memory consumption.

  Also, it is determined which group memory consumption is counted as the memory allocated when the class is loaded and the object is generated by the class loader object, and the total memory consumption of the group for which the memory consumption is counted is An error is generated if the limit value is exceeded. A group selection algorithm for determining which group's memory consumption is to be counted as the memory consumption of which group can be arbitrarily determined. Changing the group selection algorithm changes in which units the memory consumption can be limited. A specific example of the group selection algorithm will be described later.

  In order to realize these functions, the Java VM 10 has a data structure in which a group ID can be set for a class loader object, a data structure for holding a group ID to which the object belongs, and a memory of the group for each group. It has an area for holding a memory consumption integrated value obtained by summing up memory consumption counted as consumption and a memory consumption limit value set for the group. In addition, the Java VM 10 includes an API for setting these.

  The OSGiFW 11 supports bundle installation, a cooperation function between bundles, and the like. The OSGiFW 11 according to the present embodiment has a unique remodeling unit that first calls back a Resolved event to the resource management bundle 12a when the SP bundle 131 is installed.

  The resource management bundle 12a is one of the owner bundles 12, and is installed when the SP bundle 131 is installed by allocating a group ID for each SP bundle set 13 and setting a memory consumption limit value in the Java VM 10. The group ID is set in the class loader object of the SP bundle 131. Specifically, the resource management bundle 12a includes information on the SP bundle 131 that constitutes one SP bundle set 13 (hereinafter referred to as “bundle set information”) and the amount of memory permitted to be used by the SP bundle set 13 (hereinafter referred to as “bundle set information”). , Referred to as “bundle set memory amount”), associate the group ID obtained from the Java VM 10 with the obtained bundle set information, notify the Java VM 10 of the group ID and the bundle set memory amount, and determine the bundle set memory amount Set as a limit value for group memory consumption.

  Further, when the SP bundle 131 is installed and the resource management bundle 12a receives the Resolved event, the class loader object of the installed SP bundle 131 is acquired through the standard API of Java / OSGi, and the class loader object of the SP bundle 131 is acquired. The Java VM 10 is notified of the information including the group ID associated with the SP bundle set 13 to which the SP bundle 131 belongs, and the group ID is set in the class loader object of the SP bundle 131.

  The bundle set information is an identifier that uniquely identifies the bundle by the Bundle-SymbolicName and Bundle-Version defined by the OSGi specification, and one or more identified SP bundles 131 are designated. The bundle set information and the bundle set memory amount are obtained from a server 3 installed outside as a device separate from the memory management device 1. Various methods such as an XML file can be considered for delivery of bundle set information and the like. Note that the bundle set information and the like may be stored in advance in the storage unit of the memory management device 1 itself.

[Operation of memory management device]
Next, the operation of the memory management device 1 will be described.

  The memory management device 1 performs a process for creating a group, which is a unit for managing resources, and sets a memory consumption limit value for each group, and allocates a memory when a class is loaded to generate an object. Processing will be described.

  First, processing for creating a group and setting a memory consumption limit value for each group will be described.

  The resource management bundle 12a acquires bundle set information and a bundle set memory amount from an external server 3 connected via a communication network.

  When the SP bundle 131 is installed in the OSGiFW 11 and the resource management bundle 12a receives the Resolved event from the OSGiFW 11, the group ID associated with the SP bundle set 13 to which the installed SP bundle 131 belongs is acquired from the Java VM 10. At this time, the Java VM 10 newly creates a group, assigns a group ID, and returns the group ID to the resource management bundle 12a.

  Then, the resource management bundle 12a acquires the class loader object of the installed SP bundle 131, and notifies the Java VM 10 of the acquired class loader object and the above group ID. The Java VM 10 sets a group ID for the notified class loader object.

  In addition, the resource management bundle 12a notifies the Java VM 10 of the group ID and the bundle set memory amount of the SP bundle set 13 of the installed SP bundle 131. The Java VM 10 sets the bundle set memory amount notified to the notified group ID as a memory consumption limit value.

  When the SP bundle 131 is installed, the OSGiFW 11 calls back the resource management bundle 12a first, so that the group ID can be set before the installed SP bundle 131 secures resources.

  Next, a process for allocating memory to the generated object will be described.

  When a class is loaded by a class loader object and an object is generated, a group selection algorithm, which will be described later, selects a group based on the object calling relationship, and sets a group ID for the generated object. When allocating a memory necessary for generating an object, it is checked whether or not the total memory consumption of the group exceeds the limit value for the set group ID. Hereinafter, a method of checking the memory consumption will be described.

  If the value obtained by adding the generated object size to the memory consumption integrated value of the selected group is less than or equal to the memory consumption limit value of the group, the memory allocation is successful, and the object is added to the memory consumption integrated value. The memory consumption integrated value is updated by adding the size of the memory, and an object corresponding to the size of the object is allocated from the heap area to generate the object.

  If the value obtained by adding the size of the generated object to the integrated memory consumption value of the selected group is larger than the limit value of the memory consumption of the group, execute GC and release the memory of the unreferenced object After that, it is determined whether to allocate memory by adding the size of the generated object to the memory consumption integrated value after GC of the selected group. If the value obtained by adding the object size to the memory consumption integrated value exceeds the memory consumption limit value even after the GC is executed, an OOM error is generated. If the value obtained by adding the object size to the memory consumption integrated value is less than or equal to the memory consumption limit value, the memory allocation is successful, and the memory size is calculated by adding the object size to the memory consumption integrated value after GC. The amount integrated value is updated, and an object corresponding to the size of the object is allocated from the heap area to generate the object.

  As described above, according to the present embodiment, a bundle group composed of one or more SP bundles 131 is set as an SP bundle set 13, a group is formed for each SP bundle set 13, and a group ID is assigned. By counting the memory consumption integrated value for each group and setting a memory consumption limit value for each group, it becomes possible to limit the memory consumption for each group in an arbitrary unit.

  A method of storing a plurality of heap areas by actually dividing the heap area for each group instead of the value of the memory consumption limit for each group is also conceivable. However, in this method, when changing the allocation size of the heap area for each group, it is necessary to reconfigure the heap area, and there is a possibility that an object already secured in the heap area may move. For this reason, it is difficult to change the heap area that is flexibly divided during JavaVM activation. In this embodiment, since the memory consumption limit for each group is simply held as a limit value, it is only necessary to refer to whether or not the memory consumption exceeds the limit value when allocating memory. The limit value for each group can be flexibly changed without causing the movement of the object secured in the area.

  In the above description, the memory consumption amount of the SP bundle set 13 is limited. However, it is possible to restrict the memory consumption amount by assigning a group ID to the PF set 14 as well.

  In the above description, the SP bundle 131 has been described. However, the present invention is also applicable to the case where the owner bundle 12 is installed.

[Group selection algorithm]
Next, the group selection algorithm will be described.

  When allocating memory, changing the algorithm that selects the group that counts the amount of memory to be allocated changes the unit in which memory consumption can be limited (for example, thread unit, bundle unit, etc.) Become. In this embodiment, four group selection algorithms will be described as an example.

  Here, the relationship between the PF set and the SP bundle set is considered. The following 4 types (2 × 2 types) can be considered as which of the PF set and the SP bundle set is the class provider / caller.

Quadrant a) Class provider: PF set Caller: PF set Quadrant b) Class provider: PF set Caller: SP bundle set Y
Quadrant c) Class provider: SP bundle set X Caller: PF set Quadrant d) Class provider: SP bundle set X Caller: SP bundle set Y
Since quadrant b and quadrant c are both SP bundle sets for the PF set, the SP bundle set may be SP bundle set X (SP_X) or SP bundle set Y (SP_Y). The side is SP_X and the caller is SP_Y for the sake of convenience.

  FIG. 2 is a table showing the calling relationship for each quadrant. The inside of the table shows the caller's stack and the class provider's stack, with the lower frame showing the caller's stack and the upper frame showing the class provider's stack.

  FIG. 3 is a diagram illustrating an example of a stack referred to when a group selection algorithm described later is described. For a certain thread executed by the Java VM 10, the bottom stack is stacked as a stack of the PF set of the stack [0]. Show the state. The numbers in the frame in FIG. 3 indicate the numbers of the respective stacks, which are called in order of numbers. The characters in the frame indicate the provider of the class that created each stack. The upward arrow outside the frame in FIG. 3 indicates the flow of the call, and ad next to the arrow indicate which quadrant the call relationship corresponds to. For example, the class of the PF set of the stack [0] calls the class of the SP bundle set 1 (hereinafter referred to as “SP_BS1”) of the stack [1]. In this case, since the PF set is the caller and SP_BS1 is the class providing side, this corresponds to quadrant c. In the specific example described later, an arrow is extended from the circle mark on the right side outside the frame in FIG. 3 to indicate the memory consumption count destination.

  Hereinafter, terms will be defined before explaining the group selection algorithm. Express constants in uppercase and variable initials in lowercase. The constant here refers to a value that does not change in a single group selection algorithm process. As constants indicating the group ID, there are GROUPID_PF indicating the group ID set in the class loader object of the PF set, and STACK_GROUP ID indicating the group ID set in the class loader object of the class to be processed in each stack. is there. As variables for substituting the group ID, there are a variable groupID and a groupID that are temporarily used to determine a groupID indicating a group for finally counting the memory consumption. Also, let the top stack of each thread be TOPSTACK, and the variable indicating the stack being processed as the caller be curStack. In the group selection algorithm described below, curStack is traced down to TOPSTACK in order, and when the next of the bottom stack [0] is specified, curStack indicates Null.

  Since the memory allocation is performed on the top stack of the thread, the group selection algorithm is always executed every time memory allocation is required in TOPSTACK.

  Hereinafter, each group selection algorithm will be described. The subject of all the group selection algorithms described below is JavaVM10.

<First group selection algorithm>
A flowchart showing the operation of the first group selection algorithm is shown in FIG.

  In the first group selection algorithm, the STACK_GROUPID of TOPSTACK is set to groupID (S101).

  That is, as shown in FIG. 5, the memory consumption of each stack class is counted in a group set for each stack class.

  As described above, the memory consumption of each stack class is allocated to the group set for each stack class, so the memory is set for each set of implementation classes (PF set and SP bundle set) regardless of the caller. The consumption can be limited.

<Second group selection algorithm>
A flowchart showing the operation of the second group selection algorithm is shown in FIG. The second group selection algorithm is an algorithm for tracing down the stack one by one and searching for the first caller stack.

  TOPSTACK is assigned to curStack (S201), and curStack is shifted one by one to the lower stack until curStack points to the bottom stack (S202, S203).

  Then, STACK_GROUPID of curStack is set to groupID (S204).

  That is, the memory consumption of all stacks is assigned to the group set for the class of stack [0] that is first called.

  FIG. 7 shows the allocation state of the memory consumption of each stack when the second group selection algorithm is executed. As shown in FIG. 7, the memory consumption of all stacks of a thread is allocated to the bottom stack [0]. Here, how the memory consumption of the stack [6] is counted will be described. The stack [6] is called by the stack [5], and the stack [5] is called by the stack [4]. The stack [4] is called by the stack [3], and the stack [3] is called by the stack [2]. The stack [2] is called by the stack [1], and the stack [1] is called by the stack [0]. Since there is no caller in the stack [0], as a result, the memory consumption of the stack [6] is counted as the memory consumption of the PF set of the stack [0]. After the processing of stack [6] is performed, stack [6] disappears from the thread and stack [5] becomes TOPSTOP. Since the same processing is performed on the stacks [5] to [0], all are counted as the memory consumption of the PF set of the stack [0].

  As described above, the memory consumption amount of all stack classes is assigned to the group set for the stack class that is first called, so that the source consumption amount can be limited in units of threads.

<Third group selection algorithm>
A flowchart showing the operation of the third group selection algorithm is shown in FIG. The third group selection algorithm selects a group to which the requested memory consumption is allocated every time memory is requested with TOPSTOP.

  First, as an initial value, GROUPID_PF is substituted for groupID (S301), and TOPSTACK is substituted for curStack (S302).

  The group ID of the stack pointed to by curStack is substituted for curGroupID (S303).

  If curGroupID is GROUPID_PF (YES in S304) and groupID is not GROUPID_PF (NO in S305), that is, if the caller is the PF set and the class provider is in the quadrant c of the SP bundle set, the value of the groupID at that time That is, the processing is terminated with the group of the SP bundle set of the stack on the class providing side as the selected group.

  If curGroupID is not GROUPID_PF (NO in S304), or if curGroupID is GROUPID_PF (YES in S304) and groupID is GROUPID_PF (YES in S305), that is, if it is quadrant a, b, d, groupID The value of curGroupID is substituted into (S306), and the stack pointed to by curStack is lowered by one (S307).

  If curStack is not Null, the process returns to S303 (NO in S308), and if curStack is Null (YES in S308), processing of the groupID value as the selected group is terminated.

  The PF set serving as the base of the system cannot realize the function for the PF set by using the SP bundle set. Therefore, the memory consumption of the PF set that provides the function is allocated to the group set for the SP bundle set that uses the function. In other words, in the relationship between the PF set generated by the PF provider as the function provider and the SP bundle set generated by the SP provider as the function user, the memory consumption of the PF set is provided by the caller / class. Regardless of the side, it counts as the memory consumption of the SP bundle set that uses the function.

  For example, as an example of the quadrant b in which the SP bundle set calls the PF set, the PF set provides a bundle that implements http service, and the SP bundle set obtains and calls the http service, so that the HTTP service provided by the PF set is provided. An example of using the function can be considered.

  Further, as an example of the quadrant c in which the PF set calls the SP bundle set, there is a call to BundleActivator # start defined in the OSGi specification. The OSGiFW, that is, the PF set is called, but the reason that the SP bundle set provides the class is to use the “function for starting the SP bundle on the target terminal” provided by the PF set. In any case, the quadrant c is a callback type as described in the background art, that is, the SP bundle set on the class providing side uses the function.

  Note that when the quadrant a or quadrant d, that is, when the PF set calls the PF set, or when the SP bundle set calls the SP bundle set, the memory consumption of the called SP bundle set regardless of the provision of functions. Count as.

  The relationship between the caller / class provider stack is as shown in FIG. This figure shows in which stack the memory consumption of the upper class provider stack is counted in the relationship between the two stacks. The tip of the arrow extending from the circle indicates the stack where the memory consumption is counted. As shown in the figure, the allocation destination of the memory consumption is the stack on the upper class providing side in quadrant c, and the lower caller stack in quadrants a, b, and d.

  FIG. 10 shows the allocation status of the memory consumption of each stack when the third group selection algorithm is executed. Hereinafter, how the memory consumption of each stack is counted will be described.

  First, the memory consumption of the stack [6], which is a PF set, is counted as the memory consumption of the caller stack [5] because the caller stack [5] is SP_BS1 (quadrant b).

  The memory consumption of the stack [5], which is SP_BS1, is counted as the memory consumption of the caller stack [4] because the caller stack [4] is SP_BS2 (quadrant d).

  The memory consumption of the stack [4] is counted as the memory consumption of the stack [4] on the class providing side (quadrant c) because the stack [3] of the caller is the PF set.

  Therefore, the memory consumption in the stacks [4] to [6] is counted as the memory consumption of the stack [4], that is, SP_BS2.

  Similarly, the memory consumption of the stack [3] is counted as the memory consumption of the caller stack [2] because the caller stack [2] is the PF set (quadrant a).

  The memory consumption of the stack [2] is counted as the memory consumption of the call stack [1] because the call stack [1] is SP_BS1 (quadrant b).

  The memory consumption of the stack [1] is counted as the memory consumption of the stack [1] on the class providing side (quadrant c) because the stack [0] of the caller is a PF set.

  Therefore, the memory consumption in the stacks [1] to [3] is counted as the memory consumption of the stack [1], that is, SP_BS1.

  Finally, the memory consumption of the stack [0] is counted as the memory consumption of the stack [0], that is, the PF set because there is no caller stack.

  As described above, the memory consumption amount of the PF set that provides the function is assigned to the group set for the SP bundle set that uses the function, so that the memory consumption amount can be limited for each bundle set that uses the function.

<4th group selection algorithm>
In the third group selection algorithm, regarding the relationship between the provision and use of functions, a group is selected as a PF set that provides functions and an SP bundle set that uses functions. On the other hand, since the function provision / use relationship also exists between SP bundle sets, the fourth group selection algorithm considers the function provision / use relationship between SP bundle sets.

  A flowchart showing the operation of the fourth group selection algorithm is shown in FIG. The fourth group selection algorithm selects a group to which the requested memory consumption is allocated every time memory is requested with TOPSTOP.

  When using the fourth group selection algorithm, the Java VM 10 prepares a data structure that can set CTF (Class Type Flag: a flag indicating whether the class is “provide function” or “use function”) in the data structure of the class loader object. And a function of setting the designated CTF in the data structure of the designated class loader object. Unless otherwise specified, the CTF of the class loader object of the PF set is “use function”. In the following, CUR_CTF represents the CTF of the curStack class, and CTF assigned to the stack of the SP bundle set closest to curStack is substituted for last_CTF, except for the initial value, in the stack above curStack. In addition to groupID, the group ID set in the SP bundle set closest to curStack in the stack above curStack is substituted for groupID.

  First, as an initial value, GROUPID_PF is substituted for groupID (S401), and TOPSTACK is substituted for curStack (S402).

  “Provide function” is substituted into last_CTF (S403), and the group ID of the stack pointed to by curStack is substituted into curGroupID (S404).

  When curGroupID is GROUPID_PF (YES in S405), curGroupID is different from groupID (NO in S406), and when CUR_CTF is "use of function" (YES in S407), the groupID value at that time is selected End processing as a group. On the other hand, if curGroupID is the same as groupID (YES in S406) or if CUR_CTF is not “use of function” (NO in S407), the process proceeds to S412 and processing is continued for the next lower stack.

  If curGroupID is not GROUPID_PF (NO in S405), curGroupID is different from groupID (NO in S408), and if last_CTF is "use of function" (YES in S409), the groupID value at that time is selected To finish the process. On the other hand, if curGroupID is the same as groupID (YES in S408) or if last_CTF is not “use of function” (NO in S409), the groupID and last_CTF are updated (S410, S411), and the process proceeds to S412. Continue processing for the lower stack. If curGroupID is the same as groupID (YES in S408), it is not necessary to update the groupID in S410, and the process proceeds to S411.

  When processing is continued for the next lower stack, the stack pointed to by curStack is lowered by one (S412). If curStack is not Null, the process returns to S404 (NO in S413), and if curStack is Null (YES in S413). Then, the process ends with the groupID value at that time as the selected group.

  FIG. 12 shows the calling relationship of each quadrant and the memory consumption count destination. It differs from the third group selection algorithm in quadrant d, that is, the allocation destination of memory consumption when the SP bundle set calls the SP bundle set. In the fourth group selection algorithm, when the caller / class provider stack relationship is in quadrant d, the allocation destination of the memory consumption varies depending on the CTF value of the class provider stack. Specifically, when the CTF of the stack on the class providing side is “use of function” (left side of quadrant d), the memory consumption is allocated to the stack on the class providing side, and the CTF of the stack on the class providing side is “function”. If it is “provide” (right side of quadrant d), the memory consumption is allocated to the stack of the caller.

  FIG. 13 shows the allocation status of the memory consumption of each stack when the fourth group selection algorithm is executed. FIG. 13A shows an assignment situation when stack [5] is a function use class, and FIG. 13B shows an assignment situation when stack [5] is a function provision class.

  First, it will be described how stack [5] is counted in FIG. 13A, which is a function use class.

  The memory consumption of the stack [6], which is a PF set, is counted as the memory consumption of the caller stack [5] because the caller stack [5] is SP_BS1 (quadrant b).

  The memory consumption of the stack [5] which is SP_BS1 is counted as the memory consumption of the stack [5] on the class providing side because the caller stack [4] is SP_BS2 and is a function use class (quadrant). d).

  The stack [4] to stack [0] are the same as the example described in the third group selection algorithm.

  Next, how stack [5] is counted in FIG. 13B, which is a function providing class, will be described.

  The memory consumption of the stack [6], which is a PF set, is counted as the memory consumption of the caller stack [5] because the caller stack [5] is SP_BS1 (quadrant b).

  The memory consumption of the stack [5], which is SP_BS1, is counted as the memory consumption of the stack [4] of the caller since the caller stack [4] is SP_BS2 and is a function providing class (quadrant d ).

  The stack [4] to stack [0] are the same as the example described in the third group selection algorithm.

  As described above, when the stack status is in quadrant d, the memory consumption of the SP bundle set that provides the function is counted as the memory consumption of the SP bundle set that uses the function. In addition, even when calling between SP bundle sets, the resource consumption count destination can be changed by providing and using the function.

  In addition, in order to implement | achieve said 4th group selection algorithm, the following functions are added with respect to the resource management bundle 12a and JavaVM10.

  The resource management bundle 12a has a function of acquiring information on whether the class of the SP bundle 131 provides or uses a function from the server 3 or the like and setting a CTF for each class of the SP bundle 131 to the Java VM 10. Have. The Java VM 10 prepares a data structure that can set a CTF in a class loader object, and has a function of setting a CTF specified in the class loader object.

  Hereinafter, processing for setting a CTF for an object will be described.

  In addition to the bundle set information and the bundle set memory amount, the resource management bundle 12a acquires a CTF to be set in the class of the SP bundle 131 included in the bundle set information.

  When the SP bundle 131 is installed in the OSGiFW 11 and the resource management bundle 12a receives the Resolved event from the OSGiFW 11, the group ID associated with the SP bundle set 13 to which the installed SP bundle 131 belongs is acquired from the Java VM 10. Subsequently, the class loader object of the installed SP bundle 131 is acquired, the acquired class loader object and the group ID are notified to the Java VM 10, and further, the acquired class loader object and the corresponding CTF are notified to the Java VM 10. The Java VM 10 sets the group ID and CTF for the notified class loader object.

  As described above, according to the present embodiment, the unit for limiting the memory consumption is determined by changing the group selection algorithm by determining the group for counting the memory consumption based on the group selection algorithm. Can change. Specifically, when the first group selection algorithm is used, the memory consumption can be limited in units of mounting classes, and when the second group selection algorithm is used, the memory consumption can be limited in units of threads. Further, when the third and fourth group selection algorithms are used, the memory consumption can be limited in units of bundle sets that use functions. As a result, when multiple SP providers share a system and provide services at the same time, which group (SP provider) counts the memory consumption of various SP bundles that operate in a coordinated manner. You can decide flexibly.

  Further, since the group selection algorithm uses only information that can be traced from the stack by pointer reference, it is possible to reduce the speed reduction during memory allocation.

[Measurement of memory consumption]
Next, a memory consumption measuring method of the memory management device 1 in the present embodiment will be described. The Java VM 10 has a function of returning the total memory consumption allocated to the specified group. When the group ID is specified and the memory consumption of the group is inquired, the Java VM 10 first performs GC. Alternatively, before inquiring about the memory consumption, the inquiring program side may request System. GC may be performed using gc () or the like. Here, it does not matter whether GC is performed for each group ID or the entire heap area.

  After GC, the sizes of objects that are not GC targets with the specified group ID are summed, and the total value is returned as the memory consumption of the specified group.

  As described above, the memory consumption can be measured in units of group IDs.

[About group deletion]
Next, group deletion will be described. The Java VM 10 has a function of deleting a group corresponding to the specified group ID.

  When the deletion target group ID is specified, the Java VM 10 deletes the specified group ID when there is no longer a reference to the object to which the group ID is assigned. As a result, the group can be deleted.

〔Example〕
Hereinafter, some examples in the present embodiment will be described.

<Example in Calling from PF Set to SP Bundle Set>
Consider an example in which the SP bundle set 1 (hereinafter referred to as SP1) calls the SP bundle set 2 (hereinafter referred to as SP2) in the third and fourth group selection algorithms.

  When the PF set is called inside SP2, as shown in FIG. 14, when the SP bundle calls the PF set, the SP bundle may be called again by the processing of the PF set. The class of the PF set having such a stack structure includes, for example, AccessController. doPrivileged () and the like. For such a class, the CTF is set to “provide function” and the fourth group selection algorithm is applied.

  As described above, the call from the stack [3] to the stack [4] is counted as the SP2 memory consumption of the stack [3] in the fourth group selection algorithm. In this example, when SP1 uses the function of SP2, the stack [2] to stack [4] are called in order for SP1 to use the function of SP2. That is, the memory allocated to the stacks [2] to [4] is desirably counted as the memory consumption of the SP1 that uses the function, and this can be realized.

<Example in which a PF set is divided in detail>
A class loaded from the bootstrap class loader is regarded as a Java VM 10 class, and a class loaded from the system class loader is regarded as an OSGiFW 11 class. A different group ID is set for each class loader object structure, and the first group selection algorithm is used.

  As described above, the memory consumption can be limited for each class loaded from the same class loader. In particular, in the first group selection algorithm, the number of PF sets 14 is one, but the PF set 14 can be divided into Java VM 10 and OSGiFW 11.

<Example in which a thread and a group ID are linked>
When linking a thread and a group ID, a data structure capable of setting a group ID for the thread is added to the Java VM 10 and the fifth group selection algorithm shown in FIG. 15 is used.

  The fifth group selection algorithm selects the group ID set for the thread (S501). When a thread is set up, the group ID set in the class loader object of the class that sets up the thread is set in the structure of the set up thread.

  As described above, basically, the same effect as that obtained when the second group selection algorithm is used can be obtained. However, since the operation of tracing down the stack is unnecessary, it is faster than the case where the second group selection algorithm is used. The group ID can be determined.

<Example of GC multiple system>
The GC is considered to be performed for each group ID and for the entire heap area.

  Compared with the method performed for the entire heap area, the method performed for each group can operate without being influenced by other group IDs even when GC frequently occurs in a certain group ID.

  On the other hand, the method performed for the entire heap area has the following advantages compared to the method performed for each group ID. In a situation where GC frequently occurs with different group IDs, an operation of searching for a referenced object from the root frequently occurs, resulting in an overhead. However, when GC is performed on the entire heap area, all the objects are searched at once, so that there is an advantage that such overhead is eliminated.

<Example of multiple limit values>
Until now, only one limit value for memory usage has been set for a group, but in this embodiment, two limit values for memory usage are set for a group. One of the limit values is SoftLimit, and the other is HardLimit. Here, SoftLimit <HardLimit. Further, the Java VM 10 holds, for each group ID, a cache memory consumption integrated value that is a total of memory consumptions allocated to objects that are not GC targets at the end of GC.

  When the cache memory consumption integrated value of the selected group exceeds the SoftLimit when the memory is allocated, it is determined that the memory allocation has failed and an OOM error is generated without executing the GC.

  If the cache memory consumption integrated value of the selected group does not exceed SoftLimit, the same processing as in the case where the limit value is one is performed with HardLimit as the memory consumption limit value. Specifically, when the value obtained by adding the size of the generated object to the accumulated memory consumption value of the selected group is equal to or less than HardLimit, the memory allocation is successful, and the accumulated memory consumption of the selected group is determined. If the value obtained by adding the size of the generated object to the value is larger than HardLimit, GC is executed, and the memory size is increased by adding the size of the generated object to the new memory consumption integrated value of the selected group. Judge whether to allocate. If the value obtained by adding the object size to the memory consumption integrated value exceeds HardLimit even after GC is executed, an OOM error is generated.

  If the SP bundle of a specific group consumes resources up to the memory consumption limit value in a short time and is released by the GC, if the memory consumption limit value is one GC frequently occurs, and as a result, the processing speed of the entire JavaVM may be reduced. By using this example, if SoftLimit <the cache memory consumption integrated amount of the corresponding group ID, an OOM error occurs before GC, so it is possible to suppress frequent occurrence of GC. Reduction in processing speed can be suppressed.

<Example in which limit value is set in PF set>
The resource consumption of the PF set 14 starts from the activation of the Java VM 10. Therefore, after the Java VM 10 is started, after the resource management bundle 12a is started and the memory consumption limit value of the PF set 14 is set, there is a possibility that the limit value to be restricted for the PF set 14 is exceeded. .

  Therefore, a limit value for the PF set 14 is set as a startup option when the Java VM 10 is started.

  As described above, it is possible to reliably set the limit value for the PF set 14 and prevent the limit value of the PF set 14 from being exceeded.

DESCRIPTION OF SYMBOLS 1 ... Memory management apparatus 10 ... JavaVM (Java virtual machine)
11 ... OSGiFW
12 ... Owner bundle 12a ... Resource management bundle 13 ... SP bundle set 131 ... SP bundle 14 ... PF set

Claims (12)

A memory management device for managing memory used by a bundle operating on a software platform,
A setting unit for creating a group in a memory management unit, setting a limit value of a memory amount that can be used for each group, and setting the group in a class loader object of the bundle when installing the bundle ;
When the class loader object of the bundle or the software platform requests a memory, and a selection means for selecting the bundle or group set to the class loader object of the software platform which requested the memory as the count which the request amount of memory ,
A predicted integrated value obtained by adding the required memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected by the selection unit and a limit value set for the group, and When the integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the required memory amount is added to the memory consumption integrated value of the group to update the memory consumption integrated value. Assigning means for generating an error when the predicted integrated value exceeds the limit value;
A memory management device comprising: A memory management device for managing memory used by a bundle operating on a software platform,
A setting unit for creating a group in a memory management unit, setting a limit value of a memory amount that can be used for each group, and setting the group in a class loader object of the bundle when installing the bundle ;
When the class loader object of the bundle or the software platform requests a memory, the caller of the bundle or the software platform that requested the memory is traced, and the bundle that is the first caller or the group to which the software platform belongs is requested. A selection means for selecting as a memory amount counting destination;
A predicted integrated value obtained by adding the required memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected by the selection unit and a limit value set for the group, and When the integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the required memory amount is added to the memory consumption integrated value of the group to update the memory consumption integrated value. Assigning means for generating an error when the predicted integrated value exceeds the limit value;
A memory management device comprising: A memory management device for managing memory used by a bundle operating on a software platform,
A setting unit for creating a group in a memory management unit, setting a limit value of a memory amount that can be used for each group, and setting the group in a class loader object of the bundle when installing the bundle ;
When the class loader object of the bundle or the software platform requests the memory, the call source of the bundle or the software platform that requested the memory is traced, and the group to which the bundle called by the software platform belongs is determined as the required memory amount. A selection means for selecting as a count destination;
A predicted integrated value obtained by adding the required memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected by the selection unit and a limit value set for the group, and When the integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the required memory amount is added to the memory consumption integrated value of the group to update the memory consumption integrated value. Assigning means for generating an error when the predicted integrated value exceeds the limit value;
A memory management device comprising: A memory management device for managing memory used by a bundle operating on a software platform,
A setting unit for creating a group in a memory management unit, setting a limit value of a memory amount that can be used for each group, and setting the group in a class loader object of the bundle when installing the bundle ;
Function setting means for setting a function provision flag or a function use flag in the bundle;
When the class loader object of the bundle or the software platform requests a memory, the caller of the bundle or the software platform that requested the memory is traced, and the group to which the bundle called by the software platform belongs, or function use A selection means for selecting a group to which the bundle with the flag set belongs as a count destination of the requested memory amount;
A predicted integrated value obtained by adding the required memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected by the selection unit and a limit value set for the group, and When the integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the required memory amount is added to the memory consumption integrated value of the group to update the memory consumption integrated value. Assigning means for generating an error when the predicted integrated value exceeds the limit value;
A memory management device comprising: A memory management device for managing memory used by a bundle operating on a software platform,
A setting unit for creating a group in a memory management unit, setting a limit value of a memory amount that can be used for each group, and setting the group in a class loader object of the bundle when installing the bundle;
Thread setting means for setting, as a group of the thread, a group set in the bundle or the software platform class loader object when the thread is set up by the bundle or the software platform;
When the class loader object of the bundle or the software platform requests a memory, a selection unit that selects a group set in a thread to which the bundle or the software platform that requested the memory belongs as a count destination of the requested memory amount;
A predicted integrated value obtained by adding the required memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected by the selection unit and a limit value set for the group, and When the integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the required memory amount is added to the memory consumption integrated value of the group to update the memory consumption integrated value. Assigning means for generating an error when the predicted integrated value exceeds the limit value;
A memory management device comprising: A memory management method for managing memory used by a bundle operating on a software platform,
By computer,
Creating a group in the memory management unit and setting a limit value for the amount of memory available for each group;
When installing the bundle, setting the group on the class loader object of the bundle;
When the bundle or the software platform class loader object requests memory, the group set in the bundle or the software platform class loader object that requested the memory is selected as a count destination of the requested memory amount; and
Comparing a predicted integrated value obtained by adding the requested memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected in the selecting step and a limit value set for the group; ,
When the predicted integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the memory consumption integrated value is calculated by adding the required memory amount to the memory consumption integrated value of the group. A step to update,
If the expected integrated value exceeds the limit value, generating an error;
A memory management method. A memory management method for managing memory used by a bundle operating on a software platform,
By computer,
Creating a group in the memory management unit and setting a limit value for the amount of memory available for each group;
When installing the bundle, setting the group on the class loader object of the bundle;
When the class loader object of the bundle or the software platform requests a memory, the caller of the bundle or the software platform that requested the memory is traced, and the bundle that is the first caller or the group to which the software platform belongs is requested. A step of selecting the memory amount as a count destination;
Comparing a predicted integrated value obtained by adding the requested memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected in the selecting step and a limit value set for the group; ,
When the predicted integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the memory consumption integrated value is calculated by adding the required memory amount to the memory consumption integrated value of the group. A step to update,
If the expected integrated value exceeds the limit value, generating an error;
A memory management method. A memory management method for managing memory used by a bundle operating on a software platform,
By computer,
Creating a group in the memory management unit and setting a limit value for the amount of memory available for each group;
When installing the bundle, setting the group on the class loader object of the bundle;
When the class loader object of the bundle or the software platform requests the memory, the call source of the bundle or the software platform that requested the memory is traced, and the group to which the bundle called by the software platform belongs is determined as the required memory amount. A step to select as a count destination;
Comparing a predicted integrated value obtained by adding the requested memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected in the selecting step and a limit value set for the group; ,
When the predicted integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the memory consumption integrated value is calculated by adding the required memory amount to the memory consumption integrated value of the group. A step to update,
If the expected integrated value exceeds the limit value, generating an error;
A memory management method. A memory management method for managing memory used by a bundle operating on a software platform,
By computer,
Creating a group in the memory management unit and setting a limit value for the amount of memory available for each group;
When installing the bundle, setting the group on the class loader object of the bundle;
Setting a function provision flag or a function use flag in the bundle;
When the class loader object of the bundle or the software platform requests a memory, the caller of the bundle or the software platform that requested the memory is traced, and the group to which the bundle called by the software platform belongs, or function use Selecting the group to which the bundle with the flag set belongs as a counting destination of the requested memory amount;
Comparing a predicted integrated value obtained by adding the requested memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected in the selecting step and a limit value set for the group; ,
When the predicted integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the memory consumption integrated value is calculated by adding the required memory amount to the memory consumption integrated value of the group. A step to update,
If the expected integrated value exceeds the limit value, generating an error;
A memory management method. A memory management method for managing memory used by a bundle operating on a software platform,
By computer,
Creating a group in the memory management unit and setting a limit value for the amount of memory available for each group;
When installing the bundle, setting the group on the class loader object of the bundle;
When the bundle or the software platform sets up a thread, setting the group to which the bundle or the software platform that sets up the thread belongs to the thread;
When a class loader object of the bundle or the software platform requests memory, a group set in a thread to which the bundle or the software platform that requested the memory belongs is selected as a count destination of the requested memory amount;
Comparing a predicted integrated value obtained by adding the requested memory amount to a memory consumption integrated value that is a total value of memory already allocated to the group selected in the selecting step and a limit value set for the group; ,
When the predicted integrated value is less than or equal to the limit value, the memory of the required memory amount is allocated from the heap area, and the memory consumption integrated value is calculated by adding the required memory amount to the memory consumption integrated value of the group. A step to update,
If the expected integrated value exceeds the limit value, generating an error;
A memory management method. Assigning a group ID for identifying a group selected as a counting destination of consumption of the memory to an object generated when memory is requested;
Totaling the sizes of the objects to which the specified group ID is assigned, and determining the memory consumption of the group indicated by the group ID;
The memory management method according to claim 6, further comprising : 12. A memory management program for causing a computer to execute each step according to claim 6 .

Images