Microsoft Technology Licensing, LLC

Nutanix, Inc.

Artem Yevgenyevich Livshits

Karan Gupta

Mohan Maturi

Rahul Singh

Abhishek Gupta

Brajesh Kumar Shrivastava

Prakash Narayanasamy

Ramesh U Chandra

Andrey Alexseyevich Pyatkov

Angshuman Bezbaruah

Ming Chen

Christopher James Antos

Rahul Paul

Suresh Sivaprakasam

Ning Zhou

Shrivatsan Vasudhevan

Swagat Borah

Vyas Ram Selvam

An indexing technique provides an index data structure for efficient retrieval of a snapshot from a long-term storage service (LTSS) of an archival storage system. The snapshot is generated from typed data of a logical entity, such as a virtual disk (vdisk). The data of the snapshot is replicated to a frontend data service of the LTSS sequentially and organized as one or more data objects for storage by a backend data service of LTSS in an object store of the archival storage system. Metadata associated with the snapshot (i.e., snapshot metadata) is recorded as a log and persistently stored on storage media local to the frontend data service. The snapshot metadata includes information describing the snapshot data, e.g., a logical offset range of a snapshot of the vdisk and, thus, is used to construct the index data structure. Notably, construction of the index data structure is deferred until after the entirety of the snapshot data has been replicated and received by the frontend data service.

Technique for efficiently indexing data of an archival storage system

A technique improves storage efficiency of an object store configured to maintain numerous snapshots for long-term storage in an archival storage system by efficiently determining data that is exclusively owned by an expiring snapshot to allow deletion of the expiring snapshot from the object store. The technique involves managing index data structures to enable efficient garbage collection across a very large number of data objects. When a snapshot expires, the technique obviates the need to scan the numerous snapshot data objects to determine which index structures are no longer needed and can be reclaimed (garbage collected). The technique is directed to management of underlying storage based on different sets of policies. When certain snapshots expire and are ready for deletion, the technique is directed to finding those data blocks that are no longer referenced (used) by any valid snapshots.

Garbage collection from archival of storage snapshots

In one embodiment, a computing device accesses an entity database storing information about entities in a virtualization environment. Each of the entities is associated with a single entity type and a shard. The shard further corresponds to the single entity type. The computing device determines an entity trail for the single shard, based on a modification history for one or more of the entities associated with the shard. The entity trail is divided into a plurality of time segments. The computing device receives an update from a client device indicating an update to an entity that is associated with the shard, and a client timestamp. The computing device selects a time segment corresponding to the client timestamp, and updates that portion of the entity trail with the client update.

Entity database historical data

In particular embodiments, a system for managing a virtualization environment includes host machines, each of the host machines including a hypervisor, user virtual machines (UVMs) and a virtual machine controller. The virtualization environment also includes virtual disks comprising a plurality of storage devices, and being accessible by the virtual machine controllers. The virtual machine controllers conduct I/O transactions with the virtual disks. The system stores an entity-relationship graph representing elements in the virtualization environment. Each of the elements is represented by an entity-type node in the entity-relationship graph, and relationships between the elements are represented by edges between the nodes.

Entity database distributed replication

Entity database framework

A configuration management system that uses a data compression method to compress entries in a data set. An entry is selected as a prefix value and prefix compression of the data set is performed. The entry to serve as the prefix value is quickly selected using an iterative approach. In each iteration, subgroups of entries are formed from groups formed in prior iterations based on the values of characters at successive positions in the entries. The approach is readily implemented using data structures represented as lists.

Method and apparatus for compressing a data set

The present invention extends to methods, systems, computer program products, and data structures for managing database snapshot storage. Spatial properties database transactions are used to manage database snapshot storage allocation and reclamation. When a read transaction and subsequent write transactions refer to disjoint portions of a database, the read transaction can continue to read portions of data directly from the database. When a read transaction and subsequent write transactions refer to intersecting portions of a database, the read transaction can be transitioned to 'snapshot' mode. The write transaction can publish a database snapshot can configure the read transaction to read contested portions of data from the published snapshot.

Managing database snapshot storage

Carrying out maintaining a software configuration management system are disclosed. In particular, a way to reverse prior revisions without removing their history in the server are described. When a client submits an undo command to reverse the effects of one or more revisions within a stated revision range of a file, the revision history is updated by submitting a new revision that effectively removes the changes embodied within the range of undone revisions. Implementing undoing prior revisions preserves the revision history for a file, in case there is a need to access the undone revisions at a later time.

Undoing changes in a software configuration management system

A method and system provides an improved representation of merge conflicts in a three-way merge operation of three sequences: Original, Version, and Version. A merge program first compares the three sequences to identify a list of difference chunks of elements between the Original and Version, and a list of difference chunks between the Original and Version. From the two sets of difference chunks, the merge program creates an annotated list of chunks. Each chunk in the annotated list is identified by a conflict flag that indicates whether the chunk is a part of a conflict and if it is, what sequence(s) being merged it belongs to. A merged document is then constructed based on the annotated list of chunks, with the chunks identified in the merged document with conflict markers for viewing by a user.

Method and system for providing a representation of merge conflicts in a three-way merge operation

Methods and data structures are disclosed for carrying out identifying differences between large files comprising many lines (or other units of comparison such as rows, words, paragraphs, sentences, etc.). The disclosed methods and data structures facilitate and carry out a streamlined, yet thorough comparison of two files to identify differences between them. The streamlining is achieved by pre-processing the files prior to submitting them to any known longest common subsequence (LCS) search engine. The output of the LCS generator is post-processed to compensate for changes to the sequences introduced by the pre-processing stage.

Growing community of inventors

Bellevue, WA, United States of America

Artem Yevgenyevich Livshits