RPC Client Stubs for Typed Serverless Media Workflows
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing media processing workflows face challenges in efficiently executing custom algorithms on a large number of media items in high-throughput fashion, particularly due to the complexity of manual effort and technical knowledge required for encapsulating algorithms in scalable applications, and the limitations of fixed workflows and serverless functions that lack strong typing and require manual invocation mechanisms.
Innovation Solution
The system encapsulates custom algorithms into individually-scaled serverless functions, using a remote procedure call (RPC) framework that automatically generates invocation mechanisms and performs communication and media processing operations, enabling flexible execution across various workflows.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If custom algorithms are encapsulated into a fixed parallel workflow with dynamically scaled containers, then high-throughput execution is achieved, but the workflow lacks flexibility for complex hierarchical workflows and dynamic variations
Solution Approach 1:
The patent transforms the fixed workflow into a dynamic one by introducing state machines that can transition between different workflow states based on conditions. The workflow engine supports dynamic workflow definitions that can be modified at runtime, enabling hierarchical workflows and dynamic variations while maintaining high-throughput execution through containerization and orchestration.
2Ease of manufacture
If serverless functions are used to encapsulate custom algorithms, then scalability and reduced manual effort are achieved, but the functions lack strong typing support requiring manual invocation mechanisms
Solution Approach 1:
The patent implements self-service by automatically generating invocation mechanisms for serverless functions. The system includes a code generator that creates strongly-typed invocation code based on function metadata, eliminating the need for manual invocation mechanism development. This automatic code generation provides strong typing support while maintaining ease of use and scalability.
3Reliability
If manual invocation mechanisms are generated for serverless functions, then strong typing support is achieved, but significant time and technical knowledge are required
Solution Approach 1:
The patent applies preliminary action by pre-generating strongly-typed invocation mechanisms through automatic code generation. The system analyzes function definitions and metadata beforehand to create ready-to-use invocation code with proper type checking. This eliminates the need for developers to manually create invocation mechanisms, significantly reducing development time while maintaining strong typing support and reliability.
4Productivity
If developers manually create scalable applications to execute custom algorithms, then high-throughput execution is achieved, but significant technical knowledge in multiple areas is required
Solution Approach 1:
The patent introduces an intermediary workflow engine that mediates between custom algorithms and the execution infrastructure. This workflow engine handles the complexity of scaling, container orchestration, and resource management, allowing developers to focus on algorithm development without needing deep knowledge of media processing techniques, encoding/decoding, or load balancing. The system automatically manages the technical complexities while maintaining high-throughput execution capability.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
In various embodiments, a function build application compiles source code to generate an executable version of a function that has a first function signature. The function build application then replaces a first data type of a first parameter included in the first function signature with a second data type to generate a second function signature for a client stub function. Subsequently, the function build application generates a remote procedure call (RPC) client that includes the client stub function. Notably, the RPC client causes the function to execute when the client stub function is invoked. Advantageously, unlike conventional techniques that require manual generation of strongly typed functions, the function build application automatically customizes the RPC client for the function.