JP2012113380A - Service provision device, service provision method, and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To monitor memory usage of each tenant with high accuracy in a multi-tenant system.SOLUTION: A processing unit 112 executes a sub-process 151 and a main process 152 which process requests, each of which includes one of multiple properties, by securing memory needed for processing of the request. A sampling unit 111 associates one property among one or more properties which are monitoring candidates among the multiple properties with the sub-process 151. If an inputted request includes the associated property, the sampling unit 111 sends the request to the sub-process 151, and if it includes a property other than that, it sends the request to the main process 152. A sub-process monitor unit 113 acquires and outputs memory usage associated with the processing of the request in the sub-process 151, for each property of the request.

Description

  The present invention relates to a service providing apparatus, a service providing method, and a program, and in particular, a service providing apparatus, a service providing method, and a program for monitoring a memory usage amount for a request.

  When the resources constituting the system are shared among a plurality of user organizations (hereinafter referred to as tenants), such a system is generally called a multi-tenant system. There are various realization methods in the multi-tenant system. Here, a plurality of tenants share a process on a computer, and a plurality of threads operating on the process provide services to a plurality of tenants.

  FIG. 23 is a diagram illustrating an example of a correspondence relationship between a thread operating on a multi-tenant system and a tenant. In a multi-tenant type system, each thread operating on a process processes a request from an individual user belonging to each tenant. In the example of FIG. 23, requests by users 1, 2, 3,..., M are processed by threads 1, 2, 3,. Here, user 1 belongs to tenant 1, user 2 and user 3 belong to tenant 2, and user M belongs to tenant N, respectively. That is, thread 1 processes requests from tenant 1, threads 2 and 3 process requests from tenant 2, and thread M processes requests from tenant N. Such a correspondence relationship between the user and the thread is canceled every time one process is completed, and a certain thread processes a request from a user belonging to a different tenant at another timing.

  As described above, in the multi-tenant type system, the operation cost per tenant of the system can be reduced by sharing resources among a plurality of tenants. On the other hand, it is desirable for a tenant who is a user to be able to use a multi-tenant system under the same conditions as a general system in which resources are not shared with other tenants as much as possible. As such a condition, for example, the provision of a service to a certain tenant and the service quality are prevented from being influenced by the usage amount of the shared resource by another tenant, that is, performance isolation. In order to achieve performance isolation, for example, for a tenant that uses a large amount of shared resources, a dedicated resource pool is allocated, or resource usage restrictions are set, so that resource usage for each tenant can be reduced. Responses are made accordingly. In order to perform such performance isolation, it is necessary to grasp the resource usage of each tenant.

  Non-Patent Document 1 describes a framework for performance isolation including resource monitoring functions and corresponding functions based on resource monitoring results in a multi-tenant system. However, Non-Patent Document 1 does not disclose a specific method for realizing resource monitoring.

  Here, the problem of resource monitoring in the multi-tenant system when the monitoring target resource is the memory usage will be described.

  FIG. 24 is a diagram illustrating an example of a change in memory usage in the process of the multi-tenant system. In a multi-tenant system, multiple threads are processed concurrently in the same process (hereinafter referred to as a multi-thread process), and each of the multiple threads shares the memory space of the process with each other. To do. A certain memory area may be used by a plurality of threads at the same time. For this reason, the memory usage cannot be monitored for each thread, and the memory usage for each tenant cannot be monitored.

  A method for monitoring the memory usage of such a multi-thread process for each thread is disclosed in Patent Document 1, for example. The system described in Patent Document 1 monitors the memory usage of the entire process and the threads that have been executed, and apportions the memory usage of the entire process to each thread that has been executed at a predetermined ratio. Calculate the approximate memory usage for each thread.

JP 2009-110213 A

Xu Cheng, Yuliang Shi, Qingzhong Li, "A Multi-tenant Oriented Performance Monitoring, Detecting and Scheduling Architecture Based on SLA", 2009 Joint Conferences on Pervasive Computing (JCPC), pp.599-604, 2009.

  However, in the method described in Patent Document 1, an approximate value of the memory usage for each thread is calculated by apportioning the memory usage of the entire process to each thread, so that the memory usage monitoring accuracy is low. was there. In particular, when applied to a system with a large number of threads executed simultaneously, the approximate value of the memory usage of each thread is greatly affected by the memory usage of other threads, and the monitoring accuracy is greatly reduced.

  An object of the present invention is to solve the above-described problems and provide a service providing apparatus, a service providing method, and a program capable of accurately monitoring the memory usage for each tenant in a multi-tenant system.

  The service providing apparatus according to the present invention includes a processing unit that executes a sub-process and a main process that processes a request including any of a plurality of attributes while securing a memory necessary for processing the request, If any one of one or more attributes that are candidates for monitoring is associated with the subprocess, and the input request includes the associated attribute, the request is assigned to the subprocess. And when there are other attributes, sampling means for sending the request to the main process, and sub-process monitoring means for obtaining and outputting the amount of memory secured by the sub-process for each request attribute Including.

  The service providing method according to the present invention executes a sub-process and a main process that process a request including any of a plurality of attributes while securing a memory necessary for processing the request, and the plurality of attributes. Any one of one or more attributes that are candidates for monitoring is associated with the sub-process, and if the input request includes the associated attribute, the request is transmitted to the sub-process, When other attributes are included, the request is transmitted to the main process, and the amount of memory secured by the sub-process is acquired and output for each request attribute.

  The program of the present invention executes a sub-process and a main process, which processes a request including each of a plurality of attributes in a computer while securing a memory necessary for processing the request, If any one of one or more attributes that are candidates for monitoring is associated with the subprocess, and the input request includes the associated attribute, the request is transmitted to the subprocess. When other attributes are included, the request is transmitted to the main process, and a process for acquiring and outputting the amount of memory secured by the sub-process for each request attribute is executed.

  The effect of the present invention is that the memory usage for each tenant can be accurately monitored in a multi-tenant system.

