Abstract: A method may include generating, for a host application, an image including an image heap including objects and a writeable object partition including a subset of the objects. The method may further include initializing, by executing the image in a process of a computer system, a first isolate including a first address space and a first read-only map of the image heap. The first read-only map may designate the writeable object partition of the image heap as copy-on-write. The method may further include initializing, by executing the image in the process, a second isolate including a second address space and a second read-only map of the image heap. The method may further include performing, in the first isolate and using the first read-only map, a first task that accesses an object, and performing, in the second isolate and using the second read-only map, a second task that accesses the object.

Abstract: A method may include generating, for a host application, an image including an image heap including objects and a writeable object partition including a subset of the objects. The method may further include initializing, by executing the image in a process of a computer system, a first isolate including a first address space and a first read-only map of the image heap. The first read-only map may designate the writeable object partition of the image heap as copy-on-write. The method may further include initializing, by executing the image in the process, a second isolate including a second address space and a second read-only map of the image heap. The method may further include performing, in the first isolate and using the first read-only map, a first task that accesses an object, and performing, in the second isolate and using the second read-only map, a second task that accesses the object.

Abstract: A system that allocates memory for immutable data on a computing device. The system allocates a memory region on the computing device to store immutable data for an executing application. This memory region is smaller than the immutable data for the application. When the system subsequently receives a request to access a block of immutable data for the application, the system allocates space in this memory region for the block, and proceeds to load the block into the memory region. If at a later time the space occupied by this first block is needed for another block, the system unloads and discards the first block. If a subsequent operation needs to use information in the first block, the system regenerates the block by transforming raw data associated with the block into a form that can be directly accessed by the application, and then reloads the block into the memory region.

Abstract: A system that allocates memory for immutable data on a computing device. The system allocates a memory region on the computing device to store immutable data for an executing application. This memory region is smaller than the immutable data for the application. When the system subsequently receives a request to access a block of immutable data for the application, the system allocates space in this memory region for the block, and proceeds to load the block into the memory region. If at a later time the space occupied by this first block is needed for another block, the system unloads and discards the first block. If a subsequent operation needs to use information in the first block, the system regenerates the block by transforming raw data associated with the block into a form that can be directly accessed by the application, and then reloads the block into the memory region.

Abstract: One embodiment of the present invention provides a system that allocates memory for immutable data on a computing device. During operation, the system receives an application to be executed on the computing device. Next, the system allocates a memory region on the computing device to store immutable data for the application. Note that this memory region is smaller than the immutable data for the application. When the system subsequently receives a request to access a block of immutable data for the application, the system allocates space in this memory region for the block, and proceeds to load the block into the memory region. However, if at a later time the space occupied by this first block is needed for another block, the system unloads and discards the first block.

Abstract: One embodiment of the present invention provides a system that reduces the number of heap handles in a program. First, the system builds an intermediate representation of the program. The system then analyzes the intermediate representation to determine whether executing a function may cause a garbage-collection operation. If so, the system further analyzes the program to determine whether a heap handle in the program is defined and/or used in proximity to a call to the function. Next, the system determines whether the heap handle can be replaced by an ordinary pointer, in order to facilitate subsequently converting the heap handle to an ordinary pointer, if possible. Note that converting a heap handle to an ordinary pointer reduces the space requirements for the program and increases the speed and efficiency of the program and garbage collection operations.

Abstract: One embodiment of the present invention provides a system that determines whether a data structure, such as an array, is modifiable. First, the system loads a source file for a class. The system then examines the source file to identify a set of data structures in the class, and uses escape analysis to determine whether each data structure is modifiable. The system then performs an action based on the determination. In a variation on this embodiment, if the data structure is not determined to be modifiable, performing the action involves storing the data structure in a read-only memory (ROM) instead of a random-access memory (RAM), which leaves more RAM available for other purposes.

Abstract: Systems and methods for the efficient handling of rare events by modification of executable code is provided. The present invention eliminates the need for event checking code and handling in the primary execution path of compiled code by using a patch table to modify code during execution. Accordingly, event handling does not introduce additional instructions to the primary execution path, and thus will not interfere with compiler optimizations for maximal performance along the primary execution path. The present invention, therefore, provides event handling for events that occur rarely while reducing the size of the code for execution on memory-constrained devices.

Abstract: One embodiment of the present invention provides a system that facilitates managing compiled program methods in a unified heap. The system partitions the unified heap into a first area and a second area. This allows the system to store objects other than compiled program methods and temporary compiler data structures in the first area, and to store compiled program methods and temporary compiler data structures in the second area.

Abstract: A mechanism is disclosed for enabling virtual method dispatch structures (vstructures) to be created on an as-needed basis. When an object class is loaded, a vstructure specific to that object class is not created. Rather, the vstructure for that object class is created only if and when a virtual method of that object class is invoked. By creating vstructures on an as-needed basis, the number of vstructures created during the execution of a program is minimized. This in turn reduces the number of vstructures that need to be updated whenever a reference to a method is changed (for example, as a result of a garbage collection operation). To further optimize the efficiency of the vstructure update process, vstructure entries that point to the same method may be linked. That way, when the reference to a method is changed, all vstructures affected by that change can be quickly identified.

