Runtime-Agnostic Execution Environment for Dynamic Resource Scaling

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Computer systems face challenges in executing programs across different environments due to tight coupling between program concurrency and execution environments, limiting the ability to utilize available compute resources efficiently, especially when moving from single machines to clusters or clouds.

Innovation Solution

An execution environment that translates user code into a runtime-agnostic representation, allowing dynamic binding to selected execution runtimes and adjusting concurrency based on data size and available resources, enabling efficient execution across various environments.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If a program is written for one execution environment with specific concurrency expressions, then the program can execute correctly in that environment, but the program cannot be executed in another execution environment

Engineering Contradiction:
Improveprogram portability across execution environmentsVSAvoidconcurrency expression coupling to execution environment
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent introduces a runtime-agnostic intermediate representation as an intermediary layer between user code and execution runtimes. This intermediate representation decouples the program from specific execution environments, allowing the same program to be executed across different environments (single machine, cluster, cloud) without modification. The intermediate representation serves as the mediator that translates high-level concurrency expressions into environment-specific execution instructions.

Inventive Principle:
Principle #24Intermediary (Mediator)

2Productivity

If a program is modified to execute on a cluster or cloud, then the program can utilize distributed resources, but the program cannot use resources made available dynamically such as by adding a new machine

Engineering Contradiction:
Improveutilization of compute resourcesVSAvoiddynamic resource scaling capability
Core Design Contradiction:
ProductivityVSAdaptability or versatility

Solution Approach 1:

The patent implements dynamic resource allocation by allowing the level of concurrency for each task to be determined at runtime based on available compute resources. The system can dynamically adjust the number of parallel task instances executed according to the current state of the execution environment, whether resources are added or removed during runtime. This dynamic approach enables the program to automatically scale with available resources without requiring modification.

Inventive Principle:
Principle #15Dynamics

3Productivity

If compute resources are increased in the execution environment, then more tasks can be executed in parallel, but the program structure must be tightly coupled to the execution environment to express concurrency

Engineering Contradiction:
Improveparallel execution capabilityVSAvoidconcurrency expression coupling
Core Design Contradiction:
ProductivityVSDevice complexity

Solution Approach 1:

The patent creates a universal intermediate representation that can execute on multiple types of systems (single machine, cluster, cloud) without requiring environment-specific modifications. The same intermediate representation can leverage different levels of compute resources and parallel execution capabilities across various platforms. This universality allows the program to automatically adapt to and utilize available parallel resources regardless of the underlying execution environment.

Inventive Principle:
Principle #6Universality (Multi-functionality)

Data Source

PatentUS10592218B2Dynamic data and compute resource elasticity
Publication Date: 2020.03.17 MICROSOFT CORP
  • US10592218B2 patent drawing
  • US10592218B2 patent drawing
  • US10592218B2 patent drawing

AI summary

An execution environment in a computer system provides dynamic data and compute resources elasticity for user code to improve execution efficiency. The execution environment translates the user code into a runtime agnostic representation with a set of tasks. For each task, the execution environment determines a level of concurrency for executing the task based on the size of the set of input data for the task, the amount of compute resources available at the time of invocation of the task, and any context-sensitive heuristics provided by the user code.