It is a block diagram which shows the characteristic structure of 1st embodiment of this invention. It is a block diagram which shows the structure of the multi-tenant system in 1st embodiment of this invention. It is a flowchart which shows the operation | movement of the request process of the service provision apparatus 100 in 1st embodiment of this invention. It is a flowchart which shows the operation | movement of the response process of the service provision apparatus 100 in 1st embodiment of this invention. It is a flowchart which shows the operation | movement of the sub process monitoring process of the service provision apparatus 100 in 1st embodiment of this invention. It is a figure which shows the example of the memory monitoring log 131 in 1st embodiment of this invention. It is a figure which shows the example of the memory monitoring result information 132 in 1st embodiment of this invention. It is a figure which shows the example of the monitoring frequency information 133 in 1st embodiment of this invention. It is a figure which shows the other example of the monitoring frequency information 133 in 1st embodiment of this invention. It is a figure which shows the example of the monitoring object information 134 in 1st embodiment of this invention. It is a figure which shows the example of a change of the memory usage-amount of the service provision apparatus 100 in 1st embodiment of this invention. It is a block diagram which shows the structure of the multi-tenant system in 2nd embodiment of this invention. It is a flowchart which shows the operation | movement of the process specific information access process of the service provision apparatus 100 in 2nd embodiment of this invention. It is a block diagram which shows the structure of the multi-tenant system in 3rd embodiment of this invention. It is a figure which shows the example of the rough memory monitoring result information 135 in 3rd embodiment of this invention. It is a block diagram which shows the structure of the multi-tenant system in the 4th embodiment of this invention. It is a flowchart which shows the operation | movement of the request process of the service provision apparatus 100 in the 4th embodiment of this invention. It is a flowchart which shows the operation | movement of the sampling queue process of the service provision apparatus 100 in 4th embodiment of this invention. It is a block diagram which shows the structure of the multi-tenant system in the 5th embodiment of this invention. It is a flowchart which shows the operation | movement of the request process of the service provision apparatus 100 in 5th embodiment of this invention. It is a flowchart which shows the operation | movement of the response process of the service provision apparatus 100 in the 5th embodiment of this invention. It is a figure which shows the example of the monitoring object information 140 in the 5th Embodiment of this invention. It is a figure which shows the example of the correspondence of the thread | sled which operate | moves on a multitenant type | system | group, and a tenant. It is a figure which shows the example of the change of the memory usage in the process of a multi-tenant type system.

