Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A system, comprising: one or more processors; and one or more memories, the one or more memories having stored thereon instructions, which, when executed by the one or more processors, configure the one or more processors to: receive, at a first time, a request to execute a program code, the request including information usable for executing the program code; determine, based at least on the information included in the request, that the requested execution of the program code is not time-sensitive; and subsequent to determining that the requested execution of the program code is not time-sensitive, determine that delaying the requested execution of the program code until a subsequent time period subsequent to the first time and performing the requested execution of the program code using computed capacity available during the subsequent time period would consume resources that are in lower demand or consume less resources compared to performing the requested execution of the program code using compute capacity available at the first time; and cause the program code to be executed using compute capacity acquired for the subsequent time period.
This invention relates to a system for optimizing compute resource utilization by intelligently delaying non-time-sensitive program executions to periods of lower demand. The system addresses the problem of inefficient resource allocation in computing environments where compute capacity is often underutilized during certain time periods while experiencing high demand at others. By identifying non-time-sensitive tasks, the system can defer their execution to subsequent time periods where compute resources are in lower demand or where available capacity can be acquired at a lower cost or with reduced resource consumption. The system includes one or more processors and memory storing instructions that, when executed, perform several functions. Upon receiving a request to execute program code, the system analyzes the request to determine if the execution is time-sensitive. If not, the system evaluates whether delaying execution to a later time period would result in more efficient resource usage, such as lower demand or reduced resource consumption. If so, the system schedules the execution for the subsequent time period, leveraging available compute capacity during that period. This approach helps balance workload distribution, reduce costs, and improve overall system efficiency by avoiding peak demand periods.
2. The system of claim 1 , wherein the instructions, when executed by the one or more processors, further configure the one or more processors to: receive another request to execute another program code, said another request including information usable for executing said another program code; determine, based at least on the information included in said another request, that the requested execution of said another program code is time-sensitive; and cause said another program code to be executed using immediately available compute capacity.
This invention relates to a system for managing the execution of program code in a computing environment, particularly addressing the challenge of efficiently allocating compute resources to time-sensitive tasks. The system dynamically assigns compute capacity to program code execution requests based on their urgency and resource requirements. When a request to execute program code is received, the system analyzes the included information to determine whether the execution is time-sensitive. If the execution is deemed time-sensitive, the system prioritizes the request by allocating immediately available compute capacity to ensure timely execution. This approach optimizes resource utilization by dynamically adjusting to the urgency of tasks, preventing delays for critical operations while efficiently managing overall system performance. The system may also include mechanisms to monitor and adjust compute capacity allocation in real-time, ensuring that time-sensitive tasks are processed without unnecessary delays. This solution is particularly useful in environments where latency and responsiveness are critical, such as real-time data processing, financial transactions, or high-priority computational tasks.
3. The system of claim 1 , wherein the instructions, when executed by the one or more processors, further configure the one or more processors to determine that the requested execution of the program code is not time-sensitive based on a flag included in the request indicating that the request is not a time-sensitive request.
This invention relates to a system for managing program code execution in a computing environment, particularly focusing on optimizing resource allocation for non-time-sensitive tasks. The system identifies and processes requests for program code execution based on their time sensitivity, allowing for more efficient resource utilization. The system includes one or more processors and memory storing instructions that, when executed, enable the system to receive a request to execute program code and determine whether the request is time-sensitive. If the request includes a flag indicating it is not time-sensitive, the system prioritizes the execution accordingly, potentially deferring or scheduling it during lower-demand periods. This approach helps balance workload distribution, reducing latency for critical tasks while efficiently handling non-urgent requests. The system may also include additional components, such as a scheduler or resource manager, to dynamically adjust execution priorities based on system load and request characteristics. By distinguishing between time-sensitive and non-time-sensitive requests, the system improves overall computational efficiency and resource allocation in shared or high-demand environments.
4. The system of claim 1 , wherein the instructions, when executed by the one or more processors, further configure the one or more processors to determine that the requested execution of the program code is not time-sensitive based on a program code identifier included in the request that identifies the program code.
A system for managing program code execution in a computing environment addresses the challenge of efficiently allocating computational resources while ensuring timely execution of critical tasks. The system includes one or more processors and memory storing instructions that, when executed, enable the system to receive a request to execute program code and analyze the request to determine whether the execution is time-sensitive. This determination is based on a program code identifier included in the request, which uniquely identifies the program code. If the execution is not time-sensitive, the system can prioritize or defer the execution to optimize resource usage. The system may also include additional components, such as a scheduler, to manage execution timing and resource allocation dynamically. By distinguishing between time-sensitive and non-time-sensitive tasks, the system improves overall system efficiency and responsiveness, particularly in environments with high computational demand or limited resources. The solution is applicable in cloud computing, distributed systems, and real-time processing applications where resource optimization is critical.
5. The system of claim 1 , wherein the instructions, when executed by the one or more processors, further configure the one or more processors to determine that the requested execution of the program code is not time-sensitive based on a user identifier included in the request that identifies a user associated with the program code.
This invention relates to a system for managing program code execution in a computing environment, specifically addressing the challenge of optimizing resource allocation for non-time-sensitive tasks. The system evaluates whether a requested execution of program code is time-sensitive by analyzing a user identifier included in the request. If the user identifier indicates that the execution is not time-sensitive, the system prioritizes the task accordingly, allowing for more efficient resource utilization. The system includes one or more processors and memory storing instructions that, when executed, enable this functionality. The instructions also configure the processors to receive a request to execute program code, identify the user associated with the request, and determine the time-sensitivity of the execution based on the user's profile or preferences. This determination allows the system to defer or schedule the execution of non-time-sensitive tasks during periods of lower system load, thereby improving overall system performance and resource efficiency. The system may also include additional components, such as a scheduling module, to manage the execution of tasks based on their time-sensitivity. The invention aims to enhance computational efficiency by dynamically adjusting task prioritization based on user-specific criteria.
6. The system of claim 1 , wherein the instructions, when executed by the one or more processors, further configure the one or more processors to: determine a time period during which the requested execution of the program code should be performed; and determine that performing the requested execution of the program code using compute capacity available during the subsequent time period within the time period would consume resources that are in lower demand or consume less resources than performing the requested execution of the program code at one or more other times within the time period.
This invention relates to optimizing compute resource utilization in cloud or distributed computing environments. The problem addressed is inefficient resource allocation, where compute tasks may be executed during peak demand periods, leading to higher costs, slower performance, or wasted capacity. The system intelligently schedules program code execution by analyzing available compute capacity and demand patterns to identify optimal execution times. The system determines a time period for executing requested program code and evaluates compute capacity availability within that period. It identifies a subsequent time window where executing the code would consume resources that are either in lower demand or require fewer resources compared to other times within the period. This ensures tasks are performed during off-peak or underutilized periods, reducing costs and improving efficiency. The system may also consider factors like resource pricing, performance requirements, and workload priorities to make scheduling decisions. By dynamically adjusting execution timing based on real-time or predicted demand, the system maximizes resource utilization and minimizes operational expenses. This approach is particularly useful in cloud computing, where resource costs vary based on demand and capacity availability.
7. The system of claim 6 , wherein the request indicates the time period during which the requested execution of the program code should be performed.
A system for managing the execution of program code in a computing environment addresses the challenge of efficiently scheduling and controlling program execution based on specific time constraints. The system includes a computing device that receives a request to execute program code, where the request specifies a time period during which the execution should occur. The computing device processes the request by determining whether the specified time period is valid and available for execution. If the time period is valid, the system schedules the execution of the program code within the requested time frame. The system may also include a storage device for storing the program code and a network interface for receiving the request from a client device. The system ensures that the program code is executed only during the authorized time period, providing control over execution timing to prevent unauthorized or out-of-schedule operations. This approach is particularly useful in environments where execution timing is critical, such as in batch processing, scheduled tasks, or time-sensitive applications. The system may further include mechanisms to validate the request, authenticate the requester, and enforce security policies to ensure secure and compliant execution.
8. A computer-implemented method, comprising: as implemented by one or more computing devices configured with specific executable instructions, receiving, at a first time, a request to execute a program code, the request including information usable for executing the program code; determining, based at least on the information included in the request, that the requested execution of the program code is not time-sensitive; and subsequent to determining that the requested execution of the program code is not time-sensitive, determining that delaying the requested execution of the program code until subsequent time period subsequent to the first time and performing the requested execution of the program code using computed capacity available during the subsequent time period would consume resources that are in lower demand or consume less resources compared to performing the requested execution of the program code using compute capacity available at the first time; and causing the program code to be executed using compute capacity acquired for the subsequent time period.
This invention relates to optimizing compute resource utilization in cloud computing environments by intelligently delaying non-time-sensitive program executions to periods of lower demand or reduced resource consumption. The method involves receiving a request to execute program code, analyzing the request to determine if the execution is time-sensitive, and if not, evaluating whether delaying execution to a later time would result in more efficient resource usage. If so, the system schedules the execution for a subsequent time period where compute capacity is either less in demand or consumes fewer resources, thereby improving overall system efficiency. The approach leverages dynamic resource allocation to balance workloads, reducing costs and improving performance by avoiding peak usage times. The method is implemented by computing devices executing specific instructions to assess request parameters, make scheduling decisions, and allocate compute capacity accordingly. This technique is particularly useful in cloud environments where resource demand fluctuates, enabling providers to optimize infrastructure utilization and users to benefit from cost-effective execution.
9. The method of claim 8 , further comprising: receiving another request to execute another program code, said another request including information usable for executing said another program code; determining, based at least on the information included in said another request, that the requested execution of said another program code is time-sensitive; and causing said another program code to be executed using immediately available compute capacity.
This invention relates to a system for managing the execution of program code in a computing environment, particularly addressing the challenge of efficiently allocating compute resources to time-sensitive tasks. The method involves receiving a request to execute program code, where the request includes metadata or parameters necessary for execution. The system analyzes this information to determine whether the requested execution is time-sensitive, meaning it requires immediate processing to avoid delays or performance degradation. If the execution is deemed time-sensitive, the system prioritizes the task by allocating immediately available compute capacity, ensuring timely processing. This approach optimizes resource allocation by dynamically responding to urgency levels, preventing bottlenecks in high-priority workloads. The method may also involve similar steps for subsequent requests, where additional requests are evaluated for time sensitivity and executed using available compute resources accordingly. The system ensures efficient use of computing power while meeting the demands of time-critical applications.
10. The method of claim 8 , further comprising determining that the requested execution of the program code is not time-sensitive based on a flag included in the request indicating that the request is not a time-sensitive request.
A system and method for managing program code execution in a computing environment addresses the challenge of efficiently allocating computational resources while ensuring timely execution of critical tasks. The invention provides a mechanism to prioritize and schedule program code execution based on time sensitivity, optimizing resource utilization and performance. The method involves receiving a request to execute program code, where the request includes metadata indicating whether the execution is time-sensitive. The system evaluates this metadata to determine the urgency of the request. If the request includes a flag indicating that the execution is not time-sensitive, the system identifies the request as non-time-sensitive. This classification allows the system to defer or schedule the execution of such requests during periods of lower computational demand, thereby freeing up resources for higher-priority tasks. Additionally, the method may involve monitoring system load and dynamically adjusting the scheduling of non-time-sensitive requests to maintain optimal performance. The system may also prioritize time-sensitive requests over non-time-sensitive ones, ensuring that critical operations are executed promptly while non-critical tasks are handled efficiently without disrupting system performance. This approach enhances overall system efficiency and responsiveness.
11. The method of claim 8 , further comprising determining that the requested execution of the program code is not time-sensitive based on a program code identifier included in the request that identifies the program code.
A system and method for managing program code execution in a computing environment, particularly addressing the challenge of efficiently handling non-time-sensitive tasks to optimize resource utilization. The method involves receiving a request to execute program code, where the request includes a program code identifier. The system analyzes this identifier to determine whether the requested execution is time-sensitive. If the execution is determined to be non-time-sensitive, the system may defer or prioritize the execution differently compared to time-sensitive tasks. This approach allows the system to allocate resources more effectively, reducing unnecessary delays for critical operations while ensuring non-time-sensitive tasks are processed without disrupting system performance. The method may also involve additional steps such as validating the request, verifying access permissions, and managing execution environments to ensure secure and efficient processing. By distinguishing between time-sensitive and non-time-sensitive tasks, the system improves overall computational efficiency and responsiveness.
12. The method of claim 8 , further comprising determining that the requested execution of the program code is not time-sensitive based on a user identifier included in the request that identifies a user associated with the program code.
A system and method for managing program code execution in a computing environment addresses the challenge of efficiently allocating computational resources while ensuring timely execution of critical tasks. The invention determines whether a requested execution of program code is time-sensitive based on a user identifier included in the request. This identifier associates the request with a specific user, allowing the system to assess the urgency of the task. If the execution is deemed non-time-sensitive, the system may defer or prioritize the task accordingly, optimizing resource allocation. The method integrates with a broader system that processes requests for program code execution, validates user permissions, and manages execution environments. By analyzing user identifiers, the system distinguishes between urgent and non-urgent tasks, improving efficiency in environments where multiple users submit varying priority requests. This approach ensures that high-priority tasks are executed promptly while non-critical tasks are handled in a manner that conserves system resources. The invention is particularly useful in cloud computing, distributed systems, or multi-tenant environments where resource management and task prioritization are essential for performance and cost optimization.
13. The method of claim 8 , further comprising: determining a time period during which the requested execution of the program code should be performed; and determining that performing the requested execution of the program code using compute capacity available during the subsequent time period within the time period would consume resources that are in lower demand or consume less resources than performing the requested execution of the program code at one or more other times within the time period.
This invention relates to optimizing the execution of program code in a computing environment by leveraging compute capacity during periods of lower resource demand. The problem addressed is the inefficient use of computing resources, particularly in cloud or distributed systems, where execution tasks may be scheduled without considering real-time resource availability or demand patterns. The solution involves dynamically determining an optimal time period for executing program code based on available compute capacity and resource demand. The method includes analyzing the requested execution of program code to identify a suitable time period for its performance. It then evaluates whether executing the code during a subsequent time period within the identified window would consume resources that are either in lower demand or require fewer resources compared to other times within the same window. This approach ensures that compute tasks are scheduled during periods of lower demand, improving resource utilization and potentially reducing costs. The method may also involve assessing historical or predicted resource usage patterns to inform scheduling decisions. By aligning execution with lower-demand periods, the system avoids overloading high-demand times and optimizes overall system performance.
14. The method of claim 13 , wherein the request indicates the time period during which the requested execution of the program code should be performed.
This invention relates to a system for managing the execution of program code in a distributed computing environment, addressing the challenge of efficiently scheduling and executing code across multiple computing resources while ensuring timely and reliable performance. The system allows users to submit requests for program code execution, specifying parameters such as the desired computing resources, execution environment, and performance requirements. The system then processes these requests by identifying available computing resources that meet the specified criteria, allocating the necessary resources, and executing the program code accordingly. A key feature of the system is the ability to handle requests that include a specified time period during which the execution of the program code should be performed. This allows users to schedule executions at optimal times, ensuring resource availability and minimizing conflicts with other tasks. The system also monitors the execution process, tracks resource usage, and provides feedback to users regarding the status and results of their requests. This approach improves efficiency, scalability, and reliability in distributed computing environments by dynamically managing resource allocation and execution scheduling based on user-defined parameters.
15. Non-transitory physical computer storage including computer-executable instructions that, when executed by a computing system, cause the computing system to: receive, at a first time, a request to execute a program code, the request including information usable for executing the program code; determine, based at least on the information included in the request, that the requested execution of the program code is not time-sensitive; and subsequent to determining that the requested execution of the program code is not time-sensitive, determine that delaying the requested execution of the program code until a subsequent time period subsequent to the first time and performing the requested execution of the program code using computed capacity available during the subsequent time period would consume resources that are in lower demand or consume less resources compared to performing the requested execution of the program code using compute capacity available at the first time; and cause the program code to be executed using compute capacity acquired for the subsequent time period.
This invention relates to optimizing compute resource utilization in cloud computing environments by intelligently delaying non-time-sensitive program executions to periods of lower resource demand. The system receives a request to execute program code, including information needed for execution, and determines whether the execution is time-sensitive. If not, the system evaluates whether delaying execution to a later time period would reduce resource consumption or utilize resources in lower demand compared to immediate execution. If beneficial, the system schedules the execution for the later period, acquiring compute capacity accordingly. This approach helps balance workload distribution, reduce costs, and improve overall system efficiency by avoiding peak demand periods. The solution is particularly useful for batch processing, background tasks, or any non-urgent computations where execution timing flexibility exists. The system dynamically assesses resource availability and demand patterns to make optimal scheduling decisions, ensuring efficient use of cloud infrastructure while maintaining performance for time-sensitive tasks. The invention leverages stored computer-executable instructions to implement this logic, ensuring seamless integration with existing cloud computing platforms.
16. The non-transitory physical computer storage of claim 15 , wherein the instructions further cause the computing system to: receive another request to execute another program code, said another request including information usable for executing said another program code; determine, based at least on the information included in said another request, that the requested execution of said another program code is time-sensitive; and cause said another program code to be executed using immediately available compute capacity.
This invention relates to a computer storage system that manages the execution of program code based on time sensitivity. The system addresses the problem of efficiently allocating compute resources to ensure time-sensitive tasks are executed promptly while optimizing overall system performance. The storage medium contains instructions that, when executed by a computing system, enable dynamic prioritization of program execution requests. When a request to execute program code is received, the system analyzes the request's information to determine if the execution is time-sensitive. If time-sensitive, the system allocates immediately available compute capacity to execute the program code without delay. This ensures critical tasks are processed promptly, while non-time-sensitive tasks can be scheduled based on available resources. The system may also handle multiple requests, dynamically adjusting resource allocation to prioritize time-sensitive operations. The invention improves system responsiveness and efficiency by intelligently managing compute resources based on the urgency of tasks.
17. The non-transitory physical computer storage of claim 15 , wherein the instructions further cause the computing system to determine that the requested execution of the program code is not time-sensitive based on a flag included in the request indicating that the request is not a time-sensitive request.
This invention relates to computer systems that manage program code execution, particularly in environments where time-sensitive and non-time-sensitive requests must be distinguished. The problem addressed is the need to efficiently process program execution requests while ensuring that time-sensitive operations are prioritized over non-time-sensitive ones. The system includes a non-transitory physical computer storage medium containing instructions that, when executed, cause a computing system to receive a request to execute program code and determine whether the request is time-sensitive. The determination is based on a flag included in the request, where the absence of the flag or a specific value indicates that the request is not time-sensitive. The system then processes the request accordingly, ensuring that time-sensitive operations are handled with higher priority. This approach optimizes resource allocation by distinguishing between urgent and non-urgent tasks, improving overall system efficiency and responsiveness. The invention may be part of a larger system that manages multiple execution requests, where the flag-based classification allows for dynamic prioritization. The solution is particularly useful in distributed computing environments, cloud platforms, or any system where execution requests vary in urgency.
18. The non-transitory physical computer storage of claim 15 , wherein the instructions further cause the computing system to determine that the requested execution of the program code is not time-sensitive based on a program code identifier included in the request that identifies the program code.
This invention relates to computer systems that manage the execution of program code, particularly in environments where execution timing is critical. The problem addressed is ensuring efficient resource utilization while maintaining performance for time-sensitive tasks. The system includes a non-transitory physical computer storage medium containing instructions that, when executed, cause a computing system to process requests for program code execution. The system evaluates whether the requested execution is time-sensitive by analyzing a program code identifier included in the request. If the execution is determined to be non-time-sensitive, the system may prioritize or schedule the task accordingly, optimizing resource allocation. The system may also compare the program code identifier against a predefined list or criteria to make this determination. This approach helps balance workload distribution, ensuring that critical tasks are processed promptly while non-critical tasks are handled efficiently without unnecessary delays. The invention improves system performance by dynamically adjusting execution priorities based on task characteristics, reducing latency for time-sensitive operations and conserving computational resources for less urgent tasks.
19. The non-transitory physical computer storage of claim 15 , wherein the instructions further cause the computing system to determine that the requested execution of the program code is not time-sensitive based on a user identifier included in the request that identifies a user associated with the program code.
A system and method for managing program code execution in a computing environment addresses the challenge of efficiently allocating computational resources while ensuring timely execution of critical tasks. The system analyzes requests to execute program code and determines whether the execution is time-sensitive based on user-specific identifiers included in the request. If the execution is not time-sensitive, the system may defer or prioritize the execution differently compared to time-sensitive tasks. This approach optimizes resource utilization by distinguishing between urgent and non-urgent workloads, reducing unnecessary delays for critical operations while efficiently handling less time-sensitive tasks. The system may also track user-specific execution patterns to further refine scheduling decisions. This method is particularly useful in multi-user computing environments where different users may have varying priorities for their program code execution. The solution improves overall system performance by dynamically adjusting execution priorities based on user context and task urgency.
20. The non-transitory physical computer storage of claim 15 , wherein the instructions further cause the computing system to: determine a time period during which the requested execution of the program code should be performed; and determine that performing the requested execution of the program code using compute capacity available during the subsequent time period within the time period would consume resources that are in lower demand or consume less resources than performing the requested execution of the program code at one or more other times within the time period.
This invention relates to optimizing the execution of program code in a computing system by leveraging available compute capacity during periods of lower resource demand. The system dynamically schedules program code execution to minimize resource consumption and cost. The computing system includes a non-transitory physical computer storage medium storing instructions that, when executed, cause the system to determine an optimal time period for executing requested program code. This involves analyzing the compute capacity available during different time periods within the specified execution window and identifying a time when resource demand is lower or when fewer resources are consumed compared to other times. The system then schedules the execution accordingly, ensuring efficient use of computing resources while reducing operational costs. This approach is particularly useful in cloud computing environments where resource allocation and cost management are critical. The invention improves system efficiency by dynamically adapting to varying resource demands, avoiding peak usage times, and optimizing performance without manual intervention.
Unknown
June 23, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.