Abstract: The present invention provides a deployment platform that enables solution modules to be created and deployed without writing new code. The solution modules may include existing solutions, solution components, connectors, and the like selected from a solution library. The deployment platform includes a development engine providing functionality for generating deployment information for the solution module. The deployment information may include a blueprint or other information for deploying the solution module to target infrastructure. The deployment platform also includes a deployment engine providing functionality for deploying the solution module to the target infrastructure automatically. During deployment, the deployment engine pushes components of the solution module to the target infrastructure in accordance with the deployment information.

Abstract: Methods and systems for compression of aging data during compaction are disclosed. A method includes: ingesting a plurality of data objects into a dispersed storage network (DSN); determining that a compaction threshold is met for a storage medium in the DSN; and compacting the storage medium, the compaction including, for each of the plurality of data objects: determining a number of times the data object has been compacted; in response to the number of times the data object has been compacted exceeding a predetermined threshold, compressing the data object and rewriting the compressed data object to a new area on a storage medium; and in response to the number of times the data object has been compacted not exceeding the predetermined threshold, rewriting the data object to the new area on the storage medium without compressing the data object.

Abstract: Techniques are provided for the scheduling of file pre-fetches from a file system into a cache memory, to reduce subsequent latency associated with future accesses to those files. A methodology implementing the techniques according to an embodiment includes monitoring accesses to files of the file system (e.g., file open and file read operations) and maintaining a record for each of the accessed files. The record includes an identifier of the file, the number of accesses of the file, and the number of cache memory misses associated with those accesses. The method also includes storing the record into a file access history database (FAHD). The method further includes generating, in response to an Operating System (OS) shutdown, a frequently used file list (FUFL) based on the FAHD. The method further includes pre-fetching files identified by a selected subset of the FUFL to the cache memory during an OS boot.

Abstract: Systems and techniques are provided for mutable data ingestion and storage. Data for a database may be received at a computing device. New data from the data for the database may be stored as a mutable data chunk. The data for the database may be determined to include updated data for a previously stored mutable data chunk. The updated data may be applied to the previously stored mutable data chunk to update the previously stored mutable chunk. A second previously stored mutable data chunk may be determined to have been initially stored a specified amount of time ago. In response to determining that the second previously stored mutable data chunk was initially stored the specified amount of time ago, the second previously stored mutable data chunk may be caused to become an immutable data chunk.

Abstract: Garbage collection (GC) to reclaim memory in computing systems sometimes suspends applications, web services, and other mutator programs in order to scan their execution stacks, which reduces their responsiveness. But suspension times are decreased by behavior-driven stack scan optimization (BDSSO) functionality that increases the concurrency of mutator execution with GC stack scanning. BDSSO obtains execution stack frame occurrence data, determines frame execution likelihoods, selects a stack scan depth based on the likelihoods, and installs a scan return barrier at the selected depth. Then the GC scans the execution stack below the barrier while the mutator runs, thus increasing concurrency and improving mutator responsiveness. Selected barrier locations vary according to actual stack activity to provide optimized concurrency instead of using an inflexible approach to barrier placement. Existing profiler samples or virtual machine interfaces can be reused by BDSSO.

Abstract: Techniques for determining an age category for an object and identifying objects for memory leak analysis based on age categories are described. An age category classifier generates a set of age categories, each corresponding to a respective time interval. The age category classifier monitors garbage collection processes on the heap. The age category classifier determines a current age category based on a duration of time that has elapsed between (a) an initiation of a current garbage collection cycle and (b) a reference event. The age category classifier identifies objects transferred from one object group to another object group during the current garbage collection cycle. The age category classifier stores the current age category as the transfer age category in the headers of the transferred objects. The transfer age categories of the objects may be used for reducing the number of objects that are analyzed in a memory leak analysis.

Abstract: Garbage collection methods and systems include adding a data object to one of multiple queues owned by a first garbage collection thread. The queues include a public queue and multiple private queues. A task is popped from one of the plurality of queues to perform garbage collection. The public queue is swapped with one of the private plurality of private queues if there are no tasks in the public queue.

Abstract: Garbage collection methods include adding a data object to one of multiple queues owned by a first garbage collection thread. The queues include a public queue and multiple private queues. A task is popped from one of the plurality of queues to perform garbage collection. The public queue is swapped with one of the private plurality of private queues if there are no tasks in the public queue.