(First embodiment)
Next, a first embodiment of the present invention will be described in detail with reference to the drawings. First, the configuration of the first embodiment of the present invention will be described.

  FIG. 2 is a block diagram showing a configuration of the multi-tenant system in the first embodiment of the present invention.

  Referring to FIG. 2, the multi-tenant system includes a service providing apparatus 100 and a plurality of user terminals 200. The service providing apparatus 100 and the user terminal 200 are communicably connected via a network or the like.

  The service providing apparatus 100 includes a sampling unit 111, a processing unit 112, a sub-process monitoring unit 113, a memory monitoring log storage unit 121, a memory monitoring result storage unit 122, a monitoring number storage unit 123, and a monitoring target storage unit 124.

  Here, the sampling unit 111 receives a request from each of the plurality of user terminals 200, determines whether the attribute of the request is a monitoring candidate (or should be monitored), and if it is a monitoring candidate, the attribute The request is transmitted to the sub-process 151 on the processing unit 112, and if the request is not a monitoring candidate, the request is transmitted to the main process 152 on the processing unit 112.

  In the embodiment of the present invention, each request includes a tenant ID for identifying a tenant as an attribute of the request, and the sampling unit 111 determines whether each tenant is a monitoring candidate based on the tenant ID. Shall be determined.

  Each request includes a user ID for identifying the user instead of the tenant ID, and the sampling unit 111 acquires the tenant ID of the tenant to which each user ID belongs by a correspondence table (not shown). It may be a request attribute.

  The processing unit 112 is a CPU (Central Processing Unit), and executes processing of the sub-process 151 and the main process 152.

  In the embodiment of the present invention, the processing of the sub-process 151, the processing of the main process 152, or the processing of each thread is actually executed by the processing unit 112. In the following description, however, The process is described as being executed or executed by each thread.

  The main process 152 processes a request other than the monitoring target received from the sampling unit 111. On the main process 152, as shown in FIG. 23, a plurality of threads operate, and each thread processes a plurality of requests simultaneously in parallel.

  The sub-process 151 processes the monitoring target request received from the sampling unit 111. Similarly to the main process 152, a plurality of threads operate on the sub-process 151, and each thread processes a plurality of requests simultaneously in parallel.

  Note that each of the main process 152 and the sub-process 151 is assigned a unique memory space necessary for the operation, and each thread secures a memory necessary for processing the request and processes the request. Also, it is assumed that the threads on the main process 152 share a memory space allocated to the processes, and a certain memory area on the memory space may be used simultaneously by a plurality of threads. Similarly, it is assumed that the threads on the sub-process 151 share the memory space allocated to the processes, and a certain memory area on the memory space may be used simultaneously by a plurality of threads.

  The sub-process monitoring unit 113 acquires the memory usage amount of the sub-process 151 (the memory amount secured by the sub-process 151) and records it in the memory monitoring log 131 of the memory monitoring log storage unit 121 together with the monitoring target tenant ID. .

  The memory monitoring log storage unit 121 stores a memory monitoring log 131. FIG. 6 is a diagram illustrating an example of the memory monitoring log 131 according to the first embodiment of this invention. As illustrated in FIG. 6, the memory monitoring log 131 records a record 141 including the number of received requests for each tenant ID, the start memory usage, and the end memory usage in the sub-process 151.

  The memory monitoring result storage unit 122 stores memory monitoring result information 132. FIG. 7 is a diagram illustrating an example of the memory monitoring result information 132 according to the first embodiment of this invention. As shown in FIG. 7, the memory monitoring result information 132 includes the memory usage for the tenant ID.

  The monitoring frequency storage unit 123 stores monitoring frequency information 133. FIG. 8 is a diagram illustrating an example of the monitoring frequency information 133 according to the first embodiment of this invention. The monitoring frequency information 133 includes the monitoring frequency for each tenant ID. Here, the number of times of monitoring indicates the number of times the memory usage for the tenant ID is monitored by the sub-process monitoring unit 113 (the number of records 141 generated for the tenant ID in the memory monitoring log 131). .

  The monitoring target storage unit 124 stores monitoring target information 134. FIG. 10 is a diagram illustrating an example of the monitoring target information 134 according to the first embodiment of this invention. The monitoring target information 134 includes the tenant ID of the monitoring target being processed by the subprocess 151 (associated with the subprocess 151).

  In the embodiment of the present invention, the thread is a Java (registered trademark) thread, and a Java VM (Virtual Machine) operates in each of the sub-process 151 and the main process 152, and a plurality of threads are executed on each Java VM. Shall work. Further, as shown in FIG. 24, the memory usage by a thread increases cumulatively with the processing of a request, and is released by garbage collection provided by Java at a predetermined timing.

  Service providing apparatus 100 may be a computer that includes a storage medium storing a program and that operates by control based on the program. In this case, the sampling unit 111 and the sub-process monitoring unit 113 may also operate on the processing unit 112 by control based on a program. In addition, the memory monitoring log storage unit 121, the monitoring frequency storage unit 123, and the monitoring target storage unit 124 may be configured as individual storage media or a single storage medium.

  Next, the operation of the service providing apparatus 100 according to the first embodiment of the present invention will be described.

  First, request processing of the service providing apparatus 100 according to the first embodiment of the present invention will be described. FIG. 3 is a flowchart showing the request processing operation of the service providing apparatus 100 according to the first embodiment of the present invention.

  The sampling unit 111 receives a request from the user terminal 200 (step S101).

  The sampling unit 111 determines whether the tenant ID of the request is a monitoring candidate (step S102). Here, the sampling unit 111 refers to the monitoring number information 133 in the monitoring number storage unit 123 and determines a tenant ID whose monitoring number is equal to or less than a predetermined value as a monitoring candidate.

  The tenant ID may be included in the URL transmitted with the request. In this case, for example, the URL is “http://sample.com/tenant_xxx/”, and “tenant_xxx” included in the URL is the tenant ID.

  If it is determined in step S102 that the tenant ID of the request is a monitoring candidate (step S102 / Yes), the sampling unit 111 determines whether the request can be monitored (step S103).

  Here, the sampling unit 111 sets a condition for determining whether or not the request can be monitored (hereinafter referred to as a monitorable condition) as “the tenant ID is not set in the monitoring target information 134 of the monitorable monitoring target storage unit 124. (There is no other request being processed in the sub-process 151) ”or“ The tenant ID set in the monitoring target information 134 is the same as the tenant ID of the request (the tenant of the request being processed in the sub-process 151) The ID is the same as the tenant ID of the received request), and if the monitorable condition is satisfied, the request is determined to be monitorable.

  If a plurality of requests are not generated for the same tenant ID at the same time, the monitoring condition may be that “the tenant ID is not set in the monitoring target information 134 of the monitoring target monitoring target storage unit 124”. .

  When it is determined in step S103 that the request can be monitored (step S103 / Yes), if the tenant ID is not set in the monitoring target information 134, the sampling unit 111 sets the tenant ID of the request in the monitoring target information 134. Is set (the tenant ID is associated with the sub-process 151) (step S104).

  Then, the sampling unit 111 notifies the tenant ID of the request to the sub-process monitoring unit 113 (Step S105), and transmits the request to the sub-process 151 (Step S106).

  For example, it is assumed that the monitoring frequency information 133 as illustrated in FIG. 8 is stored in the monitoring frequency storage unit 123 and the tenant ID of the request is “tenant_B”. Here, when determining the tenant ID having the smallest number of monitoring times as the monitoring candidate, the sampling unit 111 sets the tenant ID “tenant_B” as the monitoring candidate because the number of monitoring times “5 times” of the tenant ID “tenant_B” is the smallest. Judgment.

  Here, if the tenant ID is not set in the monitoring target information 134, the sampling unit 111 determines that the tenant ID “tenant_B” can be monitored, and the tenant ID “tenant_B” in the monitoring target information 134 as illustrated in FIG. Set. Then, the sampling unit 111 notifies the sub-process monitoring unit 113 of the tenant ID “tenant_B” and transmits a request to the sub-process 151.

  Further, even when the tenant ID “tenant_B” is set as the tenant ID in the monitoring target information 134, the sampling unit 111 determines that the tenant ID “tenant_B” can be monitored and sets the tenant ID “tenant_B” to the sub-process monitoring unit. 113 is notified, and the request is transmitted to the sub-process 151.

  The sub process 151 processes the request received from the sampling unit 111.

  On the other hand, if it is determined in step S102 that the tenant ID of the request is not a monitoring candidate (step S102 / No), or if it is determined in step S103 that the request cannot be monitored (step S103 / No), The sampling unit 111 transmits the request to the main process 152 (Step S107).

  For example, when the monitoring count information 133 as illustrated in FIG. 8 is stored in the monitoring count storage unit 123 and the tenant ID of the request is “tenant_A”, the sampling unit 111 monitors the monitoring count “tenant_A”. Since “10 times” is not the minimum, it is determined that the tenant ID “tenant_A” is not a monitoring candidate, and the request is transmitted to the main process 152.

  In addition, as illustrated in FIG. 10, when the tenant ID “tenant_B” is set in the monitoring target information 134 and the tenant ID “tenant_C” of the request is determined as a monitoring candidate, the sampling unit 111 determines that the tenant ID “tenant_C”. Determines that monitoring is impossible, and sends a request to the main process 152.

  Next, response processing of the service providing apparatus 100 in the first embodiment of the present invention will be described. FIG. 4 is a flowchart showing the response processing operation of the service providing apparatus 100 according to the first embodiment of the present invention.

  The sampling unit 111 receives a response that is a processing result of the request from the sub-process 151 or the main process 152 (step S121).

  When a response is received from the sub-process 151 (step S122 / Yes), the sampling unit 111 determines whether a response has been received for all requests transmitted to the sub-process 151 (step S123).

  In step S123, when responses are received for all requests (step S123 / Yes), the sampling unit 111 deletes the tenant ID from the monitoring target information 134 of the monitoring target storage unit 124 (step S124).

  For example, as illustrated in FIG. 10, when the tenant ID “tenant_B” is set in the monitoring target information 134 and responses are received for all requests transmitted to the sub-process 151, the tenant ID “ Tenant_B "is deleted.

  The sampling unit 111 transmits a response to the user terminal 200 that is the transmission source of the request (step S125).

  In step S122, when a response is received from the main process 152 (step S122 / No), or in step S123, there is a response that has not been received in response to the request transmitted to the subprocess 151 (step S123 / No), the sampling unit 111 transmits a response to the user terminal 200 that is the transmission source of the request (step S125).

  As described above, the sampling unit 111 deletes the tenant ID set in the monitoring target information 134 after receiving all responses to a plurality of requests generated simultaneously for the tenant ID. Thereby, the sub-process 151 is controlled so that only the same tenant ID is processed at the same time.

  Next, the sub-process monitoring process of the service providing apparatus 100 according to the first embodiment of the present invention will be described. FIG. 5 is a flowchart showing the operation of the sub-process monitoring process of the service providing apparatus 100 according to the first embodiment of the present invention.

  The sub-process monitoring unit 113 receives the tenant ID of the request transmitted to the sub-process 151 from the sampling unit 111 (Step S201).

  The sub-process monitoring unit 113 acquires the memory usage of the sub-process 151 (Step S202).

  For example, the sub-process monitoring unit 113 acquires the memory usage of the entire sub-process 151 by using a process memory usage measurement function provided by JavaVM.

  The sub-process monitoring unit 113 determines whether or not the tenant ID received in step S201 is the same as the tenant ID of the latest record 141 stored in the memory monitoring log 131 (step S203).

  In step S203, when the received tenant ID is different from the tenant ID of the latest record 141 (step S203 / No), the sub-process monitoring unit 113 stores the end-time memory of the latest record 141 stored in the memory monitoring log 131. The usage amount is updated with the memory usage amount acquired in step S202 (step S204).

  The sub-process monitoring unit 113 adds 1 to the number of monitoring times for the tenant ID of the latest record 141 in the monitoring number information 133 of the monitoring number storage unit 123 (step S205).

  Then, the sub-process monitoring unit 113 adds a new record 141 to the memory monitoring log 131 (Step S206). Here, the sub-process monitoring unit 113 sets the tenant ID received in step S201 to the tenant ID of the added new record 141, 1 for the number of received requests, and the start-time memory usage and the end-time memory usage. The memory usage acquired in step S202 is set for both.

  For example, when the records 141a, b, and c in FIG. 6 are recorded in the memory monitoring log 131 and the received tenant ID is “tenant_B”, the sub-process monitoring unit 113 uses the memory at the end of the record 141c. The amount is updated with “250 MB”. Then, the sub-process monitoring unit 113 adds 1 to the number of monitoring times for the tenant ID “tenant_B” in the monitoring number information 133. Further, the sub-process monitoring unit 113 adds a record 141d whose tenant ID is “tenant_B”, and sets “250 MB” as the start-time memory usage and the end-time memory usage.

  On the other hand, when the received tenant ID is the same as the tenant ID of the latest record 141 in step 203 (step S203 / Yes), the sub-process monitoring unit 113 accepts the latest record 141 stored in the memory monitoring log 131. 1 is added to the number of requests (step S207).

  For example, when the records 141a, b, c, and d in FIG. 6 are recorded in the memory monitoring log 131 and the received tenant ID is “tenant_B”, the sub-process monitoring unit 113 requests the reception of the record 141d. Add 1 to the number.

  When step S206 or step S207 ends, the sub-process monitoring unit 113 repeats the processing of step S201 to step S207.

  As a result, a new record 141 is added to the memory monitoring log 131 every time the tenant ID processed by the sub-process 151 is switched, and the number of received requests and the memory usage at the start in the period until the next tenant ID is switched. The amount and the memory usage at the end are recorded.

  Then, the sub-process monitoring unit 113 aggregates the memory usage recorded in the memory monitoring log 131 for each tenant ID when requested by the administrator or at a predetermined timing set by the administrator. The monitoring result information 132 is stored in the memory monitoring result storage unit 122.

  For example, the sub-process monitoring unit 113 calculates the difference between the end-time memory usage and the start-time memory usage for each record 141 of the memory monitoring log 131 in FIG. The total memory usage of the tenant ID corresponding to the record 141 is calculated, and the average value of the memory usage is calculated by dividing it by the number of received requests. Then, the sub-process monitoring unit 113 aggregates the average value of the memory usage of each record 141 for each tenant ID, and stores the memory monitoring result information 132 as illustrated in FIG. 7 in the memory monitoring result storage unit 122.

  The sub-process monitoring unit 113 records the monitoring start time and end time together in each record 141 of the memory monitoring log 131, calculates the memory usage in a predetermined time zone, and uses the memory usage with respect to time. You may calculate transition of.

  Further, in order to prevent the occurrence of garbage collection while the sub-process 151 is processing a request, the sampling unit 111, for example, while the tenant ID is set in the monitoring target information 134, Thus, it may be controlled not to perform garbage collection. In this case, when the memory shortage occurs in the sub-process 151, the sampling unit 111 stops sending the monitoring target tenant ID request to the sub-process 151, and after receiving all replies from the sub-process 151. , JavaVM is forcibly controlled to perform garbage collection.

  Here, the memory usage monitored in the service providing apparatus 100 according to the first embodiment of the present invention will be described. FIG. 11 is a diagram illustrating an example of a change in memory usage of the service providing apparatus 100 according to the first embodiment of this invention.

  In the first embodiment of the present invention, a request including a monitoring candidate tenant ID is processed by a thread on the sub-process 151, and a request not including a monitoring candidate tenant ID is processed by a thread on the main process 152. Is done. Therefore, by monitoring the memory usage of the sub-process 151, the sub-process monitoring unit 113 can accurately acquire the memory usage of the monitoring candidate tenant from the memory usage of other tenants.

  For example, as illustrated in FIG. 11, the request of the tenant ID “tenant_B” is processed by the thread 2 on the sub-process 151, and the request of the tenant ID “tenant_A” and “tenant_C” is processed by the thread 1 on the main process 152. Is done. The sub-process monitoring unit 113 can accurately monitor the memory usage of the tenant ID “tenant_B” by monitoring the memory usage of the sub-process 151.

  Thus, the operation of the first embodiment of the present invention is completed.

  In the first embodiment of the present invention, the sub-process monitoring unit 113 detects the switching of the tenant ID processed by the sub-process 151 and adds the number of monitoring times of the monitoring number information 133. The sampling unit 111 may perform this.

  In the first embodiment of the present invention, the sampling unit 111 uses tenant IDs whose number of monitoring is a predetermined value or less as monitoring candidates based on the number of monitoring for each tenant. It may be given by a method.

  For example, the sampling unit 111 may calculate the number of times of monitoring for the total number of requests received for each tenant ID, and may select a tenant ID whose value is a predetermined value or less as a monitoring candidate.

  FIG. 9 is a diagram showing another example of the monitoring number information 133 according to the first embodiment of this invention. In the example of FIG. 9, the monitoring count information 133 includes the monitoring count for each tenant ID and the total number of requests. In the case of the monitoring count information 133 as shown in FIG. 9, the monitoring count is the minimum for the tenant ID “tenant_B”, but the monitoring count for the total number of requests is the minimum, ie, the tenant ID “tenant_A” is 0.1. Therefore, when the tenant ID having the smallest number of monitoring times with respect to the total number of requests is set as the monitoring candidate, the sampling unit 111 sets the tenant ID “tenant_A” as the monitoring candidate.

  In addition, a tenant ID designated in advance by an administrator or the like may be designated as the monitoring candidate tenant ID.

  In addition, as a monitoring candidate tenant ID, any of a plurality of tenant IDs set in advance by an administrator or the like may be specified by switching at a predetermined time interval.

  Further, the sampling unit 111 may preferentially select a tenant with a large memory usage as a monitoring candidate based on the history of the memory usage monitored during a predetermined period according to the first embodiment of the present invention. . Similarly, the sampling unit 111 selects a tenant having a large memory usage for each day, day of the week, or time period in a month based on the history of the memory usage monitored during a predetermined period. A tenant with a large memory usage may be preferentially selected as a monitoring candidate on the day, day of the week, or time period when the data is extracted and monitored.

  Next, a characteristic configuration of the first embodiment of the present invention will be described. FIG. 1 is a block diagram showing a characteristic configuration of the first embodiment of the present invention.

  The service providing apparatus 100 includes a sampling unit 111, a processing unit 112, and a sub-process monitoring unit 113.

  Here, the processing unit 112 executes a sub-process 151 and a main process 152 that process a request including any of a plurality of attributes while securing a memory necessary for processing the request. The sampling unit 111 associates any one of one or more attributes that are monitoring candidates among the plurality of attributes with the sub-process 151, and when the input request includes the associated attribute, Is transmitted to the sub-process 151, and when the other attributes are included, the request is transmitted to the main process 152. The sub-process monitoring unit 113 acquires and outputs the memory usage associated with request processing in the sub-process 151 for each request attribute.

  Next, the effect of the first embodiment of the present invention will be described.

  According to the first embodiment of the present invention, the memory usage for each tenant can be accurately monitored in the multi-tenant system.

  The reason is that, when the attribute of the input request is a monitoring candidate, the sampling unit 111 transmits the request to the sub-process 151, and the sub-process monitoring unit 113 uses the memory associated with the request processing in the sub-process 151. This is to get the amount. As a result, the memory usage of the acquired tenant of the monitoring candidate is distinguished from the memory usage of other tenants and is not affected by the number of threads operating on the process, so the monitoring accuracy is increased. .

  Further, according to the first embodiment of the present invention, the memory usage can be acquired with a lower processing load than the method of recording the memory usage every time the process receives a request as in Patent Document 1. The reason is that the sub-process 151 processes only the request of the monitoring candidate tenant, and the sub-process monitoring unit 113 records the memory usage of the sub-process 151 only for the request of the monitoring candidate tenant.

  Further, according to the first embodiment of the present invention, it is possible to perform flexible monitoring control so as to acquire the memory usage of a specific tenant. The reason is that the sub-process 151 processes only the request of the monitoring candidate tenant, and the sub-process monitoring unit 113 acquires the memory usage of the sub-process 151 only for the request of the monitoring candidate tenant. As a result, the administrator sets a specific tenant as a monitoring candidate, or the service providing apparatus 100 sets a monitoring candidate based on the monitoring history, whereby only the specific tenant can be efficiently acquired.

