Microsoft Technology Licensing, LLC

Marcus Eduardo Markiewicz

Michal Krzysztof Piaseczny

Michael J McCormack

Michael John Novak

Chris J Guzak

Tyler Kien Beam

Christopher Warren Bryant

Jack Allen Nichols

Adam Christopher Czeisler

Jonathan Alexander Bockelman

Amnon Itamar Govrin

Juan-Lee Pang

Brett A Shirley

Theresa Naramore

Daniel Vincent Fiordalis

George R Fordham

Marcelo Albuquerque Fernandes Mas

Benjamin M Yim

Benjamin Edward Rampson

Daniel Cory

Barry Christopher Allyn

Matthew James Ruhlen

Timothy E Getsch

B Scott Ruble

Naresh Sundaram

Matthew John Androski

Nicolas Ratigan Borden

Randall L Davis

Andrew John Verprauskus

Andrew M Warden

Tai The Do

Michael Allen Brotherton

Amog Rajenderan

Krikor Nigoghosian, Jr

Boris Isaac Feldman

Manish Soni

Nisha Tekchand Singh

Bowen Xue

Tai T Do

Krikor Nigoghosian

In an implementation, a sync engine running on a computing device synchronizes a local copy of a file with a copy of the file hosted by an online file service. An application on the device receives a request/command to open the file and responsively opens a temporary copy of the file in memory. The application populates the temporary file with content from the local copy of the file and also establishes a connection between the application and a co-authoring service. Note that the connection between the application and the co-authoring session bypasses the sync engine such, when connected to the co-authoring service, the application is able to synchronize the content in the temporary copy of the file with content in the hosted copy of the file over the connection.

Enhanced co-authoring and file syncing

In various implementations, streams are sent and received by a computing device engaged in an authoring session with respect to an electronic document. The computing device stores the streams in multiple container files associated with an instance of the electronic document open on the computing device. The device maintains an indices file to reflect a presence of the streams in the container files, such that fast access can be provided to the streams at a later time. The indices file comprises multiple probabilistic data structures corresponding to the container files that each indicate on a probabilistic basis whether a given stream is present in a corresponding one of the container files. The computing device uses the indices file to retrieve the streams from the container files.

Probabilistic indices for accessing authoring streams

A method of and system for asynchronous replication of data from a source database to a destination database is carried out by utilizing a probabilistic replication filter to manage the state of replication. The method may include receiving a list of identifiers for a plurality of entities in a data set in the source database, loading at least a portion of the list into a probabilistic replication filter, the portion including an identifier for each one of the plurality of entities in the data set that have not yet been replicated in the destination database, examining the list of identifiers to determine if a first identifier is in the probabilistic replication filter, and upon determining that the first identifier is in the probabilistic replication filter, replicating an entity associated with the first identifier and removing the first identifier from the probabilistic replication filter.

Data replication using probabilistic replication filters

Techniques for telemetry data collection including receiving first telemetry data items each including a first value for a first performance measurement, generating respective data objects providing values for a first set of attributes including multiple context attributes and a performance attribute determined based on the first value, performing a machine-based selection of outlier data objects from the data objects, obtaining a targeting rule specifying selection conditions for at least two of the context attributes and corresponding to a selected subset of the outlier data objects, providing the targeting rule to multiple telemetry sources, and receiving second telemetry data items each associated with a different telemetry source that satisfied the selection conditions, and each including a second value for a second performance measurement, with the first telemetry data items not including values for the second performance measurement.

Machine-based recognition and dynamic selection of subpopulations for improved telemetry

The systems and methods disclosed herein relate to using the clusters of a file to store versioning of a dataset. When the dataset is initially stored, a file is created that is twice the size of the dataset. The file may include one cluster (or a first set of clusters) that is marked as active and a second cluster (or a second set of clusters) that are marked inactive. The dataset is initially saved to the active cluster(s), and a version number is stored with the dataset. When the dataset is next saved, an application scans the file to determine whether there is (or are) an inactive cluster(s). If there is an inactive cluster(s) the second version of the dataset is saved to the inactive clusters. Both clusters are then marked active.

Efficient clustered persistence

A computing system includes at least one processor and memory storing instructions executable by the at least one processor, wherein the instructions, when executed, cause the computing system to instruct a synchronization engine to synchronize first and second versions of a file, the first version being stored on a first storage system and the second version being stored on a second storage system, receive a backoff indicator corresponding to the file, based on the backoff indicator, instruct the synchronization engine to backoff synchronizing changes to the file, and allow the changes to the file to be synchronized by a co-authoring application, maintain a first set of collaborative metadata indicative of content of the first version of the file, and maintain a second set of collaborative metadata indicative of content of the second version of the file.