Abstract: Techniques for selectively promoting objects in a generational garbage collector are provided. Rather than using a single promotion policy, information about objects are used to determine and effectively enforce a suitable promotion policy for them. This information, for example, may be information about the general context under which the object is allocated or executed, or it may pertain to a particular operation, thread, function (or method) where garbage is likely to be generated and/or mostly garbage is generated. When it is determined that garbage is likely to be generated or mostly garbage is to be generated, a more suitable promotion policy can be enforced rather than a general (or normal). Objects are allocated using two or more memory allocators. Typically, objects that are likely to be garbage are allocated in a manner that effectively delays or bars their promotion to the next generation.

Abstract: One embodiment of the present invention provides a method and a system for synchronous detection and signaling of memory quota violations for sequential memory allocation in a shared heap. The system detects a potential quota violation if a check of approximate memory usage indicates that an attempt to allocate memory may violate a task's memory quota. Upon detecting such a potential quota violation, the system proceeds to reconcile the task's exact memory usage. If the task's exact memory usage violates the task's memory quota, the system signals a synchronous quota violation at the time of the violation. Synchronously signaling quota violations in this manner provides accurate quota violation detection and signaling without reducing the performance of sequential memory allocation. The method also improves the accuracy of approximate per-task memory usage tracking by reconciling exact memory usage when an estimate of the task's memory usage exceeds the task's memory quota.

Abstract: A method is disclosed for reducing dynamic pauses during dynamic compilation. Applications running on a system detect the rendering of dynamic output to a user. The dynamic output represents a change in visual or audio data while any application is running. When an application detects such output it notifies the system, which monitors the frequency of the dynamic output. If the frequency of the dynamic output exceeds a threshold, the system informs a compiler on the system to suspend compilation. Compilation normally occurs when an interpreter on the system is instructed to pass processing control to the compiler. One way this occurs is if a method currently being processed by the interpreter has been marked for compilation. Thus, in order to suspend compilation, the compiler ceases to mark methods for compilation so that the interpreter will not be instructed to pass processing control to the compiler.

Abstract: Apparatus, methods and computer program products are disclosed to improve allocation of physical memory in a memory limited device when the amount of unallocated memory approaches a threshold. In this situation the disclosed technology will identify memory pages that have substantially the same content, identify the process-contexts that map to the identified memory pages, remap these process-contexts to one of the identical memory pages, recycle all of the other identical memory pages to increase the amount of unallocated memory, and conditions the process-contexts to appropriately trap accesses to the mapped page.

Abstract: One embodiment of the present invention provides a method and a system for patching a set of objects containing references. The system uses a location structure to keep track of the locations of references within the set of objects. During the patching process, the system converts the references within the set objects from an absolute form into an offset-based form, where offsets are computed with respect to base addresses of objects. The system then applies an offset-based patch to the set of objects and to the location structure using a binary-patching technique. After applying the patch, the system converts the references in the set of objects back into absolute form. By using an offset-based patch, the system reduces the number of reference changes that need to be specified in the patch, thereby reducing the size of the patch.

Abstract: One embodiment of the present invention provides a system that allocates memory for immutable data on a computing device. During operation, the system receives an application to be executed on the computing device. Next, the system allocates a memory region on the computing device to store immutable data for the application. Note that this memory region is smaller than the immutable data for the application. When the system subsequently receives a request to access a block of immutable data for the application, the system allocates space in this memory region for the block, and proceeds to load the block into the memory region. However, if at a later time the space occupied by this first block is needed for another block, the system unloads and discards the first block.

Abstract: One embodiment of the present invention provides a method and a system for tracking memory usage of tasks in a shared heap. The system performs a full garbage-collection operation on the shared heap, during which a base memory usage is determined for each task. The system then periodically samples task state during execution to generate an estimate of newly allocated memory for each task. The base memory usage and the estimate of newly allocated memory for each task are combined to produce an estimate of current memory usage for each task. This estimate of current memory usage is used to determine whether a task is likely to be violating a memory quota. If so, the system triggers a remedial action, which can include: a full garbage-collection operation; a generational garbage-collection operation; or generation of a signal which indicates that a memory quota violation has occurred.

Abstract: One embodiment of the present invention provides a system that facilitates determining a frequency of execution of compiled methods within a virtual machine. The system starts by determining if a compiled method is executing. If so, the system sets a flag corresponding to the compiled method to indicate that the compiled method is executing. Periodically, the system scans the flag and increments the value of a corresponding counter if the flag is set, and then resets the flag. Finally, the system analyzes the value of the counter to determine a frequency of execution of the compiled method.

Abstract: One embodiment of the present invention provides a system that facilitates keeping track of memory usage of tasks in a shared heap. The system operates by performing a garbage collection operation on the shared heap, wherein the garbage collection operation is a compacting garbage collection operation which preserves the ordering of objects within the shared heap. The system determines a memory usage for each task in the shared heap by adding the memory usage for intervals containing objects for each task in the shared heap to the memory usage count for each task to produce an actual memory usage for each task. This garbage collection may or may not be a generational garbage collection operation.

Abstract: A method is disclosed for reducing dynamic pauses during dynamic compilation. Applications running on a system detect the rendering of dynamic output to a user. The dynamic output represents a change in visual or audio data while any application is running. When an application detects such output it notifies the system, which monitors the frequency of the dynamic output. If the frequency of the dynamic output exceeds a threshold, the system informs a compiler on the system to suspend compilation. Compilation normally occurs when an interpreter on the system is instructed to pass processing control to the compiler. One way this occurs is if a method currently being processed by the interpreter has been marked for compilation. Thus, in order to suspend compilation, the compiler ceases to mark methods for compilation so that the interpreter will not be instructed to pass processing control to the compiler.