(Second embodiment)
Next, a second embodiment of the present invention will be described in detail with reference to the drawings.

  The second embodiment of the present invention is different from the first embodiment of the present invention in that the sub-process 151 acquires process specific information from the main process 152.

  Process-specific information is data that is referenced or updated across multiple requests from users among data that can only be accessed from within the process, such as data held in a memory area specific to the process It is. For example, session data in a WEB application corresponds to process specific information. When a series of requests for referencing and updating such process-specific information is processed separately in the sub-process 151 and the main process 152, the sub-process 151 and the main process 152 refer to the same process-specific information. The series of requests cannot be processed correctly.

  In the second embodiment of the present invention, the process specific information mediating unit 114 updates and references process specific information existing in the memory space of the main process 152 in response to a request from the sub-process 151.

  Next, the configuration of the second embodiment of the present invention will be described. In the second embodiment of the present invention, the same components as those in the first embodiment are denoted by the same reference numerals as those in the first embodiment (FIG. 2), and detailed description thereof is omitted.

  FIG. 12 is a block diagram showing the configuration of the multi-tenant system according to the second embodiment of the present invention.

  Referring to FIG. 12, the service providing apparatus 100 according to the second embodiment of the present invention includes a process-specific information mediating unit 114 in addition to the configuration of the first embodiment of the present invention.

  In response to a request from the sub-process 151, the process-specific information mediating unit 114 updates and references process-specific information existing in the memory space of the main process 152.

  Next, the operation of the service providing apparatus 100 according to the second embodiment of the present invention will be described.

  FIG. 13 is a flowchart showing the operation of the process specific information access process of the service providing apparatus 100 according to the second embodiment of the present invention.

  Here, it is assumed that the process-specific information mediating unit 114 is realized by a program that operates on the main process 152 and the sub-process 151.

  When an access process such as reference or update of process specific information occurs in a thread on the sub process 151 (step S301), the process specific information mediating unit 114 of the sub process 151 interrupts the access process, and the process of the main process 152 The unique information intermediary unit 114 is requested to perform access processing through inter-process communication (step S302). Here, the process specific information mediating unit 114 of the sub-process 151 notifies the variable name of the process specific information to be referred if the access process is a reference, and the variable name of the process specific information to be updated if the access process is an update. And the updated value.

  In response to a request from the process unique information mediating unit 114 of the sub-process 151, the process unique information mediating unit 114 of the main process 152 refers to the process unique information of the specified variable name existing in the memory space of the main process 152, Update is performed (step S303).

  The process unique information mediating unit 114 of the main process 152 transmits the result of reference or update to the process unique information mediating unit 114 of the sub-process 151 as an access processing result (step S304).

  The process specific information mediating unit 114 of the sub-process 151 returns the processing result received from the main process 152 as a result of the access processing that has occurred in the thread (step S305).

  For example, when AOP (Aspect Oriented Programming) is used as an interrupt for the process for accessing process-specific information, the sub-process 151 performs the main process for the process performed instead of the method getState () that refers to the process-specific information. A process for requesting process specific state information to the process 152 is defined. The process specific information mediating unit 114 of the subprocess 151 cancels execution of getState () requested by the thread on the subprocess 151, and requests process specific state information from the main process 152 through interprocess communication. In response to this request, the process specific information mediating unit 114 of the main process 152 executes the getState () method and returns the result to the sub-process 151 by inter-process communication. Then, the process specific information mediating unit 114 of the subprocess 151 returns the received result as the result of the getState () method.

  Thus, the operation of the second embodiment of the present invention is completed.

  According to the second embodiment of the present invention, even when a request of a monitoring candidate tenant refers to or updates process-specific information, the sub-process 151 monitors the memory usage by using the tenant as a monitoring candidate. be able to. The reason is that the process specific information mediating unit 114 updates and references process specific information existing in the memory space of the main process 152 in response to a request from the sub-process 151.

