Hash Map Deduplication for Executable Control Blocks
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing linker technologies either result in code bloat through static linking or instability due to dynamic linking failures, as they struggle to manage and deduplicate execution control blocks effectively across software applications.
Innovation Solution
A system that creates a hash map of executable control blocks by hashing their signatures, allowing for efficient deduplication and consistent in-memory patching, replacing references to control blocks with their hashed entries, thereby minimizing code redundancy and ensuring dynamic linking stability.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If static linking is used to link external library execution control blocks, then the compiled binary file includes all necessary code, but the binary file becomes bloated with redundant library execution control blocks
Solution Approach 1:
The patent merges multiple execution control blocks with identical hash signatures into a single shared copy in memory. When the same control block is referenced by multiple functions or modules, only one instance is loaded and shared, eliminating redundancy while maintaining static linking reliability.
Solution Approach 2:
The patent changes the state of execution control blocks by computing hash signatures and using them as identifiers for deduplication. Control blocks are transformed from opaque binary code into hash-mapped entries that can be efficiently compared and deduplicated based on their cryptographic hash values.
2Weight of stationary object
If dynamic linking is used to resolve external dependencies, then the binary file size is reduced, but the system becomes unstable when libraries are missing, incorrect version, or stored in wrong location
Solution Approach 1:
The patent performs preliminary hashing of all external library execution control blocks during the compilation and linking phase. Hash signatures are pre-computed and stored in the binary, enabling the runtime system to verify library presence and version correctness before execution, preventing dynamic linking failures.
Solution Approach 2:
The patent implements a feedback mechanism where the runtime linker verifies hash signatures of loaded libraries against expected values. If verification fails (missing library, wrong version, wrong location), the system can respond appropriately rather than failing silently or corruptly.
3Quantity of substance
If traditional linking methods are used without hash mapping, then code redundancy exists in the binary, but in-memory deduplication and consistent patching cannot be achieved
Solution Approach 1:
The patent introduces a hash map as an intermediary data structure between the binary code and physical memory. This hash map enables efficient lookup, deduplication, and tracking of execution control blocks, allowing the system to manage memory efficiently without significantly increasing overall system complexity.
Solution Approach 2:
The patent creates hash-based copies or references to execution control blocks rather than duplicating the actual code. Multiple functions can reference the same control block through its hash signature, enabling virtual sharing without physical duplication in memory.
4Device complexity
If execution control blocks are managed without hash signatures, then simpler linking is possible, but consistent in-memory patching and version differentiation cannot be achieved
Solution Approach 1:
The patent uses hash signatures as unique identifiers that effectively 'color-code' or label each execution control block version. This allows the system to distinguish between different versions of the same control block and apply patches consistently to the correct version based on its hash signature.
Data Source
AI summary
In an example implementation according to aspects of the present disclosure, a method for creating a hash map comprising at least one entries corresponding to at least one executable control blocks, storing the execution control blocks in a shared function address space, and executing the at least one executable control blocks based on referencing a corresponding entry in the hash map.