Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method of flow control in a device comprising a central processing unit and a computing device, the method being executed by a compiler that is linked as a library and running on the central processing unit, for processing of a flow control statement to adapt a data structure of a program running on the computing device, comprising the steps of: registering a plurality of variables of the device in a variable list, storing, for each of the plurality of variables that is currently in existence, a node pointer as original node pointer for this variable, processing instructions contained within the flow control statement, determining, for each of the plurality of variables that is currently in existence, whether a current node pointer is different from the original node pointer, marking a current node of each of the plurality of variables, for which a difference to an original node has been determined, as replacement for the original node, evaluating the data structure, which is an expression graph, and creating a code output, wherein language-specific flow control statements are added to the code output, creating instructions for the computing device based on the data structure, generating the expression graph by executing a program on the central processing unit and creating instructions for the computing device based on the expression graph, turning the expression graph into program instructions for the computing device.
This invention relates to flow control in computing devices, specifically optimizing data structures during program execution. The method is implemented by a compiler linked as a library and running on a central processing unit (CPU) to process flow control statements for a program executing on a computing device. The process begins by registering variables in a variable list and storing their initial node pointers as original node pointers. The compiler then processes instructions within the flow control statement, comparing each variable's current node pointer to its original pointer. If a difference is detected, the current node is marked as a replacement for the original node. The data structure, represented as an expression graph, is evaluated, and code output is generated with language-specific flow control statements. The compiler creates instructions for the computing device based on the expression graph, converting it into executable program instructions. This approach dynamically adapts the program's data structure during execution, improving efficiency and correctness in handling flow control operations.
2. The method of claim 1 , wherein each of the plurality of variables is registered from within a constructor call that constructs the variable and/or wherein each of the plurality of variables is removed from the list of variables from within a destructor call.
This invention relates to a system for managing variables within a software application, specifically addressing the challenge of efficiently tracking and controlling variable lifetimes to prevent memory leaks and ensure proper resource management. The method involves dynamically registering and deregistering variables within a list to monitor their usage and lifecycle. The system constructs variables through a constructor call, during which each variable is automatically registered in a centralized list. This registration process ensures that the system is aware of the variable's existence and can track its state. Similarly, when a variable is no longer needed, it is removed from the list through a destructor call, which signals the system to release associated resources. This approach ensures that variables are properly managed, reducing the risk of memory leaks and improving application stability. The method supports both individual and batch operations, allowing variables to be registered or deregistered in groups. This flexibility accommodates different programming paradigms and use cases, such as object-oriented or procedural programming. The system may also include additional features, such as error handling to manage registration failures or invalid destructor calls, ensuring robust operation even in edge cases. By automating variable lifecycle management, the invention simplifies development while enhancing performance and reliability.
3. The method of claim 1 , wherein evaluating the data structure comprises assigning a register name to at least one of the nodes in the data structure.
This invention relates to optimizing data structures in computing systems, particularly for register allocation in compilers or interpreters. The problem addressed is the inefficient use of registers during program execution, which can lead to performance bottlenecks due to excessive memory access or suboptimal register management. The method involves analyzing a data structure representing program variables or intermediate code to improve register allocation. A key step is evaluating the data structure by assigning register names to at least one of its nodes. This assignment helps map variables to physical or virtual registers, reducing memory access and improving execution speed. The data structure may represent dependencies, usage patterns, or other relationships between variables, and the evaluation process ensures that registers are allocated in a way that minimizes conflicts and maximizes efficiency. The method may also include preprocessing the data structure to identify critical variables or dependencies before register assignment. This preprocessing can involve analyzing variable lifetimes, usage frequency, or interference graphs to determine optimal register allocation strategies. The assignment of register names may be based on heuristics, static analysis, or dynamic profiling to ensure the most effective use of available registers. By dynamically or statically assigning registers to variables in the data structure, the method enhances performance by reducing register spills (moving data between registers and memory) and improving instruction scheduling. This approach is particularly useful in compilers, just-in-time (JIT) compilers, and interpreters where efficient register management is crucial for performance optimization.
4. The method of claim 1 , wherein processing instructions contained within the flow control statement further comprises recording, by device data types, all steps of computation.
This invention relates to a method for enhancing computational transparency in software execution, particularly in systems where tracking and auditing computational steps is critical. The method addresses the challenge of ensuring visibility into computational processes, which is essential for debugging, security, and compliance in fields such as financial transactions, scientific computing, and regulated industries. The method involves processing instructions within a flow control statement, where the instructions are designed to record all steps of computation. The recording is performed by categorizing data according to device data types, which may include variables, constants, intermediate results, and other computational elements. This categorization allows for structured logging of each computational step, enabling detailed reconstruction and analysis of the execution path. The method ensures that every operation, from initial input to final output, is documented in a traceable manner. This is particularly useful in environments where auditability is required, such as in financial systems where regulatory compliance demands a clear record of all computations. By associating each step with its corresponding data type, the method provides a granular view of the computation, facilitating error detection, performance optimization, and security verification. The recorded data can be used for post-execution analysis, debugging, or real-time monitoring, depending on the application. The structured approach to logging ensures that the computational history is both comprehensive and organized, reducing the complexity of troubleshooting and validation processes. This method is applicable to various computing environments, including embedded systems, cloud computing, and
5. The method of claim 1 , wherein marking the current node of each of the plurality of variables, for which a difference to the original node has been determined, as replacement for the original node, further contains adding a replace pointer to the original node.
This invention relates to a method for optimizing data structures, specifically for managing variable nodes in a computational system. The problem addressed is the inefficiency in tracking changes to variable nodes, which can lead to redundant processing and increased memory usage. The method involves identifying variables where a difference from their original state has been detected and marking these as replacements for the original nodes. This marking process includes adding a replace pointer to the original node, ensuring that subsequent operations reference the updated node rather than the outdated original. The method improves system performance by reducing redundant operations and ensuring that only the most current version of each variable is used. The replace pointer allows for efficient tracking of changes without requiring extensive memory overhead or complex traversal algorithms. This approach is particularly useful in systems where variables undergo frequent modifications, such as in dynamic programming environments or real-time data processing applications. The invention ensures that all operations are performed on the latest version of the data, enhancing accuracy and efficiency in computational tasks.
6. The method of claim 1 , wherein marking the current node further comprises adding dependencies to prevent inadvertent overwriting of variables.
A system and method for managing data in a computational environment, particularly for preventing unintended variable overwrites during execution. The method involves tracking and marking nodes within a data structure to ensure data integrity. When a node is marked, dependencies are added to the node to prevent inadvertent overwriting of associated variables. These dependencies establish relationships between variables, ensuring that modifications to one variable do not unintentionally affect others. The method may also include identifying variables that are at risk of being overwritten and applying protective measures, such as locking or flagging, to those variables. The system may further include a monitoring component that detects potential conflicts and enforces the dependency rules to maintain data consistency. This approach is particularly useful in environments where multiple processes or threads interact with shared variables, such as in parallel computing, distributed systems, or real-time applications. By enforcing dependencies, the method ensures that variable states remain predictable and errors due to unintended overwrites are minimized.
7. The method of claim 1 , wherein output code is generated from the data structure at the beginning of every flow control statement.
A system and method for optimizing code generation in a programming environment involves transforming a source code program into an intermediate data structure that represents the program's control flow and data dependencies. The data structure is then used to generate optimized output code. The method ensures that the data structure accurately reflects the program's logic, including conditional branches, loops, and other flow control constructs. To enhance efficiency, the system generates output code from the data structure at the beginning of every flow control statement, such as if-else blocks, loops, and switch cases. This approach allows for early optimization and reduces redundant processing during code generation. The method may also include analyzing the data structure to identify optimization opportunities, such as loop unrolling, dead code elimination, or constant propagation, before generating the final output code. The system is particularly useful in compilers, interpreters, and other tools that require efficient translation of high-level code into executable instructions. By generating output code at key control flow points, the method ensures that optimizations are applied consistently and reduces the likelihood of errors in the generated code.
8. The method of claim 1 , wherein the entry and exit of a flow control statement are represented within the data structure by an entry node and an exit node, and the evaluation of the data structure is effected at the end of the processing.
This invention relates to a method for representing and evaluating flow control statements within a data structure, particularly in the context of program analysis or execution. The problem addressed is the need to efficiently model and evaluate conditional logic, loops, and other control structures in a way that preserves their behavior while enabling systematic analysis or transformation. The method involves representing the entry and exit points of a flow control statement using distinct nodes within a data structure. An entry node marks the beginning of the flow control statement, while an exit node marks its conclusion. These nodes are interconnected with other elements of the data structure to reflect the logical flow of the program. The evaluation of the data structure is deferred until the end of processing, allowing for comprehensive analysis or execution of the entire structure before resolving the outcomes of the flow control statements. This approach enables precise tracking of control flow, simplifies program analysis, and supports optimizations or transformations that depend on understanding the complete behavior of conditional logic and loops. The method is particularly useful in compilers, static analyzers, or runtime environments where accurate modeling of control flow is essential.
9. The method of claim 8 , wherein the order of the flow control statements is enforced by using dependency pointers, and/or wherein nodes that are replaced by other nodes are evaluated before the entry node of the corresponding flow control statement, and/or wherein nodes that use other nodes as input parameters that are replaced by other nodes are evaluated after the entry node of the corresponding flow control statement, and/or wherein nodes that are replacing other nodes are anchored between the entry node and the exit node of the corresponding flow control statement.
This invention relates to optimizing the execution of flow control statements in a computing system, particularly in scenarios where nodes within a computational graph are replaced or modified. The problem addressed is ensuring correct evaluation order and dependency management when nodes are dynamically replaced, which can disrupt the intended sequence of operations in flow control structures like loops or conditionals. The method enforces the order of flow control statements using dependency pointers, which track relationships between nodes to maintain execution precedence. When a node is replaced by another node, the replaced node is evaluated before the entry node of its corresponding flow control statement, ensuring dependencies are resolved before the flow control logic executes. Conversely, nodes that rely on replaced nodes as input parameters are evaluated after the entry node of the associated flow control statement, preventing premature execution. Additionally, nodes that replace others are anchored between the entry and exit nodes of the flow control statement, ensuring they are processed within the correct scope. This approach maintains the integrity of the computational graph by dynamically adjusting evaluation order based on node replacements, which is critical for correctness in systems where nodes are frequently modified or substituted. The method is particularly useful in environments like just-in-time compilation or dynamic program optimization, where runtime modifications to the execution graph are common.
10. The method of claim 8 , wherein nodes can be evaluated in a parent scope, unless this is prevented by dependencies, but nodes cannot be evaluated in a sub-scope.
This invention relates to a method for evaluating nodes within a hierarchical scope structure, addressing challenges in dependency management and scope evaluation in computational systems. The method ensures that nodes are evaluated in their parent scope unless restricted by dependencies, while explicitly preventing evaluation in sub-scopes. This approach enhances control over execution flow and data isolation, particularly in systems where scope hierarchy and dependency resolution are critical, such as programming language interpreters, configuration management, or rule-based systems. The method builds on a foundational technique for evaluating nodes within a defined scope, where nodes represent discrete units of computation or data. The key innovation lies in enforcing evaluation constraints: nodes are processed in their parent scope by default, but dependencies between nodes may override this behavior. For example, if a node depends on another node that must be evaluated in a different scope, the system adjusts accordingly. However, the method strictly prohibits evaluation in sub-scopes, ensuring that computations remain confined to their intended hierarchical level. This prevents unintended side effects and maintains consistency in systems where scope boundaries are semantically significant. The technique is particularly useful in environments where scope isolation is critical, such as in secure multi-tenant systems, modular programming, or policy enforcement frameworks. By explicitly defining evaluation rules, the method reduces ambiguity and improves predictability in node processing.
11. The method of claim 1 , wherein optimizations are performed on the data structure before the data structure is evaluated.
A system and method optimize data structures to improve evaluation efficiency. The technology addresses the problem of slow processing times when evaluating complex data structures, which can lead to inefficiencies in computational tasks. The method involves performing optimizations on a data structure before it is evaluated, reducing the computational overhead during evaluation. These optimizations may include simplifying the structure, reducing redundant elements, or reorganizing data for faster access. The method ensures that the data structure is in an optimal state before evaluation begins, minimizing delays and improving overall system performance. By pre-processing the data structure, the system avoids unnecessary computations during evaluation, leading to faster execution times and better resource utilization. This approach is particularly useful in applications where real-time processing or high-throughput data handling is required, such as in databases, machine learning, or large-scale data analytics. The optimizations are tailored to the specific characteristics of the data structure and the evaluation process, ensuring maximum efficiency gains.
12. The method of claim 1 , wherein the computing device is a parallel computing device or a video card.
A parallel computing device or video card processes data using multiple processing units to improve computational efficiency. Traditional computing systems often struggle with tasks requiring high parallelism, such as graphics rendering, scientific simulations, or machine learning, due to limitations in single-core processing power. Parallel computing devices and video cards address this by distributing workloads across multiple cores or processors, significantly accelerating performance for parallelizable tasks. These systems typically include specialized hardware, such as graphics processing units (GPUs), which excel at handling large-scale parallel operations. The method involves leveraging these devices to execute parallel algorithms, where data is divided into smaller tasks processed simultaneously by different processing units. This approach enhances throughput and reduces processing time for applications like real-time rendering, data analysis, and high-performance computing. The use of parallel computing devices or video cards optimizes resource utilization and enables efficient handling of computationally intensive workloads that would be impractical on traditional single-core systems.
13. A computer program product comprising a non-transitory computer-readable storage medium storing a program for a processing device, comprising software code portions for performing the steps recited in claim 1 when the program is run on the processing device.
This invention relates to a computer program product for processing data, specifically addressing the need for efficient and reliable execution of data processing tasks on a processing device. The program is stored on a non-transitory computer-readable storage medium and includes software code portions designed to perform a series of data processing steps when executed by the processing device. These steps involve receiving input data, analyzing the data to identify relevant patterns or features, and generating output data based on the analysis. The program may also include error handling mechanisms to ensure robustness during execution. The storage medium ensures the program remains intact and accessible for repeated use. The invention aims to provide a reliable and efficient way to process data, particularly in applications where accuracy and performance are critical. The software code portions are optimized to minimize computational overhead while maintaining high accuracy in the processing results. The program can be adapted for various data processing tasks, including but not limited to data analysis, pattern recognition, and decision-making processes. The non-transitory storage medium ensures the program remains available for execution without degradation over time. This invention enhances the efficiency and reliability of data processing operations in computing environments.
Unknown
October 29, 2019
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.