Abstract: Managing memory allocations in a computer system may include tagging a class of data structures with a tag that identities a longer memory-allocation time for objects that correspond to the class. In response to a memory-allocation request for an object, whether or not the object is associated with the tag can be determined through the class. If the object is not associated with the tag, memory can be allocated for the object from a first memory-allocation area that corresponds to a shorter memory-allocation time, and if the object is associated with the tag, memory can be allocated for the object from a second memory-allocation area that corresponds to the longer memory-allocation time.

Abstract: This application relates to receiving, by a processing device executing a virtual machine, bytecode including an object to be loaded into a memory space, the object being tagged with a garbage collection descriptor. The garbage collection descriptor is generated according to an annotation to the object in a source code. The application further provides for determining, in view of the garbage collection descriptor, a region of the memory space to store the object, in which the memory space includes a first region to store a first set of objects that have survived less than a determined number of rounds of garbage collection and a second region to store a second set of objects that have survived at least the determined number of rounds of garbage collection in the first region. The application further provides for storing the object in the region of the memory space and adding the object to one of the first objects or the second set of objects in view of the region.

Abstract: Systems and methods for determining garbage collection (GC) scope in a distribute storage system using chunk-based storage. The systems and methods are compatible with multi-version concurrency control (MVCC) semantics.

Abstract: A method for collection instance resizing. The method may include identifying at least one collection object within a collection framework of a virtual machine. The method may also include determining the at least one identified collection object satisfies at least one preconfigured criteria. The method may further include determining a garbage collection cycle count associated with the at least one identified collection object exceeds a preconfigured threshold. The method may also include determining an occupancy ratio associated with the at least one identified collection object is less than a preconfigured shrink threshold. The method may further include restructuring the at least one identified collection object based on the at least one identified collection object satisfying the at least one preconfigured criteria, the garbage collection cycle count exceeding the preconfigured threshold, and the occupancy ratio being less than the preconfigured shrink threshold.

Abstract: A rapid virtual machine (VM) cloning technique is provided that creates cloned VMs on hosts from multiple source VMs, rather than a single source VM that may otherwise be a bottleneck. The described technique selects particular hosts, disposed in particular racks, on which to create VM clones in a dynamic manner that reduces total deployment time for the plurality of VMs. A rapid VM reconfiguration technique is also provided that reduces the time spent reconfiguring the provisioned VMs for use in a distributed computing application.

Abstract: A method, system and computer program product for optimally allocating objects in a virtual machine environment implemented on a NUMA computer system. The method includes: obtaining a node identifier; storing the node identifier in a thread; obtaining an object identifier of a lock-target object from a lock thread; writing a lock node identifier into the lock-target object; traversing an object reference graph where the object reference graph contains an object as a graph node, a reference from the first object to a second object as an edge, and a stack allocated to a thread as the root node; determining whether a move-target object contains the lock node identifier; moving the move-target object to a subarea allocated to a lock node if it contains the lock node identifier, and moving the move-target object to the destination of the current traversal target object if the lock node identifier is not found.

Abstract: An apparatus, system, and method are disclosed for data block usage information synchronization for a non-volatile storage volume. The method includes referencing first data block usage information for data blocks of a non-volatile storage volume managed by a storage manager. The first data block usage information is maintained by the storage manager. The method also includes synchronizing second data block usage information managed by a storage controller with the first data block usage information maintained by the storage manager. The storage manager maintains the first data block usage information separate from second data block usage information managed by the storage controller.

Abstract: A method to schedule garbage collection operations may be executed in a client/server system using multiple servers. The method includes comparing usage of memory in respective ones of the plurality of servers to one or more memory usage thresholds and dynamically identifying one or more servers in which to perform garbage collection of memory objects during a particular time period. By distributing the durations over which garbage collection is performed on respective servers, the client server system, among other things, reduces the pauses in servicing client requests.

Abstract: A system includes computer-readable storage media encoded with code defining a computer process. The computer process is configured to monitor its own resource utilization so that it can detect a resource-utilization condition. In response to a detection of the utilization condition, the computer process causes its own resource utilization to be reduced.

