JP2001134452A - Device and method for managing usage of resource - Google Patents

Abstract

PROBLEM TO BE SOLVED: To provide a method for managing the resource use of a specific resource according to the related code set of a code to be executed on behalf of a down-loaded applet. SOLUTION: A resource marker is related with a related code so that the resource amount used of a specific resource according to the related code can be indicated. The resource marker is updated when the related code increases or decreases the total resource amount used of the specific resource.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION The present invention relates generally to software applications, and more particularly, to a method and apparatus for managing resource usage in an object-based system.

[0002] Consumers are strongly demanding cost reduction. Thus, for example, in consumer systems, attempts have been made to minimize the capacity of memory and CPU devices and minimize overall cost. For example, cable TV set-top boxes have limited memory space and CPU power. As object-based systems are being incorporated into consumer devices, managing the efficient use of resources in them has become increasingly important every day. In other words, (especially among many causes)
As a result of limited resources, tracking and managing resource usage has become a major challenge in the object-oriented field.

In particular, it is important to track the use of untrusted code resources. For example, it is important to track the resource usage of applets downloaded from untrusted URLs to set-top boxes. Downloaded applets may be designed artificially or non-artificially to consume resources, such as memory space and CPU time, in prohibitive amounts.

[0004] It is also important to track and manage the use of resources of the associated code set. For example, threads running on behalf of applets may consume excessively the limited resources of the set-top box, either together or individually. Therefore, it is not enough to simply track and manage the resource usage of individual threads. Applets may, for example, initiate multiple threads that work together to consume resources. Tracking the resource usage of an individual thread can only kill that individual thread. However, before forcibly terminating the resource consuming thread, the applet may launch another resource consuming thread. That is, if there is a way to determine that an applet or related code set is consuming too much resources, all the applet associated with the greedy applet and / or controlled by the applet Threads can be thwarted from excessive consumption of resources.

[0005] Thus, there is a need for improved methods and apparatus for tracking and managing resource usage. There is also a need for a mechanism for tracking and managing the use of its resources for related code sets.

[0006]

SUMMARY OF THE INVENTION To meet the needs described above, the present invention generally provides an apparatus and method for managing the use of resources by associated code, such as code executed on behalf of an applet. The present invention, in one embodiment, discloses a method for managing the use of a particular resource by an associated code set. The resource indicator is associated with the associated code, and the resource indicator indicates the usage of a specific resource by the associated code. For example, a counter can be used to determine how many bytes of resources (eg, Java)
[Registered Trademark] heap memory) is consumed. The resource indicator is updated as the associated code increases or decreases the total usage of its particular resource. For example, the counter is incremented when the applet is allocated memory for its use and increases the memory usage, and decremented when the applet's memory is being reused.

[0007] In another embodiment, the invention is embodied in a computer-readable medium having computer code for managing resource use. The computer readable medium includes a computer code for associating a resource indicator with a related code that indicates the resource usage of the particular resource by the related code, and when the total resource usage of the particular resource by the related code increases or decreases. , Computer code for updating the resource indicator.

[0008] In another embodiment, a computer system for managing resource usage by a related code set is disclosed. The computer system has a resource context associated with a set of related codes. For example, assume that one resource is associated with each applet set obtained from a particular source (eg, a URL). The resource context has a resource indicator associated with a particular resource type, indicating how much of that type of resource is being used by the associated code set. For example, a resource context has a counter for tracking the amount of memory (eg, Java ™ heap memory) used by the applet. The computer system also has a resource object associated with the resource context. This resource object is a resource of the resource type described above,
Shows how much is used by the associated code set. The memory counter may indicate that the resource context applet is using only memory (eg, Java ™ heap memory), for example, only 20 bytes. The computer system further includes an update mechanism configured to increment the resource indicator of the resource context when the associated code set increases usage of the resource of the resource type associated with the updated resource indicator. Have.