(Third embodiment)
Next, a third embodiment of the present invention will be described in detail with reference to the drawings.

  In the third embodiment of the present invention, the sampling unit 111 determines the monitoring candidate tenant based on the estimated memory usage for each tenant in the main process 152. The form is different.

  Next, the configuration of the third embodiment of the present invention will be described. In the third embodiment of the present invention, components similar to those in the first embodiment are given the same reference numerals as those in the first embodiment (FIG. 2), and detailed description thereof is omitted.

  FIG. 14 is a block diagram showing the configuration of the multi-tenant system according to the third embodiment of the present invention.

  Referring to FIG. 14, the service providing apparatus 100 according to the third embodiment of the present invention includes a main process monitoring unit 115 and an approximate memory monitoring result storage unit 125 in addition to the configuration of the first embodiment of the present invention. Including.

  The main process monitoring unit 115 obtains an approximate value (hereinafter referred to as approximate memory usage) of the memory usage for each tenant in the main process 152 (memory amount secured for each tenant in the main process 152), and calculates the approximate memory The estimated memory monitoring result information 135 in the monitoring result storage unit 125 is stored.

  The approximate memory usage is information used to determine a monitoring candidate tenant in the sub-process 151. The monitoring accuracy of the approximate memory usage may be lower than the monitoring accuracy of the memory usage acquired by the sub-process monitoring unit 113. Further, it is desirable that the approximate memory usage amount is obtained by a simple method with little influence on the main process 152. In the third embodiment of the present invention, the main process monitoring unit 115 acquires the approximate memory usage for each tenant in the main process 152 by a method similar to the method described in Patent Document 1. . That is, the main process monitoring unit 115 monitors the memory usage of the entire main process 152 and the tenant that is executing processing in the main process 152, and the memory usage of the entire main process 152 is monitored for each tenant that has been executing. Approximate memory usage for each tenant is calculated by prorated distribution at a predetermined rate.

  The approximate memory monitoring result storage unit 125 stores approximate memory monitoring result information 135. FIG. 15 is a diagram illustrating an example of the approximate memory monitoring result information 135 according to the third embodiment of this invention. As shown in FIG. 15, the approximate memory monitoring result information 135 includes a cumulative approximate memory usage amount, a total number of requests, and an approximate memory usage amount for each tenant ID in the main process 152.

  The sampling unit 111 refers to the approximate memory monitoring result information 135 and determines a monitoring candidate tenant ID based on the approximate memory usage of the main process 152.

  Next, the operation of the service providing apparatus 100 according to the third embodiment of the present invention will be described.

  First, the main process monitoring unit 115 acquires the approximate memory usage amount for each tenant in the main process 152 by the same method as in Patent Document 1.

  For example, if the memory usage in a certain period is 300 MB and the tenant ID of the request processed in that period is “tenant_A” and “tenant_B”, these tenants use 150 MB each of the memory. As a result, it is added to the accumulated approximate memory usage of each tenant in the approximate memory monitoring result information 135, and 1 is added to the total number of requests of each tenant. Then, the main process monitoring unit 115 calculates the approximate memory usage per request by dividing the accumulated approximate memory usage of each tenant by the total number of requests at a predetermined timing, and saves it in the approximate memory monitoring result information 135. To do. As a result, the approximate memory monitoring result storage unit 125 stores the approximate memory usage as shown in FIG.

  Next, request processing in the third embodiment of the present invention will be described. The operation of the request process in the third embodiment of the present invention is the same as that of the first embodiment (FIG. 3) of the present invention except for the process of determining whether or not the tenant ID is a monitoring candidate (step S102). It becomes.

  In step S102, the sampling unit 111 refers to the approximate memory monitoring result information 135 in the approximate memory monitoring result storage unit 125, and sets a tenant ID whose approximate memory usage is a predetermined value or less as a monitoring candidate.

  For example, when the approximate memory monitoring result information 135 as shown in FIG. 15 is stored in the approximate memory monitoring result storage unit 125 and the tenant ID having the maximum approximate memory usage is determined as a monitoring candidate, the sampling unit 111 Since the estimated memory usage “30 MB” of the ID “tenant_A” is the maximum, the tenant ID “tenant_A” is set as a monitoring candidate.

  Further, the sampling unit 111 may refer to the monitoring number information 133 in the monitoring number storage unit 123, and may select a tenant ID whose approximate memory usage per monitoring number is a predetermined value or more as a monitoring candidate.

  For example, when the monitoring frequency information 133 as shown in FIG. 8 is stored in the monitoring frequency storage unit 123 and the approximate memory monitoring result information 135 as shown in FIG. 15 is stored in the approximate memory monitoring result storage unit 125, the sampling unit 111 Since the estimated memory usage “28 MB / 7 = 4 MB” per number of monitoring of the ID “tenant_C” is the maximum, the tenant ID “tenant_C” is set as a monitoring candidate.

  As described above, when the monitoring candidate is determined based on the number of times of monitoring as in the first embodiment of the present invention, the tenant ID “tenant_B” is determined as the monitoring candidate. In the third embodiment, the tenant ID “tenant_A” or the tenant ID “tenant_C” having a large approximate memory usage amount in the main process 152 is determined as a monitoring candidate.

  Thus, the operation of the third embodiment of the present invention is completed.

  In the third embodiment of the present invention, the sampling unit 111 uses tenant IDs whose estimated memory usage in the main process 152 is a predetermined value or more as a monitoring candidate. However, the sampling unit 111 uses the estimated memory usage. The monitoring candidate may be determined by another method using the measurement result.

  For example, the main process monitoring unit 115 calculates the number of tenants processed simultaneously for each tenant together with the approximate memory usage in the main process 152, and the sampling unit 111 increases the approximate memory as the number of tenants processed simultaneously increases. A tenant with a low accuracy of the usage amount and a low accuracy of the approximate memory usage may be preferentially selected as a monitoring candidate.

  Further, the sampling unit 111 uses both the approximate memory usage and the accuracy of the approximate memory usage. For example, a tenant having a low accuracy of the approximate memory usage relative to the approximate memory usage may be preferentially selected as a monitoring candidate. Good.

  According to the third embodiment of this invention, the memory usage can be preferentially monitored for a tenant that is estimated to have a large memory usage in the main process 152. This is because the sampling unit 111 calculates the approximate memory usage in the main process 152, and the sampling unit 111 determines the tenant ID of the monitoring candidate based on the approximate memory usage.

