Amazon Technologies, Inc.

Marc John Brooker

Timothy Allen Wagner

David R Richardson

Madhuvanesh Parthasarathy

Marc Stephen Olson

Danny Wei

Norbert Paul Kusters

James Michael Thompson

Tate Andrew Certain

Ajay Nair

Mikhail Danilov

Tobias L Holgers

Tao Chen

Anthony Nicholas Liguori

Christopher Magee Greenwood

Surya Prakash Dhoolam

Nachiappan Arumugam

John Luther Guthrie, Ii

Christopher Nathan Watson

Marc Levy

Philip Daniel Piwonka

James Christopher Sorenson

Calvin Yue-Ren Kuo

Kerry Quintin Lee

Jonathan I Turow

Weili Zhong McClenahan

Niall Mullen

Christopher Richard Jacques De Kadt

Fan Ping

Shobha Agrawal

Eric Jason Brandwine

David Everard Brown

Divya Ashok Kumar Jain

Dylan Owen Marriner

Scott Daniel Wisniewski

Mark Bradley Davis

Robert Michael Johnson

Mark Edward Rafn

John Robert Smiley

Lakshmi N Pallikila

Bei-Jing Guo

Julian Embry Herwitz

Marvin Michael Theimer

Mitchell Gannon Flaherty

Sean Philip Reque

Derek Steven Manwaring

Cheng Pan

Pieter Kristian Brouwer

Kristina Kraemer Brenneman

Osman Surkatty

Matthew Joseph Zulak

Jerry Lin

Bryan Nicholas Moffatt

Niranjan Jayakar

Craig Wesley Howard

Andrew James Lusk

Paul William Berg

Shubham Katiyar

Samvid Hariram Dwarakanath

David Alexander Dunlap

Adam Charles Siefker

Venkatesh Vijayaraghavan

Manigandan Radhakrishnan

Kyunghwan Choi

Tarun Goyal

Thomas A Volpe

Leah Shalev

Asif Khan

Eden Grail Adogla

Douglas Stewart Laurence

Roland Alexander Paterson-Jones

Matthew Scott Garman

Kevin Ross O'Neill

Mark Joseph Cavage

Robert James Hanson

Benjamin Arthur Hawks

Abhinav Agrawal

Jamie Hunter

John Clark Coonley Duksta

Rudresh Amin

Jakub Wojciak

Cornelle Christiaan Pretorius Janse Van Rensburg

Nishant Satya Lakshmikanth

Stefano Stefani

Yan Valerie Leshinsky

James Alfred Gordon Greenfield

Marcin Piotr Kowalski

Andrew Kent Warfield

Jonathan Paul Thompson

Christopher Allen Suver

Gary Michael Herndon

Joshua Dawie Mentz

Steven J Kruy

Michael Groenewald

Nare Alan Hayrapetyan

Mustafa I Abrar

Gourav Roy

David Charles Wein

Sankhyayan Debnath

A data storage system includes a head node and mass storage devices. The head node is configured to flush data stored in a storage of the head node to a set of the mass storage devices of the data storage system. A head node may flush both current version data and point-in-time version data to the set of mass storage devices. Also, the data storage system maintains an index that indicates storage locations of data for particular portions of a volume before and after the data is flushed to the set of mass storage devices. In some embodiments an index includes a current version reference for a volume or portion of a volume and one or more point-in-time snapshot references.

Data system with flush views

Systems and methods are provided for generating an index of a set of vectors as a distributed proximity-based graph data structure comprising representative vectors corresponding to subsets of the set of vectors, storing the set of vectors across a plurality of storage devices of a distributed storage system based on the distributed proximity-based graph data structure, and loading, in response to a vector query, a plurality of subsets of the set of vectors from the distributed storage system based on the distributed proximity-based graph data structure.

Scalable graph-based vector storage and search in distributed storage systems

Compact hosting of database query processors is performed using virtualization snapshots. When a request to access a database is received via a previously established connection from a client for an idle query processor that is not currently executing, a virtualization snapshot may be identified that is associated with the idle query processor. The virtualization snapshot of the query processor may be used to restore the query processor into virtual execution on a host system for the database using an origin snapshot that shares clean pages across multiple query processors on the host system. The request may be performed by the restored query processor in virtual execution on the host system.

Compact hosting of database query processors using virtualization snapshots

Systems and methods are described for providing auxiliary functions in an on-demand code execution system in a manner that enables efficient execution of code. A user may generate a task on the system by submitting code. The system may determine the auxiliary functions that the submitted code may require when executed on the system, and may provide these auxiliary functions by provisioning or configuring sidecar virtualized execution environments that work in conjunction with the main virtualized execution environment executing the submitted code. Sidecar virtualized execution environments may be identified and obtained from a library of preconfigured sidecar virtualized execution environments, or a sidecar agent that provides the auxiliary function may be identified from a library, and then a virtualized execution environment may be provisioned with the agent and/or configured to work in conjunction with the main virtualized execution environment.

Execution of auxiliary functions in an on-demand network code execution system

Methods, systems, and computer-readable media for distributed transactions across multiple consensus groups are disclosed. A distributed transaction system comprises a proposer and a plurality of consensus groups, including a first consensus group comprising a first plurality of members and a second consensus group comprising a second plurality of members. The proposer proposes a transaction to at least a portion of the first consensus group and at least a portion of the second consensus group. A majority of the members in the first consensus group agree to perform the transaction, where the transaction is selected from a plurality of proposed transactions involving the first consensus group. A majority of the members in the second consensus group also agree to perform the transaction. The members of the first and second consensus groups perform the transaction to update a plurality of stored replicas.