The present invention has numerous advantages. For example, by tracking resource use by related code (eg, multiple applets with the same source), actions to stop or prevent excessive consumption of resources are implemented throughout the related code set. For example, when an applet is downloaded from a particular website to a set-top box, the applet's use of set-top resources is carefully monitored. If the usage is too high, warn the applet that the resource usage needs to be cut or terminated. If the applet continues to increase resource usage, terminate all threads associated with the applet. Therefore, even if an applet is artificially designed to generate a plurality of threads that consume resources, it is possible to terminate all such threads. Also, the execution of any system thread executing the applet code can be reliably terminated in a manner that does not destroy the state of resource objects that do not own the harmful applet.

[0010] The foregoing and other advantages of the invention will become more apparent from the detailed description that follows and the accompanying drawings.

[0011]

DETAILED DESCRIPTION OF THE INVENTION The following is a detailed description of a specific embodiment of the present invention. In the following, the invention will be described in relation to particular embodiments, but this is not intended to limit the invention to these embodiments. On the contrary, the intention is to cover various modifications, improvements, and equivalents, within the spirit and scope of the invention, as defined by the appended claims. In the following description, numerous details are set forth to provide a thorough understanding of the present invention. However, the present invention can be implemented without specifying some or all of these items. In other instances, well known process operations and / or structures have not been described in order to not unnecessarily obscure the present invention.

The present invention generally relates to a method and apparatus for managing the use of resources by associated code, such as code executed on behalf of applets downloaded from a particular website. Associated code includes any code that can theoretically be charged as a single entity of resource usage by itself. Associated code includes, for example, a thread or a method that is downloaded directly onto a method and executed directly by the applet, as part of the code and / or thread started by the applet. For example, a system method is called by an applet method. Related code also includes code that executes on behalf of multiple applets obtained from the same source (eg, a website) or from a related source (eg, a site owned by the same company). Further, the related code may take a form other than the applet.

For simplicity, throughout this specification, code executed on behalf of an applet will be used as an example of related code. The embodiments disclosed herein track the use of resources by each applet. An example is tracking and managing the total memory consumption by applets. Another example is tracking and managing the CPU time required by an applet in a particular duration (eg, as a percentage of CPU time in a particular duration).

[0014] Tracking resource usage is also done by associating each applet with some indicator. This indicator tracks how much a particular resource has been consumed by the applet. An indicator may, for example, track the absolute consumption of a particular resource. As an example, there is a case where a counter tracks the number of bytes consumed by a specific applet (for example, in a Java (registered trademark) heap memory). Alternatively, the indicator may, for example, track the relative consumption of a particular resource. As an example, the percentage of time that an applet has used the CPU for a predetermined period is tracked by a CPU usage indicator. Each applet has a plurality of associated indicators, each of which tracks how much the applet and associated code is consuming a particular type of resource. Each applet may have, for example, a memory usage indicator, a CPU usage indicator, and a network usage indicator.

[0015] Each assigned or utilized resource object may be associated with a corresponding applet. To determine which applet or applet set corresponds to a particular resource object, any suitable factors can be considered.
For example, when one memory block is allocated to an applet, the applet is regarded as corresponding to the memory block and is associated with the allocated memory block. The mechanism for associating a resource object with a corresponding set of related codes will be described later in connection with FIG.

When a resource object is associated with a particular applet, the appropriate resource indicators for that applet are updated after the resource object has been assigned to use the applet and after the resource object has been unassigned from the applet. For example, if a block of memory is allocated to use an applet,
The applet's memory counter is incremented by the size of the allocated memory block.

Some of the mechanisms used to track the use of resources by applets are represented in the form of entities (referred to herein as resource contexts). Further, the resource context is an entity to be requested to use the resource when the code associated with the resource context uses the resource. That is, a resource context is an entity through which resource usage can be tracked and managed. Resource contexts are also associated with code bodies and resources consumed by the execution of such code bodies.

FIG. 1 is a diagram illustrating the relationship between various mechanisms for managing resource use in accordance with one embodiment of the present invention. As shown in the figure, the resource context 102 has a set of indicators to track how much the resource context is consuming each type of resource. In one embodiment, the indicators track CPU usage, memory usage, network usage, number of open files, number of open sockets, and number of monitors.