(Fourth embodiment)
Next, a fourth embodiment of the present invention will be described in detail with reference to the drawings.

  The fourth embodiment of the present invention is different from the first embodiment of the present invention in that the sampling unit 111 stores and processes a request including the monitoring candidate tenant ID in the sampling queue 116.

  Next, the configuration of the fourth embodiment of the present invention will be described. In the fourth embodiment of the present invention, components similar to those in the first embodiment are given the same reference numerals as those in the first embodiment (FIG. 2), and detailed description thereof is omitted.

  FIG. 16 is a block diagram showing a configuration of a multi-tenant system according to the fourth embodiment of the present invention.

  Referring to FIG. 16, the service providing apparatus 100 according to the fourth embodiment of the present invention includes a sampling queue 116 in addition to the configuration of the first embodiment of the present invention.

  The sampling queue 116 holds a predetermined number of requests.

  If the tenant ID of the request is a monitoring candidate, the sampling unit 111 stores the request in the sampling queue 116. When the request stored in the sampling queue 116 can be monitored, the sampling unit 111 transmits the request to the sub-process 151.

  Next, the operation of the service providing apparatus 100 according to the fourth embodiment of the present invention will be described.

  First, request processing of the service providing apparatus 100 according to the fourth embodiment of the present invention will be described. FIG. 17 is a flowchart showing an operation of request processing of the service providing apparatus 100 according to the fourth embodiment of the present invention.

  First, the sampling unit 111 receives a request from the user terminal 200 (step S401).

  The sampling unit 111 determines whether the tenant ID of the request is a monitoring candidate (step S402).

  If it is determined in step S402 that the tenant ID of the request is a monitoring candidate (step S402 / Yes), the sampling unit 111 stores the request in the sampling queue 116 (step S403).

  On the other hand, if it is determined in step S402 that the tenant ID of the request is not a monitoring candidate (step S402 / No), the sampling unit 111 transmits the request to the main process 152 (step S404).

  Next, sampling queue processing of the service providing apparatus 100 according to the fourth embodiment of the present invention will be described. FIG. 18 is a flowchart showing the sampling queue processing operation of the service providing apparatus 100 according to the fourth embodiment of the present invention.

  When the sampling unit 111 stores the request in the sampling queue 116 (step S403) or deletes the Nantes ID from the monitoring target information 134 (step S124), the sampling unit 111 sequentially requests the sampling queue 116 from the top. One is read (step S441).

  The sampling unit 111 determines whether the request can be monitored (step S442). Here, the sampling unit 111 determines whether or not the request can be monitored based on the monitoring conditions similar to those in the first embodiment of the present invention.

  If it is determined in step S442 that the request can be monitored (step S442 / Yes), if the tenant ID is not set in the monitoring target information 134, the sampling unit 111 sets the tenant ID of the request in the monitoring target information 134. Is set (step S443).

  Then, the sampling unit 111 notifies the tenant ID of the request to the sub-process monitoring unit 113 (Step S444), and transmits the request to the sub-process 151 (Step S445).

  If it is determined in step S442 that the request cannot be monitored (step S442 / No), the sampling unit 111 determines whether or not the request remains in the sampling queue 116 for a predetermined time or more (step S447). .

  If it is determined in step S447 that the sampling queue 116 stays in the sampling queue 116 for a predetermined time (step S447 / Yes), the sampling unit 111 transmits a request to the main process 152 (step S448).

  In Step S447, when it is determined that the sample does not stay in the sampling queue 116 for a predetermined time or longer (Step S447 / No), the sampling unit 111 holds the request in the sampling queue 116 as it is.

  When the request is transmitted to the sub-process 151 or the main process 152 (Step S445 or Step S448), the sampling unit 111 deletes the request from the sampling queue 116 (Step S446).

  The sampling unit 111 repeats steps S441 to S447 until all requests stored in the sampling queue 116 are processed (step S449).

  Note that the response processing and sub-process monitoring processing operations of the service providing apparatus 100 in the fourth embodiment of the present invention are the same as those in the first embodiment (FIGS. 4 and 5) of the present invention. .

  Thus, the operation of the fourth embodiment of the present invention is completed.

  According to the fourth embodiment of the present invention, it is possible to efficiently monitor a plurality of monitoring candidate tenants as compared to the first embodiment of the present invention. The reason is that the sampling unit 111 holds the request including the tenant ID of the monitoring candidate in the sampling queue 116 and transmits the request to the sub-process 151 when the request stored in the sampling queue 116 can be monitored. Because. As a result, even when a request from another tenant is received while a tenant is being monitored in the sub-process 151, it is possible to start monitoring other tenants after waiting for the monitoring of the tenant being monitored to end. Can be monitored efficiently.

