Microsoft Technology Licensing, LLC

Clock Synchronization

Alexander Shamis

Richendra Khanna

Dushyanth Narayanan

Yutaka Suzue

Aleksandar Dragojevic

Matthew Renzelmann

Miguel Castro

Knut Magne Risvik

Anders Tungeland Gjerdrum

Stanko Novakovic

Georgios Chatzopoulos

Edmund Bernard Nightingale

Cheng Huang

Sergey M Yekhanin

Chiranjeeb Buragohain

Sylvan Wesley Clebsch

Miguel Oom Temudo De Castro

Ming-Chuan Wu

Parikshit Santhan Gopalan

Felix Schuster

Robert John Jenkins, Jr

Timothy Tan

In various examples there is a computing device in communication with at least one other computing device via a communications network. The computing device has a memory and a central processing unit having a trusted execution environment comprising trusted regions of the memory. The computing device has an operating system configured to create a memory mapping between a virtual address space of the memory and a memory of the at least one other computing device and to provide details of the memory mapping to the trusted execution environment. The trusted execution environment is configured to execute an application which is able to communicate with the other computing device directly using the memory mapping provided by the operating system.

Side-channel protection

In various examples, there is provided methods performed by nodes in a cluster of nodes to establish a master clock at a new master node following a reconfiguration of the nodes included in the cluster, whereby the master clock is provided by an old master node prior to the reconfiguration, and synchronize a local clock of slave nodes to clock of the new master node. The new master node sends a message to the slave nodes instructing them to disable their respective local clocks, receives acknowledgements that the local clocks have been disabled, waits until a time at which all leases have expired for any nodes removed from the cluster, sets the value of its clock to be greater than a maximum value that could have been provided by the old master node at the time the leases expired and indicates to the other nodes to re-enable their local clocks.

Clock synchronization

In various examples, there is provided methods performed by nodes in a cluster of nodes for performing transactions comprising one or more read operations and/or one or more write operations. The node comprises a local clock which is synchronized with a master clock and maintains a measure of uncertainty indicating current minimum and maximum values of the master clock. The method to perform transactions involving read operations generates a read timestamp representing a point in time which is earlier than a current minimum value of the master clock. The method then reads the objects and determines, for each of them, whether a timestamp associated with that object is later than the read timestamp. If so, an error handling procedure is performed for that object.

Performing transactions in distributed transactional memory systems

A distributed graph database that enables scaling and efficient processing is described. The distributed graph database can, for example, scale up to petabytes of data to enable transactional processing of graph data with low latency and low processing overhead. The distributed graph database can include a cluster of devices and a remote direct memory access (RDMA)-based communication layer to perform low latency messaging between devices of the cluster of devices. Additionally, the distributed graph database can include a shared memory layer that provides one or more data structures, a transaction layer to facilitate query processing, and a graph database layer stored in computer-readable media and executed on a processor to implement a graph data model. In at least one example, the graph data model can be mapped to the one or more data structures.

Distributed graph database

An 'RDMA-Based Memory Allocator' applies remote direct memory access (RDMA) messaging to provide fast lock-free memory allocations and de-allocations for shared memory distributed across multiple servers in an RDMA-based network. Alternately, in various implementations, the RDMA-Based Memory Allocator combines RDMA messaging and remote procedure call (RPC) requests to provide fast lock-free memory allocations and de-allocations for shared memory distributed across multiple servers in an RDMA-based network. In either case, any of the networked servers can act as either or both a client for requesting (or releasing) memory allocations and a host for hosting a portion of the distributed memory. Further, any server (including the requesting client) may act as the host for the distributed memory being allocated or de-allocated by any client via RDMA messaging. Advantageously, being lock-free improves overall performance of memory access between networked computers by reducing overall system latency.

Distributed lock-free RDMA-based memory allocation and de-allocation

A 'Key-Value Manager' applies an RDMA-based memory allocator to implement a distributed and lock-free B-Tree based key-value store. In various implementations, the Key-Value Manager is implemented as a standalone library running concurrently on large numbers of networked computing devices. The RDMA-based memory allocator of the Key-Value Manager allocates and accesses the memory of the key-value store via various sequences of RDMA messages (e.g., RDMA reads, RDMA writes, and RDMA atomic compare and swap (CAS) operations). As such, CPUs of computing devices hosting the memory of the key-value store do not need to be notified of or involved in RDMA-based reads and writes to that memory. Consequently, CPU utilization for any computing device that hosts any portion of the key-value store is minimal, thereby enabling the Key-Value Manager to scale to very large numbers of concurrent accesses by very large numbers of computing devices.

Distributed self-directed lock-free RDMA-based B-tree key-value manager

A 'Distributed Storage Controller' applies an RDMA-based memory allocator to implement a distributed thread-safe and lock-free storage system in shared memory distributed across multiple networked computers. The Distributed Storage Controller enables any number of client applications, processes, subroutines, etc., on any number of networked computers to concurrently perform self-directed lock-free allocations, de-allocations, reads, writes, etc., on the shared memory via sequences of one-way RDMA messages (e.g., RDMA reads, RDMA writes, and RDMA atomic compare and swap (CAS) operations) without requiring CPU locks. As such, the CPUs of computing devices hosting the shared memory do not need to be notified of RDMA-based reads, writes or CAS operations on that memory. Consequently, CPU utilization for computing devices hosting any portion of the shared memory is minimal, thereby enabling the Distributed Storage Controller to scale to very large numbers of concurrent accesses by very large numbers of networked computing devices.

Low latency RDMA-based distributed storage

The techniques and/or systems described herein implement erasure coding to generate various chunks for a data collection (e.g., data chunks and at least one encoding chunk). The chunks are then distributed and stored within an individual group (e.g., a pod) of storage units, where a pod of storage units is determined based on characteristics that affect an amount of time it takes to recover a data collection or to restore lost data.

Erasure coding of data within a group of storage units based on connection characteristics

An 'RDMA-Based RPC Request System' combines the concepts of RPC and RDMA in a way that can be implemented on commodity networking communications hardware, e.g., RDMA-enabled network interface controllers (NICs) in an Ethernet-based network. In various implementations, the RDMA-Based RPC Request System enables fast lock-free and thread-safe execution of RPC requests between different computers in a network via RDMA-based messages. In other words, the RDMA-Based RPC Request System combines RDMA messaging and RPC requests to enable fast RPC requests via a sequence of RDMA messages transmitted over Ethernet using commodity NICs between networked computers in a data center or other network environment. This RDMA message process is both lock-free and thread-safe. Advantageously, being both lock-free and thread-safe improves overall performance of memory access and RPC requests between networked computers by reducing overall system latency for transmission and execution of RPC requests over commodity networking hardware.

Growing community of inventors

Seattle, WA, United States of America

Alexander Shamis