The resource context 102 is also associated with one or more predefined limits for each resource type (eg, heap memory). Each limit set indicates how much related code can access a resource of the related type in the resource context before action is taken to prevent excessive consumption of the resource. The resource context 102 can be associated with three types of memory usage limits, for example, 2 kilobytes, 4 kilobytes, and 5 kilobytes (maximum usage). If the memory usage of this resource context exceeds 2 kilobytes, the applet associated with the resource context will be alerted that the usage of that resource has reached the level of 3 kilobytes, up to the maximum usage of 5 kilobytes. If the memory usage of the resource context exceeds 3 kilobytes, a warning is issued that the resource context will be terminated shortly due to excessive consumption of resources. If the applet exceeds the first and / or second limits, no more memory allocation is allowed. If the usage exceeds 5 kilobytes, the applet for that resource context is terminated without warning.

In the embodiment shown in FIG. 1, resource context 102 includes a plurality of limits or thresholds on memory usage, namely limit 1 and limit 2.
Resource object 10 having a maximum limit, a lower limit array and an upper limit array for a particular resource type
4 associated with it. Although not shown in the figure,
A resource context can be associated with any number of resource objects (eg, resource objects corresponding to CPU usage, network usage, socket usage, file usage, and monitor usage resources).

Referring again to FIG. 1, the maximum limit represents the maximum amount of memory that can be consumed by the associated code associated with the resource context. Limits 1 and 2 represent thresholds used to trigger a warning that memory usage is approaching a maximum threshold. For example, limit 1 can be set to 1 kilobyte, limit 2 to 2 kilobytes, and maximum limit to 3 kilobytes.

If the associated resource context exceeds the limit 1 (eg, if the associated applet uses more than 1 kilobyte), the applet will be alerted that it is approaching its maximum usage limit. Restriction 2
(E.g., if the associated applet uses more than 2 kilobytes), the applet will be alerted that it is even closer to its maximum usage limit. And if the maximum usage is exceeded (if the applet uses more than 3 kilobytes), access to the memory by the applet will be terminated without any further warning. Similarly, when the applet drops below the threshold,
The applet is notified that it is no longer approaching the maximum threshold.

[0023] Any mechanism can be implemented to notify the applet that memory is about to be exceeded or is no longer being exceeded.
In the embodiment shown, resource object 104 has access to resource callback 118. The resource object gains access to the resource callback when the application registers and indicates a notification about the use of the resource. When a certain threshold is exceeded, or when the same threshold or another threshold is no longer being exceeded, a callback for the registered user is started.

To obtain a hysteresis effect, it is possible to provide a pair of values for each limit. For example,
Once the usage of a resource exceeds limit 1, the usage of that resource must drop below a lower limit below limit 1 in order to trigger a notification. Then, in order to trigger the notification again, the use of the resource needs to exceed the upper limit value higher than the limit 1. Similarly, lower and upper limits are provided for limit 2 and maximum limit.

A resource context is associated with a particular set of related codes. This association can be made in any suitable way. For example, an application framework that receives a set of application codes may pre-determine the assignment of a resource context to a particular set of related codes. This decision can be made based on any appropriate policy considerations. For example, all codes assigned to a specific protection domain may be assigned to one resource context. As will be apparent to those skilled in the art, protection domains (those with features included in the security features of JDK 1.2) generally provide permissions to the codeset. That is, the mechanism for allocating a protection domain to a specific code set can be used to allocate a resource context to the code set.

A protection domain is generally associated with a particular thread based on which class loader used to load the class of the method being executed by the particular thread. For some embodiments for assigning protection domains to threads based on class loaders, see the Java2 Platform Security Architecture.
ity Architecture), API design (API Design),
Gong's implementation (Implementation b
y Li Gong) (Addison Wesley Publishing, ISBN 201-
31000-7), which is incorporated herein by reference as it is.