(Fifth embodiment)
Next, a fifth embodiment of the present invention will be described in detail with reference to the drawings.

  In the fifth embodiment of the present invention, the first implementation of the present invention is such that a plurality of sub-processes 151 operate on the processing unit 112 and each of the plurality of tenants is monitored by each sub-process 151. The form is different.

  Next, the configuration of the fifth embodiment of the present invention will be described. In the fifth embodiment of the present invention, the same components as those in the first embodiment are denoted by the same reference numerals as those in the first embodiment (FIG. 2), and detailed description thereof is omitted.

  FIG. 19 is a block diagram showing a configuration of a multi-tenant system according to the fifth embodiment of the present invention.

  In the fifth embodiment of the present invention, the processing unit 112 executes processing of a plurality of subprocesses 151. In the fifth embodiment of the present invention, the service providing apparatus 100 includes a plurality of sub-process monitoring units 113. Each of the plurality of sub-process monitoring units 113 acquires the memory usage of each of the plurality of sub-processes 151.

  When the request including the tenant ID of the monitoring candidate satisfies the monitorable condition regarding any of the subprocesses 151, the sampling unit 111 transmits the request to the subprocess 151 that satisfies the monitorable condition. If the monitorable condition is not satisfied, the request is transmitted to the main process 152.

  The sub-process monitoring unit 113 acquires the memory usage of each sub-process 151 and records it in the memory monitoring log 131.

  FIG. 22 is a diagram showing an example of the monitoring target information 134 in the fifth embodiment of the present invention. The monitoring target information 134 includes, for each sub-process ID that identifies the sub-process 151, a monitoring-target tenant ID being processed by the sub-process 151 (associated with the sub-process 151).

  Next, the operation of the service providing apparatus 100 according to the fifth embodiment of the present invention will be described.

  First, request processing of the service providing apparatus 100 according to the fifth embodiment of the present invention will be described. FIG. 20 is a flowchart showing the request processing operation of the service providing apparatus 100 according to the fifth embodiment of the present invention.

  The sampling unit 111 receives a request from the user terminal 200 (step S501).

  The sampling unit 111 determines whether the tenant ID of the request is a monitoring candidate (step S502).

  When it is determined in step S502 that the tenant ID of the request is a monitoring candidate (step S502 / Yes), the sampling unit 111 determines whether the request can be monitored in any of the plurality of subprocesses 151 ( Step S503).

  Here, the sampling unit 111 determines that the request can be monitored by the sub-process 151 when any of the plurality of sub-processes 151 satisfies the above-described monitoring condition. In the determination of the monitorable condition, the sampling unit 111 has a sub-process 151 that is processing a request with the same tenant ID as the tenant ID of the request even if there is a sub-process 151 that has no request being processed. Determines that the sub-process 151 is a sub-process 151 that can be monitored.

  If it is determined in step S503 that the request can be monitored (step S503 / Yes), if the tenant ID is not set for the subprocess ID determined to be monitorable in the monitoring target information 134, the sampling unit 111 sets the tenant ID of the request for the subprocess ID (associates the tenant ID with the subprocess ID) (step S504).

  Then, the sampling unit 111 notifies the subprocess monitoring unit 113 that monitors the subprocess 151 determined to be able to monitor the tenant ID of the request (step S505), and transmits the request to the subprocess 151 that is determined to be monitorable. (Step S506).

  On the other hand, if it is determined in step S502 that the tenant ID of the request is not a monitoring candidate (step S502 / No), or in step S503, it is determined that the request cannot be monitored in any of the plurality of subprocesses 151. In the case (step S503 / No), the sampling unit 111 transmits a request to the main process 152 (step S507).

  Next, response processing of the service providing apparatus 100 according to the fifth embodiment of the present invention will be described. FIG. 21 is a flowchart showing the response processing operation of the service providing apparatus 100 according to the fifth embodiment of the present invention.

  The sampling unit 111 receives a response to the request from the sub-process 151 or the main process 152 (step S521).

  When a response is received from the sub-process 151 (step S522 / Yes), the sampling unit 111 determines whether a response has been received for all requests transmitted to the sub-process 151 (step S523).

  In step S523, when responses are received for all the requests transmitted to the subprocess 151 (step S523 / Yes), the sampling unit 111 reads the subprocess 151 from the monitoring target information 134 of the monitoring target storage unit 124. The tenant ID for is deleted (step S524).

  The sampling unit 111 transmits a response to the user terminal 200 that is the transmission source of the request (step S525).

  In step S522, when a response is received from the main process 152 (step S522 / No), or in step S522, there is a response that has not been received with respect to the request transmitted to the sub-process 151 (step S523 / No), the sampling unit 111 also transmits a response to the user terminal 200 that is the transmission source of the request (step S525).

  Next, sub-process monitoring processing of the service providing apparatus 100 according to the fifth embodiment of the present invention will be described. In the sub-process monitoring process in the fifth embodiment of the present invention, each sub-process monitoring unit 113 performs the same process as the sub-process monitoring process (FIG. 5) in the first embodiment of the present invention.

  Thus, the operation of the fifth embodiment of the present invention is completed.

  According to the fifth embodiment of the present invention, a plurality of tenants can be monitored more efficiently than in the first embodiment of the present invention. The reason is that a plurality of sub-processes 151 operate on the processing unit 112, the sampling unit 111 transfers a request including the tenant ID of the monitoring candidate to one of the plurality of sub-processes 151, and the sub-process monitoring unit 113 This is because the memory usage of each sub-process 151 is acquired. Thereby, a plurality of tenants can be monitored simultaneously and efficiently.

  Although the present invention has been described with reference to the embodiment, the present invention is not limited to the above embodiment. Various changes that can be understood by those skilled in the art can be made to the configuration and details of the present invention within the scope of the present invention.

  For example, in the embodiment of the present invention, the tenant ID is targeted as a request attribute, and the memory usage for each tenant is monitored, but the target attribute is not limited to this, and the user who sent the request By using identifiers and identifiers of processing contents (functions) executed by requests, the memory usage for each user and processing contents (functions) may be monitored.

  In the embodiment of the present invention, a plurality of threads operate on a process, the plurality of threads share the memory space of the process, and a plurality of requests are processed simultaneously in parallel. If the request can be processed in parallel, the request may be processed by a method other than threading.

  In the embodiment of the present invention, the memory usage in the process increases cumulatively with the request processing and is freed by garbage collection. However, the memory is required during the request processing. May be secured at the time of becoming, and may be released when it becomes unnecessary. In this case, the sub-process monitoring unit 113 may periodically monitor the memory usage of the sub-process 151 and set the maximum value as the memory usage in each record 141 of the memory monitoring log 131.

