Patent application number | Description | Published |
20090327372 | Garbage Collection via Multiobjects - Computer system, method and article of manufacture for garbage collection in computer systems that combines individual objects into linearized trees called multiobjects and thereafter utilizes multiobjects to implement most memory management operations such as detection of dead objects and compaction without the need to inspect individual objects, thereby improving performance and reducing power consumption. | 12-31-2009 |
20090327377 | Copying entire subgraphs of objects without traversing individual objects - Copying or compacting performance in garbage collection is improved by copying a first memory area (preferably comprising multiple objects) to a second memory area without traversing individual objects in the copied memory area and adjusting all copied memory locations identified as pointers in a metadata data structure. An entire linearized subgraph of the object graph can be copied at a time. | 12-31-2009 |
20100057792 | Determining the Address Range of a Subtree of a Linearized Tree - A method and computer system for determining the memory address range of a subtree of a linearized tree of objects or the original version of such tree when the tree has been modified or is concurrently being modified by other threads. The primary application of the method is in garbage collection for multiprocessor shared memory computers with very large memories, but it is also relevant for a number of other applications. | 03-04-2010 |
20100182170 | Fast approximate dynamic Huffman coding with periodic regeneration and precomputing - A fast data compression method approximating dynamic Huffman coding for applications with exteremely large data sets is disclosed. The method includes periodic regeneration of the Huffman coding tables and use of precomputed information to speed up encoding and decoding. | 07-22-2010 |
20100185632 | Utilizing information from garbage collector in serialization of large cyclic data structures - A method for serializing cyclic or shared data structures using information from the garbage collector to determine that some objects in the data structure being serialized cannot have more than one reference. | 07-22-2010 |
20100191777 | Serialization of shared and cyclic data structures using compressed object encodings - A method of encoding data structures using compressed object encodings during serialization. A compressed representation of the data is generated directly while encoding. Serialization means converting a data structure to a string of bytes for external storage or communication. | 07-29-2010 |
20100211753 | Parallel garbage collection and serialization without per-object synchronization - Parallel garbage collection, tracing, copying, and/or serialization of source memory areas is achieved without per-object synchronization instructions by dividing a source memory area into non-overlapping partitions, accessing each partition by only one thread at a time, and using a combination of global and thread-local data structures to minimize synchronization overhead and maximize achievable parallelism, while providing a full solution for handling pointers that cross partition boundaries. | 08-19-2010 |
20100223433 | Configurable object graph traversal with redirection for garbage collection - A configurable object graph traversal component with redirection capability for use in garbage collectors and other related applications. The component may be implemented in either hardware or in software, and provides an interface that allows reuse of the same component for the various traversal tasks performed during garbage collection. The interface supports redirecting traversal to new copies of moved objects, updating referring cells, performing cycle detection efficiently, and in some embodiments also supports selecting the direction of traversal, handling exits from the traversed memory region specially, and providing access to the old address of copied cells. | 09-02-2010 |
20100281082 | Subordinate Multiobjects - Attached and detached subordinate multiobjects provide a means for managing references to within multiobjects in multiobject-based garbage collection (multiobjects are basically linearized trees of objects that are treated as a single unit in various garbage collection operations). Attached subordinate multiobjects provide an efficient means for dealing with transient references from registers, local variables and short-lived data structures, and detached subordinate multiobjects are created when the link connecting an attached subordinate multiobject to its containing multiobject is severed by a write to the data structure. | 11-04-2010 |
20100287216 | Grouped space allocation for copied objects - A method of efficiently allocating space for copied objects during garbage collection by grouping many objects together, and after determining which objects belong to a group, allocating space for them in one unit and copying the objects to the allocated space (possibly in parallel). | 11-11-2010 |
20100287350 | Exact Free Space Tracking for Region-Based Garbage Collection - A method for exactly tracking the amount of free space in an independently collectable memory region is described. This enables more accurate decisions about the utility of collecting each individual region. The method uses zombie multiobjects (special multiobject descriptors denoting inaccessible space) to track which inaccessible areas have already been added to a region's free space counters. | 11-11-2010 |
20100293206 | Clustering related objects during garbage collection - Clustering related objects in a region-based garbage collector is solved by associating one or more regions with each cluster, and allocating objects from a region belonging to the primary cluster for the object. Relatedness may refer to, e.g., proximity to a cluster center (such as topic) in a persistent knowledge base or a home node in a distributed object system. The cluster for an object may be determined, e.g., from reachability from particular roots or objects during global tracing. For new objects, the initial cluster may be guessed based on history of where objects allocated in that call site have recently been clustered (possibly several stack frames deep). | 11-18-2010 |
20110099151 | Saving snapshot of a knowledge base without blocking - A consistent snapshot of a large main memory knowledge base is saved to persistent storage without blocking the application for the duration of serializing and writing the knowledge base. Taking the snapshot comprises bringing the knowledge base to a consistent state (in a multithreaded application), using virtual memory facilities to obtain a copy-on-write copy of the knowledge base in memory, and using a separate thread or process to serialize the copy-on-write copy to persistent storage. | 04-28-2011 |
20110106745 | Semantic Network with Selective Indexing - Indexing overhead in a semantic network is reduced by omitting some links from indexes in semantic network elements in response to one or more omission rules. Inference strategy over the semantic network is modified to prioritize inference strategies in such a way that the impact of the omissions on inference results is minimized. | 05-05-2011 |
20110107338 | Selecting isolation level for an operation based on manipulated objects - Concurrency control overhead in transactional memory and main memory databases is reduced by automatically selecting the appropriate isolation level for each operation based on the objects accessed by the operation. | 05-05-2011 |
20110112823 | Ellipsis and movable constituent handling via synthetic token insertion - Movable and elliptic constituents are handled in a parser by inserting synthetic tokens that do not occur in the input. Parser actions can push a syntax tree or semantic value to be realized later as a synthetic token, and some synthetic tokens (for cataphoric ellipsis) may be inserted without a prior push but require a later definition. At clause boundary it may be checked that all mandatory tokens have been inserted. | 05-12-2011 |
20110119047 | Joint disambiguation of the meaning of a natural language expression - At least two ambiguous aspects of the meaning of a natural language expression are disambiguated jointly. In the preferred embodiment, word sense ambiguity, reference ambiguity, and relation ambiguity are resolved simultaneously, finding the disambiguation result(s) that simultaneously optimize the weight of the solution, taking into account semantic information, constraints, and common sense knowledge. Choices are enumerated for each constituent being disambiguated, combinations of choices are constructed and evaluated according to semantic information on which meanings are sensible, and the choices with the best weights are selected, with the enumeration pruned aggressively to reduce computational cost. | 05-19-2011 |
20110119049 | Specializing disambiguation of a natural language expression - Disambiguation of the meaning of a natural language expression proceeds by constructing a natural language expression, and then incrementally specializing the meaning representation to more specific meanings as more information and constraints are obtained, in accordance with one or more specialization hierarchies between semantic descriptors. The method is generalized to disjunctive sets of interpretations that can be specialized hierarchically. | 05-19-2011 |
20110125487 | Joint disambiguation of syntactic and semantic ambiguity - Ambiguities in a natural language expression are interpreted by jointly disambiguating multiple alternative syntactic and semantic interpretations. More than one syntactic alternative, represented by parse contexts, are analyzed together with joint analysis of referents, word senses, relation types, and layout of a semantic representation for each syntactic alternative. Best combinations of interpretations are selected from all participating parse contexts, and are used to form parse contexts for the next step in parsing. | 05-26-2011 |
20110131033 | Weight-Ordered Enumeration of Referents and Cutting Off Lengthy Enumerations - In many reference resolution problems there are many candidate referents, and the overhead of enumerating them can be considerable. The overhead is reduced by stopping enumeration before all candidate referents have been enumerated, utilizing the properties of ordered and semi-ordered enumerators. Converting semi-ordered enumerators into ordered enumerators and combining several ordered enumerators into a single using dynamic weightings for handling determiner interpretations are disclosed. | 06-02-2011 |
20110252075 | Monitoring writes using thread-local write barrier buffers and soft synchronization - During garbage collection, writes to objects being copied (relocated) are monitored (tracked) using a write barrier that uses a thread-local write barrier buffer. In the preferred embodiment, soft synchronization is used for reading the thread-local write barrier buffers. In response to detecting a write to an object, the object may be re-copied, the copying may be made to fail, the write may be propagated to another copy of the object, or, e.g., another node in a distributed system may be notified of the write. | 10-13-2011 |
20110252216 | Thread-local hash table based write barrier buffers - A write barrier is implemented using thread-local hash table based write barrier buffers. The write barrier, executed by mutator threads, stores addresses of written memory locations or objects in the thread-local hash tables, and during garbage collection, an explicit or implicit union of the addresses in each hash table is used in a manner that is tolerant to an address appearing in more than one hash table. | 10-13-2011 |
20110264712 | Copy planning in a concurrent garbage collector - A garbage collector is disclosed that permits extensive separation of mutators and the garbage collector from a synchronization perspective. This relative decoupling of mutator and collector operation allows the garbage collector to perform relatively time-intensive operations during garbage collection without substantially slowing down mutators. The present invention makes use of this flexibility by first conservatively determining which objects in a set of regions of interest are live, then planning where to copy the objects (preferably including clustering), and finally performing the actual copying. | 10-27-2011 |
20110264713 | Garbage collector with concurrent flipping without read barrier and without verifying copying - In an object-relocating garbage collector, objects are copied and new copies taken into use concurrently with mutator execution without needing to use a read barrier, and importantly, without requiring verification (read-back) of each copied word and without requiring atomic instructions for the copying. Write barriers, thread-local write barrier buffers and processing them by the garbage collector, and write propagation are used for achieving this. | 10-27-2011 |
20110264870 | Using region status array to determine write barrier actions - A fast method for determining which actions to take in a write barrier in a concurrent garbage collector is described. A region status array indexed by a region index computed from the written address is used for determining the status of the region containing the written object and for selecting, in part, the actions taken by the write barrier. By carefully manipulating the region status array, various operations and changes in write barrier actions can be performed very efficiently. | 10-27-2011 |
20110264880 | Object copying with re-copying concurrently written objects - Objects are copied concurrently with mutator execution, while tracking writes to the objects being copied. Objects (or fields) that are written into during copying are re-copied to the same destination locations. Mutators use the original objects until copying is complete and are, in some embodiments, atomically (with respect to the mutators) switched to use the new copies, together with a final re-copy. | 10-27-2011 |
20110276776 | Addressing for Huge Direct-Mapped Object Systems - A method, computing system, and computer program product are provided for quickly and space-efficiently mapping an object's address to its home node in a computing system with a very large (possibly multi-petabyte) data set. The addresses of objects comprise three fields: a chunk number, a region sub-index within the chunk, and an offset within the region, with chunks being used to achieve good compromise between small lookup tables and reducing waste of usable virtual address space. | 11-10-2011 |
20110289039 | Semantic network clustering influenced by index omissions - Some links are omitted from indexes associated with semantic network elements and clustering is influenced by such omissions. | 11-24-2011 |
20110289045 | Inference over semantic network with some links omitted from indexes - An inference system responsive to omitting links from indexes in semantic network elements is described. The inference system prioritizes strategies that avoid trying to follow links from an index from which they may have been omitted. | 11-24-2011 |
20120104176 | Electric sail with voltage multipliers in tethers - The effective area of an electric sail depends on the voltage applied to tethers. The use of higher voltages is made possible by moving voltage multipliers to tethers, perhaps 100 meters out from the body of the spacecraft. | 05-03-2012 |
20130117554 | User key management for the Secure Shell (SSH) - Management of user keys for public key authentication using the SSH in large SSH deployments is automated by deploying a management system in the environment, discovering SSH identity keys and authorized keys, analyzing authorized connections between user accounts, and automatically managing the authorized connections and the key pairs used for authentication. | 05-09-2013 |
20130191627 | Controlling and auditing SFTP file transfers - Encrypted SFTP file transfers and other encrypted file transfers may be audited and what files can be transferred may be controlled at a firewall or other gateway. Transferred files may be subjected to data loss prevention analysis and/or virus checks. | 07-25-2013 |
20130191630 | Auditing and controlling encrypted communications - Use of one or more computer systems may be audited by performing a man-in-the-middle attack against a cryptographic protocol (e.g., SSH) at one or more interceptors, transmitting audit data to a centralized audit server. Operations performed using the encrypted connection may be controlled and restricted. | 07-25-2013 |
20130191631 | Auditing and policy control at SSH endpoints - SSH sessions and other protocol sessions (e.g., RDP) may be audited using an interceptor embedded within an SSH server or other protocol server. Operations performed over an SSH connection may be controlled, including controlling what files are transferred. | 07-25-2013 |
20150030313 | DISPLAYING SESSION AUDIT LOGS - Methods and apparatus for generation of session audit log displays are disclosed. Audit log data is captured in association with at least one session in a computerized system. A video presentation is generated based on the captured audio log data. A video presentation of at least a part of the at least one session can then be displayed based on the generated data. | 01-29-2015 |