As shown in FIG. 1, a specific thread 1 running on behalf of the resource context 102
06 is also being executed in the protection domain 116. More specifically, a particular method 110 in thread 106 is currently executing and is associated with a corresponding stack frame 108. The executing method 110 in the thread 106 has the class 11
2 is loaded by the class loader 114. The class loader 114 is a protection domain 116
, And the protection domain 116 is further associated with the resource context 102. In one embodiment, each thread is assigned and traced to an associated resource context via a class loader and its associated protection domain.

It is of course possible to assign a plurality of code sets belonging to different protection domains to the same resource context. As an example, if the first applet is Pe
Consider the case where the second applet originated from a website controlled by psi and originated from a website controlled by Pizza Hut. These two applets have different protection domains because they originate from different websites and are loaded by different class loaders, but because the Pizza Hut and Pepsi are shared, they have the same resource context. Requesting the use of resources.

[0029] Some mechanisms for tracking resource use may be associated with the resource itself. In one embodiment, each assigned resource object can be invoked with a corresponding resource context. As shown in the figure, the memory block 120 has a pointer to the corresponding resource context 102 associated with one code set corresponding to the memory block. Thus, resource allocation is requested for the corresponding resource context, and resource deallocation is attributed to the corresponding resource context via the associated pointer. For example, when a resource is allocated, the appropriate resource counter in the corresponding source context is incremented.

FIGS. 2A and 2B are flowcharts illustrating a process 200 for allocating memory, according to one embodiment of the present invention. Similar procedures can be implemented for any type of resource that is generally allocated in absolute amounts (eg, bytes). For example, it is possible to implement this procedure in the allocation of open files, open sockets, and monitors.

First, in operation 202, an active protection domain is determined. For the technology for determining the active protection domain, see the Java2 Platform Security Architecture.
y Architecture), API Design, Implementation by Li Gong
Li Gong) (Addison Wesley Publishing, ISBN 201-31)
000-7) is described in detail in the present specification. Next, in operation 204, a resource context associated with the active protection domain is identified. The assignment of the resource context is a policy decision and can be implemented in any suitable way, but in the case of the resource context of the embodiment shown in the figure, it is mapped directly to the active protection domain.

The mapping of a resource context to a particular protection domain may have been previously set by the application framework. Alternatively, the application framework may separately form a class loader for each code source (for example, each URL site). Then, all classes loaded by a certain class loader are assigned to a specific protection domain corresponding to the code source. Then, the application framework instantiates the resource context, and the instantiated resource context is associated with the protection area of the specific class loader.

Next, at operation 206, a memory counter is incremented corresponding to the identified resource context. Then, in a subsequent operation 206, it is determined whether the resource usage has exceeded a threshold. For example, it is determined whether the threshold of the limit 1, the limit 2, or the maximum limit of FIG. 1 has been exceeded. Alternatively, it may be determined whether or not the upper limit has been exceeded.

If the resource usage does not exceed the threshold, memory is allocated in operation 210 and a resource context is recorded for the allocated memory. For example, a pointer to the resource context is recorded in the allocated memory location. Therefore, when the allocation of the memory part is released, the resource counter of the appropriate resource context is decremented. After the resource context is recorded, the memory allocation procedure ends.

If the usage of the resource exceeds the threshold, the process of resource reuse is triggered in operation 212. For example, a garbage collection procedure is started for the heap memory. One embodiment of resource reuse will be described later in connection with FIG. Resource reuse is triggered to deallocate any memory that is no longer used by the associated code set of the corresponding resource context.
When this memory deallocation is triggered, the memory usage will not exceed the threshold anymore.

When resource reuse is triggered, operation 214 determines whether the threshold is still exceeded. If the threshold has not been exceeded, operation 210
Is allocated, and a resource context is recorded for the allocated memory. Then, the memory allocation procedure 200 ends. Thus, the application is given the opportunity to reduce (cut back) memory usage.

If the threshold is still exceeded, in operation 216 a registered resource callback is notified. Any other alert-type mechanism can be implemented to alert that the code set of the resource context is approaching the maximum limit for a particular resource. As a callback type alarm, a mechanism that allows an application to register a callback from the application framework can be used. For example, an applet registers to receive a notification when memory usage exceeds a threshold. When the threshold value is actually exceeded, for example, a notification is received that the memory usage is approaching the maximum memory usage.