Abstract: Embodiments of the invention enhance a garbage collection process running on a parallel system or distributed computing environment. Using a garbage collector in such an environment allows a more in-depth analysis to be performed than is possible on other systems. This is because the number of compute nodes present in many parallel systems, and the connections between them, allows the overhead of doing advanced analysis to be spread across the nodes and the results of that analysis to be shared among the nodes.

Abstract: Aspects for conservative garbage collecting are disclosed. In one aspect, root objects included in a call stack are identified, which comprise integers and pointers. Integer representations are tagged and distinguishable from untagged pointer representations. Root objects are traced to corresponding memory locations such that a subsequent tracing is performed on the pointer representations and skipped on the integer representations. Memory allocated to objects unreachable by the call stack is then freed. In another aspect, an object graph associated with a call stack is tagged, and a heap is generated comprising objects included in an executed portion of the call stack. Objects included in an unexecuted portion of the call stack are traced to corresponding memory locations on the heap such that a subsequent tracing is only performed on the untagged pointer representations. Memory locations corresponding to heap objects unreachable by the unexecuted portion of the call stack are then cleared.

Abstract: System and Methods for time based object aging for generational garbage collectors are provided. Time data is received from a user identifying the amount of time an object should survive in a generation defined in a heap. Generational garbage collection is performed, and objects are promoted from one generation to the next oldest generation based on the time data received.

Abstract: A system and method for use with garbage collected systems and languages, for enabling an allocated heap memory to be updated (e.g., increased or decreased) at runtime, subject to sufficient availability of physical memory. In accordance with an embodiment, a Java Virtual Machine (JVM) is associated with a management console, which allows a systems administrator to monitor current heap utilization at runtime. The heap is visualized as a contiguous chunk of memory with one or more extension points, e.g., by use of a trailing pointer to a null list. If later, at runtime, the heap size needs to be incremented then the trailing pointer can be set to a new chunk of memory with a size of (new value?old value), so that the cumulative new size is made equal to a new value specified on the console.

Abstract: A generational garbage collector utilizes a pool-based heap to store objects dynamically generated at runtime. The pool-based heap is configured as a collection of pools where each pool stores objects associated with the same generation. Each pool contains a pool header that identifies the generation of all objects within the pool. The pools are aligned to a memory boundary that is a multiple of the pool size. Select bits of an object's memory address may be used to access the pool header so that an object's generation, which is needed in various phases of the garbage collection process, is readily determined.

Abstract: A disclosed method includes: specifying a first object pointed by a first pointer, wherein the first object is in a heap area that includes plural generational areas; determining whether or not an address in a generational area, which is different from a first generational area that includes the first object, is set as a movement destination address of the first object; upon determining that the address is set as the movement destination address of the first object, obtaining the movement destination address of the first object; and updating the first pointer with the movement destination address of the first object.

Abstract: A system and method for efficient garbage collection. A general-purpose central processing unit (CPU) sends a garbage collection request and a first log to a special processing unit (SPU). The first log includes an address and a data size of each allocated data object stored in a heap in memory corresponding to the CPU. The SPU has a single instruction multiple data (SIMD) parallel architecture and may be a graphics processing unit (GPU). The SPU efficiently performs operations of a garbage collection algorithm due to its architecture on a local representation of the data objects stored in the memory. The SPU records a list of changes it performs to remove dead data objects and compact live data objects. This list is subsequently sent to the CPU, which performs the included operations.

Abstract: The present disclosure describes garbage collection that provides prompt reclamation of large objects. A heap space is divided into Young regions, Old regions, and Humongous regions. A remembered set is created and maintained, during the execution of one or more programs, for each region that specifies where there are references from outside the region to inside the region. A garbage collection list is generated specifying regions to perform garbage collection on. All Young regions and at least one Humongous region are included in the garbage collection list. If it is determined to include Old regions, the Old regions are selected and included in the garbage collection list. Then, a garbage collection is performed on the regions specified in the garbage collection list. During the garbage collection, the indication for each region is utilized to determine reachable objects in the region, ensuring that reachable objects are not deallocated.

Abstract: A garbage collector includes a core, and extension handlers to support collection of objects of a designated managed class. The handler, which may be implemented in managed code, receives notification of garbage collection phases, and receives control from the core when the core encounters an object of the designated class. The handler can then thread together discovered objects of the designated class, walk a list of objects and detect whether any are unreachable, and/or provide an executor for the designated class. The core notifies handlers about progress in tracing strong pointers, tracing weak pointers, pointer update, pinning, weak pointer forwarding, and untraced pointer relocation. A pointer can be marked as untraced, so the core ignores it during pointer tracing phases. If the core encounters an object which has a weak pointer field, the core can pass control to a handler's tracing method. The core may perform generational garbage collection.

