Message-Based Code Execution via Key-Value Storage

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Traditional computing system architectures face inefficiencies due to latency and throughput limitations introduced by data communication buses, particularly when storage resource throughput exceeds data bus capabilities, leading to delays in accessing data for computing resources.

Innovation Solution

A message-based architecture utilizing a key-value storage system where computing resources access and merge executable code with stored data, leveraging NVMe protocol and PCIe transport to minimize latency by integrating compute and storage resources within computing nodes.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Device complexity

If traditional data bus architecture is used to connect computing resources and storage resources, then system simplicity is maintained, but latency increases and throughput is limited when storage throughput exceeds data bus capabilities

Engineering Contradiction:
Improvesystem architecture simplicityVSAvoiddata access latency
Core Design Contradiction:
Device complexityVSLoss of time

Solution Approach 1:

The system is segmented into multiple computing nodes, each with integrated storage resources. This segmentation allows each node to access its local storage directly without competing for shared data bus resources, thereby reducing latency while maintaining overall system simplicity through modular design.

Inventive Principle:
Principle #1Segmentation

Solution Approach 2:

The patent transitions from a centralized data bus architecture to a distributed architecture where computing and storage resources are coupled at the node level. This dimensional change from centralized to distributed connectivity provides alternative access paths and eliminates the data bus bottleneck without requiring complete architectural overhaul.

Inventive Principle:
Principle #17Another dimension (Dimensionality change)

2Productivity

If storage resources are designed with high throughput capabilities, then data availability is improved, but data access latency increases due to data bus limitations

Engineering Contradiction:
Improvestorage throughputVSAvoiddata access latency
Core Design Contradiction:
ProductivityVSLoss of time

Solution Approach 1:

Computing resources and storage resources are merged within the same computing node, creating a tight coupling that eliminates data bus intermediate steps. This merging allows high-throughput storage resources to be directly accessed by computing resources at minimal latency, as they share the same node infrastructure and memory space.

Inventive Principle:
Principle #5Merging (Combining)

3Ease of operation

If computing resources frequently access stored data, then computational tasks can be executed, but efficiency decreases due to data bus latency and throughput limitations

Engineering Contradiction:
Improvedata access capabilityVSAvoidcomputational efficiency
Core Design Contradiction:
Ease of operationVSProductivity

Solution Approach 1:

Data is pre-loaded into local storage resources within the computing node before computational tasks require it. This preliminary action ensures that when computing resources need to access data, it is already available in high-speed local storage rather than requiring retrieval through the slower data bus, thereby maintaining ease of access while improving computational efficiency.

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentUS11372697B2Message based code execution using key-value storage
Publication Date: 2022.06.28 NETAPP INC
  • US11372697B2 patent drawing
  • US11372697B2 patent drawing
  • US11372697B2 patent drawing

AI summary

Methods and systems for executing code are provided. A message with executable code is received by a processor that utilizes the message to generate a key associated with a value having executable code stored at a key-value store. The processor retrieves the value from the key-value store using the generated key. The processor then merges the executable code in the received message and the executable code in the retrieved value to generate a merged value for code execution.