Class to Structure Data Flow Conversion for FPGA Deployment
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Object-oriented programming languages rely heavily on dynamic mechanisms like pointers and memory addressing, which are not supported in programmable hardware devices such as FPGAs, making it difficult to deploy class-oriented data flow programs on these devices.
Innovation Solution
A method to convert class-oriented data flow programs into structure-oriented data flow programs, allowing deployment on devices that do not support class operations by replacing class instances with structures and using generic structures for dynamic type determination at runtime.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If class-oriented programming is used, then dynamic type handling and operational flexibility are improved, but compatibility with programmable hardware devices is worsened
Solution Approach 1:
The patent creates a copy of the class-oriented program and transforms it into a structure-oriented equivalent. The conversion process copies the functionality while replacing class instances with structures, enabling deployment on hardware that cannot execute object-oriented code. This allows the original dynamic type handling capabilities to be preserved in the source environment while generating hardware-compatible code.
Solution Approach 2:
The patent introduces a conversion tool or intermediary system that acts as a bridge between class-oriented programming environments and hardware deployment targets. This intermediary automatically translates class instances into structures, handling the incompatibility between dynamic OOP mechanisms and static hardware resources without requiring changes to the underlying hardware architecture.
2Adaptability or versatility
If dynamic memory allocation and pointers are used, then operational flexibility is improved, but device complexity and resource requirements are worsened
Solution Approach 1:
The patent extracts the dynamic memory allocation and pointer operations from the program and replaces them with static structure-based implementations. By removing these complex dynamic mechanisms, the program becomes suitable for deployment on programmable hardware with limited resources, while still maintaining the essential operational flexibility through structure-oriented data handling.
Solution Approach 2:
The patent changes the fundamental parameters of data representation from dynamic objects with pointers to static structures with fixed layouts. This parameter change transforms the program's memory model from flexible but resource-intensive to constrained but hardware-compatible, allowing deployment on devices with static resources while preserving functional behavior.
3Adaptability or versatility
If class instances are used, then code reusability and inheritance are improved, but compatibility with static resource devices is worsened
Solution Approach 1:
The patent copies the inheritance hierarchy and polymorphic behavior from the class-oriented program and reimplements them using structure-oriented techniques. Common base structures are defined to represent parent classes, and derived structures inherit from these bases, enabling code reuse and polymorphism without requiring actual class instances or dynamic dispatch mechanisms on the hardware.
Solution Approach 2:
The patent creates universal base structures that can represent multiple class types through polymorphic behavior. A single structure definition can serve multiple purposes by interpreting the same data layout in different ways depending on the context, enabling inheritance and code reusability patterns to function on hardware that only supports static structures.
Data Source
AI summary
System and method for converting a class oriented data flow program to a structure oriented data flow program. A first data flow program is received, where the first data flow program is an object oriented program comprising instances of one or more classes, and wherein the first data flow program is executable to perform a first function. The first data flow program is automatically converted to a second data flow program, where the second data flow program does not include the instances of the one or more classes, and where the second data flow program is executable to perform the first function. The second data flow program is stored on a computer memory, where the second data flow program is configured to be deployed to a device, e.g., a programmable hardware element, and where the second data flow program is executable on the device to perform the first function.