Computing devices can utilize communication networks to exchange data. Companies and organizations operate computer networks that interconnect a number of computing devices to support operations or to provide services to third parties. The computing systems can be located in a single geographic location or located in multiple, distinct geographic locations (e.g., interconnected via private or public communication networks). Specifically, data centers or data processing centers, herein generally referred to as a “data center,” may include a number of interconnected computing systems to provide computing resources to users of the data center. The data centers may be private data centers operated on behalf of an organization or public data centers operated on behalf, or for the benefit of, the general public.
To facilitate increased utilization of data center resources, virtualization technologies allow a single physical computing device to host one or more instances of virtual machines that appear and operate as independent computing devices to users of a data center. With virtualization, the single physical computing device can create, maintain, delete, or otherwise manage virtual machines in a dynamic manner. In turn, users can request computer resources from a data center, including single computing devices or a configuration of networked computing devices, and be provided with varying numbers of virtual machine resources. 7
One example use of data centers is to process or analyze streaming data, organized as a collection of data items (in some contexts referred to as “messages”) in a data stream. In this context, a data “stream” is a set of data that is periodically or continuously updated, rather than being available as a complete collection. In some instances, data within a data stream may be transient, and thus available only for a limited time. For example, each item within a data stream may “expire” and thus become unavailable after a threshold period, such as 24 hours from a time point at which the item entered the stream. In some cases, the volume of data on a data stream varies significantly over time. For example, a data stream may be reflective of user activity, and thus the volume of data may vary considerably based on active hours of relevant users. Due to these characteristics of data streams, such as the potential for varying volumes and limited-time access to data items, it is often desirable for analysis and processing of data streams to occur with timing commensurate to publishing of data to the data stream. This enables such analysis and processing to “keep up” with data published to the stream, and avoids backlogs that may result in undesirable delay or in some cases may result in data being lost prior to processing.
Generally described, aspects of the present disclosure relate to controlling ingestion of streaming data to serverless function executions. Due to the highly efficient and flexible nature of serverless computing, serverless compute systems are well suited to processing data from streaming data sources. For example, because serverless computing can efficiently and quickly scale computing processes, processing on a serverless computing environment can be scaled to match a volume of data in a data stream. This in turn enables data within the stream to be quickly processed according to requirements for that processing, including real-time processing requirements. One issue with use of serverless functions (sets of code executed on a serverless compute system) to process data streams is the general need for an intermediary between a data stream and serverless function executions. Because a data stream represents a readable set of data while a serverless function must generally be invoked, there is often a need for intermediary logic to read data from a data stream and invoke execution of a corresponding function. However, a naïve intermediary between a data stream and a serverless computing system can lead to inefficiencies. For example, each execution of a serverless function may result in some overhead, associated with, e.g., transmitting a call to execute the function, handling the call, beginning execution, etc. Accordingly, a basic system that iteratively retrieves and submits each individual data item to a serverless compute system may result in inefficiencies. One mechanism for avoiding this inefficiency is to “batch” together multiple data items from a stream, submitting each batch for collective processing via a serverless function. However, this in turn can lead to problems, particularly in cases where individual data items are not correctly processed by a serverless function execution. For example, if one data item within a batch of five is malformed, execution of a serverless function may process most of the data items before failing on the malformed item, resulting in failure of the execution with respect to an entire batch of data items. Should basic retry logic be implemented at the intermediary system, this pattern may be repeated multiple times, resulting in inefficient use of computing resources (given, e.g., that at least some data items of the batch are successfully processed on each call and therefore effort is duplicated). While more complex intermediary logic may be possible to address these cases, the wide variety of possible cases is difficult to support via pre-defined configuration of the intermediary system. Moreover, the logic required to address all possible cases can result in significant computational expenditure at the intermediary system, should that logic be implemented at the intermediary system.
Embodiments of the present disclosure address these problems by facilitating control of an intermediary system, acting between a data stream and serverless function executions, from within the serverless function executions. Serverless functions provide numerous benefits, including rapid extensibility for execution of user-defined code. These benefits in turn provide for an efficient location at which to implement logic to control an intermediary system. As disclosed herein, an intermediary system (which may in some embodiments be referred to herein as a “poller device” or the like, as discussed in more detail below) may enable a serverless function execution, when interacting with the intermediary system, to control various aspects of operation of the intermediary system in retrieving data from a data stream, submitting that data to a subsequent serverless function execution, or both. This can enable the intermediary system to operate based logic handling a wide variety of use cases, without requiring that such logic actually be conducted on the intermediary system. Rather, such logic may be performed within a serverless function execution, removing need for pre-configuration of the intermediary system or the implementation of complex logic on the intermediary system.
For example, in the case where a batch of data items contains one or more items that cause processing failures, a serverless function execution in accordance with embodiments of the present disclosure may notify an intermediary device of how to submit additional data items for processing to a subsequent serverless function execution. Illustratively, if an error occurs when processing the third data item in a batch of five at a serverless function execution, the execution may notify an intermediary system to resubmit the batch beginning from the third data item. As a result, successful processing of the first two data items need not be repeated. Similarly, if the function execution determines that the third data item is malformed and cannot be processed, the execution may notify an intermediary system to resubmit the batch from the fourth data item, enabling processing to resume while avoiding the malformed data item. In instances where items within a stream required ordered processing, a serverless function execution may return a single pointer indicating a location of a data item in the stream from which to restart submission. In instances where unordered processing is acceptable, the function may return instructions to an intermediary device identifying a set of locations within the stream, such as a set of locations successfully processed, a set of locations unsuccessfully processed that should be resubmitted, a set of locations unsuccessfully processed that should not be resubmitted, a set of locations not processed, or a combination thereof.
In addition to selecting data items for submission or resubmission, an intermediary system may additionally or alternatively enable a serverless function execution to control other aspects of serverless function invocation, such as “target” function (e.g., the particular serverless function to which batches of data items should be submitted), a batch size (e.g., a number of items submitted to each execution), a batch cadence (e.g., a timing between function invocations), or the like. Further, an intermediary system may additionally or alternatively enable a serverless function execution to control other aspects of operation of the intermediary system, such as how the intermediary system reads data items from a data stream, including for example an identifier of the data stream, which data items are read from the stream (e.g., by dictation of filtering criteria), a batch size for reading from the stream (e.g., a number of data items read per read request), a cadence for read requests (e.g., how often reads occur), etc. In some embodiments, an intermediary system may provide functionality in addition to reading from a data stream and invoking a serverless function. For example, an intermediary system may provide for monitoring state of the system, such as by submitting completion notifications to a destination on successful processing of a data item, batch of data items, etc. The intermediary system can additionally or alternatively enable a serverless function to control these aspects of operation, such as by modifying a destination for monitoring information. For example, on successfully processing a batch, a function execution may return a location (e.g., as a uniform resource locator or the like) to which to submit a completion notification, and the intermediary system may transmit the completion notification to the location. In this manner, a wide variety of logic can be implemented at serverless function executions to control operation of the intermediary system, and thereby control ingestion of streaming data to serverless function executions.
As described herein, a serverless compute system (which may also be referred to as a “serverless code execution system” or an “on-demand code execution system”) enables rapid execution of code, which may be supplied by users of the serverless compute system. On submitting code, the serverless compute system can then enable the user to submit “calls” or “invokes” to execute the code, at which point the serverless compute system will generate an execution environment for the code and execute the code within the environment to provide the desired functionality. The environment can then be destroyed shortly after providing the desired functionality, such that a user is responsible only for resources used during execution. These execution times are often very short, making serverless computing highly efficient, particularly for tasks with varying demand levels. Because the serverless compute system (and not the end user) generally handles management of execution environments, these systems are generally referred to as “serverless,” despite the general use of servers to support such environments.
The serverless compute system, as described in detail herein, may provide a network-accessible service enabling users to submit or designate computer-executable code to be executed by virtual machine instances (or other execution environments, such as containers providing operating-system level virtualization) on the serverless compute system. Each set of code on the serverless compute system may define a “task” or “function” and implement specific functionality corresponding to that function when executed on a virtual machine instance of the serverless compute system. Individual implementations of the function on the serverless compute system may be referred to as an “execution” of the function (or a “function execution”). The serverless compute system can further enable users to trigger execution of a function based on a variety of potential events, such as detecting new data at a network-based storage system, transmission of an application programming interface (“API”) call to the serverless compute system, or transmission of a specially formatted hypertext transport protocol (“HTTP”) packet to the serverless compute system. Thus, users may utilize the serverless compute system to execute any specified executable code “on-demand,” without requiring configuration or maintenance of the underlying hardware or infrastructure on which the code is executed. Further, the serverless compute system may be configured to execute functions in a rapid manner (e.g., in under 100 milliseconds [ms]), thus enabling execution of functions in “real-time” (e.g., with little or no perceptible delay to an end user).
Because the serverless compute system can provide the ability to execute a function on-demand, without configuration of an underlying device on which to execute the code, the on serverless compute system can provide an excellent platform on which to implement processing or analytics with respect to data streams. For example, the serverless compute system can enable a user to implement streaming analytics effectively without regard for the volume of data published to an input data stream, as scaling of compute resources to process the data can be handled by the serverless compute system, rather than being preconfigured by a user. One aspect that enables such behavior is an ability for serverless function executions to be parallelized. For example, as the volume of data items in a data stream grows, the stream may be partitioned into sub-streams, sometimes referred to as “shards.” Each shard may contain a portion of data from the data stream, which portion may be processed or analyzed independently or semi-independently from other portions. In accordance with embodiments of the present disclosure, each shard may be associated with a particular intermediary device, which functions to read data items from the shard and invoke a serverless function execution to process those data items. Notably, the intermediary devices from each shard may not be required to control how function execution occurs; rather, they may submit requests to execute a serverless function to the serverless compute system, which may locate an appropriate environment and execution code of the function in the environment. Thus, if two intermediary devices (e.g., of two different shards) are operating concurrently but not submitting overlapping execution requests, requests of both devices may be fulfilled by execution of code in the same environment. If two such devices are submitting overlapping execution requests, execution of the function may occur independently in two different environments (by virtue of operation of the serverless code execution system). This ability to simply and efficiently parallelize execution enables processing of data streams to scale appropriately to the volume of data on the stream.
Embodiments of the present disclosure maintain these benefits, by enabling individual function executions to control operation of an intermediary device providing data items to subsequent function executions. Specifically, embodiments of the present disclosure may be implemented without requiring centralized control over a data stream, and without requiring a single persistent function execution to control such ingestion. Accordingly, should a data stream grow in size and “split” into multiple shards, an intermediary device for each shard may submit data items from the shard to a respective function execution, which function execution can in turn control how the device for that shard submits data items to subsequent executions. This operation thus maintains parallelization of operation. In addition, because serverless function executions can control operation of an intermediary device with respect to subsequent invocations, there is no requirement that a particular serverless function execution persist to control the intermediary device. Rather, each execution can evaluate the data items submitted and implement logic to control subsequent operation of the intermediary device. The device can then alter its operation and submit additional calls to execution the function, which may be unrelated to prior executions (e.g., the code of the function may execute in a different environment, may lack state information of a prior execution, etc.). Accordingly, there is no requirement for continuity between function executions. Embodiments of the present disclosure thus maintain existing benefits regarding use of serverless function executions to conduct streaming analytics, while providing for greater control of intermediary devices.
To better illustrative ingestion control functionalities that may be implemented by interactions between a serverless function execution and an intermediary device as disclosed herein,
In
To facilitate operation, the intermediary device illustratively maintains two pointers, each corresponding to a location within the data stream. The first pointer, pointer 22, indicates a location of a last item within the data stream acknowledged as processed by the serverless function. Because the illustration of
In addition, the intermediary device maintains a second pointer, read pointer 24, which indicates a “read position,” or a position of a last read data item from the data stream 20. In
It is further assumed for illustration in
As noted above,
This bisection strategy may help to isolate malformed or error-prone data items under simple and widely applicable control logic. However, as can be seen in table 12, this strategy can result in significant duplicative processing. Specifically, in table 12, a first invocation of a serverless function includes all seven data items in a batch. The resulting function execution may iteratively process the data items, failing on data item 3. As a result, a failure response is returned. In response to the error, the intermediary device can bisect the batch, resulting in a batch of data items 1 through 3. A resulting second invocation of the serverless function includes data items 1 through 3. The resulting function execution may iteratively process the data items, again failing on data item 3. As a result, a failure response is returned. In response to the error, the intermediary device once again bisects the past batch (or batch portion), resulting in a new batch of only data item 1, which is passed in a subsequent invocation. As shown in
As can be seen in table 12, the “bisect batch on error” strategy results in successful isolation of the malformed data item 3, and successful processing of the remaining data items in the initial batch. However, it also results in significant excess computation. For example, under conditions of iterative processing (where each data item is processed prior to a subsequent data item), data item 1 is processed a total of three times, in invocations 1, 2, and 3. Similarly, data item 2 is processed 4 times, in invocations 1, 2, 4, and 5. This results in a significant loss in efficiency relative to the techniques described herein, in which a function invocation may return information controlling subsequent operation of an intermediary device, such as which data items are resubmitted to a function for processing.
Table 14 depicts example submission of data items to a serverless function where operation of the intermediary device is controlled at least in part by execution of logic within an execution of the serverless function. Similarly to table 12, each line in table 14 reflects an individual invocation and a corresponding result. However, unlike table 12, the result of table 14 can indicate complete success (“S”), complete failure (“F”), or partial failure, with partial failure indicating a position within the data stream at which processing failed (in the form of “F{n}”, where n represents the position) corresponding to a position of a first data item to be resubmitted in a subsequent invocation. Accordingly, the modified responses of table 14 relative to table 12 enable a serverless function invocation to instruct an intermediary device as to a first data item to be resubmitted, reducing duplicate processing relative to the interactions of table 12, as well as a reduction in the total number of invocations.
Specifically, the first invocation of table 14 matches that of table 12, passing the entire initial batch of data items 1 through 7 to a serverless function. As in table 12, this invocation results in at least a partial failure of processing due to the presence of data item 3. However, in contrast to table 12, where a response indicates only success or failure, the response of table 14 identifies data item 3 as the first failed data item, indicating that the batch is to be resubmitted beginning with data item 3. (Equivalently in this example, a response of S{2}, indicating success up to data item 2, may be returned.) Accordingly, at interaction 2, the intermediary device resubmits the batch beginning with data item 3. Because data item 3 is assumed to be malformed, this second invocation fails entirely (e.g., no data items were successfully processed). The interactions of table 14 may proceed similar to the interactions of table 12 in the case of total failure, bisecting the batch and resubmitting a first bisected portion. Accordingly, invocation 3 and 4 represent iterative bisections of the batch of invocation 2, each of which fails due to the presence of data item 3. At interaction 4, the failure of a batch containing only data item 3 results in the intermediary device identifying data item 3 as malformed, thus omitting the data item from subsequent invocations. (Similarly to as noted above with respect to table 12, interaction 4 may be repeated up to a retry limit, in some examples.) Accordingly, invocation 5 passes data item 4 for processing, as the second half of the bisection occurring after invocation 3, and invocation 6 passes data items 5-7 for processing as the second half of the bisection occurring after invocation 2. Both invocations 5 and 6 succeed, resulting in complete processing of the batch.
As can be seen when comparing table 12 and 14, the ability of a serverless function execution to indicate a specific failure point at invocation 1 substantially changes the interactions of the respective tables. Relative to table 12, table 14 contains fewer invocations, and does not result in duplicative processing with respect to data items. Accordingly, the interactions of table 14 can represent a significant improvement in computational efficiency relative to those of table 12.
It should be noted that additional logic implemented at a serverless function may further improve performance when processing a data stream. For example, the invocations of table 14 may be modified such that the response of a serverless function indicates that a data item is recognized as malformed and should not be resubmitted. Illustratively, a serverless function may return a map indicating a status of each data item within a submitted batch, such as a “success” status, a “failure-no retry” status, or a “failure-retry” status. An intermediary device may then retry those data items with the retry status, enabling it to quickly halt retrying of “failure-no retry” data items. In this scenario, table 14 may thus be modified to remove data item 3 from invocation 2, which may also result in obviating invocations 3 and 4. Accordingly, the number of invocations can be further reduced. Notably, these improvements can occur without requiring customized logic to be implemented at an intermediary device. Rather, instructions for subsequent operation of the intermediary device can be provided by a serverless function execution, such as in the response provided by that function in response to an invocation.
While
While
As will be appreciated by one of skill in the art in light of the present disclosure, the embodiments disclosed herein improves the ability of computing systems, such as serverless compute systems, to implement processing of data streams, such as in conducting streaming data analytics. More specifically, embodiments of the present disclosure enable efficient and highly customizable ingestion of data items into serverless function executions without requiring extensive logic performance on an intermediary device and without requiring a separate centralized device to provide such logic. Moreover, the presently disclosed embodiments address technical problems inherent within computing systems; specifically, the difficult of efficiently conducting analysis and processing of streaming data items in a manner that maintains efficiency and flexibility to account for changing volumes of data items as well as accounting for the wide variety of outcomes of such analysis and processing. These technical problems are addressed by the various technical solutions described herein, including the use of a response from a serverless function invocation to control subsequent serverless function invocations by an intermediary device. Thus, the present disclosure represents an improvement on existing data stream processing systems and computing systems in general.
By way of illustration, various example client devices 102 are shown in communication with the serverless code execution system 110, including a desktop computer, laptop, and a mobile phone. In general, the client devices 102 can be any computing device such as a desktop, laptop or tablet computer, personal computer, wearable computer, server, personal digital assistant (PDA), hybrid PDA/mobile phone, mobile phone, electronic book reader, set-top box, voice command device, camera, digital media player, and the like. The serverless code execution system 110 may provide the client devices 102 with one or more user interfaces, command-line interfaces (CLI), application programing interfaces (API), and/or other programmatic interfaces for generating and uploading user-executable source code (e.g., as part of a disk image), invoking the user-provided source code (e.g., submitting a request to execute the source code on the serverless code execution system 110), scheduling event-based code executions or timed code executions, tracking the user-provided source code, and/or viewing other logging or monitoring information related to their requests and/or source code. Although one or more embodiments may be described herein as using a user interface, it should be appreciated that such embodiments may, additionally or alternatively, use any CLIs, APIs, or other programmatic interfaces.
The illustrative environment 100 further includes one or more auxiliary services 106, which can interact with the serverless code execution environment 110 to implement desired functionality on behalf of a user. Auxiliary services 106 can correspond to network-connected computing devices, such as servers, which generate data accessible to the serverless code execution environment 110 or otherwise communicate to the serverless code execution environment 110. For example, the auxiliary services 106 can include web services (e.g., associated with the user computing devices 102, with the serverless code execution system 110, or with third parties), databases, really simple syndication (“RSS”) readers, social networking sites, or any other source of network-accessible service or data source. In some instances, auxiliary services 106 may be invoked by code execution on the serverless code execution system 110, such as by API calls to the auxiliary services 106. In some instances, auxiliary services 106 may be associated with the serverless code execution system 110, e.g., to provide billing or logging services to the serverless code execution system 110. In some instances, auxiliary services 106 actively transmit information, such as API calls or other task-triggering information, to the serverless code execution system 110. In other instances, auxiliary services 106 may be passive, such that data is made available for access by the serverless code execution system 110. For example, components of the serverless code execution system 110 may periodically poll such passive data sources, and trigger execution of code within the serverless code execution system 110 based on the data provided. While depicted in
The illustrative environment 100 further includes a stream data system 170. As discussed above, the stream data processing system can provides the ability for upstream devices to place data onto a message stream 172, such as by publishing “messages” onto the stream 172, which may be designated based on a specific “topic.” While a single stream 172 is shown in
The client devices 102, auxiliary services 106, stream data system 170, and serverless code execution system 110 may communicate via a network 104, which may include any wired network, wireless network, or combination thereof. For example, the network 104 may be a personal area network, local area network, wide area network, over-the-air broadcast network (e.g., for radio or television), cable network, satellite network, cellular telephone network, or combination thereof. As a further example, the network 104 may be a publicly accessible network of linked networks, possibly operated by various distinct parties, such as the Internet. In some embodiments, the network 104 may be a private or semi-private network, such as a corporate or university intranet. The network 104 may include one or more wireless networks, such as a Global System for Mobile Communications (GSM) network, a Code Division Multiple Access (CDMA) network, a Long Term Evolution (LTE) network, or any other type of wireless network. The network 104 can use protocols and components for communicating via the Internet or any of the other aforementioned types of networks. For example, the protocols used by the network 104 may include Hypertext Transfer Protocol (HTTP), HTTP Secure (HTTPS), Message Queue Telemetry Transport (MQTT), Constrained Application Protocol (CoAP), and the like. Protocols and components for communicating via the Internet or any of the other aforementioned types of communication networks are well known to those skilled in the art and, thus, are not described in more detail herein.
The serverless code execution system 110 and stream data system 170 are depicted in
Further, the serverless code execution system 110 and stream data system 170 may be implemented directly in hardware or software executed by hardware devices and may, for instance, include one or more physical or virtual servers implemented on physical computer hardware configured to execute computer executable instructions for performing various features that will be described herein. The one or more servers may be geographically dispersed or geographically co-located, for instance, in one or more data centers. In some instances, the one or more servers may operate as part of a system of rapidly provisioned and released computing resources, often referred to as a “cloud computing environment.”
In the example of
In
To enable interaction with the serverless code execution system 110, the system 110 includes multiple frontends 120, which enable interaction with the serverless code execution system 110. In an illustrative embodiment, the frontends 120 serve as a “front door” to the other services provided by the serverless code execution system 110, enabling users (via user computing devices 102) to provide, request execution of, and view results of computer executable source code. The frontends 120 include a variety of components to enable interaction between the serverless code execution system 110 and other computing devices. For example, each frontend 120 may include a request interface providing user computing devices 102 with the ability to upload or otherwise communication user-specified code and associated data sets to the serverless code execution system 110 (e.g., in the form of a disk image) and to thereafter request execution of that code. In one embodiment, the request interface communicates with external computing devices (e.g., user computing devices 102, auxiliary services 106, etc.) via a graphical user interface (GUI), CLI, or API. The frontends 120 process the requests and makes sure that the requests are properly authorized. For example, the frontends 120 may determine whether the user associated with the request is authorized to access the source code specified in the request.
References to source code as used herein may refer to any program code (e.g., a program, routine, subroutine, thread, etc.) written in a specific program language. In the present disclosure, the terms “source code,” “user code,” and “program code,” may be used interchangeably. Source code which has been compiled for execution on a specific device is generally referred to herein as “machine code.” Both “source code” and “machine code” are representations of the same instructions, which may be collectively referred to as “code.” Such code may be executed to achieve a specific function, for example, in connection with a particular web application or mobile application developed by the user. As noted above, individual collections of code (e.g., to achieve a specific function) are referred to herein as “tasks” or “functions,” while specific executions of that code are referred to as “task executions,” “function executions,” “code executions,” or simply “executions.” Source code for a task may be written, by way of non-limiting example, in JavaScript (e.g., node.js), Java, Python, and/or Ruby (and/or another programming language). Tasks may be “triggered” for execution on the serverless code execution system 110 in a variety of manners. In one embodiment, a user or other computing device may transmit a request to execute a task may, which can generally be referred to as “call” to execute of the task (e.g., a “task call,” a “function call,” etc.). Such calls may include an identifier of the task to be executed and one or more arguments to be used for executing the task. A request interface of the frontend 120 may receive calls to execute tasks as Hypertext Transfer Protocol Secure (HTTPS) requests from a user. Also, any information (e.g., headers and parameters) included in the HTTPS request may also be processed and utilized when executing a task. As discussed above, any other protocols, including, for example, HTTP, MQTT, and CoAP, may be used to transfer the message containing a task call to the request interface.
Prior to calling for execution of a function, an end user may submit (e.g., to a frontend 120) code for the function and associated data to be used to execute the function. In one embodiment, the code is provided in the form of a disk image containing the code and other data that the code may use during execution. Illustratively, creation of a function may result in the frontend 120 creating metadata for the function, which defines for example the user creating the function, the disk image used to facilitate execution of the function, trigger conditions for the function, and the like. In one embodiment, functions may be versioned, with function metadata identifying the available versions and at least some other metadata for a function may vary across versions. For example, different versions may be associated with different disk images. Function data and metadata is illustratively stored in the function data store 160. The function data store 160 correspond to any persistent data store. In one embodiment, the function data store 160 is implemented as logical storage on a cloud storage service, such as an object storage system. An example of such an object storage system is AMAZON™'s SIMPLE STORAGE SERVICE™ (or “S3™”). In accordance with embodiments of the present disclosure, user-submitted code may correspond to functions for conducting stream data processing.
After a user has created a function on the serverless code execution system 110, the system 110 may accept calls to execute that function, which may also be referred to as “function invocations.” To handle calls to execute a function, the frontend 120 can include an execution queue, which can maintain a record of requested task executions. Illustratively, the number of simultaneous function executions by the serverless code execution system 110 is limited, and as such, new function executions initiated at the serverless code execution system 110 (e.g., via an API call, via a call from an executed or executing function, etc.) may be placed on the execution queue and processed, e.g., in a first-in-first-out order. In some embodiments, the serverless code execution system 110 may include multiple execution queues, such as individual execution queues for each user account. For example, users of the serverless code execution system 110 may desire to limit the rate of function executions on the serverless code execution system 110 (e.g., for cost reasons). Thus, the serverless code execution system 110 may utilize an account-specific execution queue to throttle the rate of simultaneous function executions by a specific user account. In some instances, the serverless code execution system 110 may prioritize function executions, such that function executions of specific accounts or of specified priorities bypass or are prioritized within the execution queue. In other instances, the serverless code execution system 110 may execute functions immediately or substantially immediately after receiving a call for that function, and thus, the execution queue may be omitted.
In addition to functions executed based on explicit user calls and data from auxiliary services 106, the serverless code execution system 110 may in some instances operate to trigger execution of functions independently. For example, the serverless code execution system 110 may operate (based on instructions from a user) to trigger execution of a function at each of a number of specified time intervals (e.g., every 10 minutes).
The frontend 120 can further includes an output interface configured to output information regarding the execution of functions on the serverless code execution system 110. Illustratively, the output interface may transmit data regarding function executions (e.g., results of a function, errors related to the function execution, or details of the function execution, such as total time required to complete the execution, total data processed via the execution, etc.) to the user computing devices 102 or to auxiliary services 106, which may include, for example, billing or logging services. The output interface may further enable transmission of data, such as service calls, to auxiliary services 106. For example, the output interface may be utilized during execution of a function to transmit an API request to an external service 106 (e.g., to store data generated during execution of the function).
Code executions triggered on the serverless code execution system 110 of
As used herein, the term “virtual machine instance” is intended to refer to an execution of software or other executable code that emulates hardware to provide an environment or platform on which software may execute (an “execution environment”). Due to their emulation of hardware, these virtual machine instances are sometimes referred to as “system virtual machines.” Virtual machine instances are generally executed by hardware devices, which may differ from the physical hardware emulated by the virtual machine instance. For example, a virtual machine may emulate a first type of processor and memory while being executed on a second type of processor and memory. Thus, virtual machines can be utilized to execute software intended for a first execution environment (e.g., a first operating system) on a physical device that is executing a second execution environment (e.g., a second operating system). In some instances, hardware emulated by a virtual machine instance may be the same or similar to hardware of an underlying device. For example, a device with a first type of processor may implement a plurality of virtual machine instances, each emulating an instance of that first type of processor. Thus, virtual machine instances can be used to divide a device into a number of logical sub-devices (each referred to as a “virtual machine instance”). While virtual machine instances can generally provide a level of abstraction away from the hardware of an underlying physical device, this abstraction is not required. For example, assume a device implements a plurality of virtual machine instances, each of which emulate hardware identical to that provided by the device. Under such a scenario, each virtual machine instance may allow a software application to execute code on the underlying hardware without translation, while maintaining a logical separation between software applications running on other virtual machine instances. This process, which is generally referred to as “native execution,” may be utilized to increase the speed or performance of virtual machine instances. Other techniques that allow direct utilization of underlying hardware, such as hardware pass-through techniques, may be used as well.
As shown in
To facilitate rapid execution of code, each worker 181 may be configured to maintain a set of instances 183 in a “pre-warmed” state, being at least partially configured to begin execution of code. For example, instances may be created on the worker and configured with access to computing resources (CPU, RAM, drive storage, etc.). In some cases, it may be impractical or impossible to maintain instances 183 in a fully warmed state for all possible code executions, as executions may be associated with a wide variety of at least partially distinct data sets (e.g., disk images and/or snapshots). Thus, instances 183 may be maintained in a “greatest commonality” for a given group of tasks, such as being provisioned with a set of computing resources common to those tasks, being configured to accept an operating system type used by those tasks, etc.
On receiving instructions to provision an instance 183 to support execution of the task, the worker 181 may adjust the configuration of the instance 183 to support that execution. Specifically, the worker 181 may provision the instance 183 with access to a disk image or snapshot corresponding to the task. In some instances, the worker 181 may retrieve the disk image for the task and store the full image locally. In other instances, the worker 181 may provide to an instance 183 what appears to be full local access to the disk image or snapshot, while “lazily” retrieving portions of that image or snapshot in response to a request to read such portions. Techniques for providing lazy retrieval of image portions are discussed in the U.S. patent application Ser. No. 17/105,250, filed Nov. 25, 2020 and entitled “LOW LATENCY ACCESS TO DATA SETS USING SHARED DATA SET PORTIONS” (the “'250 Application”) the entirety of which is hereby incorporated by reference.
In addition, the system 110 includes a number of components for facilitating distribution of calls to execute a function from frontends 120 to particular VM instances 183. For example, the serverless code execution system 110 includes one or more worker managers 140 configured to manage execution environments (e.g., virtual machine instances) hosted by workers 181 among a worker fleet 180. The worker managers 140—each of which are illustratively implemented as physical or virtual-on-physical devices—illustratively “lease” particular VM instances 183 within the fleet 180, thus gaining operational control to, for example, instruct virtual machine instances 183 to execute code of the function. Thus, on receiving a call to execute a function, a frontend 120 may distribute the call to a worker manager 140, which may identify a currently-leased VM instance 183 in which to implement the function, and cause the instance 183 to implement the function.
In the instance that a worker manager 140 does not currently lease a VM instance 183 corresponding to the called function, the worker manager 140 can contact a placement service 160 to request a lease on an additional instance 183, which is illustratively configured to grant to the worker managers 140 leases to individual VM instances 183. Illustratively, the placement service 160 may maintain state information for VM instances 183 across the fleet 180, as well as information indicating which manager 140 has leased a given instance 183. When a worker manager 140 requests a lease on an additional instance 183, the placement service 160 can identify an appropriate instance 183 (e.g., warmed with software and/or data required to support a call to implement a function) and grant to the manager 140 a lease to that instance 183. In the case that such an instance 183 does not exist, the placement service 160 can instruct a worker 181 to create such an instance 183 (e.g., by creating an instance 183 or identifying an existing unused instance 183, providing the instance 183 with access to a required set of data to support execution, etc.) thereafter grant to the worker manager 140 a lease to that instance 183, thus facilitating execution.
To facilitate interaction with external data sources, such as the stream data system 170 or auxiliary services 106, the system 110 including a polling fleet 130, which operates to poll external data sources for data. Illustratively, the polling fleet 130 may include one or more computing devices (shown in
The poller fleet 130 can be configured to include a dynamic number of poller devices 132A-N (e.g., implemented as virtual machine instances on an underlying computing system), based on the number of message shards 174 within a message stream 172. For example, as shown by the dotted lines of
In accordance with embodiments of the present disclosure, operation of each poller device 132 may be controlled at least in part based on invocation responses provided by executions of serverless functions (e.g., within a VM instance 183). For example, each poller device 132 may initially operate based on a pre-established configuration corresponding, e.g., to the message stream 172 or shard 174. Each invocation of the serverless function may result in execution of serverless code, which in turn provides a response to the poller device 132. This response may include instructions modifying subsequent operation of the poller device 132, such as controlling subsequent serverless function invocations, controlling subsequent retrieval of data items from a corresponding shard 174, or a combination thereof. As discussed above with respect to
While some functionalities are generally described herein with reference to an individual component of the serverless code execution system 110 or the stream data system 170, other components or a combination of components may additionally or alternatively implement such functionalities. For example, while a poller device 132A may operate to poll a message shard 174 for messages, the message shards 174 may additionally or alternatively be configured to notify the serverless code execution system 110 (e.g., the frontend) of new messages on the shard 174.
The memory 180 may contain computer program instructions (grouped as modules in some embodiments) that the processing unit 190 executes in order to implement one or more aspects of the present disclosure. The memory 180 generally includes random access memory (RAM), read only memory (ROM) and/or other persistent, auxiliary or non-transitory computer readable media. The memory 180 may store an operating system 184 that provides computer program instructions for use by the processing unit 190 in the general administration and operation of the worker manager 140. The memory 180 may further include computer program instructions and other information for implementing aspects of the present disclosure. For example, in one embodiment, the memory 180 includes a user interface unit 182 that generates user interfaces (and/or instructions therefor) for display upon a computing device, e.g., via a navigation and/or browsing interface such as a browser or application installed on the computing device. In addition, the memory 180 may include and/or communicate with one or more data repositories (not shown), for example, to access user program codes and/or libraries.
In addition to and/or in combination with the user interface unit 182, the memory 180 may include a polling unit 186, control signal processing unit 188, and serverless interface unit 189. In one embodiment, the polling unit 186, control signal processing unit 188, and serverless interface unit 189 individually or collectively implement various aspects of the present disclosure. For example, the polling unit 186 can represent code executable to poll a message stream 172 to identify and obtain data items from the stream 172. The serverless interface unit 189 can represent code executable to invoke such a serverless function and pass one or more such data items for processing. The control signal processing unit 188 may obtain and parse responses from such function invocations, including parsing of control signals in such responses that control subsequent operation of the polling unit 186, serverless interface unit 189, or both.
While the polling unit 186, control signal processing unit 188, and serverless interface unit 189 are shown in
With reference to
As shown in
In order to process data items from the message shard 174A, the poller device 132A, and (2), generates a batch of data items. Illustratively, the poller device 132A may combine a next n data items read from the shard 174A and not yet successfully processed by the serverless function, where n is a pre-configured invocation batch size for the poller device 132A.
Thereafter, at (3), the poller device 132A submits the batch size to a function execution 402A, on a worker 181, for processing. While
At (4), the function execution 402 processes the batch of data items according to logic within code of the function. The logic may include any of a variety of types of processing and analytics for streaming data, such as aggregating data, validating data, evaluating data for certain conditions, etc. In accordance with embodiments of the present disclosure, the logic may further generate poller instructions that control subsequent operation of the poller device 132A with respect to reading data items, serverless function invocations to process data items, or a combination thereof.
In one embodiment, the poller instructions are based at least in part on current processing of the function execution 402. For example, if the execution 402 successfully processes one or more data items from a submitted batch, the execution 402 may generate instructions indicating that the one or more data items should not be resubmitted. In the instance that data stream processing proceeds linearly, the instructions may indicate, for example, a location within the data stream at which to begin submitting data items within subsequent invocations. In the instance that processing does not require linearity, the instructions may indicate, for example, specific data items to be resubmitted or not resubmitted. As another example based on current processing, a function execution 402 may determine that a batch size should be changed. For example, an execution 402 may be configured to target a given execution time, which may be set by a programming of the function based on parameters such as a maximum allowed execution time, overhead for each execution, mean time to conduct processing of each data item, and the like. The execution 402 may monitor present execution time with respect to a batch, and increase or decrease the invocation batch size based on the execution time, such as by increasing batch size to extend execution time or decreasing batch size to reduce execution time. As discussed above, the poller device 132A may implement these instructions such that subsequent operation of the poller device 132A is modified according to the logic implemented in the function execution 402.
In another embodiment, the poller instructions may be based at least partly on information regarding configuration or past operation of the poller device 132, which may be passed to the function execution 402 along with the batch of data items. For example, when resubmitting a data item within a batch, the poller device 132A may indicate for each data item a number of prior submissions of the data item to a function execution, timing of such submissions, results associated with such submissions, and the time. The function execution 402 may utilize this information (or, in the case of newly tried data items, the absence of such information) to determine whether, and potentially how, the data item should be resubmitted in subsequent calls, if a current processing of the data item does not succeed. In this manner, the function execution 402 may implement custom “retry logic” controlling whether and how data items are resubmitted. Similarly, metadata regarding operation of the poller device 132A, such as a rate of detecting new data items on the shard 174A, a number of data items read by the device 132A and not yet processed (e.g., a “backlog”), a rate of function invocation, and the like may be passed to a function execution, which the execution may process to generate poller instructions modifying a variety of operational aspects of the poller device 132A. Accordingly, a variety of potentially complex logic may be implemented at the function execution 402 to control operation of the poller device 132A.
As shown in
With reference to
The routine 500 begins at block 502, where the poller device 132 obtains reads data items from a data stream. As discussed above, a stream may include a set of data items arranged, e.g., according to a time of publication to the stream. The poller device 132 may interact with a host device hosting the stream to retrieve a set of data items. In one embodiment, the poller device 132 iteratively retrieves data items such as by requesting new data items every n seconds. Retrieval of data items may be referred to as “pulling” data items from the data stream. In another embodiment, a host device hosting a data stream may be configured to “push” data items to a poller device 132, by notifying the device 132 when new data items are available. In some configurations, a poller device 132 may have a maximum cache capacity for read data items that have not yet been successfully processed by a serverless function. Accordingly, when the data stream contains more unprocessed data items than the cache capacity, the poller device 132 may be configured to read up to the maximum number of unprocessed data items from the stream and store such read data items in the data cache. As discussed above, the poller device 132 illustratively maintains a read pointer indicating a last read data item from the stream by reference to a location of that data item in the stream (e.g., as a data item number, where data items are sequentially numbered within the stream). In cases where processing may be non-linear, a poller device 132 may maintain a data map indicating read data items from a stream.
While reading of data items from a data stream is described as part of the routine 500, in some embodiments a poller device 132 may implement separate routines for reading from a data stream and for submitting read data items to a serverless function execution. Accordingly, block 502 may form all or part of a first routine, and the remaining blocks of
At block 504, the poller device 132 generates a batch of data items from those read from the data stream. Illustratively, the batch can include a number of data items controlled by a batch size, which may be a configuration parameter of the poller device 132. The batch size may be set, for example, based on an expected processing rate of a serverless function used to process the data items (e.g., such that the latency in processing individual data items is within an expected range, such that executions of the serverless function are expected to finish in a given time, etc.). Each batch may include one or more data items read from the stream and unprocessed by a corresponding serverless function. For example, the batch may include a first unprocessed data item and one or more subsequent data items, up to the number of data items controlled by the batch size or a most recent data item in the stream. In instances where linear processing is not required, a batch may include another selection of unprocessed data items, such as a randomly selected set of unprocessed data items or a set selected according to various grouping parameters for a batch (e.g., meeting a target batch data size, meeting criteria for combining different types of data items, etc.). As discussed above, the poller device 132 may illustratively maintain a pointer to a location in the data stream of a last processed data item. In cases where processing may be non-linear, a poller device 132 may maintain a data map indicating processed data items from a stream.
At block 506, the poller device 132 invokes a serverless function to process the batch of data items. The particular serverless function may be set according to a configuration parameter of the poller device 132. For example, a user that created a serverless function on the serverless code execution system 110 may specify that the function should be invoked based on data items within the data stream, and as such, the system 110 may instantiate a poller device 132 to read from the stream and invoke the serverless function. Invocation of serverless functions is discussed in more detail above, but in brief, invocation may include submitting a call to the serverless code execution system 110 (e.g., to a frontend 120) that identifies the serverless function being invoked as well as the batch of data items. For example, the call may pass the batch of data items as a parameter in the call, or pass other information identifying the batch of data items (e.g., as locations in the data stream, such that the function may read the batch from the stream). As discussed above, the system 110 can respond to the invocation by executing the serverless function within an execution environment of the system 110 (e.g., a VM instance 183). Accordingly, code of the serverless function can execute to conduct any processing of the data items within the data stream designated within that code.
In accordance with embodiments of the present disclosure, code of the serverless function can further execute to generate instructions controlling subsequent ingestion of data items from the stream by the serverless function. Illustratively, to enable complex error-handling, the serverless function may generate instructions indicating how data items should be selected for a subsequent batch, such as a location in the data stream from which to begin forming the batch (or equivalently a location in the data stream of a last data item for which processing completed, indicating that a subsequent batch should begin from a subsequent location in the data stream), one or more data items to exclude from a subsequent batch, etc. The instructions may additionally or alternatively control various other attributes of the poller device 132 related to ingestion of data items to the serverless function, such as an instruction to modify a timing of a subsequent invocation of the serverless function, an instruction to modify a number of data items to include in a subsequent batch, or an instruction to modify reading of data items from the data stream (e.g., modifying which items are read, a timing of reads, a number of data items to read, etc.). Still further, the instructions may additionally or alternatively control other functionalities or attributes of the poller device 132, such as a location to which the device 132 submits monitoring information. Accordingly, code within the serverless function is enabled to control a variety of aspects of operation of the poller device 132, enabling complex functionality to be implemented at the device 132 without requiring logic to implement that functionality to be executed on the device 132.
In one embodiment, to facilitate generation of instructions by a serverless function, the invocation of the function can include or indicate metadata regarding prior or current operation of the poller device 132. For example, an invocation may indicate, for each data item in a batch, whether (and potentially how many times) the data item has been previously submitted in an invocation of the function. Such information may illustratively enable various “retry logic” at the function, enabling the function to specify when a data items should be resubmitted in a subsequent invocation without requiring static retry logic to be implemented at the poller device 132. In other examples, an invocation may indicate information such as a number of cached (e.g., read but not yet processed) data items at the poller device 132, results of prior invocations, timing of prior invocations, parameters of the poller device 132, rates of new data items occurring in the data stream, or the like. Code of a serverless function may utilize this various metadata to generate instructions controlling subsequent operation of the poller device 132, thus facilitating potentially complex logic to control ingestion of data items into the serverless function.
At block 508, the poller device 132 obtains the instructions from the execution of the serverless function. For example, the invocation of block 506 may be a synchronous invocation, such that serverless code execution system 110 delays a response until execution of the function completes. The instructions may therefore be obtained in the response. In another example, the invocation of block 506 may be asynchronous, such that a response acknowledging the invocation is received potentially before a corresponding execution occurs. In this example, the function may separately submit instructions to the poller device 132.
At block 510, the poller device 132 modifies subsequent invocations according to the instructions. For example, the poller device 132 may generate a subsequent batch of data items by include in the subsequent batch data items from the stream beginning at a location in the stream identified within the instructions, which location may illustratively represent a first not-yet-processed data item within the stream. In other examples, the poller device 132 may generate subsequent batches by modifying its operation according to other instructions, such as by modifying a timing (e.g., a cadence) of subsequent invocations of the serverless function, modifying a number of data items in the subsequent batch, etc. Additionally or alternatively, the poller device 132 may modify subsequent reads of data items from the stream, such as by modifying which items are read, a timing of reads, a number of data items to read, etc. The routine 500 then returns to block 502, where the poller device 132 can continue to operate according to the modified operation.
The routine 500 is depicted in
All of the methods and processes described above may be embodied in, and fully automated via, software code modules executed by one or more computers or processors. The code modules may be stored in any type of non-transitory computer-readable medium or other computer storage device. Some or all of the methods may alternatively be embodied in specialized computer hardware.
Conditional language such as, among others, “can,” “could,” “might” or “may,” unless specifically stated otherwise, are otherwise understood within the context as used in general to present that certain embodiments include, while other embodiments do not include, certain features, elements and/or steps. Thus, such conditional language is not generally intended to imply that features, elements and/or steps are in any way required for one or more embodiments or that one or more embodiments necessarily include logic for deciding, with or without user input or prompting, whether these features, elements and/or steps are included or are to be performed in any particular embodiment.
Disjunctive language such as the phrase “at least one of X, Y or Z,” unless specifically stated otherwise, is otherwise understood with the context as used in general to present that an item, term, etc., may be either X, Y or Z, or any combination thereof (e.g., X, Y and/or Z). Thus, such disjunctive language is not generally intended to, and should not, imply that certain embodiments require at least one of X, at least one of Y or at least one of Z to each be present.
Unless otherwise explicitly stated, articles such as ‘a’ or ‘an’ should generally be interpreted to include one or more described items. Accordingly, phrases such as “a device configured to” are intended to include one or more recited devices. Such one or more recited devices can also be collectively configured to carry out the stated recitations. For example, “a processor configured to carry out recitations A, B and C” can include a first processor configured to carry out recitation A working in conjunction with a second processor configured to carry out recitations B and C.
Any routine descriptions, elements or blocks in the flow diagrams described herein and/or depicted in the attached figures should be understood as potentially representing modules, segments, or portions of code which include one or more executable instructions for implementing specific logical functions or elements in the routine. Alternate implementations are included within the scope of the embodiments described herein in which elements or functions may be deleted, or executed out of order from that shown or discussed, including substantially synchronously or in reverse order, depending on the functionality involved as would be understood by those skilled in the art.
It should be emphasized that many variations and modifications may be made to the above-described embodiments, the elements of which are to be understood as being among other acceptable examples. All such modifications and variations are intended to be included herein within the scope of this disclosure and protected by the following claims.
Number | Name | Date | Kind |
---|---|---|---|
4949254 | Shorter | Aug 1990 | A |
5283888 | Dao et al. | Feb 1994 | A |
5835764 | Platt et al. | Nov 1998 | A |
5970488 | Crowe et al. | Oct 1999 | A |
5983197 | Enta | Nov 1999 | A |
6237005 | Griffin | May 2001 | B1 |
6260058 | Hoenninger et al. | Jul 2001 | B1 |
6385636 | Suzuki | May 2002 | B1 |
6463509 | Teoman et al. | Oct 2002 | B1 |
6501736 | Smolik et al. | Dec 2002 | B1 |
6523035 | Fleming et al. | Feb 2003 | B1 |
6549936 | Hirabayashi | Apr 2003 | B1 |
6708276 | Yarsa et al. | Mar 2004 | B1 |
7036121 | Casabona et al. | Apr 2006 | B1 |
7308463 | Taulbee et al. | Dec 2007 | B2 |
7340522 | Basu et al. | Mar 2008 | B1 |
7360215 | Kraiss et al. | Apr 2008 | B2 |
7558719 | Donlin | Jul 2009 | B1 |
7577722 | Khandekar et al. | Aug 2009 | B1 |
7590806 | Harris et al. | Sep 2009 | B2 |
7640574 | Kim et al. | Dec 2009 | B1 |
7665090 | Tormasov et al. | Feb 2010 | B1 |
7707579 | Rodriguez | Apr 2010 | B2 |
7730464 | Trowbridge | Jun 2010 | B2 |
7774191 | Berkowitz et al. | Aug 2010 | B2 |
7823186 | Pouliot | Oct 2010 | B2 |
7831464 | Nichols et al. | Nov 2010 | B1 |
7870153 | Croft et al. | Jan 2011 | B2 |
7886021 | Scheifler et al. | Feb 2011 | B2 |
7949677 | Croft et al. | May 2011 | B2 |
7954150 | Croft et al. | May 2011 | B2 |
8010679 | Low et al. | Aug 2011 | B2 |
8010990 | Ferguson et al. | Aug 2011 | B2 |
8024564 | Bassani et al. | Sep 2011 | B2 |
8046765 | Cherkasova et al. | Oct 2011 | B2 |
8051180 | Mazzaferri et al. | Nov 2011 | B2 |
8051266 | DeVal et al. | Nov 2011 | B2 |
8065676 | Sahai et al. | Nov 2011 | B1 |
8065682 | Baryshnikov et al. | Nov 2011 | B2 |
8095931 | Chen et al. | Jan 2012 | B1 |
8127284 | Meijer et al. | Feb 2012 | B2 |
8146073 | Sinha | Mar 2012 | B2 |
8166304 | Murase et al. | Apr 2012 | B2 |
8171473 | Lavin | May 2012 | B2 |
8201026 | Bornstein et al. | Jun 2012 | B1 |
8209695 | Pruyne et al. | Jun 2012 | B1 |
8219987 | Vlaovic et al. | Jul 2012 | B1 |
8296267 | Cahill et al. | Oct 2012 | B2 |
8321554 | Dickinson | Nov 2012 | B2 |
8321558 | Sirota et al. | Nov 2012 | B1 |
8336079 | Budko et al. | Dec 2012 | B2 |
8352608 | Keagy et al. | Jan 2013 | B1 |
8387075 | McCann et al. | Feb 2013 | B1 |
8392558 | Ahuja et al. | Mar 2013 | B1 |
8402514 | Thompson et al. | Mar 2013 | B1 |
8417723 | Lissack et al. | Apr 2013 | B1 |
8429282 | Ahuja | Apr 2013 | B1 |
8448165 | Conover | May 2013 | B1 |
8479195 | Adams et al. | Jul 2013 | B2 |
8490088 | Tang | Jul 2013 | B2 |
8555281 | Van Dijk et al. | Oct 2013 | B1 |
8560699 | Theimer et al. | Oct 2013 | B1 |
8566835 | Wang et al. | Oct 2013 | B2 |
8601323 | Tsantilis | Dec 2013 | B2 |
8613070 | Borzycki et al. | Dec 2013 | B1 |
8615589 | Adogla et al. | Dec 2013 | B1 |
8631130 | Jackson | Jan 2014 | B2 |
8667471 | Wintergerst et al. | Mar 2014 | B2 |
8677359 | Cavage et al. | Mar 2014 | B1 |
8694996 | Cawlfield et al. | Apr 2014 | B2 |
8700768 | Benari | Apr 2014 | B2 |
8713093 | Upadhyay et al. | Apr 2014 | B1 |
8719415 | Sirota et al. | May 2014 | B1 |
8725702 | Raman et al. | May 2014 | B1 |
8756322 | Lynch | Jun 2014 | B1 |
8756696 | Miller | Jun 2014 | B1 |
8763091 | Singh et al. | Jun 2014 | B1 |
8769519 | Leitman et al. | Jul 2014 | B2 |
8793676 | Quinn et al. | Jul 2014 | B2 |
8799236 | Azari et al. | Aug 2014 | B1 |
8799879 | Wright et al. | Aug 2014 | B2 |
8806266 | Qu et al. | Aug 2014 | B1 |
8806468 | Meijer et al. | Aug 2014 | B2 |
8806644 | McCorkendale et al. | Aug 2014 | B1 |
8819679 | Agarwal et al. | Aug 2014 | B2 |
8825863 | Hansson et al. | Sep 2014 | B2 |
8825964 | Sopka et al. | Sep 2014 | B1 |
8839035 | Dimitrovich et al. | Sep 2014 | B1 |
8850432 | Mcgrath et al. | Sep 2014 | B2 |
8869300 | Singh et al. | Oct 2014 | B2 |
8874952 | Tameshige et al. | Oct 2014 | B2 |
8904008 | Calder et al. | Dec 2014 | B2 |
8949457 | Theroux et al. | Feb 2015 | B1 |
8966495 | Kulkarni | Feb 2015 | B2 |
8972980 | Banga et al. | Mar 2015 | B2 |
8990807 | Wu et al. | Mar 2015 | B2 |
8997093 | Dimitrov | Mar 2015 | B2 |
9002871 | Bulkowski et al. | Apr 2015 | B2 |
9021501 | Li et al. | Apr 2015 | B2 |
9026658 | Xu et al. | May 2015 | B2 |
9027087 | Ishaya et al. | May 2015 | B2 |
9038068 | Engle et al. | May 2015 | B2 |
9052935 | Rajaa | Jun 2015 | B1 |
9086897 | Oh et al. | Jul 2015 | B2 |
9086924 | Barsness et al. | Jul 2015 | B2 |
9092837 | Bala et al. | Jul 2015 | B2 |
9098528 | Wang | Aug 2015 | B2 |
9104477 | Kodialam et al. | Aug 2015 | B2 |
9110732 | Forschmiedt et al. | Aug 2015 | B1 |
9110770 | Raju et al. | Aug 2015 | B1 |
9111037 | Nalis et al. | Aug 2015 | B1 |
9112813 | Jackson | Aug 2015 | B2 |
9116733 | Banga et al. | Aug 2015 | B2 |
9130900 | Tran | Sep 2015 | B2 |
9141410 | Leafe et al. | Sep 2015 | B2 |
9146764 | Wagner | Sep 2015 | B1 |
9152406 | De et al. | Oct 2015 | B2 |
9154955 | Bertz et al. | Oct 2015 | B1 |
9164754 | Pohlack | Oct 2015 | B1 |
9176871 | Serlet | Nov 2015 | B1 |
9183019 | Kruglick | Nov 2015 | B2 |
9189778 | Sh. Al-Rashidi | Nov 2015 | B1 |
9195520 | Turk | Nov 2015 | B2 |
9208007 | Harper et al. | Dec 2015 | B2 |
9218190 | Anand et al. | Dec 2015 | B2 |
9223561 | Orveillon et al. | Dec 2015 | B2 |
9223966 | Satish et al. | Dec 2015 | B1 |
9250893 | Blahaerath et al. | Feb 2016 | B2 |
9268586 | Voccio et al. | Feb 2016 | B2 |
9298633 | Zhao et al. | Mar 2016 | B1 |
9317689 | Aissi | Apr 2016 | B2 |
9323556 | Wagner | Apr 2016 | B2 |
9361145 | Wilson et al. | Jun 2016 | B1 |
9405582 | Fuller et al. | Aug 2016 | B2 |
9411645 | Duan et al. | Aug 2016 | B1 |
9413626 | Reque et al. | Aug 2016 | B2 |
9417918 | Chin et al. | Aug 2016 | B2 |
9430290 | Gupta et al. | Aug 2016 | B1 |
9436555 | Dornemann et al. | Sep 2016 | B2 |
9461996 | Hayton et al. | Oct 2016 | B2 |
9471775 | Wagner et al. | Oct 2016 | B1 |
9471776 | Gu et al. | Oct 2016 | B2 |
9483335 | Wagner et al. | Nov 2016 | B1 |
9489227 | Oh et al. | Nov 2016 | B2 |
9497136 | Ramarao et al. | Nov 2016 | B1 |
9501345 | Lietz et al. | Nov 2016 | B1 |
9514037 | Dow et al. | Dec 2016 | B1 |
9537788 | Reque et al. | Jan 2017 | B2 |
9563613 | Dinkel et al. | Feb 2017 | B1 |
9565190 | Telvik et al. | Feb 2017 | B1 |
9575798 | Terayama et al. | Feb 2017 | B2 |
9588790 | Wagner et al. | Mar 2017 | B1 |
9594590 | Hsu | Mar 2017 | B2 |
9596350 | Dymshyts et al. | Mar 2017 | B1 |
9600312 | Wagner et al. | Mar 2017 | B2 |
9613127 | Rus et al. | Apr 2017 | B1 |
9626204 | Banga et al. | Apr 2017 | B1 |
9628332 | Bruno, Jr. et al. | Apr 2017 | B2 |
9635132 | Lin et al. | Apr 2017 | B1 |
9652306 | Wagner et al. | May 2017 | B1 |
9652617 | Evans et al. | May 2017 | B1 |
9654508 | Barton et al. | May 2017 | B2 |
9661011 | Van Horenbeeck et al. | May 2017 | B1 |
9678773 | Wagner et al. | Jun 2017 | B1 |
9678778 | Youseff | Jun 2017 | B1 |
9703681 | Taylor et al. | Jul 2017 | B2 |
9715402 | Wagner et al. | Jul 2017 | B2 |
9720661 | Gschwind et al. | Aug 2017 | B2 |
9720662 | Gschwind et al. | Aug 2017 | B2 |
9727725 | Wagner et al. | Aug 2017 | B2 |
9733967 | Wagner et al. | Aug 2017 | B2 |
9760387 | Wagner et al. | Sep 2017 | B2 |
9760443 | Tarasuk-Levin et al. | Sep 2017 | B2 |
9767271 | Ghose | Sep 2017 | B2 |
9785476 | Wagner et al. | Oct 2017 | B2 |
9787779 | Frank et al. | Oct 2017 | B2 |
9798831 | Chattopadhyay et al. | Oct 2017 | B2 |
9799017 | Vermeulen et al. | Oct 2017 | B1 |
9811363 | Wagner | Nov 2017 | B1 |
9811434 | Wagner | Nov 2017 | B1 |
9817695 | Clark | Nov 2017 | B2 |
9830175 | Wagner | Nov 2017 | B1 |
9830193 | Wagner et al. | Nov 2017 | B1 |
9830449 | Wagner | Nov 2017 | B1 |
9864636 | Patel et al. | Jan 2018 | B1 |
9898393 | Moorthi et al. | Feb 2018 | B2 |
9910713 | Wisniewski et al. | Mar 2018 | B2 |
9921864 | Singaravelu et al. | Mar 2018 | B2 |
9928108 | Wagner et al. | Mar 2018 | B1 |
9929916 | Subramanian et al. | Mar 2018 | B1 |
9930103 | Thompson | Mar 2018 | B2 |
9930133 | Susarla et al. | Mar 2018 | B2 |
9952896 | Wagner et al. | Apr 2018 | B2 |
9977691 | Marriner et al. | May 2018 | B2 |
9979817 | Huang et al. | May 2018 | B2 |
9983982 | Kumar et al. | May 2018 | B1 |
10002026 | Wagner | Jun 2018 | B1 |
10002036 | Fuchs et al. | Jun 2018 | B2 |
10013267 | Wagner et al. | Jul 2018 | B1 |
10042660 | Wagner et al. | Aug 2018 | B2 |
10048974 | Wagner et al. | Aug 2018 | B1 |
10061613 | Brooker et al. | Aug 2018 | B1 |
10067801 | Wagner | Sep 2018 | B1 |
10102040 | Marriner et al. | Oct 2018 | B2 |
10108443 | Wagner et al. | Oct 2018 | B2 |
10139876 | Lu et al. | Nov 2018 | B2 |
10140137 | Wagner | Nov 2018 | B2 |
10146635 | Chai et al. | Dec 2018 | B1 |
10162655 | Tuch et al. | Dec 2018 | B2 |
10162672 | Wagner et al. | Dec 2018 | B2 |
10162688 | Wagner | Dec 2018 | B2 |
10191861 | Steinberg | Jan 2019 | B1 |
10193839 | Tandon et al. | Jan 2019 | B2 |
10198298 | Bishop et al. | Feb 2019 | B2 |
10203990 | Wagner et al. | Feb 2019 | B2 |
10248467 | Wisniewski et al. | Apr 2019 | B2 |
10255090 | Tuch et al. | Apr 2019 | B2 |
10277708 | Wagner et al. | Apr 2019 | B2 |
10282229 | Wagner et al. | May 2019 | B2 |
10303492 | Wagner et al. | May 2019 | B1 |
10331462 | Varda et al. | Jun 2019 | B1 |
10346625 | Anderson et al. | Jul 2019 | B2 |
10353678 | Wagner | Jul 2019 | B1 |
10353746 | Reque et al. | Jul 2019 | B2 |
10360025 | Foskett et al. | Jul 2019 | B2 |
10360067 | Wagner | Jul 2019 | B1 |
10365985 | Wagner | Jul 2019 | B2 |
10387177 | Wagner et al. | Aug 2019 | B2 |
10402231 | Marriner et al. | Sep 2019 | B2 |
10423158 | Hadlich | Sep 2019 | B1 |
10437629 | Wagner et al. | Oct 2019 | B2 |
10445140 | Sagar et al. | Oct 2019 | B1 |
10459822 | Gondi | Oct 2019 | B1 |
10496547 | Naenko et al. | Dec 2019 | B1 |
10503626 | Idicula et al. | Dec 2019 | B2 |
10528390 | Brooker et al. | Jan 2020 | B2 |
10531226 | Wang et al. | Jan 2020 | B1 |
10552193 | Wagner et al. | Feb 2020 | B2 |
10552442 | Lusk et al. | Feb 2020 | B1 |
10564946 | Wagner et al. | Feb 2020 | B1 |
10572375 | Wagner | Feb 2020 | B1 |
10592269 | Wagner et al. | Mar 2020 | B2 |
10608973 | Kuo et al. | Mar 2020 | B2 |
10615984 | Wang | Apr 2020 | B1 |
10623476 | Thompson | Apr 2020 | B2 |
10637817 | Kuo et al. | Apr 2020 | B2 |
10649749 | Brooker et al. | May 2020 | B1 |
10649792 | Kulchytskyy et al. | May 2020 | B1 |
10650156 | Anderson et al. | May 2020 | B2 |
10652350 | Wozniak | May 2020 | B2 |
10678522 | Yerramreddy et al. | Jun 2020 | B1 |
10686605 | Chhabra et al. | Jun 2020 | B2 |
10691498 | Wagner | Jun 2020 | B2 |
10713080 | Brooker et al. | Jul 2020 | B1 |
10719367 | Kim et al. | Jul 2020 | B1 |
10725752 | Wagner et al. | Jul 2020 | B1 |
10725826 | Sagar et al. | Jul 2020 | B1 |
10733085 | Wagner | Aug 2020 | B1 |
10754701 | Wagner | Aug 2020 | B1 |
10776091 | Wagner et al. | Sep 2020 | B1 |
10776171 | Wagner et al. | Sep 2020 | B2 |
10817331 | Mullen et al. | Oct 2020 | B2 |
10817346 | Culp et al. | Oct 2020 | B1 |
10824484 | Wagner et al. | Nov 2020 | B2 |
10831898 | Wagner | Nov 2020 | B1 |
10846117 | Steinberg | Nov 2020 | B1 |
10853112 | Wagner et al. | Dec 2020 | B2 |
10853115 | Mullen et al. | Dec 2020 | B2 |
10884722 | Brooker et al. | Jan 2021 | B2 |
10884787 | Wagner et al. | Jan 2021 | B1 |
10884802 | Wagner et al. | Jan 2021 | B2 |
10884812 | Brooker et al. | Jan 2021 | B2 |
10891145 | Wagner et al. | Jan 2021 | B2 |
10915371 | Wagner et al. | Feb 2021 | B2 |
10942795 | Yanacek et al. | Mar 2021 | B1 |
10949237 | Piwonka et al. | Mar 2021 | B2 |
10956185 | Wagner | Mar 2021 | B2 |
10956244 | Cho | Mar 2021 | B1 |
11010188 | Brooker et al. | May 2021 | B1 |
11016815 | Wisniewski et al. | May 2021 | B2 |
11044198 | Ahn | Jun 2021 | B1 |
11082333 | Lam et al. | Aug 2021 | B1 |
11095706 | Ankam et al. | Aug 2021 | B1 |
11099870 | Brooker et al. | Aug 2021 | B1 |
11099917 | Hussels et al. | Aug 2021 | B2 |
11115404 | Siefker et al. | Sep 2021 | B2 |
11119809 | Brooker et al. | Sep 2021 | B1 |
11119813 | Kasaragod | Sep 2021 | B1 |
11119826 | Yanacek et al. | Sep 2021 | B2 |
11126469 | Reque et al. | Sep 2021 | B2 |
11132213 | Wagner et al. | Sep 2021 | B1 |
11146569 | Brooker et al. | Oct 2021 | B1 |
11159528 | Siefker et al. | Oct 2021 | B2 |
11188391 | Sule | Nov 2021 | B1 |
11190609 | Siefker et al. | Nov 2021 | B2 |
11231955 | Shahane et al. | Jan 2022 | B1 |
11243819 | Wagner | Feb 2022 | B1 |
11243953 | Wagner et al. | Feb 2022 | B2 |
11263034 | Wagner et al. | Mar 2022 | B2 |
11327992 | Batsakis | May 2022 | B1 |
11354169 | Marriner et al. | Jun 2022 | B2 |
11360793 | Wagner et al. | Jun 2022 | B2 |
11392497 | Brooker et al. | Jul 2022 | B1 |
11461124 | Wagner et al. | Oct 2022 | B2 |
11467890 | Wagner | Oct 2022 | B2 |
11550713 | Piwonka et al. | Jan 2023 | B1 |
11561811 | Wagner | Jan 2023 | B2 |
11593270 | Brooker et al. | Feb 2023 | B1 |
11714675 | Brooker et al. | Aug 2023 | B2 |
11836516 | Brooker et al. | Dec 2023 | B2 |
11861386 | Varun Mukesh et al. | Jan 2024 | B1 |
20010044817 | Asano et al. | Nov 2001 | A1 |
20020083012 | Bush et al. | Jun 2002 | A1 |
20020120685 | Srivastava et al. | Aug 2002 | A1 |
20020172273 | Baker et al. | Nov 2002 | A1 |
20030071842 | King et al. | Apr 2003 | A1 |
20030084434 | Rer | May 2003 | A1 |
20030149801 | Kushnirskiy | Aug 2003 | A1 |
20030177186 | Goodman et al. | Sep 2003 | A1 |
20030191795 | Bernardin et al. | Oct 2003 | A1 |
20030208569 | O'Brien et al. | Nov 2003 | A1 |
20030229794 | James, II et al. | Dec 2003 | A1 |
20040003087 | Chambliss et al. | Jan 2004 | A1 |
20040019886 | Berent et al. | Jan 2004 | A1 |
20040044721 | Song et al. | Mar 2004 | A1 |
20040049768 | Matsuyama et al. | Mar 2004 | A1 |
20040098154 | McCarthy | May 2004 | A1 |
20040158551 | Santosuosso | Aug 2004 | A1 |
20040205493 | Simpson et al. | Oct 2004 | A1 |
20040249947 | Novaes et al. | Dec 2004 | A1 |
20040268358 | Darling et al. | Dec 2004 | A1 |
20050027611 | Wharton | Feb 2005 | A1 |
20050044301 | Vasilevsky et al. | Feb 2005 | A1 |
20050120160 | Plouffe et al. | Jun 2005 | A1 |
20050132167 | Longobardi | Jun 2005 | A1 |
20050132368 | Sexton et al. | Jun 2005 | A1 |
20050149535 | Frey et al. | Jul 2005 | A1 |
20050193113 | Kokusho et al. | Sep 2005 | A1 |
20050193283 | Reinhardt et al. | Sep 2005 | A1 |
20050237948 | Wan et al. | Oct 2005 | A1 |
20050257051 | Richard | Nov 2005 | A1 |
20050262183 | Colrain et al. | Nov 2005 | A1 |
20050262512 | Schmidt et al. | Nov 2005 | A1 |
20060010440 | Anderson et al. | Jan 2006 | A1 |
20060015740 | Kramer | Jan 2006 | A1 |
20060031448 | Chu et al. | Feb 2006 | A1 |
20060036941 | Neil | Feb 2006 | A1 |
20060080678 | Bailey et al. | Apr 2006 | A1 |
20060123066 | Jacobs et al. | Jun 2006 | A1 |
20060129684 | Datta | Jun 2006 | A1 |
20060155800 | Matsumoto | Jul 2006 | A1 |
20060168174 | Gebhart et al. | Jul 2006 | A1 |
20060184669 | Vaidyanathan et al. | Aug 2006 | A1 |
20060200668 | Hybre et al. | Sep 2006 | A1 |
20060212332 | Jackson | Sep 2006 | A1 |
20060218601 | Michel | Sep 2006 | A1 |
20060242647 | Kimbrel et al. | Oct 2006 | A1 |
20060242709 | Seinfeld et al. | Oct 2006 | A1 |
20060248195 | Toumura et al. | Nov 2006 | A1 |
20060259763 | Cooperstein et al. | Nov 2006 | A1 |
20060282330 | Frank et al. | Dec 2006 | A1 |
20060288120 | Hoshino et al. | Dec 2006 | A1 |
20070033085 | Johnson | Feb 2007 | A1 |
20070050779 | Hayashi | Mar 2007 | A1 |
20070067321 | Bissett et al. | Mar 2007 | A1 |
20070076244 | Suzuki et al. | Apr 2007 | A1 |
20070094396 | Takano et al. | Apr 2007 | A1 |
20070101325 | Bystricky et al. | May 2007 | A1 |
20070112864 | Ben-Natan | May 2007 | A1 |
20070130341 | Ma | Jun 2007 | A1 |
20070174419 | O'Connell et al. | Jul 2007 | A1 |
20070180449 | Croft et al. | Aug 2007 | A1 |
20070180450 | Croft et al. | Aug 2007 | A1 |
20070180493 | Croft et al. | Aug 2007 | A1 |
20070186212 | Mazzaferri et al. | Aug 2007 | A1 |
20070192082 | Gaos et al. | Aug 2007 | A1 |
20070192329 | Croft et al. | Aug 2007 | A1 |
20070198656 | Mazzaferri et al. | Aug 2007 | A1 |
20070199000 | Shekhel et al. | Aug 2007 | A1 |
20070220009 | Morris et al. | Sep 2007 | A1 |
20070226700 | Gal et al. | Sep 2007 | A1 |
20070240160 | Paterson-Jones | Oct 2007 | A1 |
20070255604 | Seelig | Nov 2007 | A1 |
20070300297 | Dawson et al. | Dec 2007 | A1 |
20080028409 | Cherkasova et al. | Jan 2008 | A1 |
20080052401 | Bugenhagen et al. | Feb 2008 | A1 |
20080052725 | Stoodley et al. | Feb 2008 | A1 |
20080082977 | Araujo et al. | Apr 2008 | A1 |
20080104247 | Venkatakrishnan et al. | May 2008 | A1 |
20080104608 | Hyser et al. | May 2008 | A1 |
20080115143 | Shimizu et al. | May 2008 | A1 |
20080126110 | Haeberle et al. | May 2008 | A1 |
20080126486 | Heist | May 2008 | A1 |
20080127125 | Anckaert et al. | May 2008 | A1 |
20080147893 | Marripudi et al. | Jun 2008 | A1 |
20080178278 | Grinstein et al. | Jul 2008 | A1 |
20080184340 | Nakamura et al. | Jul 2008 | A1 |
20080189468 | Schmidt et al. | Aug 2008 | A1 |
20080195369 | Duyanovich et al. | Aug 2008 | A1 |
20080201568 | Quinn et al. | Aug 2008 | A1 |
20080201711 | Amir Husain | Aug 2008 | A1 |
20080209423 | Hirai | Aug 2008 | A1 |
20080244547 | Wintergerst et al. | Oct 2008 | A1 |
20080288940 | Adams et al. | Nov 2008 | A1 |
20080307098 | Kelly | Dec 2008 | A1 |
20090006897 | Sarsfield | Jan 2009 | A1 |
20090013153 | Hilton | Jan 2009 | A1 |
20090018892 | Grey et al. | Jan 2009 | A1 |
20090025009 | Brunswig et al. | Jan 2009 | A1 |
20090034537 | Colrain et al. | Feb 2009 | A1 |
20090055810 | Kondur | Feb 2009 | A1 |
20090055829 | Gibson | Feb 2009 | A1 |
20090070355 | Cadarette et al. | Mar 2009 | A1 |
20090077569 | Appleton et al. | Mar 2009 | A1 |
20090125902 | Ghosh et al. | May 2009 | A1 |
20090158275 | Wang et al. | Jun 2009 | A1 |
20090158407 | Nicodemus et al. | Jun 2009 | A1 |
20090177860 | Zhu et al. | Jul 2009 | A1 |
20090183162 | Kindel et al. | Jul 2009 | A1 |
20090193410 | Arthursson et al. | Jul 2009 | A1 |
20090198769 | Keller et al. | Aug 2009 | A1 |
20090204960 | Ben-Yehuda et al. | Aug 2009 | A1 |
20090204964 | Foley et al. | Aug 2009 | A1 |
20090222922 | Sidiroglou et al. | Sep 2009 | A1 |
20090271472 | Scheifler et al. | Oct 2009 | A1 |
20090288084 | Astete et al. | Nov 2009 | A1 |
20090300151 | Friedman et al. | Dec 2009 | A1 |
20090300599 | Piotrowski | Dec 2009 | A1 |
20090307430 | Bruening et al. | Dec 2009 | A1 |
20100023940 | Iwamatsu et al. | Jan 2010 | A1 |
20100031274 | Sim-Tang | Feb 2010 | A1 |
20100031325 | Maigne et al. | Feb 2010 | A1 |
20100036925 | Haffner | Feb 2010 | A1 |
20100037031 | DeSantis et al. | Feb 2010 | A1 |
20100058342 | Machida | Mar 2010 | A1 |
20100058351 | Yahagi | Mar 2010 | A1 |
20100064299 | Kacin et al. | Mar 2010 | A1 |
20100070678 | Zhang et al. | Mar 2010 | A1 |
20100070725 | Prahlad et al. | Mar 2010 | A1 |
20100083048 | Calinoiu et al. | Apr 2010 | A1 |
20100083248 | Wood et al. | Apr 2010 | A1 |
20100094816 | Groves, Jr. et al. | Apr 2010 | A1 |
20100106926 | Kandasamy et al. | Apr 2010 | A1 |
20100114825 | Siddegowda | May 2010 | A1 |
20100115098 | De Baer et al. | May 2010 | A1 |
20100122343 | Ghosh | May 2010 | A1 |
20100131936 | Cheriton | May 2010 | A1 |
20100131959 | Spiers et al. | May 2010 | A1 |
20100146004 | Sim-Tang | Jun 2010 | A1 |
20100169477 | Stienhans et al. | Jul 2010 | A1 |
20100186011 | Magenheimer | Jul 2010 | A1 |
20100198972 | Umbehocker | Aug 2010 | A1 |
20100199285 | Medovich | Aug 2010 | A1 |
20100257116 | Mehta et al. | Oct 2010 | A1 |
20100257269 | Clark | Oct 2010 | A1 |
20100269109 | Cartales | Oct 2010 | A1 |
20100298011 | Pelley et al. | Nov 2010 | A1 |
20100299541 | Ishikawa et al. | Nov 2010 | A1 |
20100312871 | Desantis et al. | Dec 2010 | A1 |
20100325727 | Neystadt et al. | Dec 2010 | A1 |
20100329149 | Singh et al. | Dec 2010 | A1 |
20100329643 | Kuang | Dec 2010 | A1 |
20110004687 | Takemura | Jan 2011 | A1 |
20110010690 | Howard et al. | Jan 2011 | A1 |
20110010722 | Matsuyama | Jan 2011 | A1 |
20110023026 | Oza | Jan 2011 | A1 |
20110029970 | Arasaratnam | Feb 2011 | A1 |
20110029984 | Norman et al. | Feb 2011 | A1 |
20110035785 | Mihara | Feb 2011 | A1 |
20110040812 | Phillips | Feb 2011 | A1 |
20110055378 | Ferris et al. | Mar 2011 | A1 |
20110055396 | DeHaan | Mar 2011 | A1 |
20110055683 | Jiang | Mar 2011 | A1 |
20110078679 | Bozek et al. | Mar 2011 | A1 |
20110099204 | Thaler | Apr 2011 | A1 |
20110099551 | Fahrig et al. | Apr 2011 | A1 |
20110131572 | Elyashev et al. | Jun 2011 | A1 |
20110134761 | Smith | Jun 2011 | A1 |
20110141124 | Halls et al. | Jun 2011 | A1 |
20110153541 | Koch et al. | Jun 2011 | A1 |
20110153727 | Li | Jun 2011 | A1 |
20110153838 | Belkine et al. | Jun 2011 | A1 |
20110154353 | Theroux et al. | Jun 2011 | A1 |
20110173637 | Brandwine et al. | Jul 2011 | A1 |
20110179162 | Mayo et al. | Jul 2011 | A1 |
20110184993 | Chawla et al. | Jul 2011 | A1 |
20110208866 | Marmolejo-Meillon et al. | Aug 2011 | A1 |
20110225277 | Freimuth et al. | Sep 2011 | A1 |
20110231680 | Padmanabhan et al. | Sep 2011 | A1 |
20110247005 | Benedetti et al. | Oct 2011 | A1 |
20110258603 | Wisnovsky et al. | Oct 2011 | A1 |
20110265067 | Schulte et al. | Oct 2011 | A1 |
20110265069 | Fee et al. | Oct 2011 | A1 |
20110265164 | Lucovsky | Oct 2011 | A1 |
20110271276 | Ashok et al. | Nov 2011 | A1 |
20110276945 | Chasman et al. | Nov 2011 | A1 |
20110276963 | Wu et al. | Nov 2011 | A1 |
20110296412 | Banga et al. | Dec 2011 | A1 |
20110314465 | Smith et al. | Dec 2011 | A1 |
20110321033 | Kelkar et al. | Dec 2011 | A1 |
20110321051 | Rastogi | Dec 2011 | A1 |
20120011496 | Shimamura | Jan 2012 | A1 |
20120011511 | Horvitz et al. | Jan 2012 | A1 |
20120016721 | Weinman | Jan 2012 | A1 |
20120041970 | Ghosh et al. | Feb 2012 | A1 |
20120054744 | Singh et al. | Mar 2012 | A1 |
20120060207 | Mardikar et al. | Mar 2012 | A1 |
20120072762 | Atchison et al. | Mar 2012 | A1 |
20120072914 | Ota | Mar 2012 | A1 |
20120072920 | Kawamura | Mar 2012 | A1 |
20120079004 | Herman | Mar 2012 | A1 |
20120096271 | Ramarathinam et al. | Apr 2012 | A1 |
20120096468 | Chakravorty et al. | Apr 2012 | A1 |
20120102307 | Wong | Apr 2012 | A1 |
20120102333 | Wong | Apr 2012 | A1 |
20120102481 | Mani et al. | Apr 2012 | A1 |
20120102493 | Allen et al. | Apr 2012 | A1 |
20120110155 | Adlung et al. | May 2012 | A1 |
20120110164 | Frey et al. | May 2012 | A1 |
20120110570 | Jacobson et al. | May 2012 | A1 |
20120110588 | Bieswanger et al. | May 2012 | A1 |
20120110603 | Kaneko et al. | May 2012 | A1 |
20120124563 | Chung et al. | May 2012 | A1 |
20120131379 | Tameshige et al. | May 2012 | A1 |
20120144290 | Goldman et al. | Jun 2012 | A1 |
20120166624 | Suit et al. | Jun 2012 | A1 |
20120173709 | Li et al. | Jul 2012 | A1 |
20120192184 | Burckart et al. | Jul 2012 | A1 |
20120197795 | Campbell et al. | Aug 2012 | A1 |
20120197958 | Nightingale et al. | Aug 2012 | A1 |
20120198442 | Kashyap et al. | Aug 2012 | A1 |
20120198514 | McCune et al. | Aug 2012 | A1 |
20120204164 | Castanos et al. | Aug 2012 | A1 |
20120209947 | Glaser et al. | Aug 2012 | A1 |
20120222038 | Katragadda et al. | Aug 2012 | A1 |
20120233464 | Miller et al. | Sep 2012 | A1 |
20120254193 | Chattopadhyay et al. | Oct 2012 | A1 |
20120324052 | Paleja et al. | Dec 2012 | A1 |
20120324236 | Srivastava et al. | Dec 2012 | A1 |
20120331113 | Jain et al. | Dec 2012 | A1 |
20130014101 | Ballani et al. | Jan 2013 | A1 |
20130042234 | DeLuca et al. | Feb 2013 | A1 |
20130054804 | Jana et al. | Feb 2013 | A1 |
20130054927 | Raj et al. | Feb 2013 | A1 |
20130055262 | Lubsey et al. | Feb 2013 | A1 |
20130061208 | Tsao et al. | Mar 2013 | A1 |
20130061212 | Krause et al. | Mar 2013 | A1 |
20130061220 | Gnanasambandam et al. | Mar 2013 | A1 |
20130067484 | Sonoda et al. | Mar 2013 | A1 |
20130067494 | Srour et al. | Mar 2013 | A1 |
20130080641 | Lui et al. | Mar 2013 | A1 |
20130091387 | Bohnet et al. | Apr 2013 | A1 |
20130097601 | Podvratnik et al. | Apr 2013 | A1 |
20130111032 | Alapati et al. | May 2013 | A1 |
20130111469 | B et al. | May 2013 | A1 |
20130124807 | Nielsen et al. | May 2013 | A1 |
20130132283 | Hayhow et al. | May 2013 | A1 |
20130132942 | Wang | May 2013 | A1 |
20130132953 | Chuang et al. | May 2013 | A1 |
20130139152 | Chang et al. | May 2013 | A1 |
20130139166 | Zhang et al. | May 2013 | A1 |
20130145354 | Bruening et al. | Jun 2013 | A1 |
20130151587 | Takeshima et al. | Jun 2013 | A1 |
20130151648 | Luna | Jun 2013 | A1 |
20130151684 | Forsman et al. | Jun 2013 | A1 |
20130152047 | Moorthi et al. | Jun 2013 | A1 |
20130167147 | Corrie et al. | Jun 2013 | A1 |
20130179574 | Calder et al. | Jul 2013 | A1 |
20130179881 | Calder et al. | Jul 2013 | A1 |
20130179894 | Calder et al. | Jul 2013 | A1 |
20130179895 | Calder et al. | Jul 2013 | A1 |
20130181998 | Malakapalli et al. | Jul 2013 | A1 |
20130185719 | Kar et al. | Jul 2013 | A1 |
20130185729 | Vasic et al. | Jul 2013 | A1 |
20130191847 | Sirota et al. | Jul 2013 | A1 |
20130191924 | Tedesco | Jul 2013 | A1 |
20130198319 | Shen et al. | Aug 2013 | A1 |
20130198743 | Kruglick | Aug 2013 | A1 |
20130198748 | Sharp et al. | Aug 2013 | A1 |
20130198763 | Kunze et al. | Aug 2013 | A1 |
20130205092 | Roy et al. | Aug 2013 | A1 |
20130205114 | Badam et al. | Aug 2013 | A1 |
20130219390 | Lee et al. | Aug 2013 | A1 |
20130227097 | Yasuda et al. | Aug 2013 | A1 |
20130227534 | Ike et al. | Aug 2013 | A1 |
20130227563 | McGrath | Aug 2013 | A1 |
20130227641 | White et al. | Aug 2013 | A1 |
20130227710 | Barak et al. | Aug 2013 | A1 |
20130232190 | Miller et al. | Sep 2013 | A1 |
20130232480 | Winterfeldt et al. | Sep 2013 | A1 |
20130239125 | Iorio | Sep 2013 | A1 |
20130246944 | Pandiyan et al. | Sep 2013 | A1 |
20130262556 | Xu et al. | Oct 2013 | A1 |
20130263117 | Konik et al. | Oct 2013 | A1 |
20130274006 | Hudlow et al. | Oct 2013 | A1 |
20130275376 | Hudlow et al. | Oct 2013 | A1 |
20130275958 | Ivanov et al. | Oct 2013 | A1 |
20130275969 | Dimitrov | Oct 2013 | A1 |
20130275975 | Masuda et al. | Oct 2013 | A1 |
20130283141 | Stevenson et al. | Oct 2013 | A1 |
20130283176 | Hoole et al. | Oct 2013 | A1 |
20130290538 | Gmach et al. | Oct 2013 | A1 |
20130291087 | Kailash et al. | Oct 2013 | A1 |
20130297964 | Hegdal et al. | Nov 2013 | A1 |
20130298183 | McGrath et al. | Nov 2013 | A1 |
20130311650 | Brandwine et al. | Nov 2013 | A1 |
20130326506 | McGrath et al. | Dec 2013 | A1 |
20130326507 | McGrath et al. | Dec 2013 | A1 |
20130332660 | Talagala et al. | Dec 2013 | A1 |
20130339950 | Ramarathinam et al. | Dec 2013 | A1 |
20130346470 | Obstfeld et al. | Dec 2013 | A1 |
20130346946 | Pinnix | Dec 2013 | A1 |
20130346952 | Huang et al. | Dec 2013 | A1 |
20130346964 | Nobuoka et al. | Dec 2013 | A1 |
20130346987 | Raney et al. | Dec 2013 | A1 |
20130346994 | Chen et al. | Dec 2013 | A1 |
20130347095 | Barjatiya et al. | Dec 2013 | A1 |
20140007097 | Chin et al. | Jan 2014 | A1 |
20140019523 | Heymann et al. | Jan 2014 | A1 |
20140019735 | Menon et al. | Jan 2014 | A1 |
20140019965 | Neuse et al. | Jan 2014 | A1 |
20140019966 | Neuse et al. | Jan 2014 | A1 |
20140040343 | Nickolov et al. | Feb 2014 | A1 |
20140040857 | Trinchini et al. | Feb 2014 | A1 |
20140040880 | Brownlow et al. | Feb 2014 | A1 |
20140047437 | Wu et al. | Feb 2014 | A1 |
20140058871 | Marr et al. | Feb 2014 | A1 |
20140059209 | Alnoor | Feb 2014 | A1 |
20140059226 | Messerli et al. | Feb 2014 | A1 |
20140059552 | Cunningham et al. | Feb 2014 | A1 |
20140068568 | Wisnovsky | Mar 2014 | A1 |
20140068608 | Kulkarni | Mar 2014 | A1 |
20140068611 | McGrath et al. | Mar 2014 | A1 |
20140073300 | Leeder et al. | Mar 2014 | A1 |
20140081984 | Sitsky et al. | Mar 2014 | A1 |
20140082165 | Marr et al. | Mar 2014 | A1 |
20140082201 | Shankari et al. | Mar 2014 | A1 |
20140101643 | Inoue | Apr 2014 | A1 |
20140101649 | Kamble et al. | Apr 2014 | A1 |
20140108722 | Lipchuk et al. | Apr 2014 | A1 |
20140109087 | Jujare et al. | Apr 2014 | A1 |
20140109088 | Dournov et al. | Apr 2014 | A1 |
20140129667 | Ozawa | May 2014 | A1 |
20140130040 | Lemanski | May 2014 | A1 |
20140137110 | Engle et al. | May 2014 | A1 |
20140164551 | Resch et al. | Jun 2014 | A1 |
20140173614 | Konik et al. | Jun 2014 | A1 |
20140173616 | Bird et al. | Jun 2014 | A1 |
20140180862 | Certain et al. | Jun 2014 | A1 |
20140189677 | Curzi et al. | Jul 2014 | A1 |
20140189704 | Narvaez et al. | Jul 2014 | A1 |
20140201735 | Kannan et al. | Jul 2014 | A1 |
20140207912 | Thibeault | Jul 2014 | A1 |
20140214752 | Rash et al. | Jul 2014 | A1 |
20140215073 | Dow et al. | Jul 2014 | A1 |
20140229221 | Shih et al. | Aug 2014 | A1 |
20140229942 | Wiseman et al. | Aug 2014 | A1 |
20140245297 | Hackett | Aug 2014 | A1 |
20140258777 | Cheriton | Sep 2014 | A1 |
20140279581 | Devereaux | Sep 2014 | A1 |
20140280325 | Krishnamurthy et al. | Sep 2014 | A1 |
20140282418 | Wood et al. | Sep 2014 | A1 |
20140282559 | Verduzco et al. | Sep 2014 | A1 |
20140282615 | Cavage et al. | Sep 2014 | A1 |
20140282629 | Gupta et al. | Sep 2014 | A1 |
20140283045 | Brandwine et al. | Sep 2014 | A1 |
20140289286 | Gusak | Sep 2014 | A1 |
20140298295 | Overbeck | Oct 2014 | A1 |
20140304246 | Helmich et al. | Oct 2014 | A1 |
20140304698 | Chigurapati et al. | Oct 2014 | A1 |
20140304815 | Maeda | Oct 2014 | A1 |
20140317617 | O'Donnell | Oct 2014 | A1 |
20140330936 | Factor et al. | Nov 2014 | A1 |
20140331222 | Zheng | Nov 2014 | A1 |
20140337953 | Banatwala et al. | Nov 2014 | A1 |
20140344457 | Bruno, Jr. et al. | Nov 2014 | A1 |
20140344736 | Ryman et al. | Nov 2014 | A1 |
20140351674 | Grube et al. | Nov 2014 | A1 |
20140359093 | Raju et al. | Dec 2014 | A1 |
20140359608 | Tsirkin et al. | Dec 2014 | A1 |
20140365781 | Dmitrienko et al. | Dec 2014 | A1 |
20140372489 | Jaiswal et al. | Dec 2014 | A1 |
20140372533 | Fu et al. | Dec 2014 | A1 |
20140380085 | Rash et al. | Dec 2014 | A1 |
20150006487 | Yang et al. | Jan 2015 | A1 |
20150025989 | Dunstan | Jan 2015 | A1 |
20150033241 | Jackson et al. | Jan 2015 | A1 |
20150039891 | Ignatchenko et al. | Feb 2015 | A1 |
20150040229 | Chan et al. | Feb 2015 | A1 |
20150046926 | Kenchammana-Hosekote et al. | Feb 2015 | A1 |
20150046971 | Huh et al. | Feb 2015 | A1 |
20150052258 | Johnson et al. | Feb 2015 | A1 |
20150058914 | Yadav | Feb 2015 | A1 |
20150067019 | Balko | Mar 2015 | A1 |
20150067830 | Johansson et al. | Mar 2015 | A1 |
20150074659 | Madsen et al. | Mar 2015 | A1 |
20150074661 | Kothari et al. | Mar 2015 | A1 |
20150074662 | Saladi et al. | Mar 2015 | A1 |
20150074675 | Qi et al. | Mar 2015 | A1 |
20150081885 | Thomas et al. | Mar 2015 | A1 |
20150095822 | Feis et al. | Apr 2015 | A1 |
20150106805 | Melander et al. | Apr 2015 | A1 |
20150120928 | Gummaraju et al. | Apr 2015 | A1 |
20150121391 | Wang | Apr 2015 | A1 |
20150134626 | Theimer et al. | May 2015 | A1 |
20150135287 | Medeiros et al. | May 2015 | A1 |
20150142747 | Zou | May 2015 | A1 |
20150142952 | Bragstad et al. | May 2015 | A1 |
20150143374 | Banga et al. | May 2015 | A1 |
20150143381 | Chin et al. | May 2015 | A1 |
20150146716 | Olivier et al. | May 2015 | A1 |
20150154046 | Farkas et al. | Jun 2015 | A1 |
20150161384 | Gu et al. | Jun 2015 | A1 |
20150163231 | Sobko et al. | Jun 2015 | A1 |
20150178019 | Hegdal et al. | Jun 2015 | A1 |
20150178110 | Li et al. | Jun 2015 | A1 |
20150186129 | Apte et al. | Jul 2015 | A1 |
20150188775 | Van Der Walt et al. | Jul 2015 | A1 |
20150199218 | Wilson et al. | Jul 2015 | A1 |
20150205596 | Hiltegen et al. | Jul 2015 | A1 |
20150206139 | Lea | Jul 2015 | A1 |
20150212818 | Gschwind et al. | Jul 2015 | A1 |
20150227598 | Hahn et al. | Aug 2015 | A1 |
20150229645 | Keith et al. | Aug 2015 | A1 |
20150235144 | Gusev et al. | Aug 2015 | A1 |
20150242225 | Muller et al. | Aug 2015 | A1 |
20150254248 | Burns et al. | Sep 2015 | A1 |
20150256514 | Laivand et al. | Sep 2015 | A1 |
20150256621 | Noda et al. | Sep 2015 | A1 |
20150261578 | Greden et al. | Sep 2015 | A1 |
20150264014 | Budhani et al. | Sep 2015 | A1 |
20150269494 | Kardes et al. | Sep 2015 | A1 |
20150271073 | Saladi et al. | Sep 2015 | A1 |
20150271280 | Zhang et al. | Sep 2015 | A1 |
20150289220 | Kim et al. | Oct 2015 | A1 |
20150309923 | Iwata et al. | Oct 2015 | A1 |
20150319160 | Ferguson et al. | Nov 2015 | A1 |
20150319174 | Hayton et al. | Nov 2015 | A1 |
20150324174 | Bromley et al. | Nov 2015 | A1 |
20150324182 | Barros et al. | Nov 2015 | A1 |
20150324210 | Carlson | Nov 2015 | A1 |
20150324229 | Valine | Nov 2015 | A1 |
20150332048 | Mooring et al. | Nov 2015 | A1 |
20150332195 | Jue | Nov 2015 | A1 |
20150334173 | Coulmeau et al. | Nov 2015 | A1 |
20150350701 | Lemus et al. | Dec 2015 | A1 |
20150356294 | Tan et al. | Dec 2015 | A1 |
20150363181 | Alberti et al. | Dec 2015 | A1 |
20150363304 | Nagamalla et al. | Dec 2015 | A1 |
20150370560 | Tan et al. | Dec 2015 | A1 |
20150370591 | Tuch et al. | Dec 2015 | A1 |
20150370592 | Tuch et al. | Dec 2015 | A1 |
20150371244 | Neuse et al. | Dec 2015 | A1 |
20150378762 | Saladi et al. | Dec 2015 | A1 |
20150378764 | Sivasubramanian et al. | Dec 2015 | A1 |
20150378765 | Singh et al. | Dec 2015 | A1 |
20150379167 | Griffith et al. | Dec 2015 | A1 |
20160011901 | Hurwitz et al. | Jan 2016 | A1 |
20160012099 | Tuatini et al. | Jan 2016 | A1 |
20160019081 | Chandrasekaran et al. | Jan 2016 | A1 |
20160019082 | Chandrasekaran et al. | Jan 2016 | A1 |
20160019536 | Ortiz et al. | Jan 2016 | A1 |
20160021112 | Katieb | Jan 2016 | A1 |
20160026486 | Abdallah | Jan 2016 | A1 |
20160048606 | Rubinstein et al. | Feb 2016 | A1 |
20160070714 | D'Sa et al. | Mar 2016 | A1 |
20160072727 | Leafe et al. | Mar 2016 | A1 |
20160072781 | Zhang et al. | Mar 2016 | A1 |
20160077901 | Roth et al. | Mar 2016 | A1 |
20160092320 | Baca | Mar 2016 | A1 |
20160092493 | Ko et al. | Mar 2016 | A1 |
20160098285 | Davis et al. | Apr 2016 | A1 |
20160100036 | Lo et al. | Apr 2016 | A1 |
20160103739 | Huang et al. | Apr 2016 | A1 |
20160110188 | Verde et al. | Apr 2016 | A1 |
20160117163 | Fukui et al. | Apr 2016 | A1 |
20160117254 | Susarla et al. | Apr 2016 | A1 |
20160119289 | Jain et al. | Apr 2016 | A1 |
20160124665 | Jain et al. | May 2016 | A1 |
20160124978 | Nithrakashyap et al. | May 2016 | A1 |
20160140180 | Park et al. | May 2016 | A1 |
20160150053 | Janczuk et al. | May 2016 | A1 |
20160188367 | Zeng | Jun 2016 | A1 |
20160191420 | Nagarajan et al. | Jun 2016 | A1 |
20160198235 | Liu et al. | Jul 2016 | A1 |
20160203219 | Hoch et al. | Jul 2016 | A1 |
20160212007 | Alatorre et al. | Jul 2016 | A1 |
20160226955 | Moorthi et al. | Aug 2016 | A1 |
20160282930 | Ramachandran et al. | Sep 2016 | A1 |
20160285906 | Fine et al. | Sep 2016 | A1 |
20160292016 | Bussard et al. | Oct 2016 | A1 |
20160294614 | Searle et al. | Oct 2016 | A1 |
20160306613 | Busi et al. | Oct 2016 | A1 |
20160315910 | Kaufman | Oct 2016 | A1 |
20160350099 | Suparna et al. | Dec 2016 | A1 |
20160350124 | Gschwind et al. | Dec 2016 | A1 |
20160357536 | Firlik et al. | Dec 2016 | A1 |
20160364265 | Cao et al. | Dec 2016 | A1 |
20160364316 | Bhat et al. | Dec 2016 | A1 |
20160371127 | Antony et al. | Dec 2016 | A1 |
20160371156 | Merriman | Dec 2016 | A1 |
20160378449 | Khazanchi et al. | Dec 2016 | A1 |
20160378525 | Bjorkengren | Dec 2016 | A1 |
20160378547 | Brouwer et al. | Dec 2016 | A1 |
20160378554 | Gummaraju et al. | Dec 2016 | A1 |
20170004169 | Merrill et al. | Jan 2017 | A1 |
20170032000 | Sharma et al. | Feb 2017 | A1 |
20170041144 | Krapf et al. | Feb 2017 | A1 |
20170041309 | Ekambaram et al. | Feb 2017 | A1 |
20170060615 | Thakkar et al. | Mar 2017 | A1 |
20170060621 | Whipple et al. | Mar 2017 | A1 |
20170068574 | Cherkasova et al. | Mar 2017 | A1 |
20170075749 | Ambichl et al. | Mar 2017 | A1 |
20170083381 | Cong et al. | Mar 2017 | A1 |
20170085447 | Chen et al. | Mar 2017 | A1 |
20170085502 | Biruduraju | Mar 2017 | A1 |
20170085591 | Ganda et al. | Mar 2017 | A1 |
20170091235 | Yammine et al. | Mar 2017 | A1 |
20170091296 | Beard et al. | Mar 2017 | A1 |
20170093684 | Jayaraman et al. | Mar 2017 | A1 |
20170093920 | Ducatel et al. | Mar 2017 | A1 |
20170134519 | Chen et al. | May 2017 | A1 |
20170142099 | Hinohara et al. | May 2017 | A1 |
20170147656 | Choudhary et al. | May 2017 | A1 |
20170149740 | Mansour et al. | May 2017 | A1 |
20170153965 | Nitta et al. | Jun 2017 | A1 |
20170161059 | Wood et al. | Jun 2017 | A1 |
20170177266 | Doerner et al. | Jun 2017 | A1 |
20170177441 | Chow | Jun 2017 | A1 |
20170177854 | Gligor et al. | Jun 2017 | A1 |
20170188213 | Nirantar et al. | Jun 2017 | A1 |
20170192825 | Biberman et al. | Jul 2017 | A1 |
20170221000 | Anand | Aug 2017 | A1 |
20170230262 | Sreeramoju et al. | Aug 2017 | A1 |
20170230499 | Mumick et al. | Aug 2017 | A1 |
20170249130 | Smiljamic et al. | Aug 2017 | A1 |
20170264681 | Apte et al. | Sep 2017 | A1 |
20170272462 | Kraemer et al. | Sep 2017 | A1 |
20170286187 | Chen et al. | Oct 2017 | A1 |
20170288878 | Lee et al. | Oct 2017 | A1 |
20170308520 | Beahan, Jr. et al. | Oct 2017 | A1 |
20170315163 | Wang et al. | Nov 2017 | A1 |
20170322824 | Reuther et al. | Nov 2017 | A1 |
20170329578 | Iscen | Nov 2017 | A1 |
20170346808 | Anzai et al. | Nov 2017 | A1 |
20170353851 | Gonzalez et al. | Dec 2017 | A1 |
20170364345 | Fontoura et al. | Dec 2017 | A1 |
20170371720 | Basu et al. | Dec 2017 | A1 |
20170372142 | Bilobrov | Dec 2017 | A1 |
20180004555 | Ramanathan et al. | Jan 2018 | A1 |
20180004556 | Marriner et al. | Jan 2018 | A1 |
20180004575 | Marriner et al. | Jan 2018 | A1 |
20180032410 | Kang et al. | Feb 2018 | A1 |
20180046453 | Nair et al. | Feb 2018 | A1 |
20180046482 | Karve et al. | Feb 2018 | A1 |
20180060132 | Maru et al. | Mar 2018 | A1 |
20180060221 | Yim et al. | Mar 2018 | A1 |
20180060318 | Yang et al. | Mar 2018 | A1 |
20180067841 | Mahimkar | Mar 2018 | A1 |
20180067873 | Pikhur et al. | Mar 2018 | A1 |
20180069702 | Ayyadevara et al. | Mar 2018 | A1 |
20180081717 | Li | Mar 2018 | A1 |
20180089232 | Spektor et al. | Mar 2018 | A1 |
20180095738 | Dürkop et al. | Apr 2018 | A1 |
20180113770 | Hasanov et al. | Apr 2018 | A1 |
20180113793 | Fink et al. | Apr 2018 | A1 |
20180121665 | Anderson et al. | May 2018 | A1 |
20180129684 | Wilson et al. | May 2018 | A1 |
20180144263 | Saxena et al. | May 2018 | A1 |
20180150339 | Pan et al. | May 2018 | A1 |
20180152401 | Tandon et al. | May 2018 | A1 |
20180152405 | Kuo et al. | May 2018 | A1 |
20180152406 | Kuo et al. | May 2018 | A1 |
20180165110 | Htay | Jun 2018 | A1 |
20180192101 | Bilobrov | Jul 2018 | A1 |
20180225096 | Mishra et al. | Aug 2018 | A1 |
20180227300 | Nakic et al. | Aug 2018 | A1 |
20180239636 | Arora et al. | Aug 2018 | A1 |
20180253333 | Gupta | Sep 2018 | A1 |
20180255137 | Hu et al. | Sep 2018 | A1 |
20180268130 | Ghosh et al. | Sep 2018 | A1 |
20180275987 | Vandeputte | Sep 2018 | A1 |
20180285101 | Yahav et al. | Oct 2018 | A1 |
20180300111 | Bhat et al. | Oct 2018 | A1 |
20180314845 | Anderson et al. | Nov 2018 | A1 |
20180316552 | Subramani Nadar et al. | Nov 2018 | A1 |
20180341504 | Kissell | Nov 2018 | A1 |
20180365422 | Callaghan et al. | Dec 2018 | A1 |
20180367517 | Tus | Dec 2018 | A1 |
20180375781 | Chen et al. | Dec 2018 | A1 |
20190004866 | Du et al. | Jan 2019 | A1 |
20190018715 | Behrendt et al. | Jan 2019 | A1 |
20190028552 | Johnson, II et al. | Jan 2019 | A1 |
20190034095 | Singh et al. | Jan 2019 | A1 |
20190043231 | Uzgin et al. | Feb 2019 | A1 |
20190068622 | Lin et al. | Feb 2019 | A1 |
20190072529 | Andrawes et al. | Mar 2019 | A1 |
20190073430 | Webster | Mar 2019 | A1 |
20190079751 | Foskett et al. | Mar 2019 | A1 |
20190102278 | Gahlin et al. | Apr 2019 | A1 |
20190140831 | De Lima Junior et al. | May 2019 | A1 |
20190141015 | Nellen | May 2019 | A1 |
20190147085 | Pal et al. | May 2019 | A1 |
20190147515 | Hurley et al. | May 2019 | A1 |
20190171423 | Mishra et al. | Jun 2019 | A1 |
20190179678 | Banerjee et al. | Jun 2019 | A1 |
20190179725 | Mital et al. | Jun 2019 | A1 |
20190180036 | Shukla | Jun 2019 | A1 |
20190188288 | Holm et al. | Jun 2019 | A1 |
20190196884 | Wagner | Jun 2019 | A1 |
20190235848 | Swiecki et al. | Aug 2019 | A1 |
20190238590 | Talukdar et al. | Aug 2019 | A1 |
20190250937 | Thomas et al. | Aug 2019 | A1 |
20190268152 | Sandoval et al. | Aug 2019 | A1 |
20190278938 | Greene et al. | Sep 2019 | A1 |
20190286475 | Mani | Sep 2019 | A1 |
20190286492 | Gulsvig Wood et al. | Sep 2019 | A1 |
20190303117 | Kocberber et al. | Oct 2019 | A1 |
20190306692 | Garty et al. | Oct 2019 | A1 |
20190311115 | Lavi et al. | Oct 2019 | A1 |
20190318312 | Foskett et al. | Oct 2019 | A1 |
20190320038 | Walsh | Oct 2019 | A1 |
20190324813 | Bogineni et al. | Oct 2019 | A1 |
20190339955 | Kuo et al. | Nov 2019 | A1 |
20190361802 | Li et al. | Nov 2019 | A1 |
20190363885 | Schiavoni et al. | Nov 2019 | A1 |
20190370113 | Zhang et al. | Dec 2019 | A1 |
20200007456 | Greenstein et al. | Jan 2020 | A1 |
20200026527 | Xu et al. | Jan 2020 | A1 |
20200028936 | Gupta et al. | Jan 2020 | A1 |
20200034471 | Danilov et al. | Jan 2020 | A1 |
20200057680 | Marriner et al. | Feb 2020 | A1 |
20200065079 | Kocberber et al. | Feb 2020 | A1 |
20200073770 | Mortimore, Jr. et al. | Mar 2020 | A1 |
20200073987 | Perumala et al. | Mar 2020 | A1 |
20200081745 | Cybulski et al. | Mar 2020 | A1 |
20200110691 | Bryant et al. | Apr 2020 | A1 |
20200120120 | Cybulski | Apr 2020 | A1 |
20200134030 | Natanzon et al. | Apr 2020 | A1 |
20200136933 | Raskar | Apr 2020 | A1 |
20200153798 | Liebherr | May 2020 | A1 |
20200153897 | Mestery et al. | May 2020 | A1 |
20200167208 | Floes et al. | May 2020 | A1 |
20200186445 | Govindaraju et al. | Jun 2020 | A1 |
20200192646 | Yerramreddy et al. | Jun 2020 | A1 |
20200213151 | Srivatsan et al. | Jul 2020 | A1 |
20200241930 | Garg et al. | Jul 2020 | A1 |
20200327236 | Pratt et al. | Oct 2020 | A1 |
20200341799 | Wagner et al. | Oct 2020 | A1 |
20200348979 | Calmon | Nov 2020 | A1 |
20200349067 | Syamala et al. | Nov 2020 | A1 |
20200366587 | White et al. | Nov 2020 | A1 |
20200401455 | Church et al. | Dec 2020 | A1 |
20200412538 | Rosado | Dec 2020 | A1 |
20210019056 | Mangione-Tran | Jan 2021 | A1 |
20210042160 | Alamouti et al. | Feb 2021 | A1 |
20210081233 | Mullen et al. | Mar 2021 | A1 |
20210117217 | Croteau et al. | Apr 2021 | A1 |
20210117534 | Maximov et al. | Apr 2021 | A1 |
20210124822 | Tiwary et al. | Apr 2021 | A1 |
20210176333 | Coleman | Jun 2021 | A1 |
20210232415 | Wagner et al. | Jul 2021 | A1 |
20210233045 | Singh et al. | Jul 2021 | A1 |
20210294646 | Hassaan et al. | Sep 2021 | A1 |
20210303720 | Creenaune et al. | Sep 2021 | A1 |
20210314250 | Laplante et al. | Oct 2021 | A1 |
20210342145 | Miller et al. | Nov 2021 | A1 |
20210342329 | Padmanabhan | Nov 2021 | A1 |
20210389963 | Wagner | Dec 2021 | A1 |
20220004423 | Brooker et al. | Jan 2022 | A1 |
20220012083 | Brooker et al. | Jan 2022 | A1 |
20220200993 | Smith | Jun 2022 | A1 |
20220201041 | Keiser, Jr. et al. | Jun 2022 | A1 |
20220214863 | Clement | Jul 2022 | A1 |
20220391238 | Wagner | Dec 2022 | A1 |
20230024699 | Bayoumi | Jan 2023 | A1 |
20230188516 | Danilov | Jun 2023 | A1 |
Number | Date | Country |
---|---|---|
2962633 | Apr 2012 | CA |
2975522 | Aug 2016 | CA |
1341238 | Mar 2002 | CN |
101002170 | Jul 2007 | CN |
101267334 | Sep 2008 | CN |
101345757 | Jan 2009 | CN |
101496005 | Jul 2009 | CN |
101627388 | Jan 2010 | CN |
101640700 | Feb 2010 | CN |
101764824 | Jun 2010 | CN |
102171712 | Aug 2011 | CN |
102246152 | Nov 2011 | CN |
102365858 | Feb 2012 | CN |
102420846 | Apr 2012 | CN |
102761549 | Oct 2012 | CN |
103098027 | May 2013 | CN |
103140828 | Jun 2013 | CN |
103384237 | Nov 2013 | CN |
103731427 | Apr 2014 | CN |
104111848 | Oct 2014 | CN |
104160378 | Nov 2014 | CN |
104243479 | Dec 2014 | CN |
104903854 | Sep 2015 | CN |
105122243 | Dec 2015 | CN |
105956000 | Sep 2016 | CN |
106921651 | Jul 2017 | CN |
107534672 | Jan 2018 | CN |
108885568 | Nov 2018 | CN |
109478134 | Mar 2019 | CN |
109564525 | Apr 2019 | CN |
112513813 | Mar 2021 | CN |
109564525 | May 2023 | CN |
2663052 | Nov 2013 | EP |
3201762 | Aug 2017 | EP |
3254434 | Dec 2017 | EP |
3356938 | Aug 2018 | EP |
3201768 | Dec 2019 | EP |
3811209 | Apr 2021 | EP |
3814895 | May 2021 | EP |
3857375 | Aug 2021 | EP |
4064052 | Sep 2022 | EP |
2002-287974 | Oct 2002 | JP |
2006-107599 | Apr 2006 | JP |
2007-080161 | Mar 2007 | JP |
2007-538323 | Dec 2007 | JP |
2010-026562 | Feb 2010 | JP |
2011-065243 | Mar 2011 | JP |
2011-233146 | Nov 2011 | JP |
2011-257847 | Dec 2011 | JP |
2012-078893 | Apr 2012 | JP |
2012-104150 | May 2012 | JP |
2013-156996 | Aug 2013 | JP |
2014-525624 | Sep 2014 | JP |
2016-507100 | Mar 2016 | JP |
2017-534107 | Nov 2017 | JP |
2017-534967 | Nov 2017 | JP |
2018-503896 | Feb 2018 | JP |
2018-512087 | May 2018 | JP |
2018-536213 | Dec 2018 | JP |
7197612 | Dec 2022 | JP |
7210713 | Jan 2023 | JP |
10-357850 | Oct 2002 | KR |
10-2021-0019533 | Feb 2021 | KR |
10-2541295 | Jun 2023 | KR |
WO 2008114454 | Sep 2008 | WO |
WO 2009137567 | Nov 2009 | WO |
WO 2012039834 | Mar 2012 | WO |
WO 2012050772 | Apr 2012 | WO |
WO 2013106257 | Jul 2013 | WO |
WO 2015078394 | Jun 2015 | WO |
WO 2015108539 | Jul 2015 | WO |
WO 2015149017 | Oct 2015 | WO |
WO 2016053950 | Apr 2016 | WO |
WO 2016053968 | Apr 2016 | WO |
WO 2016053973 | Apr 2016 | WO |
WO 2016090292 | Jun 2016 | WO |
WO 2016126731 | Aug 2016 | WO |
WO 2016164633 | Oct 2016 | WO |
WO 2016164638 | Oct 2016 | WO |
WO 2017059248 | Apr 2017 | WO |
WO 2017112526 | Jun 2017 | WO |
WO 2017172440 | Oct 2017 | WO |
WO 2018005829 | Jan 2018 | WO |
WO 2018039514 | Jan 2018 | WO |
WO 2018098443 | May 2018 | WO |
WO 2018098445 | May 2018 | WO |
WO 2020005764 | Jan 2020 | WO |
WO 2020006081 | Jan 2020 | WO |
WO 2020069104 | Apr 2020 | WO |
WO 2020123439 | Jun 2020 | WO |
WO 2020264431 | Dec 2020 | WO |
WO 2021108435 | Jun 2021 | WO |
WO 2023107649 | Jun 2023 | WO |
Entry |
---|
Anonymous: “Amazon Elastic Compute Cloud User Guide for Linux Instances—first 400 pages of 795,” Apr. 8, 2016 (Apr. 8, 2016_, XP055946665, Retrieved from the Internet: URL:https://web.archive.org/web/20160408211543if_/http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-ug.pdf (retrieved on Jul. 27, 2022] 795 pages. |
Anonymous: “Amazon Simple Workflow Service Developer Guide API Version Jan. 25, 2012,” Jun. 11, 2016 (Jun. 11, 2016), XP055946928, Retrieved from the Internet: URL:https://web.archive.org/web/20160111075522if_/http://docs.aws.amazon.com/amazonswf/latest/developerguide/swf-dg.pdf [retrieved on Jul. 28, 2022] in 197 pages. |
Anonymous: “AWS Flow Framework for Java,” Apr. 7, 2016 (Apr. 7, 2016), XP055946535, Retrieved from the Internet: URL:https://web.archive.org/web/20160407214715if_/http://docs.aws.amazon.com/amazonswf/latest/awsflowguide/swf-aflow.pdf, [retrieved Jul. 27, 2022] in 139 pages. |
European Examination Report, re EP Application No. 17743108.7, dated Oct. 12, 2022. |
First Chinese Office Action in Chinese Application No. 201780045148.9, dated Sep. 29, 2022. |
Office Action in Japanese Application No. 2020-572443 dated Sep. 29, 2022. |
Office Action in European Application No. 19736909.3 dated Oct. 12, 2022. |
Anonymous: “Docker run reference”, Dec. 7, 2015, XP055350246, Retrieved from the Internet: URL:https://web.archive.org/web/20151207111702/https:/docs.docker.com/engine/reference/run/ [retrieved on Feb. 28, 2017]. |
Adapter Pattern, Wikipedia, https://en.wikipedia.org/w/index.php?title=Adapter_pattern&oldid=654971255, [retrieved May 26, 2016], 6 pages. |
Amazon, “AWS Lambda: Developer Guide”, Jun. 26, 2016 Retrieved from the Internet, URL:http://docs.aws.amazon.com/lambda/latest/dg/lambda-dg.pdf, [retrieved on Aug. 30, 2017], 314 pages. |
Amazon, “AWS Lambda: Developer Guide”, Apr. 30, 2016 Retrieved from the Internet, URL: https://web.archive.org/web/20160430050158/http://docs.aws.amazon.com:80/lambda/latest/dg/lambda-dg.pdf, 346 pages. |
Amazon, “AWS Lambda: Developer Guide”, Retrieved from the Internet, 2019, URL : http://docs.aws.amazon.com/lambda/ latest/dg/lambda-dg.pdf, 521 pages. |
Balazinska et al., Moirae: History-Enhanced Monitoring, Published: Jan. 2007, 12 pages. |
Bebenita et al., “Trace-Based Compilation in Execution Environments without Interpreters,” ACM, Copyright 2010, 10 pages. |
Ben-Yehuda et al., “Deconstructing Amazon EC2 Spot Instance Pricing”, ACM Transactions on Economics and Computation 1.3, Sep. 2013, 15 pages. |
Bhadani et al., Performance evaluation of web servers using central load balancing policy over virtual machines on cloud, Jan. 2010, 4 pages. |
Bryan Liston, “Ad Hoc Big Data Processing Made Simple with Serverless Map Reduce”, Nov. 4, 2016, Amazon Web Services <https :/laws. amazon .com/bl ogs/compute/ad-hoc-big-data-processi ng-made-si mple-with-serverless-mapred uce >. |
CodeChef Admin discussion web page, retrieved from https://discuss.codechef.com/t/what-are-the-memory-limit-and-stack-size-on-codechef/14159, retrieved on Sep. 10, 2019. |
CodeChef IDE web page, Code, Compile & Run, retrieved from https://www.codechef.com/ide, retrieved on Sep. 9, 2019. |
Czajkowski, G., and L. Daynes, Multitasking Without Compromise: A Virtual Machine Evolution 47(4a):60-73, ACM SIGPLAN Notices—Supplemental Issue, Apr. 2012. |
Das et al., Adaptive Stream Processing using Dynamic Batch Sizing, Nov. 2014, 13 pages. |
Deis, Container, Jun. 2014, 1 page. |
Dean et al, “MapReduce: Simplified Data Processing on Large Clusters”, ACM, 2008, pp. 107-113. |
Dombrowski, M., et al., Dynamic Monitor Allocation in the Java Virtual Machine, JTRES '13, Oct. 9-11, 2013, pp. 30-37. |
Dornemann et al., “On-Demand Resource Provisioning for BPEL Workflows Using Amazon's Elastic Compute Cloud”, 9th IEEE/ACM International Symposium on Cluster Computing and the Grid, 2009, pp. 140-147. |
Dynamic HTML, Wikipedia page from date Mar. 27, 2015, retrieved using the WayBackMachine, from https://web.archive.org/web/20150327215418/https://en.wikipedia.org/wiki/Dynamic_HTML, 2015, 6 pages. |
Ekanayake et al, “Twister: A Runtime for Iterative MapReduce”, ACM, 2010, pp. 810-818. |
Espadas, J., et al., A Tenant-Based Resource Allocation Model for Scaling Software-as-a-Service Applications Over Cloud Computing Infrastructures, Future Generation Computer Systems, vol. 29, pp. 273-286, 2013. |
Fan et al., Online Optimization of VM Deployment in laaS Cloud, Dec. 17-Dec. 19, 2012, 6 pages. |
Ha et al., A Concurrent Trace-based Just-In-Time Compiler for Single-threaded JavaScript, utexas.edu, Jun. 2009. |
Hammoud et al, “Locality-Aware Reduce Task Scheduling for MapReduce”, IEEE, 2011, pp. 570-576. |
Han et al., Lightweight Resource Scaling for Cloud Applications, May 13-May 16, 2012, 8 pages. |
Hoffman, Auto scaling your website with Amazon Web Services (AWS)—Part 2, Cardinalpath, Sep. 2015, 15 pages. |
http://discuss.codechef.com discussion web page from date Nov. 11, 2012, retrieved using the WayBackMachine, from https://web.archive.org/web/20121111040051/http://discuss.codechef.com/questions/2881 /why-are-simple-java-programs-using-up-so-much-space, 2012. |
https://www.codechef.com code error help page from Jan. 2014, retrieved from https://www.codechef.com/JAN14/status/ERROR,va123, 2014. |
http://www.codechef.com/ide web page from date Apr. 5, 2015, retrieved using the WayBackMachine, from https://web.archive.org/web/20150405045518/http://www.codechef.com/ide, 2015. |
Huang, Zhe, Danny HK Tsang, and James She. “A virtual machine consolidation framework for mapreduce enabled computing clouds.” 2012 24th International Teletraffic Congress (ITC 24). IEEE, Sep. 4-Sep. 7, 2012. |
Kamga et al., Extended scheduler for efficient frequency scaling in virtualized systems, Jul. 2012, 8 pages. |
Kato, et al. “Web Service Conversion Architecture of the Web Application and Evaluation”; Research Report from Information Processing Society, Apr. 3, 2006 with Machine Translation. |
Kazempour et al., AASH: an asymmetry-aware scheduler for hypervisors, Jul. 2010, 12 pages. |
Kim et al, “MRBench: A Benchmark for Map-Reduce Framework”, IEEE, 2008, pp. 11-18. |
Kraft et al., 10 performance prediction in consolidated virtualized environments, Mar. 2011, 12 pages. |
Krsul et al., “VMPlants: Providing and Managing Virtual Machine Execution Environments for Grid Computing”, Supercomputing, 2004. Proceedings of the ACM/IEEESC 2004 Conference Pittsburgh, PA, XP010780332, Nov. 6-12, 2004, 12 pages. |
Lagar-Cavilla et al., “SnowFlock: Virtual Machine Cloning as a First-Class Cloud Primitive”, ACM Transactions on Computer Systems, vol. 29, No. 1, Article 2, Publication date: Feb. 2011, in 45 pages. |
Lin, “MR-Apriori: Association Rules Algorithm Based on MapReduce”, IEEE, 2014, pp. 141-144. |
Meng et al., Efficient resource provisioning in compute clouds via VM multiplexing, Jun. 2010, 10 pages. |
Merkel, “Docker: Lightweight Linux Containers for Consistent Development and Deployment”, Linux Journal, vol. 2014 Issue 239, Mar. 2014, XP055171140, 16 pages. |
Monteil, Coupling profile and historical methods to predict execution time of parallel applications. Parallel and Cloud Computing, Jul. 2013, <hal-01228236, pp. 81-89. |
Nakajima, J., et al., Optimizing Virtual Machines Using Hybrid Virtualization, SAC '11, Mar. 21-25, 2011, TaiChung, Taiwan, pp. 573-578. |
Qian, H., and D. Medhi, et al., Estimating Optimal Cost of Allocating Virtualized Resources With Dynamic Demand, ITC 2011, Sep. 2011, pp. 320-321. |
Ryden et al., “Nebula: Distributed Edge Cloud for Data-Intensive Computing”, IEEE, 2014, pp. 491-492. |
Sakamoto, et al. “Platform for Web Services using Proxy Server”; Research Report from Information Processing Society, Mar. 22, 2002, vol. 2002, No. 31. |
Search Query Report from IP.com, performed Dec. 2, 2020. |
Search Query Report from IP.com, performed May 27, 2021. |
Shim (computing), Wikipedia, https://en.wikipedia.org/w/index.php?title+Shim_(computing)&oldid+654971528, [retrieved on May 26, 2016], 2 pages. |
Stack Overflow, Creating a database connection pool, Nov. 10, 2009, 4 pages. |
Tan et al., Provisioning for large scale cloud computing services, Jun. 2012, 2 pages. |
Tange, “GNU Parallel: The Command-Line Power Tool”, vol. 36, No. 1, Jan. 1, 1942, pp. 42-47. |
Vaghani, S.B., Virtual Machine File System, ACM SIGOPS Operating Systems Review 44(4):57-70, Dec. 2010. |
Vaquero, L., et al., Dynamically Scaling Applications in the cloud, ACM SIGCOMM Computer Communication Review 41(1):45-52, Jan. 2011. |
Wang et al., “Improving utilization through dynamic VM resource allocation in hybrid cloud environment”, Parallel and Distributed V Systems (ICPADS), IEEE, Dec. 16-Dec. 19, 2014. Retrieved on Feb. 14, 2019, Retrieved from the internet: URL<https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=7097814, 8 pages. |
Wikipedia “API” pages from date Apr. 7, 2015, retrieved using the WayBackMachine from https://web.archive.org/web/20150407191158/https://en .wikipedia.org/wiki/Application_programming_interface. |
Wikipedia List_of_HTTP status_codes web page, retrieved from https://en.wikipedia.org/wiki/List_of_HTTP status_codes, retrieved on Sep. 10, 2019. |
Wikipedia Recursion web page from date Mar. 26, 2015, retrieved using the WayBackMachine, from https://web.archive.org/web/20150326230100/https://en.wikipedia.org/wiki/Recursion_(computer _science), 2015. |
Wikipedia subroutine web page, retrieved from https://en.wikipedia.org/wiki/Subroutine, retrieved on Sep. 10, 2019. |
Wood, Timothy, et al. “Cloud Net: dynamic pooling of cloud resources by live WAN migration of virtual machines.” ACM Sigplan Notices 46.7 (2011): 121-132. (Year: 2011). |
Wu et al., HC-Midware: A Middleware to Enable High Performance Communication SystemSimulation in Heterogeneous Cloud, Association for Computing Machinery, Oct. 20-22, 2017, 10 pages. |
Yamasaki et al. “Model-based resource selection for efficient virtual cluster deployment”, Virtualization Technology in Distributed Computing, ACM, Nov. 2007, pp. 1-7. |
Yang, The Application of MapReduce in the Cloud Computing:, IEEE, 2011, pp. 154-156. |
Yue et al., AC 2012-4107: Using Amazon EC2 in Computer and Network Security Lab Exercises: Design, Results, and Analysis, 2012, American Society for Engineering Education, Jun. 10, 2012. |
Zhang et al., VMThunder: Fast Provisioning of Large-Scale Virtual Machine Clusters, IEEE Transactions on Parallel and Distributed Systems, vol. 25, No. 12, Dec. 2014, pp. 3328-3338. |
Zheng, C., and D. Thain, Integrating Containers into Workflows: A Case Study Using Makeflow, Work Queue, and Docker, VTDC '15, Jun. 15, 2015, Portland, Oregon, pp. 31-38. |
International Search Report and Written Opinion in PCT/US2015/052810 dated Dec. 17, 2015. |
International Preliminary Report on Patentability in PCT/US2015/052810 dated Apr. 4, 2017. |
Extended Search Report in European Application No. 15846932.0 dated May 3, 2018. |
Office Action in Chinese Application No. 202110268031.5, dated Sep. 3, 2021. |
Office Action in Canadian Application No. 2,962,633 dated May 21, 2020. |
Office Action in Canadian Application No. 2,962,633 dated Jun. 18, 2021. |
Office Action in European Application No. 19199402.9 dated Mar. 23, 2021. |
Office Action in European Application No. 19199402.9 dated Dec. 3, 2021 in 4 pages. |
International Search Report and Written Opinion in PCT/US2015/052838 dated Dec. 18, 2015. |
International Preliminary Report on Patentability in PCT/US2015/052838 dated Apr. 4, 2017. |
Extended Search Report in European Application No. 15847202.7 dated Sep. 9, 2018. |
Extended Search Report in European Application No. 19199402.9 dated Mar. 6, 2020. |
Office Action in Japanese Application No. 2017-516160 dated Jan. 15, 2018. |
Notice of Allowance in Japanese Application No. 2017-516160 dated May 8, 2018. |
Office Action in Canadian Application No. 2,962,631 dated May 19, 2020. |
Office Action in Canadian Application No. 2,962,631 dated May 31, 2021. |
Office Action in Indian Application No. 201717013356 dated Jan. 22, 2021. |
Office Action in Japanese Application No. 2017-516168 dated Mar. 26, 2018. |
International Search Report and Written Opinion in PCT/US2015/052833 dated Jan. 13, 2016. |
International Preliminary Report on Patentability in PCT/US2015/052833 dated Apr. 4, 2017. |
Extended Search Report in European Application No. 15846542.7 dated Aug. 27, 2018. |
Office Action in Indian Application No. 201717019903 dated May 18, 2020. |
International Search Report and Written Opinion in PCT/US2015/064071dated Mar. 16, 2016. |
International Preliminary Report on Patentability in PCT/US2015/064071 dated Jun. 6, 2017. |
Office Action in Australian Application No. 2016215438 dated Feb. 26, 2018. |
Notice of Allowance in Australian Application No. 2016215438 dated Nov. 19, 2018. |
Office Action in Canadian Application No. 2,975,522 dated Jun. 5, 2018. |
Notice of Allowance in Canadian Application No. 2,975,522 dated Mar. 13, 2020. |
Office Action in Indian Application No. 201717027369 dated May 21, 2020. |
International Search Report and Written Opinion in PCT/US2016/016211 dated Apr. 13, 2016. |
International Preliminary Report on Patentability in PCT/US2016/016211 dated Aug. 17, 2017. |
Office Action in Chinese Application No. 201680020768.2 dated May 14, 2021 in 23 pages. |
Office Action in Chinese Application No. 201680020768.2 dated Sep. 24, 2021 in 20 pages. |
First Examination Report for Indian Application No. 201717034806 dated Jun. 25, 2020. |
International Search Report and Written Opinion in PCT/US2016/026514 dated Jun. 8, 2016. |
International Preliminary Report on Patentability in PCT/US2016/026514 dated Oct. 10, 2017. |
International Search Report and Written Opinion in PCT/US2016/026520 dated Jul. 5, 2016. |
International Preliminary Report on Patentability in PCT/US2016/026520 dated Oct. 10, 2017. |
Office Action in Chinese Application No. 2016800562398 dated Jun. 18, 2021. |
International Search Report and Written Opinion in PCT/US2016/054774 dated Dec. 16, 2016. |
Office Action in European Application No. 16781265.0 dated Jul. 13, 2020. |
Office Action in Indian Application No. 201817013748 dated Nov. 20, 2020. |
International Preliminary Report on Patentability in PCT/US2016/054774 dated Apr. 3, 2018. |
Office Action in Chinese Application No. 201680072794X dated Jun. 22, 2021. |
Office Action in European Application No. 16823419.3 dated Mar. 12, 2021. |
International Search Report and Written Opinion in PCT/US2016/066997 dated Mar. 20, 2017. |
International Preliminary Report on Patentability in PCT/US2016/066997 dated Jun. 26, 2018. |
Office Action in Chinese Application No. 201780022789.2 dated Apr. 28, 2021. |
Office Action in European Application No. 17776325.7 dated Apr. 12, 2021. |
International Search Report and Written Opinion in PCT/US/2017/023564 dated Jun. 6, 2017. |
International Preliminary Report on Patentability in PCT/US/2017/023564 dated Oct. 2, 2018. |
Office Action in Chinese Application No. 2017800451968 dated May 26, 2021. |
Office Action in Chinese Application No. 2017800451968 dated Dec. 3, 2021 in 20 pages. |
Office Action in European Application No. 17740533.9 dated May 4, 2021. |
International Search Report and Written Opinion in PCT/US2017/040054 dated Sep. 21, 2017. |
International Preliminary Report on Patentability in PCT/US2017/040054 dated Jan. 1, 2019. |
International Search Report and Written Opinion in PCT/US2017/039514 dated Oct. 10, 2017. |
International Preliminary Report on Patentability in PCT/US2017/039514 dated Jan. 1, 2019. |
Extended European Search Report in application No. 17776325.7 dated Oct. 23, 2019. |
Office Action in European Application No. 17743108.7 dated Jan. 14, 2020. |
Office Action in European Application No. 17743108.7 dated Dec. 22, 2020. |
International Search Report and Written Opinion dated Oct. 15, 2019 for International Application No. PCT/US2019/039246 in 16 pages. |
International Preliminary Report on Patentability dated Dec. 29, 2020 for International Application No. PCT/US2019/039246 in 8 pages. |
Office Action in Japanese Application No. 2020-572441 dated Dec. 22, 2021 in 8 pages. |
International Search Report for Application No. PCT/US2019/038520 dated Aug. 14, 2019. |
International Preliminary Report on Patentability for Application No. PCT/US2019/038520 dated Dec. 29, 2020. |
International Preliminary Report on Patentability and Written Opinion in PCT/US2019/053123 dated Mar. 23, 2021. |
International Search Report and Written Opinion in PCT/US2019/053123 dated Jan. 7, 2020. |
International Search Report for Application No. PCT/US2019/065365 dated Mar. 19, 2020. |
International Preliminary Report on Patentability for Application No. PCT/US2019/065365 dated Jun. 8, 2021. |
International Search Report for Application No. PCT/US2020/039996 dated Oct. 8, 2020. |
International Preliminary Report on Patentability for Application No. PCT/US2020/039996 dated Jan. 6, 2022. |
International Search Report for Application No. PCT/US2020/062060 dated Mar. 5, 2021. |
Office Action in Japanese Application No. 2020-572443 dated Feb. 28, 2022. |
Abebe et al., “EC-Store: Bridging the Gap Between Storage and Latency in Distribute Erasure Coded Systems”, IEEE 38th International Conference on Distributed Computing Systems, 2018, pp. 255-266. |
Huang et al., “Erasure Coding in Windows Azure Storege”, USENIX, 2012 in 12 pages. |
Rashmi et al., “EC-Cache: Load-Balance, Low-Latency Cluster Caching with Online Erasure Coding”, USENIX, 2016, pp. 401-417. |
Communication Pursuant to Article 94(3) EPC in European Application No. 19199402.9 dated Apr. 19, 2022 in 5 pages. |
Office Action in European Application No. 16823419.3 dated May 20, 2022 in 6 pages. |
Office Action in European Application No. 19740451.0 dated Jun. 13, 2022 in 4 pages. |
Office Action in Korean Application No. 10-2021-7000975 dated Mar. 31, 2022 in 12 pages. |
Office Action in Japanese Application No. 2021-517335 dated May 16, 2022. |
International Preliminary Report on Patentability for Application No. PCT/US2020/062060 dated Jun. 9, 2022 in 9 pages. |
Decision to refuse a European Patent Application in European Patent Application No. 16716797.2 dated Dec. 20, 2021 in 20 pages. |
Anonymous: “Amazon Cognito Developer Guide,” Jun. 24, 2001, XP093030075, retrieved from the internet: URL:https://web.archive.org/web/2021062415394lif_/https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-dg.pdf [retrieved on Mar. 9, 2023] the whole document. |
Anonymous: “AWS Lambda Developer Guide,” Jul. 1, 2021, XP093024770, retrieved from the internet: URL:https://web.archieve.org/web/20210701100128if_/https://docs.aws.amazon.com/lambda/latest/dg/lambda-dg.pdf [retrieved on Feb. 17, 2023] the whole document. |
Anonymous: “AWS Lambda Developer Guide,” Jul. 1, 2021, XP093024770, retrieved from the internet: URL:https://web.archive.org/web/20210701100128if_/https://docs.aws.amazon.com/lambda/latest/dg/lambda-dg.pdf [retrieved on Feb. 17, 2023] the whole document. |
Anonymous: SaaS Tenant Isolution Strategies Isolating Resources in a Multi-Tenant Environment,: Aug. 1, 2020, XP093030095, retrieved from the internet: URL:https://dl.awsstatic.com/whitepapers/saas-tenant-isolation-strategies.pdf [retrieved on Mar. 9, 2023] the whole document. |
Anonymous: “Security Overview of AWS Lambda,” Aug. 11, 2021, XP093030100, retrieved from the internet: URL:https://web.archive.org/web/20210811044132if_/https://docs.aws.amazon.com/whitepapers/latest/security-overview-aws-lambda/security-overview-aws-lambda.pdf [retrieved Mar. 9, 2023] the whole document. |
Sharma A. et al., “Building a Multi-Tenant SaaS Solution Using AWS Serverless Services,” Aug. 26, 2021, XP093030094, retrieved from the internet: URL:https://aws.amazon.com/blogs/apn/building-a-multi-tenant-saas-solution-using-aws-serverless-services/[retrieved on Mar. 9, 2023] the whole document. |
International Search Report and Written Opinion, re PCT Application No. PCT/US2022/052315, dated Mar. 20, 2023. |
Anonymous: “alias (command)—Wikipedia,” Jun. 28, 2016, pp. 106, XP093089956, Retrieved from the Internet: URL:https://en.wikipedia.org/w/index.php?title=Alias_(command)&oldid=727315645 [retrieved on Oct. 9, 2023. |
Al-Ali, et al., Making Serverless Computing More Serverless. 2018 IEEE 11th International Conference on Cloud Computing (CLOUD). Https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&amumber=8457832 (Year: 2018). |
Gimenez-Alventosa, et al., tAsCAAs: a Multi-Tenant Serverless Task Scheduler and Load Balancer as a Service. IEEE Access, vol. 9. https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&amumber=9528423 (Year: 2021). |
IBM, what is Serverless computing, https://www.IBM.com/topics/serverless#:-:test=Serverless%20is%20a%20cloud%20computing,managing%20servers%20or%20backend%20infrastructure, pp. 1-11 (Year: 2023). |
Khedekar, et al., Multi-Tenant Big Data Analytics on AWS Cloud Platform. 2020 10th Annual Computing and Communication Workshop and Conference (CCWC). Https://ieeexplore.ieee.org/stamp/staum.jsp?tp=&amumber=9031133 (Year: 2020). |
Neenan, Sarah Compare Serverless tools and services in the Public cloud, https://www.techtarget.com/searchcloudcomputing/feature/Compare-serverless-tools-and-services-in-the-public-cloud, TechTarget, pp. 1-4 (Year: 2023). |
Wikipedia: Serverless computing, https://en.wikipedia.org/wiki/Serverless_computing, p. 107 (Year: 2023). |
Zheng, et al., “A Multi-Tenant Framework for Cloud Container Services,” 2021 IEEE 41st International Conference on Distributed Computer Systems (ICDCS). Https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&amumber=9546534 (Year: 2021). |