Object Code Module Splitting with Lazy Loading

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Existing systems face inefficiencies in managing object code, particularly in virtualized environments, where offloading modules are not effectively unloaded after use, leading to resource wastage and performance issues due to the need for frequent loading and unloading of modules in container-based workloads.

Innovation Solution

A method involving a synthetic compiler that analyzes object code to determine a call tree hierarchy, divides it into modules, and enables lazy loading and eager unloading, optimizing runtime performance by loading modules only when needed and unloading them when not required, thereby minimizing memory footprint and improving execution efficiency.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If modules are kept in memory for extended periods in anticipation of future use, then module availability is improved, but memory consumption increases

Engineering Contradiction:

Improvemodule availabilityVSAvoidmemory consumption

Core Design Contradiction:

ReliabilityVSQuantity of substance

Solution Approach 1:

The patent segments object code into separate modules that can be independently loaded and unloaded. This allows the system to maintain only the necessary modules in memory at any given time, reducing overall memory consumption while ensuring that required modules are available when needed through on-demand loading.

Inventive Principle:

Principle #1Segmentation

2Adaptability or versatility

If modules are loaded frequently in containerized workloads, then module functionality is maintained, but system performance deteriorates due to repeated loading/unloading operations

Engineering Contradiction:

Improvemodule functionalityVSAvoidsystem performance

Core Design Contradiction:

Adaptability or versatilityVSProductivity

Solution Approach 1:

The patent performs preliminary analysis of object code to determine call tree hierarchies and identify which modules are most likely to be needed. This allows the system to proactively load and keep essential modules in memory, reducing the frequency of loading operations and improving overall system performance.

Inventive Principle:

Principle #10Preliminary action

Solution Approach 2:

The patent implements a feedback mechanism that monitors module usage patterns and adjusts loading behavior accordingly. By tracking which modules are actually executed and how frequently, the system can optimize its loading strategies to minimize repeated loading operations while maintaining full functionality.

Inventive Principle:

Principle #23Feedback

3Adaptability or versatility

If all object code is loaded into memory, then complete functionality is ensured, but resource wastage occurs due to unnecessary code residing in memory

Engineering Contradiction:

Improvefunctionality completenessVSAvoidresource wastage

Core Design Contradiction:

Adaptability or versatilityVSLoss of energy

Solution Approach 1:

The patent extracts and separates only the necessary modules from the complete object code base. By analyzing call trees and usage patterns, the system identifies and loads only the minimal set of modules required for current operations, eliminating resource wastage associated with keeping unnecessary code in memory while maintaining complete functionality when needed.

Inventive Principle:

Principle #2Taking out (Extraction)

Data Source

PatentUS11662987B2Logically splitting object code into modules with lazy loading of content

Publication Date: 2023.05.30 INTERNATIONAL BUSINESS MACHINE CORPORATION

AI summary

A method for receiving a first portion of object code, analyzing a first portion of object code in a static manner to determine a call tree hierarchy, dividing, by a synthetic compiler, the first portion of object code into a plurality of modules; and starting to run the first portion of object code to start a runtime phase, with the running of the first portion of the object code including: (i) lazy loading of the modules of the plurality of modules of the first portion of object code, and/or (ii) eager unloading of the modules of the plurality of modules of the first portion of object code.