Coordinating file synchronization between a sync engine and another application that supports document collaboration

Systems and methods for managing an index shared by a plurality of processes. One method includes reading, with a process, the index at a first state and maintaining a journal of operations to be performed on the index at the first state by the process. Each operation included in the journal includes a create operation or a delete operation. The method also includes, in response to a predetermined event, applying the journal of the one of the plurality of processes to update the index. Applying the journal includes deleting an existing entry from the index and adding a new entry to the index for each create operation included in the journal specifying a key included in an entry of the index at the second state, and ignoring each delete operation included in the journal specifying a key not included in an entry of the index at the second state.

Index management in a multi-process environment

A synchronization engine detects a notification of a change to a file. It determines whether an application associated with the file has indicated that the file is to be synchronized by the application. If so, the changes to the file are synchronized between a cloud-based storage system and a local disk by the application. Collaborative metadata, associated with the synchronized file, is updated to indicate a state of a copy of the file on the local disk and a copy of the file in the cloud-based storage system. The collaborative metadata is stored by the synchronization engine.

Writing data to storage utilizing a diverged thread for asynchronous write operations is provided. On a first thread, an analysis engine analyzes and identifies changed information to write to storage and an I/O manager copies the writes into buffers and places the buffers into a queue, while on a second thread, a flushless transactional layer (FTL) drive executes the writes to storage. By allowing the analysis to continue and enqueue writes on a first thread while the writes are written to storage on a second thread, the CPU and I/O of the system are utilized in parallel. Accordingly, efficiency of the computing device is improved.

Flushless transactional layer

To identify objects shared by entities and to, in turn, identify free space in nonvolatile storage, a computer system uses a probabilistic data structure which tests whether an element is a member of a set. Such probabilistic data structures are created for entities in the storage system that share objects. The probabilistic data structure for an entity represents the objects that are used by that entity. When an entity is deleted, each object used by that entity is compared to the probabilistic data structures of other entities to determine if there is a likelihood that the object is used by one or more of the other entities. If the likelihood determined for an object is above an acceptable threshold, then the object is not deleted. If the likelihood determined for an object is below the set threshold, then the object can be deleted and the corresponding storage locations can be marked as free.

Recovering free space in nonvolatile storage with a computer storage system supporting shared objects

Systems and methods are disclosed in which a derived table can inherit a growth pattern from a template table. A growth pattern is used to define how memory is allocated to a table as the table grows. The derived table can inherit the growth pattern defined by its template table or it can provide an override growth pattern. Inheritance of the growth pattern can be performed by explicit copying or by reference or link. Growth patterns can be edited, and the edits can be applied universally or locally.

Inheritance of growth patterns for derived tables

Systems and methods are disclosed for employing usage-optimized tables with a computer database system. In one embodiment, the database system stores create, update, and delete database operations in the usage-optimized table. The create, update, and delete database operations remain in the usage-optimized table until a flush condition is reached. When the flush condition is reached, the create, update, and delete operations are transferred to their corresponding real tables. In embodiments, the read operation does not flush the contents of the usage-optimized table to the real table. In such embodiments, the database system modifies read operations to account for data resident on the usage-optimized tables.

Usage-optimized tables

Rendering electronic chart objects is provided. A set of chart elements having a common set of properties is identified. Formatting attributes of the chart elements and the data point locations for each chart element are also identified. Path information is generated for the chart elements that includes the formatting attributes and the data point locations. The path information is provided to a rendering engine that renders a chart element. Each chart element in the set is displayed on a display screen. Chart elements having a common set of properties are only rendered once. Alternatively, chart objects are rendered by generating and storing an image of chart objects having a common geometry and common properties and by copying the stored image to each data point location. Dynamic selection of rendering engines based on property and performance criteria may be utilized to enhance rendering performance.

Rendering electronic chart objects

A database application is provided which includes functionality for providing split views. The database application includes an object model having a number of objects, methods, and properties. The object model preferably includes a form object which includes a split view representation. A number of properties are associated with the split view which provides for the presentation of data to a user of the database application.

Growing community of inventors

Mercer Island, WA, United States of America

Marcus Eduardo Markiewicz