Turning next to FIG. 2B, in operation 218,
Determine if the maximum threshold is exceeded. If the maximum threshold has not been exceeded, memory is allocated in operation 210 of FIG. 2A and a resource context is recorded for the allocated memory. However, if the maximum threshold has been exceeded, the memory counter is decremented in operation 220 (since it was previously incremented in operation 206). Then, in operation 222, Out of Mem
An ory exception was thrown to indicate that an error occurred,
No more memory allocation. Then, the memory allocation procedure 200 ends.

If a particular set of related code exceeds the maximum memory usage, a mechanism may be implemented to abort the thread executed on behalf of that related code.

FIG. 3 is a flowchart showing the resource reuse operation in FIG. 2 according to an embodiment of the present invention. First, in operation 302, a memory scan is performed on a memory object that has not been called by another object. For example, some memory may have been called once by local variables that are no longer in use. In a subsequent operation 304, for each object that has not been invoked, the size of the object is subtracted from the corresponding resource counter of the resource context invoked by the memory object (eg, during the allocation of the memory object in operation 210 of FIG. 2). , The specific resource context is recorded). Then, in operation 306, memory is reclaimed for memory objects that have not been called.

In a following operation 308, it is determined whether the memory usage has dropped below the resource usage threshold. The reason for the memory usage dropping below the threshold may be, for example, that the associated applet has reduced memory usage in response to a warning that the maximum memory usage is approaching. If the memory usage has not fallen below the threshold, the resource reuse procedure 212 ends. If memory usage falls below the threshold,
At 10, the registered research callback is notified. For example, notify the applet associated with the resource context that there is no more danger of exceeding the maximum allocated memory. Then, the memory reuse procedure 212 ends, and control is returned to the memory allocation procedure 200 of FIGS. 2A and 2B.

The resource management techniques described in connection with FIGS. 2 and 3 work well for resources whose usage limits are absolute, but which can be more easily measured or tracked in a relative manner. For resource types of
The management may be performed by implementing another mechanism. For example, CPU usage by an applet can be tracked as a percentage of time used during a particular period. If the applet's use of the CPU exceeds a certain percentage, even if the applet's use of the CPU does not stop completely,
Simply, the priority of the applet in using the CPU may be lowered.

FIG. 4 is a diagram illustrating the relationship between mechanisms for managing resource usage, according to one embodiment of the present invention. It is of course possible to manage similar resources using the procedure of FIG. First, in operation 402, CPU or network usage is monitored for all threads associated with the resource context. Next, in operation 404, it is determined whether a first threshold has been exceeded. If the first threshold is not exceeded, operation 402 continues to monitor CPU or network usage.

If the first threshold is exceeded, the operation 40
At 6, the scheduler is instructed to downgrade the priority of the thread associated with the resource context. Then, in operation 408, all threads associated with the same resource context are again monitored to determine when to promote the priority backup. Then, in operation 410, the use of the resource is
Is determined to be below the threshold of. It is of course possible to use the same threshold value for the decision to downgrade and upgrade the priority.

If the CPU or network usage has not fallen below the second threshold, operation 412 determines if the first threshold is still exceeded. If the first threshold is still exceeded, operation 4
At 06, the scheduler is again instructed to downgrade the priority of the thread associated with the resource context. That is, threads associated with a particular resource context continue to be downgraded as long as CPU or network usage exceeds the first threshold. If the first threshold has not been exceeded, the operation 408 associates the resource context with the resource context to determine whether to downgrade the priority again (via operation 414) or upgrade the priority backup (via operation 406). The CPU or network usage is monitored again for all the threads that have been set.

If the use of the resource drops below the second threshold, operation 414 raises the priority of the thread associated with the resource context.
Instruct the scheduler. Then, in operation 416,
Determine whether the priority has dropped below the original priority. If not, the operation 402 associates the resource context with the resource context to determine if the priority should be downgraded (ie, the memory consumption has exceeded the first threshold). Monitor CPU or network usage for all threads. If so, an operation 408 determines whether the priority is to be upgraded (i.e., the memory consumption has dropped below the second threshold). Monitor usage.