Abstract: Reclaiming data space by rewriting metadata is disclosed. It is determined that fewer than all of the previous version data included in a write is required to be retained, e.g., beyond a continuous data protection window. A metadata record associated with the write is modified to point only to those blocks in which previous version data that is still required to be retained is stored. Other blocks become eligible for reclamation.

Abstract: System and Methods for time-based object aging for generational garbage collectors are provided. Time data is received from a user identifying the amount of time an object should survive in a generation defined in a heap. A circular buffer is generated to store a plurality of starting time for a plurality of garbage collections. Generational garbage collection is performed, and the time data in conjunction with the starting times stored in the circular buffer are used to determine when objects are promoted from one generation to the next oldest generation.

Abstract: The reconstruction of garbage collection information corresponding to an application. Upon accessing a portion of compiler generated application code, a computing system generates computational results that identifies one or more program state storage locations that track live references or memory pointers that can be displaced during garbage collection. This may be performed for multiple application code portions (such as methods or functions of an application), and may be performed just before garbage collection. To generate the computational results, the application code portion may first be subjected to a liveness analysis to generate liveness analysis results in the form of one or more live program state storage locations in the application code portion. The computational results may then be generated using the liveness analysis results and type information from a type service to provide the set of storage locations referencing live memory objects.

Abstract: A method and system for managing one or more memory resources of a wireless handheld computing device is described. The method and system may include receiving a request to initiate a web browser module and receiving input for a web address. The method and system may also include receiving a file corresponding to the web address and reviewing one or more objects present within the file. The method and system may determine if an object already exists in the one or more memory resources. And if the object does not exist in the one or more memory resources, then the method and system may calculate a priority for the object. The priority of the object may then be assigned and stored. It may also be determined if the current object will exceed the threshold of the one or more memory resources, and discarding other objects with lower priority as needed.

Abstract: A virtual memory management unit can implement various techniques for managing paging space. The virtual memory management unit can monitor a number of unallocated large sized pages and can determine when the number of unallocated large sized pages drops below a page threshold. Unallocated contiguous smaller-sized pages can be aggregated to obtain unallocated larger-sized pages, which can then be allocated to processes as required to improve efficiency of disk I/O operations. Allocated smaller-sized pages can also be reorganized to obtain the unallocated contiguous smaller-sized pages that can then be aggregated to yield the larger-sized pages. If allocated smaller-sized pages belonging to a second process cannot be de-allocated by reorganizing, the second process can be terminated to de-allocate the pages. Furthermore, content can also be compressed before being written to the paging space to reduce the number of pages that are to be allocated to processes.

Abstract: System and Methods for time-based object aging for generational garbage collectors are provided. Time data is received from a user identifying the amount of time an object should survive in a generation defined in a heap. A circular buffer is generated to store a plurality of starting time for a plurality of garbage collections. Generational garbage collection is performed, and the time data in conjunction with the starting times stored in the circular buffer are used to determine when objects are promoted from one generation to the next oldest generation.

Abstract: System and Methods for time based object aging for generational garbage collectors are provided. Time data is received from a user identifying the amount of time an object should survive in a generation defined in a heap. Generational garbage collection is performed, and objects are promoted from one generation to the next oldest generation based on the time data received.

Abstract: A system and method for efficient garbage collection. A general-purpose central processing unit (CPU) partitions an allocated heap according to a generational garbage collection technique. The generations are partitioned into fixed size cards. The CPU marks indications of qualified dirty cards during application execution since the last garbage collection. When the CPU detects a next garbage collection start condition is satisfied, the CPU sends a notification to a special processing unit (SPU) corresponding to a determination of one or more card root addresses, each card root address corresponding to one of said marked indications. The SPU has a single instruction multiple data (SIMD) parallel architecture and may be a graphics processing unit (GPU). The SPU may utilize the parallel architecture of its SIMD core to simultaneously compute multiple card root addresses. Following, the SPU sends these addresses to the CPU to be used in a garbage collection algorithm.