DESCRIPTION OF SYMBOLS 100 Service provision apparatus 111 Sampling part 112 Processing part 113 Sub process monitoring part 114 Process specific information mediation part 115 Main process monitoring part 116 Sampling queue 121 Memory monitoring log memory | storage part 122 Memory monitoring result memory | storage part 123 Monitoring frequency memory part 124 Monitoring object memory | storage Unit 125 Estimated memory monitoring result storage unit 131 Memory monitoring log 132 Memory monitoring result information 133 Monitoring frequency information 134 Monitoring target information 135 Approximate memory monitoring result information 141 Record 151 Subprocess 152 Main process 200 User terminal

Claims (10)

A processing means for executing a sub-process and a main process, each of which includes a request including any of a plurality of attributes, securing a memory necessary for processing the request;
If any one of the plurality of attributes that are candidates for monitoring is associated with the subprocess, and the input request includes the associated attribute, the request is associated with the subprocess. A sampling means for transmitting the request to the main process when including other attributes,
A service providing apparatus comprising: a sub-process monitoring unit that acquires and outputs the amount of memory secured by the sub-process for each request attribute. If the input request attribute is the monitoring candidate and the sub-process is not processing another request, the sampling means associates the input request attribute with the sub-process and The service providing apparatus according to claim 1, wherein the service providing apparatus transmits to the sub-process. And a sampling queue for holding a request including the attribute of the monitoring candidate,
The sampling means stores the request in the sampling queue when the attribute of the input request is the monitoring candidate and is not transmitted to the sub-process, and a predetermined time after the request is stored in the sampling queue. If the request attribute is associated with the sub-process or no other request is processed in the sub-process, the request is sent to the sub-process, and so on. If not, the service providing apparatus according to claim 2, wherein the request is transmitted to the main process. The sampling unit determines whether or not the attribute included in the input request is the attribute of the monitoring candidate based on the number of monitoring for each attribute of the memory amount secured in the sub-process monitoring unit The service providing apparatus according to claim 1. Furthermore, the main process monitoring means for obtaining an approximate value of the memory amount secured in the main process for each attribute,
The sampling unit determines whether or not an attribute included in the input request is an attribute of the monitoring candidate based on an approximate value of the memory amount for each attribute. The service providing device according to 1. Further, when a request for the predetermined data is requested in the processing of the request in the sub-process, a process-specific information mediating means for obtaining the data existing in the memory of the main process and providing the sub-process is provided. A service providing apparatus according to any one of claims 1 to 5. The processing means executes a plurality of the sub-processes,
Each including a plurality of the sub-process monitoring means for acquiring the amount of memory in each of the plurality of sub-processes;
The sampling means associates each of one or more attributes that are monitoring candidates among the plurality of attributes with each of the plurality of sub-processes, and when the input request includes the associated attributes, The service providing apparatus according to claim 1, wherein the request is transmitted to the sub-process with which the attribute is associated, and when the other attribute is included, the request is transmitted to the main process. Execute a sub-process and a main process that process a request that includes one of multiple attributes, securing the memory required to process the request,
If any one of the plurality of attributes that are candidates for monitoring is associated with the subprocess, and the input request includes the associated attribute, the request is associated with the subprocess. If the request contains any other attributes, the request is sent to the main process,
A service providing method for acquiring and outputting the amount of memory secured by the sub-process for each request attribute. If the attribute of the input request is the monitoring candidate, and the subprocess is not processing another request, associate the attribute of the input request with the subprocess and send the request to the subprocess. The service providing method according to claim 8. On the computer,
Execute a sub-process and a main process that process a request that includes one of multiple attributes, securing the memory required to process the request,
If any one of the plurality of attributes that are candidates for monitoring is associated with the subprocess, and the input request includes the associated attribute, the request is associated with the subprocess. If the request contains any other attributes, the request is sent to the main process,
A service providing program for executing processing for acquiring and outputting the amount of memory secured by the sub-process for each request attribute.

Images