Distributed transactions across multiple consensus groups

Working set ratio estimations of data items in a sliding time window are determined to dynamically allocate storage for the data items. A working set ratio may be determined by accessing a fixed-size array that stores respective timestamps of last accesses of data items to determine which data items are useful to determine an estimate of a working set for the application within a range of time. The working set ratio is then determined from an estimated working set and an amount of computing resources allocated to the application by the estimated working set. The amount of the computing resources allocated to the application may then be automatically scaled according to the determine working set ratio.

Working set ratio estimations of data items in a sliding time window for dynamically allocating computing resources for the data items

Systems and methods are described for enabling graceful recovery of network connections in a virtual machine instance that has been migrated or temporarily halted. To prevent the virtual machine instance from attempting to reuse open connections, which might fail due to migration or halting, a host device identifies open connections just prior to halting the virtual machine instance on the host, and transmits to the virtual machine instance termination signals for the open connections. The host device may further transmit termination signals to the other parties to such connections. Each termination signal may be formatted so as to appear to originate from the other party to the connection, causing both parties to synchronize their knowledge of the connection. On reactivation, the virtual machine instance can recovery the connections without errors associated with attempted utilization of broken connections.

Network connection recovery after virtual machine transition in an on-demand network code execution system

Systems and methods are described for providing updating of disk images supporting serverless code execution and controlled deployment of updated disk images. A disk image can be defined as a set of layers that represent a file system include code of a serverless function and other data used by the code. A function owner can designate one layer as containing software or other data subject to update. When a new version of the layer is obtained at a serverless compute system, the system can generate a new disk image containing the updated layer. The system can then gradually transition the function to the new disk image, by dividing calls to the function among two versions of the function—one using the prior disk image, and one using the new disk image. Performance data gained from the new version of the function can be used to control the gradual transition.

Controlled automatic updates to disk image layers with compatibility verification

Systems and methods are described for reducing latency to service requests to execute code on an on-demand code execution system by maintaining snapshots of virtual machine instances in a ready state to execute such code. A user may submit code to the on-demand code execution system, which code depends on other software, such as an operating system or runtime. The on-demand code execution system can generate a virtual machine instance provisioned with the other software, and initialize the instance into a state at which it is ready to execute the code. The on-demand code execution system can then generate a snapshot of the state of the instance, and halt the instance. When a request to execute the code is received, the snapshot can be used to quickly restore the instance. The code can then be executed within the instance, reducing the need to initialize the instance or maintain the instance in an executing state.

Reducing execution times in an on-demand network code execution system using saved machine states

Methods, systems, and computer-readable media for a service for managing quantum computing resources are disclosed. A task management service receives a description of a task specified by a client. From a pool of computing resources of a provider network, the service selects a quantum computing resource for implementation of the task. The quantum computing resource comprises a plurality of quantum bits. The service causes the quantum computing resource to run a quantum algorithm associated with the task. The service receives one or more results of the quantum algorithm from the quantum computing resource.

Service for managing quantum computing resources

An on-demand code execution environment present in points of presence (POPs) and in regions serviced by the POPs is provided herein. For example, a POP may receive a request to execute a task associated with user-defined code. If the POP determines that the computing resources necessary to execute a received task are not available or that the POP should not execute the received task for another reason (e.g., the task is not commonly received and the computing resources needed to execute the task are therefore best allocated for other requests), the POP can forward the task to a region that the POP services for execution by an on-demand code execution environment present in the region. The on-demand code execution environment present in the region can execute the task and forward the results of the execution to the POP for distribution back to a user device that requested the task execution.

Multi-region request-driven code execution system

Systems and methods are described for reclamation of computing resources in an on-demand code execution system. An on-demand code execution system may execute user-submitted code on virtual machine instances, which may be provisioned with quantities of various computing resources (memory, storage, processor time, etc.). These quantities of computing resources may be unused or underutilized depending on the resource requirements of the user-submitted code, or may become idle once the user-submitted code has completed execution. A resource reclamation system may thus reclaim these underutilized computing resources and reallocate them to other uses. The resource reclamation system may interact with a reclaimable resource identification process that executes within the virtual machine instance, which may identify unused or underused computing resources, claim them, and then allow the resource reclamation system to reallocate them. The resource reclamation system may thus enable reclaiming the computing resources without requiring the virtual machine instance to be reprovisioned.

Reclaiming computing resources in an on-demand code execution system

Systems and methods are described for providing virtualized transaction retries in an on-demand network code execution system. A user may generate a task on the system by submitting code. The task may include a transaction that can succeed or fail depending on external factors, such as accessing a resource that other processes are also trying to access. The system may obtain success criteria for evaluating whether the transaction was successful, and may configure a virtual machine instance to execute the submitted code. The system may generate a 'snapshot' or otherwise capture information regarding the state of the virtual machine instance prior to executing the code, and may then execute the code or a portion of it to attempt the transaction. The system may then apply the success criteria to determine whether the transaction was successful, and if not may retry the transaction by restoring the snapshot and re-executing the code.

Virtualization-based transaction handling in an on-demand network code execution system

Data replication groups may be used to store data in a distributed computing environment. The data replication groups may include a set of nodes executing a consensus protocol to maintain data durably. The nodes of the data replication groups may generate logs containing information corresponding committed operations performed by the nodes. These logs may be collected and processed to obtain useful information corresponding to the operation of the data replication group. Furthermore, this processed information may be provided in the form of a stream to enable event driven operations corresponding to the logs.

Distributed log processing for data replication groups

Growing community of inventors

Seattle, WA, United States of America

Marc John Brooker