Abstract: A system and method for efficient garbage collection. A general-purpose central processing unit (CPU) sends a garbage collection request and a first log to a special processing unit (SPU). The first log includes an address and a data size of each allocated data object stored in a heap in memory corresponding to the CPU. The SPU has a single instruction multiple data (SIMD) parallel architecture and may be a graphics processing unit (GPU). The SPU efficiently performs operations of a garbage collection algorithm due to its architecture on a local representation of the data objects stored in the memory. The SPU records a list of changes it performs to remove dead data objects and compact live data objects. This list is subsequently sent to the CPU, which performs the included operations.

Abstract: Aspects for conservative garbage collecting are disclosed. In one aspect, root objects included in a call stack are identified, which comprise integers and pointers. Integer representations are tagged and distinguishable from untagged pointer representations. Root objects are traced to corresponding memory locations such that a subsequent tracing is performed on the pointer representations and skipped on the integer representations. Memory allocated to objects unreachable by the call stack is then freed. In another aspect, an object graph associated with a call stack is tagged, and a heap is generated comprising objects included in an executed portion of the call stack. Objects included in an unexecuted portion of the call stack are traced to corresponding memory locations on the heap such that a subsequent tracing is only performed on the untagged pointer representations. Memory locations corresponding to heap objects unreachable by the unexecuted portion of the call stack are then cleared.

Abstract: An apparatus, system, and method are disclosed for managing data with an empty data segment directive at the requesting device. The apparatus, system, and method include a token directive generation module and a token directive transmission module. The token directive generation module generates a storage request with a token directive. The token directive includes a request to store on the storage device a data segment token. The token directive substitutes for a series of repeated, identical characters or a series of repeated, identical character strings to be stored as a data segment. The token directive includes at least a data segment identifier and a data segment length. The data segment token and the token directive are substantially free from data of the data segment. The token directive transmission module transmits the token directive to the storage device.

Abstract: A list of data structures (e.g., inodes) can be accessed, and the data structures in the list can be examined. If a data structure is examined, a counter value associated with the data structure is changed to a generation number that is associated with the examination. Subsequently, the counter values can be used to identify unreferenced data structures. More specifically, the counter value for an unreferenced data structure will be different from the generation number for the most recently performed examination.

Abstract: A system of the present invention includes a storage device for distinguishably storing old objects that are objects having existed for not less than a predetermined period since being generated and new objects that are objects having existed for less than the predetermined period since being generated. Then, a new object that has existed for less than the predetermined period since being generated is selected from the storage device, and an old object having the same content as the selected new object is searched for. If such an old object is not found, the selected new object is newly stored as an old object in the storage device. If the old object is found, a reference to the selected new object is integrated with a reference to the found old object. If the old object is stored, the reference to the selected new object is changed to a reference to the stored old object.

Abstract: The techniques and mechanisms described herein are directed to a system for performing garbage collection on a large heap that is divided into several cards which are grouped into bundles. The techniques include initiating a write-watch mechanism to track accesses to a card table that identifies marked cards. The write-watch mechanism provides a list of the written card table locations to a garbage collection process which determines marked bundles based on the list. For each marked bundle, the marked cards within the marked bundle are scanned to identify the accessed objects. The accessed objects are then collected. Because determining the marked bundles is performed at the start of the garbage collection process and not whenever the memory locations within the bundle are accessed, the present technique reduces the overhead associated with bundle marking and allows the efficiency of the garbage collection process to be less dependent on heap size.

Abstract: A memory management method and a system for performing garbage collection. The method includes the steps of providing in a memory space a heap partitioned into a plurality of areas including an area for object allocation and a To area for future object allocation. In garbage collection, an object reachable from a root set among objects allocated in the area of use is copied into the To area. In addition, a finalizable object among the objects allocated in the area of use is set as a finalization target. Here, the finalizable object is an object unreachable from the root set and has a finalize method. After the garbage collection is completed, the finalizable object of finalization target allocated in the area of use is finalized.

Abstract: Instruction execution includes fetching an instruction that comprises a first set of one or more bits identifying the instruction, and a second set of one or more bits associated with a first address value. It further includes executing the instruction to determine whether to perform a trap, wherein executing the instruction includes selecting from a plurality of tests at least one test for determining whether to perform a trap and carrying out the at least one test.

