Microsoft Technology Licensing, LLC

Amazon Technologies, Inc.

Yosseff Levanoni

Weirong Zhu

Lingli Zhang

David L Detlefs

Michael M Magruder

Jan Stephen Gray

Vinod Grover

Paul F Ringseth

Amit Kumar Agarwal

Ali-Reza Adl-Tabatabai

John Joseph Duffy

Sukhdeep S Sodhi

Gad Shlomo Sheaffer

Martin Taillefer

Charles David Callahan, Ii

Dana D Groff

Dave Detlefs

Timothy Lawrence Harris

Alexander Dadiomov

Andrew L Bliss

John Lee Rapp

Stefano Stefani

James Christopher Sorenson

Colin Laird Lazier

Akshat Vig

Stephen Harris Toub

David Alan Lutz

Martin Abadi

James Ernest Johnson

Somasundaram Perianayagam

David S Callahan

Maximiliano Maccanti

Donald James McCrady

Akhilesh Mritunjai

Haoran Andy Wu

Andrew Whitaker

Hao He

Rick Molloy

Matthew B Tolton

Christopher William Dern

Marc Bowes

Steven Michael Hershey

Yongkang Zhu

Robert McGregor Marrowstone

Abigail Marie Kuic

Eric Justin Kraemer

Kritin Gokharu

Victoria Elizabeth Scearcy

Junaid Azad Mohammed

Omer Ronen

Dolev Ish Am

Cameron Ryan Alberts

Vivek Srivastava

John Joseph Gray

Sub-tables are indexed to implement performant access requests. Sub-tables may be created in a database table. Items may be stored in the table according to an indexing scheme that co-locates items in a same sub-table in an index. Access requests for items in a sub-table may be performed by applying the indexing scheme to locate the items in the sub-table from the index.

Indexing sub-tables for performant access requests

A journal-based database may include items, e.g., organized in a table, associated with a journal. The journal may include a hash-chained set of blocks individually including data representing previous and/or current versions of the individual items. The database may receive a request to redact specific data from the database. The database may search the blocks to determine whether the specific data exists. When the specific data exists in a block of the journal, the database may redate the specific data in the identified block. The database may retain existing metadata of the block such that cryptographic verifiability of the hash-chained blocks may be preserved.

Data redaction in a journal-based database

A database system may associate functions with a database table. A request to associate a function with a table in a database system may be received. An association between the table and the function may be created. The function may include parameters that are determined from values within the table which are then invoked by a request to perform the function. The associated function may cause the collection of the values prior to performance of the function.

Associating a function with a table in a database system

A distributed system may comprise a plurality of computing nodes, each of which may provide computing capacity for operating various computing services. The system may maintain a memory-based store of records representative of capacity available on the computing nodes. A record indicative of a computing node having a requested amount of capacity may be selected. The record may be modified to indicate that the computing node is a candidate for providing the requested amount of capacity. Upon receiving information confirming that the computing node has been configured to provide the requested capacity, the record may be modified to indicate that the computing node has committed to provide the requested capacity.

Cache-based partition allocation

A high level programming language provides a read-only communication operator that prevents a computational space from being written. An indexable type with a rank and element type defines the computational space. For an input indexable type, the read-only communication operator produces an output indexable type with the same rank and element type as the input indexable type but ensures that the output indexable type may not be written. The read-only communication operator ensures that any attempt to write to the output indexable type will be detected as an error at compile time.

Read-only communication operator

Embodiments are directed to optimizing data transfers between heterogeneous memory arenas. In one scenario, a computer system receives an indication that a data chunk is to be transferred from a first memory arena to a third memory arena, and then determines that for the data chunk to be transferred from the first memory arena to the third arena, the data chunk is to be transferred from the first memory arena to a second memory arena, and from the second memory arena to the third memory arena. The computer system divides the data chunk into smaller data portions and copies a first data portion from the first memory arena to the second memory arena. The computer system then copies the first data portion from the second memory arena to the third memory arena and copies a second data portion from the first memory arena to the second memory arena in parallel.

Optimizing data transfers between heterogeneous memory arenas

Handling garbage collection and exceptions in hardware assisted transactions. Embodiments are practiced in a computing environment including a hardware assisted transaction system. A method includes beginning a hardware assisted transaction, raising an exception while in the hardware assisted transaction, including creating an exception object, determining that the transaction should be rolled back, and as a result of determining that the transaction should be rolled back, marshaling the exception object out of the hardware assisted transaction.

Efficient garbage collection and exception handling in a hardware accelerated transactional memory system

A software transactional memory system implements a lightweight key-based action framework. The framework includes a set of unified application programming interfaces (APIs) exposed by an STM library that allow clients to implement actions that can be registered, queried, and updated using specific keys by transactions or transaction nests in STM code. Each action includes a key, state information, and a set of one or more callbacks that can be hooked to the validation, commit, abort, and/or re-execution phases of transaction execution. The actions extend the built-in concurrency controls of the STM system with customized control logics, support transaction nesting semantics, and enable integration with garbage collection systems.

Action framework in software transactional memory

A software transactional memory system is provided that creates an array of transactional locks for each array object that is accessed by transactions. The system divides the array object into non-overlapping portions and associates each portion with a different transactional lock. The system acquires transactional locks for transactions that access corresponding portions of the array object. By doing so, different portions of the array object can be accessed by different transactions concurrently. The system may use a shared shadow or undo copy for accesses to the array object.

Array object concurrency in STM

Software transactional memory (STM) primitives are provided that allow the results of prior open calls to be used by subsequent open calls either as-is or through another STM primitive that consumes the results of the previous invocation. The STM primitives are configured to ensure that the address of a shadow copy representing a memory location will not changed across a wide range of operations and thereby enable re-use of the shadow copy.

Primitives for software transactional memory

The present invention extends to methods, systems, and computer program products for emulating pointers. Pointers can be emulated by replacing the pointers with a &#x3c;variable#, offset&#x3e; pair and replacing each dereference site with a switch on the tag and a switch body that executes the emulated pointer access on the corresponding variable the pointer points to. Data flow optimizations can be used to reduce the number of switches and/or reduce the number of cases which need be considered at each emulated pointer access sites.

Emulating pointers

The present invention extends to methods, systems, and computer program products for aliasing buffers. Embodiment of the inventions supporting buffer aliasing through introduction of a level of indirection between a source program's buffer accesses and the target executable physical buffers, and binding the logical buffer accesses to actual physical buffer accesses at runtime. A variety of techniques for can be used supporting runtime aliasing of buffers, in a system which otherwise disallows such runtime aliasing between separately defined buffers in the target executable code. Binding of logical buffer accesses in the source program to the actual physical buffers defined in the target executable code is delayed until runtime.

Aliasing buffers

Growing community of inventors

Redmond, WA, United States of America

Yosseff Levanoni