Next, using these mechanisms to track resource usage, a particular code set can be
It can be determined whether a certain type of resource is being overused. For example, by analyzing the resource counters for a particular resource context and the associated code set (eg, comparing it to a predefined limit for that particular resource), the resource context may consume too much of a particular resource type. May be determined (or whether it is about to be consumed excessively). If a particular set of related codes is determined to be consuming too much of a particular resource type, steps are taken to stop and / or prevent further consumption.

FIG. 5 is a diagram showing a typical general-purpose computer system suitable for implementing the present invention. Computer system 1030 includes an optional storage device coupled to a memory device that includes a primary storage device 1034 (typically read-only memory or ROM) and a primary storage device 1036 (typically random access memory or RAM). Processors 1032 (also called central processing units, or CPUs). The computer system may take any suitable form. For example, the computer system may be incorporated into a navigation system or television set-top box.

The computer system 1030, or more specifically, the plurality of CPUs 1032, is configured to support virtual machines, as will be apparent to those skilled in the art. As is well known to those skilled in the art, ROM transmits data and instructions in one direction to CPU 1032, while
RAM is typically used to transfer data and instructions in both directions. CPU 1032 generally comprises
It can have any number of processors. Both primary storage devices 1034, 1036 may include any suitable computer readable media.
A secondary storage medium 1038, typically a large capacity memory device, is also bi-directionally coupled to the CPU 1032 to provide additional data storage capacity. Mass memory device 1038 is a computer-readable medium used to store programs containing computer code, data, and the like. As a typical large-capacity memory device 1038, the primary storage device 10
Storage media such as hard disks and tapes, which are generally slower than 34 and 1036. Mass memory device 938 may take the form of a magnetic or paper tape reader, or other known device. Here, if appropriate, the large-capacity memory device 1
It should be noted that the information held in 038 may be incorporated in a general manner as virtual memory occupying a portion thereof in RAM 1036. A specific primary storage device 1034 such as a CD-ROM
The data can be transferred to one direction.

CPU 1032 may also be coupled to one or more input / output devices 1040. Here, the input / output device is a video monitor, a trackball, a mouse, a keyboard, a microphone, a touch display, a transducer card reader, a magnetic or paper tape reader, a tablet, a stylus, a voice or handwriting recognition device, or other devices. Other well-known input devices, such as, but not limited to, a computer. CPU 1032 may be connected to a computer or may be coupled to a communication network, such as the Internet or an intranet, using a network connection generally indicated as 1012. With such a network connection, the CPU
It is believed that 1032 can receive information from and output information to the network when implementing the mechanisms described above for managing resource usage. This information is often represented as a sequence of instructions executed by the CPU 1032, for example, in the form of a computer data signal embedded in a carrier wave,
It can be received from or output to the network. The above-described devices and materials will be familiar to those of skill in the computer hardware and software arts.

Although only a few embodiments of the present invention have been described above, the present invention can be implemented in many other specific forms without departing from the spirit or scope thereof. For example, an operation involving resource management can be reordered (additional order). Further, steps may be omitted or added without departing from the spirit or scope of the present invention.

The techniques for managing resource use according to the present invention are particularly suitable for implementation in the context of a Java environment, but generally include any suitable object. It can be applied to the base environment. These techniques are particularly suitable for use in a platform-independent object-based environment.
It is also necessary to understand that these methods can be realized in a distributed object-oriented system.

Although the registered callbacks are started when the memory usage exceeds the threshold value, these callbacks can be completely eliminated. Once the relevant code set exceeds the maximum threshold, further memory consumption can simply be prevented or minimized. Conversely, do not initiate a registered callback when CPU or network usage by the associated code set exceeds a threshold, but implement a callback when CPU or network usage reaches a limit. Is of course also possible. It is also possible to initiate a callback when the CPU or network usage drops below a threshold.

When the resource context exceeds the limit of any resource, resource reuse is started.
Of course, it is also possible to exclude resource reuse or to start resource reuse only when a certain limit is exceeded. Also, regardless of whether the resource context has exceeded the resource limit, parallel processing may simply periodically trigger resource reuse.