Abstract: A garbage collection algorithm that achieves hierarchical copy order with parallel garbage collection threads. More specifically, the present invention provides a garbage collection method and system for copying objects from a from-space to a to-space. The method comprises the steps of (a) having multiple threads that simultaneously perform work for garbage collection (GC), (b) examining the placement of objects on blocks, and (c) changing the placement of objects on blocks based on step (b). Preferably, the method includes the additional step of calculating a placement of object(s) based on step (b), and using the result of the calculation for step (c). For example, the calculation may be used to increase the frequency of intra-block pointers and/or to increase the frequency of siblings on the same block.

Abstract: Apparatus, systems, and methods are disclosed that operate to monitor the occurrence of memory garbage collection events and node content service requests, to determine a correlation between the node content service requests and the memory garbage collection events, and to report information associated with suspicious ones of the node content service requests. Suspicious requests may be identified as those that satisfy a preselected criteria associated with the correlation. Additional apparatus, systems, and methods are disclosed.

Abstract: A garbage collection algorithm that achieves hierarchical copy order with parallel garbage collection threads. More specifically, the present invention provides a garbage collection method and system for copying objects from a from-space to a to-space. The method comprises the steps of (a) having multiple threads that simultaneously perform work for garbage collection (GC), (b) examining the placement of objects on blocks, and (c) changing the placement of objects on blocks based on step (b). Preferably, the method includes the additional step of calculating a placement of object(s) based on step (b), and using the result of the calculation for step (c). For example, the calculation may be used to increase the frequency of intra-block pointers and/or to increase the frequency of siblings on the same block.

Abstract: The present disclosure describes garbage collection that provides prompt reclamation of large objects. A heap space is divided into Young regions, Old regions, and Humongous regions. A remembered set is created and maintained, during the execution of one or more programs, for each region that specifies where there are references from outside the region to inside the region. A garbage collection list is generated specifying regions to perform garbage collection on. All Young regions and at least one Humongous region are included in the garbage collection list. If it is determined to include Old regions, the Old regions are selected and included in the garbage collection list. Then, a garbage collection is performed on the regions specified in the garbage collection list. During the garbage collection, the indication for each region is utilized to determine reachable objects in the region, ensuring that reachable objects are not deallocated.

Abstract: A garbage collection algorithm that achieves hierarchical copy order with parallel garbage collection threads. More specifically, the present invention provides a garbage collection method and system for copying objects from a from-space to a to-space. The method comprises the steps of (a) having multiple threads that simultaneously perform work for garbage collection (GC), (b) examining the placement of objects on blocks, and (c) changing the placement of objects on blocks based on step (b). Preferably, the method includes the additional step of calculating a placement of object(s) based on step (b), and using the result of the calculation for step (c). For example, the calculation may be used to increase the frequency of intra-block pointers and/or to increase the frequency of siblings on the same block.

Abstract: A method, system and computer program product for optimally allocating objects in a virtual machine environment implemented on a NUMA computer system. The method includes: obtaining a node identifier; storing the node identifier in a thread; obtaining an object identifier of a lock-target object from a lock thread; writing a lock node identifier into the lock-target object; traversing an object reference graph where the object reference graph contains an object as a graph node, a reference from the first object to a second object as an edge, and a stack allocated to a thread as the root node; determining whether a move-target object contains the lock node identifier; moving the move-target object to a subarea allocated to a lock node if it contains the lock node identifier, and moving the move-target object to the destination of the current traversal target object if the lock node identifier is not found.

Abstract: A system and method is provided for efficiently pinning references to the managed heap. The system and method allow for references to managed objects to be declared as pinned during a call to unmanaged code. The references are then reported as pinned to a garbage collector in response to invocation of a garbage collection service. The reference can be declared as pinned by a programmer within the source code or automatically invoked at run-time based on an unsafe condition. The garbage collection service will not move or relocate objects that are referenced by the active pinned local variables. If a garbage collection does not occur, the fact that the local variables are declared pinned is ignored.

Abstract: A system and method are provided for object age detection in garbage collection heaps. In one embodiment, ages of objects in a garbage collection heap at a first virtual machine at a server are determined by detecting a number of garbage collections each object has survived. An age is associated to each object according to the determined ages. The objects are grouped in age ranges, wherein the age ranges correspond to the determined ages. The age ranges are communicated to a second virtual machine at a client.