Serializing Duration-Limited Task Executions in On-Demand Code Systems
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
On-demand code execution systems face challenges in processing large data sets and long-running iterative processes due to duration limits, which can lead to incomplete executions and resource inefficiencies.
Innovation Solution
The system enables serialization of code across multiple duration-limited executions by determining when a duration limit is approaching and initiating subsequent executions from a determined state, allowing processes to be spread across multiple executions without exceeding individual limits.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If duration limits are imposed on code executions to prevent resource ties, then resource availability is improved, but task completion capability deteriorates
Solution Approach 1:
The patent divides a long-running task into multiple sequential executions, each within the duration limit. The task is segmented into chunks that can be executed separately, with state preserved between executions. This allows the system to enforce duration limits while still completing tasks that would otherwise exceed the limit, resolving the contradiction between resource availability and task completion capability.
Solution Approach 2:
The system performs preliminary actions by saving task state at predetermined intervals before the duration limit is reached. This preliminary state preservation enables resumption of execution without restarting the entire task, ensuring that even with duration limits, the task can be completed through multiple executions.
2Productivity
If code is executed within a single duration-limited execution, then resource utilization is improved, but task completion reliability deteriorates
Solution Approach 1:
The patent segments long-running iterative processes into multiple execution units, each fitting within the duration limit. By dividing the task into manageable chunks and preserving state between executions, the system maintains high resource utilization while ensuring reliable task completion through the accumulation of partial results across multiple executions.
Solution Approach 2:
The system maintains continuity of useful action by resuming task execution from the saved state rather than restarting. This ensures that the computational work accumulates continuously across multiple executions, maintaining reliability of task completion while respecting duration limits and optimizing resource utilization.
3Speed
If large data sets are processed in single executions, then processing speed is improved, but system stability deteriorates due to duration limits
Solution Approach 1:
The patent segments large data set processing into multiple executions, each processing a portion of the data within the duration limit. This segmentation maintains processing speed by keeping each execution efficient while ensuring system stability by preventing any single execution from exceeding the duration limit, thus avoiding system instability.
Data Source
AI summary
Systems and methods are described for conducting data processing against a target data set using multiple, duration-limited task executions in an on-demand code execution system. The on-demand code execution system can enable execution of user-specified code as a task, but may establish duration limits for each task execution. Such duration limits can sometimes cause a task execution to fail, such as when processing a large data set. To overcome this problem, this disclosure enables data processing to occur over multiple task executions. Each task execution can process a portion of a data set selected such that data processing of the portion can complete prior to expiration of the duration limit. If an additional portion remains, the task execution can generate state information to enable an additional execution to conduct data processing on an additional portion, and pass that state information within a call to start the additional execution.