Therefore, the embodiment described above is for the purpose of illustration, and does not limit the content of the present invention. Thus, the present invention is not limited to the details specified herein, but may be modified within the scope and equivalents of the appended claims.

[Brief description of the drawings]

FIG. 1 illustrates the relationship between mechanisms for managing the use of resources, according to one embodiment of the present invention.

FIG. 2A is a flowchart illustrating a process for allocating memory according to an embodiment of the present invention.

FIG. 2B is a flowchart illustrating a process for allocating memory according to an embodiment of the present invention.

FIG. 3 is a flowchart illustrating an operation of reusing resources in FIG. 2 according to an embodiment of the present invention;

FIG. 4 is a flowchart illustrating a process for managing CPU or network usage, according to one embodiment of the present invention.

FIG. 5 illustrates an exemplary general purpose computer system suitable for implementing the present invention.

 ────────────────────────────────────────────────── ─── Continuation of the front page (71) Applicant 591064003 901 SAN ANTONIO ROAD PALO ALTO, CA 94303, US A. (72) Inventor William F.・ Foot, USA 95014 Cupertino, CA #B, Walnut Circle South, 22441

Claims (37)

[Claims] 1. A method for managing resource usage of a particular resource by a set of related codes, wherein the related code includes a resource indicator indicating a resource usage of the particular resource by the related code. Associating; updating the resource indicator if the associated code increases or decreases the total resource usage of the particular resource. 2. The method of claim 1, wherein the value of the resource indicator represents an absolute value of the resource usage. 3. The method of claim 1, wherein the value of the resource indicator represents a relative value of the resource usage. 4. The method according to claim 1, further comprising: associating the relevant code with each resource part of the specific resource allocated to the relevant code; Disassociating each resource part of the specific resource deallocated from a code with the associated code, wherein the resource indicator decreases when a resource part is deallocated from the associated code. , When the resource part is assigned to the related code. 5. The method of claim 4, further comprising: if the resource indicator is less than or equal to a predetermined maximum threshold,
Assigning the particular resource to the associated code, indicating an error if the resource indicator exceeds the predetermined maximum threshold, and not assigning the particular resource. 6. The method of claim 5, wherein the error is indicated by throwing an out_of_memory exception. 7. The method according to claim 4, wherein the related code is separated through a garbage collection procedure. 8. The method according to claim 1, wherein the specific resources are memory usage, open file usage, open socket usage, and monitor usage. , A method selected from the group consisting of: 9. The method of claim 8, wherein the resource indication indicates a percentage of the particular resource used by the associated code. 10. The method according to claim 8 or claim 9, further comprising: associating a plurality of thresholds with the specific resource and the associated code, and using resource of the specific resource by the associated code. A method comprising: notifying a registered resource callback when the amount exceeds a first threshold. 11. The method according to claim 10, further comprising: a resource usage of the specific resource according to the related code is equal to or less than a second threshold having a value different from the first threshold. A method that includes notifying a registered resource callback when it goes down. 12. The method of claim 8, further comprising: registering a registered resource callback when a resource usage of the specific resource by the associated code falls below the first threshold. A method with notifying. 13. The method according to claim 1, wherein the specific resource is a use of a CPU or a use of a network. 14. The method according to claim 13, further comprising: associating a threshold with the specific resource and the associated code, wherein a resource usage of the specific resource by the associated code exceeds the threshold. Indicating that the priority of the related code in CPU usage is downgraded. 15. The method of claim 14, further comprising: associating a second threshold with the specific resource and the associated code, wherein the resource usage of the specific resource by the associated code is When the value falls below the second threshold, the CPU
Indicating to raise the priority of the associated code for use of the associated code. 16. The method of claim 1, wherein the associated code is configured to execute in a thread on behalf of an applet. 17. The method according to any one of claims 1 to 16, further comprising a plurality of resource indicators each indicating a resource usage of a plurality of resources by the association code. A method for associating with a code, comprising: updating a selected resource indicator when the associated code increases or decreases the total resource usage of the associated resource. 18. The method of claim 17, wherein the resources include memory usage, CPU usage, and network usage. 19. The method of claim 18, wherein the resources further include using open files and using open sockets. 20. A computer readable medium comprising computer code for managing resource usage for associating a resource indicator indicating resource usage of the particular resource by the relevant code. A computer readable medium comprising: a computer code for updating the resource indicator when the associated code increases or decreases the total resource usage of the specific resource. 21. The computer readable medium according to claim 20, further comprising: a computer code for associating the relevant code with each resource part of the specific resource allocated to the relevant code; Computer code for separating the relevant code from each resource part of the specific resource deallocated from the relevant code, wherein the resource indicator is such that the resource part is deallocated from the relevant code. A computer-readable medium that decreases in cases and increases when a resource portion is assigned to the associated code. 22. The method according to claim 20 or claim 21, further comprising: if the resource indicator is less than or equal to a predetermined maximum threshold;
Computer code for assigning the specific resource to the associated code; and computer code for indicating an error and not assigning the specific resource if the resource indicator exceeds the predetermined maximum threshold. The equipped method. 23. The computer-readable medium according to claim 20, wherein the specific resource is a group consisting of a memory, an open file, an open socket, and a monitor. The computer readable medium selected. 24. The computer readable medium according to claim 23, further comprising: a computer code for associating a plurality of thresholds with the specific resource and the associated code; A computer-readable medium comprising: computer code for notifying a registered resource callback when a resource usage of a specific resource exceeds a first threshold. 25. The computer-readable medium according to claim 23, further comprising: a second resource having a value different from the first threshold in a resource usage of the specific resource by the related code. A computer-readable medium comprising computer code for notifying a registered resource callback when the value falls below a threshold. 26. The computer readable medium according to claim 20, wherein the specific resource is a use of a CPU or a use of a network. 27. The computer readable medium of claim 26, further comprising: a computer code for associating a threshold with the specific resource and the associated code; and the specific resource by the associated code. And computer code for indicating that if the resource usage exceeds the threshold, the priority of the related code in CPU usage is downgraded. 28. The computer readable medium of claim 27, further comprising: a computer code for associating a second threshold with the specific resource and the associated code; When the resource usage of a specific resource falls below the second threshold, the CPU
And computer code for indicating that the priority of the associated code is to be raised in the use of the computer-readable medium. 29. The method according to claim 20, wherein the associated code is configured to be executed in a thread on behalf of an applet. 30. A computer system for managing resource usage by an associated code set, comprising: a resource context associated with the associated code set, associated with a resource type, wherein the resource type is associated with the associated code set. A resource context having a resource indicator indicating how much of the resource type is used by the associated code set. And wherein the associated code set is configured to increment the resource indicator of the resource context when increasing resource usage of the resource type associated with the updated resource indicator. A computer system with an update mechanism. 31. The computer system of claim 30, wherein the resource object indicates a maximum resource usage of the resource type by the associated code set.
Computer systems that have an associated maximum limit. 32. The computer system of claim 31, wherein the resource object has a first associated limit lower than the maximum limit, the computer system further comprising: A computer system comprising an alarm configured to alert the code set when resource usage exceeds the first limit. 33. The computer system of claim 32, wherein the alarm is further configured to revise the code set if resource usage by the associated code set returns below the first limit. Computer system. 34. The computer system of claim 32 or claim 33, wherein the resource object has a second associated limit that is less than the first limit, and wherein the alarm further comprises the associated A computer system configured to revise the associated code set if resource usage by the code set falls below the second limit again after exceeding the first limit. 35. The computer system according to claim 30, wherein the resource types are memory usage, CPU usage, network usage, open file usage, A computer system selected from the group consisting of using an open socket and using a monitor. 36. The computer system according to any of claims 30 to 35, wherein the update mechanism further comprises: any resources of the resource type assigned on behalf of an associated code of the resource context. A computer system configured to map the resource context to a part. 37. The computer system according to claim 30, wherein the related code set of the resource context is:
A computer system associated with a single protection domain.