Machine-Code Subroutine Objects for Scalable Policy Enforcement
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Servers face challenges in efficiently managing and enforcing policies across various organizations with different system environments and programming formats, leading to delays and scalability issues, especially when handling thousands of transactions per minute and dealing with big data.
Innovation Solution
A computer-implemented method that stores machine-code subroutine objects as building blocks for workflows, generates a machine-code syntax tree to represent executable policies, and associates it with the policy, allowing for flexible and customizable transaction management by connecting identified subroutine objects to form a workflow.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a server applies complex rules to analyze received data for policy enforcement, then policy customization and flexibility are improved, but processing time increases and timing requirements are not met
Solution Approach 1:
The patent segments policy enforcement into reusable subroutine objects that can be independently compiled and executed. Each subroutine represents a discrete policy component that can be assembled into workflows, enabling complex policy analysis to be broken down into manageable, pre-compiled units that execute faster than ad-hoc rule analysis.
Solution Approach 2:
The patent performs preliminary compilation of policy subroutines into machine code before execution. By pre-compiling policy logic into optimized machine-code subroutine objects, the system eliminates the need for interpreting complex rules during transaction processing, significantly reducing processing time while maintaining policy flexibility.
2Adaptability or versatility
If participants add customized features in a non-standardized way, then flexibility and customizability are improved, but system complexity increases and scaling issues occur
Solution Approach 1:
The patent creates a universal subroutine object interface that can represent diverse policy customizations through a standardized mechanism. Different policy requirements from various participants are accommodated by composing workflows from the same set of reusable subroutine objects, eliminating the need for separate implementation approaches for each customization scenario.
Solution Approach 2:
The patent enables policy customization through parameter configuration rather than structural modification. By allowing participants to customize policies through selecting and configuring existing subroutine objects and their parameters, the system maintains a stable core architecture while accommodating diverse customization needs without increasing fundamental system complexity.
3Adaptability or versatility
If data communication uses nonstandard protocols or formats, then adaptability to different system environments is improved, but processing efficiency decreases and scaling becomes difficult
Solution Approach 1:
The patent introduces a standardized intermediate representation layer through subroutine objects. Policy logic is translated into a universal subroutine object format that serves as an intermediary between diverse system environments and the execution engine, enabling environment compatibility without sacrificing processing efficiency in the execution phase.
4Productivity
If a server handles thousands of requests per minute with stringent response requirements, then service capacity is improved, but the ability to perform complex data analysis for policy enforcement deteriorates
Solution Approach 1:
The patent performs preliminary compilation of policy subroutines into optimized machine code before transaction processing. This pre-compilation enables the server to execute policy analysis using highly efficient machine-code routines during high-volume transaction processing, maintaining both throughput and analysis accuracy.
Solution Approach 2:
The patent creates reusable copies of policy logic in the form of compiled machine-code subroutine objects. Once policy analysis logic is compiled into machine code, the same optimized routine can be repeatedly executed for thousands of transactions without reinterpreting the original policy definitions, ensuring consistent and accurate policy enforcement at high speeds.
Data Source
AI summary
A computing server may store a plurality of machine-code subroutine objects. The computing server may receive a definition of a policy. The computing server may identify a plurality of components in the policy based on the definition. The computing server may determine, for each component in the plurality of components of the policy, a corresponding subroutine that needs to be executed to fulfill the component. The computing server may identify, for each component in the plurality of components of the policy, a corresponding machine-code subroutine object that includes the instructions to execute the corresponding subroutine. The computing server may generate a syntax tree to represent an executable workflow that implements the policy. The syntax tree may connect the identified machine-code subroutine objects that correspond to the subroutines that need to be executed to fulfill the components of the policy. The computing server may associate the syntax tree with the policy.