Patent Application
20110060895
The invention involves modular program code that is integrated into multiple software languages and hardware platforms and is involved with network computing and communications systems. The system uses program code blocks and elements that self-assemble in order to solve problems in real time by using analytics and modeling. A modular software computing system is self-organizing and embodies plasticity and evolutionary behaviors. Modular program code is used in automating computing functions and facilitates bio-inspired computing processes.
As computing networks become increasingly complex, new methods are sought to automate computing functions. In order to facilitate the automation of computer functions, particularly in the network computing context, scientists are looking to nature, and specifically to biology, for ideas. Bio-inspired computing provides several analogies to improve and automate computer systems. These include molecular and organic chemistry, genetic biology and proteomics. Scientific discoveries in these fields have applications to computer systems.
In the case of biological analogies to computer systems, the use of large and small molecules in molecular networks is an analogy for the present system. In this chemical system, molecules are recruited to solve a problem in nature. DNA is a biochemical system for the storage and activation of genes that perform specific functions. Further, RNA is a mechanism for replacement of genes to perform failsafe activation of functional processes. Similarly, genetics provides a system for the generation of proteins to interoperate in protein networks to solve biological problems.
The human immune system provides another exam* of a natural system in which antibody collectives are recruited when a threshold is achieved in order to attack an invading antigen. Very complex problems, such as a new virus, are solved by the adaptive immune system by using unique cells that pass immunity to memory for future solution generation.
Similarly, protein networks are used to activate a specific set of proteins to release new proteins to solve a problem. In some cases, this process is accelerated by the use of enzymes.
More fundamentally, the field of chemistry is used as an analogy of a system that uses modular components that are rearranged to perform specific functions. The addition and subtraction of atoms as components for chemical cores, in which the atoms are bonded to connect chemical structures, is a useful analogy for the present system. Further, chemicals interact with specific chemicals and transform chemical structures in physical processes. In particular, organic chemistry shows that small molecules influence biological behaviors in very complex systems.
Beyond the physical and biological sciences, language provides a further analogy to the present system. Words are built in sentence structures, with a translation of words between languages. Root words are ordered and reordered, with ontological reference of objects with language. Letters of the alphabet are aggregated into words and sentences of unique referential combinations. The slow transformation of language occurs with object-reference changes.
In computer science, quality of service (QoS) systems have some features of network security that involve network perimeter access limitations. Extreme Networks uses a simple pre-set modular operating system with a limited perimeter access to promote network security.
Arista Networks uses a simple view of modular code inside computer network routers. In this case, the system merely replaces a pre-programmed code module in a single fixed hardware component; in effect, the program code is simply reloaded when needed, like rebooting the software system or turning off and on a switch. This system uses no updated or evolving code. The system uses no new code to solve new problems. The system uses no mobile code (since it is fixed within a specific hardware component). The system has no code block components. The system merely replaces modules and integrates into an operating system with messages.
IBM's autonomic computing technologies provide a background for the automation and self-organization of computer network operations using pre-programmed systems. However, this system does not have the flexibility to solve novel problems on-demand.
In U.S. Pat. No. 7,277,876, Solomon shows a T-STOR database that transforms the architecture of the database and in U.S. Pat. No. 7,526,460, Solomon shows the mobile hybrid software router in which multiple artificial intelligence techniques are combined to efficiently solve problems in computer networks. These patents illustrate a model for organizing program code. Further, Solomon has shown the use of IP core elements with application to complex programmable logic devices. The program code elements organize and reorganize to solve problems with applications to FPGAs.
The invention solves a set of problems involving the organization, filtration and storage of data objects. The invention facilitates the storage and access of object components in databases. The invention also solves problems involving the pruning of garbage program code. The invention solves problems involving malicious computer program code in order to secure a computer. The invention is involved in aggregating and reaggregating program code to solve a range of computer program organization and data organization, storage and access functions.
The invention solves problems involving network computing. The invention is involved in tasks and applications that involve multiple computers interoperating in a network environment, including security, efficiency optimization and plasticity dynamics operational maximization. The invention also applies to problems involving computer modeling of program code.
The present invention involves (a) the organization of data objects in databases using program code modules, (b) the generation and organization of program code blocks and code elements into modules, (c) the use of code modules in computer networks, (d) the generation of solutions to modular code problems with advanced metaheuristics and (e) the modeling of solutions involving program code modules.
The organization of objects in databases involves the organization of program code modules for the aggregation and reaggregation of software components to optimize storage and retrieval operations. The invention describes memory optimization management involving program code components and solves software memory virtualization problems. Further, the invention shows uses of software module components for encryption by disaggregating components to increase security. Finally, the system optimizes complex video object storage and retrieval by aggregating components using software modules.
The generation and organization of program code blocks and code elements into modules is performed by aggregating code components as basic units. Software code components are organized into software modules for functional utility. Specifically, software code elements are used in a fine grained approach to generating software modules with particular applications. The invention shows how to reverse engineer missing code elements for specific applications. The invention shows how to update versions of program code and objects with code elements to efficiently solve problems. The invention uses techniques to eliminate unused object components using modular program code consisting of software blocks and elements. The system shows how to access software libraries to obtain and generate code modules and components. The system combines program code blocks and elements for self-assembly of software modules. The aggregation of program code elements activates software functionality on-demand. Not only is program code combined on-demand in the present system, but the system reaggregates the composition of program code with code elements for new uses. Finally, the invention describes ways of implementing program code modules in hardware.
The present invention further shows how to apply modular code to computer networks. The system solves allocation optimization problems with modular software. The system applies software modules to computer network hubs for maximized functionality. The system applies software modules to automate bandwidth modulation in computer networks. The system is applied to multiple parallel routers in a computer network. The system shows how to route modular software in a computer network. Finally, the system shows how software modules and components are circulated in a computer network for maximum functionality.
The invention optimizes the functional performance of software modules using metaheuristics. The system applies the ACO metaheuristic to modular software component collective behaviors. Swarm intelligence is applied to software module collectives. The invention shows how to self-organize object components with modular code. The invention shows how to reaggregate code blocks and elements using software module collective behaviors. Finally, plasticity behaviors are shown with software modules in computer networks.
The invention shows how to perform modeling of modular software components. The system provides analytical modeling of software module behaviors. The system also shows how to perform dynamic modeling of software module collective behaviors. The invention shows how to model modular software component behaviors with local search metaheuristics. Active modeling of interactions between software module behaviors and network computing architecture configurations are shown. Finally, the invention shows how modeling processes trigger computer network architecture plasticity.
There are several applications of the present system. Modular software may be implemented in different hardware and software platforms. Regarding hardware, the present invention may be implemented in application specific integrated circuits, in CPLDs and FPGAs and in microprocessors with either the Von Neumann architecture or the Harvard architecture. Further, the present invention may be implemented in hybrid platforms, including system on a chip (SoC) and network on a chip (NoC) platforms, multi-core and 3D chips and in computer networks.
Regarding software, the present invention may be implemented in traditional programming languages, like Unix, C, C++, Java and XML as well as open source platforms. In effect, the present invention is a meta-architecture that is implemented in multiple languages. The present system allows the automation of program code that is not achievable in pre-programmed languages. The present modular approach is therefore useful for translating components of these lower level languages.
In computer networks, the present invention is used to solve routing optimization problems. The present system is useful for plugging in a specific module to complete an application.
The invention is used in several computing applications. It is useful for enterprise systems for integrating different components. It is useful for organizing and managing cloud computing, telecommunications networks, local area networks, intranets and server farms. It is useful for network management in network on a chip applications. It is useful for mobile device applications that involve location-specific and time-specific applications. It is useful in control system applications and digital signal processor applications. It is useful for video, multimedia and interactive video applications. Finally, it is useful for robotics and collective robotics systems.
The invention has numerous advantages. The ability to use modular code for database management increases automation of database storage and retrieval functions. The increase in automation allows faster and more efficient database operations. The system also improves memory management functions. Further, the system increases database management efficiency while also maximizing flexibility.
The system allows increased analysis and solutions of optimization problems. By allowing the reusability of program code, by learning from earlier solutions and by employing a flexible software component solution approach, the present system automates the process of solving optimization problems. Further, because it is automated, efficient and flexible, the system integrates techniques for maximizing efficiency in computational systems, including the automation of processes to minimize junk code. The system applies computational economics to optimize software process operations.
In the context of network computing, the invention increases network optimization by constantly re-routing software components. By utilizing autonomous decentralized software module architectures, the system solves parallelization problems. The invention also facilitates the management of network traffic in a self-organizing system.
By allowing the software modules and software components to decentralize network computing functions, the network unit of control becomes the node. This approach therefore allows computing networks to remove layers of distributed computing function, such as hubs.
The system integrates artificial intelligence techniques to increase problem solving efficiencies. By using ACO, swarm intelligence and local search metaheuristics, the system is able to automatically perform environmental interaction, feedback and adaptation. These processes lead to network plasticity mechanisms.
Finally, the system uses modeling techniques to solve optimization problems on demand and to automatically implement solutions. These modeling solutions allow the system to integrate new program code components into novel configurations on-demand.
Ultimately, the system facilitates the genesis and management of an organic self-organizing modular software operating system across networks with multiple integrated applications.
Pre-programmed software has limitations. Deterministic software has the restrictions of legacy computer systems that constrain adaptation. As computer languages evolve, the requirements increasingly involve object-orientation, modularity, dynamism and architectural ubiquity. In effect, what is needed is a meta-language that integrates with programming level software architectures to implement modular program code in multiple programming languages.
While a modular software system is essential for operation in computer networks; and therefore requires elements of mobility and security, it is also essential for intra-node operation within a single chip, router or switch. The modular software system is an adaptive language in a complex system.
(1) Methods for Organization of Program Code Core and Code Elements into Software Modules
Modular software code consists of program code core and program code elements. Core code is blocks of program code that perform a specific function. Program core elements are small sequences of program code that combine together with other elements or core blocks to perform specific functionality. The program code core and elements are implemented a la carte. The combination of core blocks and elements generate software modules with particular functionality. The aggregation of specialized software modules creates a multifunctional software system. Because they are aggregated in different configurations, software modules are implemented in different sizes and functionality. Code cores and code elements represent basic building blocks for software functionality. Software modules are generated from code core and elements to satisfy functional requirements with different attributes on demand in a software system. One advantage of using modular program code is to replace or restore software modules that are not fully executing a program.
The present system uses software modules that are predetermined as well as those that are indeterminate. Preset modules have specific programmed functionality, much like an application specific integrated circuit. Once specific inputs are registered, the software module performs a function to obtain a specific output.
The present invention is also organized to have custom configured modular software. The code is designed on the fly to solve a novel problem. In this case, software components are generated from software modules to solve specific problems. Auto-generation of program code elements from software modules provides substantial system flexibility and complex functionality.
The main software program code core is a code block or set of blocks. Program code elements are a subsidiary code aspect attached to the block(s). While blocks are combined together to facilitate specific functionality in a software module, code elements are affixed to and combined with blocks in order to have functionality. A code element adds specific functionality to a block. The analogy of this approach can be drawn from organic chemistry and microbiology in which small molecules combine with large molecules to obtain specific functionality of the combined chemical unit. The code element(s) complete the specific functionality of a code block to form a software module.
(2) Methods for Organizing Blocks of Program Code into Software Modules
Program code blocks are organized into specific species and families. Common species members are compatible and interlocking. Each family block group focuses on specific task categories. This model of species and families of code blocks eliminates conflicts and increases compatibility and familiarity with similar block types to initiate and sustain a stable operating system substrate.
Code blocks are organized to solve specific optimization problems. When a system problem is discovered, specific code blocks are requested within a specific family category to solve a specific class of problem. Compatible code blocks are combined in unique configurations to solve unique problems. By combining pre-formed code blocks efficiently in modules, the system automates solutions to complex problems.
While some blocks are interchangeable, particularly within families, replacement blocks are used to provide new functionality. In these cases, a replacement block is a new version of the block family with new functionality (type 5.7 replaces type 5.5, for example). While all blocks have limited functionality, the replacement blocks represent a new version with increased functionality. In effect, the replacement of blocks updates the block it is replacing.
Updates of code blocks occur periodically as well as on-demand by the software system. Software code blocks are prioritized and reprioritized over time, particularly as new versions are available to replace and update older versions of code blocks. The replacement of code blocks with updated versions is an efficient way to reconfigure modular software.
While code blocks are pre-programmed and initiated by system administration, code blocks are also generated on-demand by the functional application. The active application attracts code blocks in an open request for blocks from code families that will solve a particular functional problem. For instance, a software module may have omitted a specific set of code blocks to complete a task. The software module then maintains an open order to request specific code blocks to complete the software module by combining the old and the new blocks into a new configuration to solve a particular problem.
Code sequences are combined with code connectors, which are conjunctions at points in program code sequences between specific components. Conjunctions connect the blocks and the elements. The conjunctions must be compatible between the connecting blocks and elements or the sequence components will be inactive.
In one implementation of the invention, open spaces are integrated into code sequences in order to allow the interjection of code blocks. Blank spaces are made available in blocks for insertion of code elements. These intentional blank spaces are intended to be used to modify any program code language structure. This idea is borrowed from the idea of “junk” or useless genes in DNA that have been generated over time to perform a function that is no longer applicable. The present system builds on the idea of junk code by intentionally creating blank spaces for the future insertion of code components. Blank spaces in code sequences are intended to allow the injection of specific code elements. These blank spaces are conjunction points.
Code elements are typically injected at the end of specific program code sequences. However, elements are injected between sequences of code as well as the end of blocks.
In an example of an application of software modules using code blocks, different programming languages may be translated by code blocks at specific junctions of the software module. While the whole language may not be effectively translated in real time, a sufficient amount of the translation may occur by accessing a table of interchangeable code by comparing ontologies and seeking relative equivalence. Though this model only works on the edges of program language translation, this may be sufficient to solve some problems in real-time involving two or more languages.
Further, the system is able to mix code blocks from different languages by using translation features at junctions to allow limited alien code interaction and functionality.
Program code elements are fine grained software micro-components affixed to program code blocks in software modules. One main feature that code elements provide to software modules is the ability to generate customized solutions to complex optimization problems. The main code core that consists of code blocks are supplemented by specific functionality of code elements. The elements provide the blocks with specific application functionality on-demand by supplying and activating specific features. One advantage of this model is the ability to add and subtract code as needed to solve evolving problems as the tasks progress without affecting the underlying superstructure of the software program.
Code elements are added to and subtracted from specific combinations of code blocks to generate and facilitate transformable code components. The code elements represent periphery components in complex assemblies of code blocks and elements. While code blocks represent a super structure for an application, elements are supplied on-demand for specific functionality. Though code elements are activated in a specific sequence, they are also organized to be activated out of a specific order so as to maximize efficiency. For example, the elements are affixed to blocks at specific locations, but may be activated in multiple sequences so as not to constrain their specific location.
Software modules consist of program code blocks and code elements. To determine the specific functionality of the modules, it is necessary to identify the composition, the configuration and the identity of the elements because the elements determine specific features and functionality.
Rather than only viewing the combination of elements with blocks as an additive process driven by a specific pre-programmed model, the present invention also develops a mechanism to work backwards to identify a specific functionality at an initial step and then reverse engineer the specific combination of elements required to complete this set of tasks. The system then constructs the specific elements by accessing a database to identify similar elements used in previous solutions. This inference approach is based on the use of a model to analyze the optimization problem and assess the solutions to the problem by generating a specific combination of application specific elements.
Program code elements are generated and combined with blocks to solve the problems. The solutions are assessed and new versions of elements are generated and implemented to improve the solutions until the problem is solved. In some cases, this approach involves applying elements in a new sequence.
The use of inference approaches to solve the optimization problem by generating program code elements involves the development of customized program code configured for each task.
(5) Methods for Updating Versions of Program Code and Objects with Program Code Elements
Program code blocks are activated in iterations. These versions of the blocks are constantly updated so as to preserve the latest and most effective program code details. The present invention facilitates the process of updating program code blocks by updating program code elements. The elements provide new code to the blocks to complete or update the program code to a new specification to solve a new set of problems. Each version of the software module adapts to specific applications. New code elements are generated by analyzing previous problems and integrating components of successful solutions. Each new version of a solution that is organized by adding new elements are advanced and tested to solve new problems beyond the old problems.
Similarly, data objects are updated by providing new data components with software modules that represent new versions of the objects. This layering approach to modifying objects is more efficient than replacing the object.
The use of new program code to update software module components by generating code elements is an efficient solution to the problem of updating program code for new applications without replacing the whole software system.
(6) Methods to eliminate unused object components with modular program code
Removing unused object components is a significant problem in computer systems. In order to maximize efficiency of computer system operations, it is necessary to select out unused object components. The modular software system disclosed in the invention is useful to accomplish the task of removing unused object components.
At periodic intervals, the system uses software modules to identify, assess and remove unused object components. Unused object components may consist of unused earlier versions of the object that become dead weight for the system. The modular program code uses blocks and elements to tag and assess the low priority of the earlier versions of the object and removes the low priority versions by placing these object components in a low priority location of a dbms. The modular software system constantly optimizes objects using this approach so as to maximize system efficiency.
Modular software identifies, assesses and removes the accumulation of junk code in the software system. The code blocks and elements combine to filter junk code. The filter is constantly updated with evolving protocols. As code is accessed by the filter, the low priority code is compared to protocols and either removed, updated or replaced.
Code blocks and elements are also applied to the modular software system itself This internal mechanism is organized to identify, assess and filter junk code blocks so as to constantly update the code blocks for maximum functionality. This internal operations control system acts as a filter to police the efficiency and effectiveness of software modules themselves.
Program code that creates conflicts with other code is identified by the internal policing capabilities of the modular software system. These conflicts between code blocks are assessed and the problems solved with addition of specific code elements from compatible families. This process is performed by comparing code structure and function in code libraries. Similarly, incomplete software modules are identified by software code blocks and the elements replaced with effective elements until the problems are solved.
The use of software modules to remove unused object components or to clear up ineffective code blocks represents an efficient self-cleaning process of the present invention. The software code monitoring of code operations is performed in regular intervals or upon demand by a software module application. The solution in most cases is to custom configure a new code element combination to maximize the performance of an application.
The system uses libraries to access code elements. The libraries are provided within the database management system to which the software modules have access. The libraries organize families of element types. When the system encounters an optimization problem, software modules identify the requirements of the problem and access the elements libraries to peruse the elements options. Specific elements are assessed, selected and combined into unique configurations in order to solve the problems.
In the case of complex evolutionary optimization problems, specific elements are combined and recombined into multiple configurations until the solutions are effective. This process of accessing elements in libraries allows on-demand real-time utility of efficient software code applications.
While some libraries are general and supply a variety of elements, other libraries are specialized and focus only on specific families with particular applications or classes of problems. In these cases, the libraries may be geographically diverse and require access from different locations. The system accesses these specialized libraries at different locations to pull together solutions to complex problems. The past successful solutions of past problems are recorded and stored in the libraries for future access. In some cases, the past solutions are insufficient to solve a new complex optimization problem, but the data sets are useful in discovering new solutions.
If the access to combinations of elements at specialized libraries fails to solve a problem, the system moves to construct customized element combinations to solve the problems. Once solved, the custom element(s) are registered in the libraries for future reference.
(8) System and Methods for Combining Program Code Blocks and Elements into Software Modules for Self-Assembly
Software modules consist of program code blocks and program code elements. The blocks and elements are self-assembled in multiple configurations in order to solve different optimization problems. Multiple components of program code elements are combined by aggregating elements from different locations. Once one or more code blocks are combined, the software modules seek out the specific code elements necessary to solve the problems.
The system uses a process of experimentation in order to combine specific code elements into a specific configuration to solve optimization problems. The software module configuration is tested by seeking to solve the problems and the system receives feedback. The system then reassesses the effectiveness of the elements, subtracts some elements, adds new elements into a new configuration and retests the new configuration. This process continues until the problem is solved.
In particular, evolutionary problems require automating the self-assembly of code blocks and elements into software modules.
(9) Methods for Activating Program Code Functionality with Code Element Aggregation
Software modules provide utility by activating a specific functional application. The software modules consist of program code blocks and program code elements. The blocks are the core components of the software modules, while the elements provide specific functionality. In effect, the elements operate as a missing link to complete the final components of the software module and therefore activate the program code in an application. Used in this sense, software modules are activated in the context of an application by completion of the module with specific elements. This approach represents a lock and key model of software activation because specific code elements act as a key to initiate execution of a larger code system.
Specific software modules are pieced together to satisfy a threshold or to complete an active mode. In some cases, all modules are needed. For example, a group of completed modules require location specificity to activate a program function.
The aggregation of software module components into a specific combination of blocks and elements to activate an application function or to solve an optimization problem transcend missing or incomplete program components. The system generates criteria for activating specific code components in specific configurations. An adjunct of this approach shows that code blocks and elements are reusable.
While program modules are organized for specific functionality by aggregating program code blocks and code elements into specific operational configurations, active and interactive applications require the restructuring of the program code component configurations. The present system provides mechanisms to reaggregate program code blocks and elements into novel configurations to solve new and evolving optimization problems. Particularly in evolutionary environments of constant change, it is necessary to establish a system for the reorganization and reaggregation of software components to solve new problems.
As the environment changes, the software system identifies the changes and reacts by reconfiguring the structure of the program code components. Specific program code components, including code blocks and code elements, are disaggregated and then reaggregated into new configurations.
The system uses set theory and combinatorial algebra as a guide for the combination of elements. The system models the software module component configuration options that are required to solve optimization problems. The model uses metaheuristics algorithms to guide the solution generation process. The model guides the software component aggregation and reaggregation processes as they interact with the evolutionary network computing environment.
This process of reaggregation is useful because it allows the modular software system to track, adapt and co-evolve with the changing environment.
In general, computer and communications hardware systems and components are stationary devices, while software code components are capable of mobility and evolutionary and problem-solving behaviors. In the present system, modular software code embodies architecture in which mobility, evolutionary and problem-solving behaviors are characterized and optimized. However, the software module architecture is compatible with hardware implementation.
Software modules are interoperational in chips and computer nodes within a computer network. The operation within different computer platforms expands operational effectiveness of the modular software system.
Software modules operate within microprocessors, ASICs, 3D chips and on system on a chip (SoC) and network on a chip (NoC) platforms of fixed structure semiconductors. Software modules are fully operational with memory components as well, utilizing various semiconductor configurations.
Further, software modules are used in evolutionary hardware, including FPGAs, CPLDs and hybrid chips. Modular software is well suited for co-evolutionary processes by continuously adapting its configuration as the hardware reconfigures so as to solve complex evolutionary environmental optimization problems.
Software modules are functional in different software operating systems, including versions of UNIX, PC-based systems and open source systems.
Software modules are also fully functional in highly parallel computer systems, including complex computer networks. Software modules are functional in switches and routers of nodes and hubs of computer networks to control system functions.
Modular program code enables continuous interactivity in hardware by executing tasks, solving problems, disaggregating, reaggregating and evolving to complete a function.
Software agents are autonomous program code that performs specific tasks such as analysis, search, organization and problem-solving functions. Software agents are used in the present system to analyze and organize software modules and their components.
Software agents employ analytical techniques, including modeling and metaheuristics algorithms, to solve complex optimization problems. Agents identify missing program code elements in software modules that are required to complete specific functionality. Agents analyze the unique combination of elements required to perform a set of tasks. Agents reverse-engineer solutions to problems and then supply the precise program code block and element combinations required to solve the problems. The system then retrieves and aggregates the components to perform specific functions.
Multi-functional software agents are used to perform multiple tasks simultaneously. For example, multi-functional software agents identify problems, identify solution candidates, assemble the program code blocks and elements into specific configurations to solve the problems, test the solutions, add new elements and regroup the blocks and elements into new configurations to solve problems. As problems evolve, the multi-functional software agents co-evolve processes with program code blocks and elements to solve these problems.
One analogy of the use of software agents in the present system is to the enzyme “dicer” used in every cells' ribosome to convert genes to RNA and to proteins. The agents configure the code blocks and elements into new arrangements by continuously analyzing and resorting the combinations of software module components.
The present system consists of modular program code that facilitates the storage, organization, reorganization and retrieval of data objects in databases. The database type may be an object database, a relational database, an object-relational database or some version of these types. The processes of aggregation and disaggregation of objects are facilitated with modular program code to increase storage and retrieval efficiency, to optimize memory utility and maximize encryption. The system is particularly useful in storing video object components.
Software modules interoperate to store and retrieve objects in databases. Program code components are used to accompany and store object components. These processes occur in different types of databases.
In the simplest example, software modules are used to facilitate the storage and retrieval of whole objects in a simple object database in a fixed location. Since the database represents a large warehouse, the whole objects are stored in specific locations in the database.
Software modules are used to facilitate the storage of object components in different locations of a database. The database type may be an object database, a relational database or an object-relational database. The software modules are used to disaggregate, position and retrieve the object parts at different locations within the database. The object parts are tagged and registered in tables for easy access to different object part locations in the database.
A similar model of object component storage and retrieval is used in distributed databases in which the locations of the databases are spatially differentiated. In these cases, software modules are used to store, organize, reorganize and retrieve object parts across multiple databases.
In a further embodiment of this approach to using software modules to facilitate storage, organization and retrieval of object parts, object parts are circulated within a database or a set of distributed databases, for efficient system management. In this example, the object parts are periodically moved from database location to location to improve efficiency. For instance, the use of active object components is increasingly stored in more easily accessed database locations while less used object components are stored deeper in a database that involves slower retrieval. In these cases, there is a need to constantly update the master table by using software modules to relocate and track the object parts from location to location as the storage locations change. While a master table is centralized, when the table is updated, it is copied and sent to strategic hubs for easy access at different locations. In addition to master tables, the system uses relational tables for automated updates and reference tables in a distributed context. Specialized tables are also used on specific types of chips to access memory components.
Finally, the system applies to transformable database architectures that reconfigure to efficiently accommodate storage of objects and object components. Active database management systems use software modules to constantly recirculate objects and object components.
Once stored in various locations of a database, or databases, software modules are useful in efficiently retrieving the objects and object components. The software modules access tables to identify object component locations.
(2) Methods for Disaggregation and Reaggregation of Objects Stored in Database with Modular Program Code
Software modules are used to break up objects into parts and store the parts in different locations of databases. The software modules first analyze the objects and identify the optimal way to divide the object into discrete components. The software modules then assess the composition of each object component to determine the best ways to store the parts. Each object component is classified by type and sorted by location within the database system. Specific object classes are identified. Video objects, spreadsheet objects, model objects and relational field objects are classified and organized. The software modules then sort the object components into organized categories and register the components in a master table identifying storage location(s). The software modules then store the object components in the specific database location(s). Once the object components are searched, the software modules access the table for the specific component location and retrieve the component parts in a specific order to reassemble the object. This process of decomposition and recomposition of object parts allows the dbms to organize objects in different locations to maximize storage and retrieval efficiency. The least used components are stored in locations that involve slower access, while the most used components are accessed rapidly from specific locations.
The software modules are used to tag the object components and to register the parts into the table. Each object part is given a code to identify the location of the database and the position of the component in the overall object.
By breaking up objects into parts, software modules are able to order and reorder the objects by using and accessing a master key in the tables. The objects are reassembled by the software modules into increasingly efficient forms as specific parts are regularly used and others are rarely used.
Different sorts of objects are stored and managed differently in the dbms using software modules. A graph or table is structured with an emphasis on relational functionality, while a video object is organized with linear functionality. Each object type is classified in different ways by the software modules in each type of database system depending on the trade-offs of each dbms.
Finally, software modules are used to push multiple objects into a distributed database management system with multiple pipeline avenues. In these cases, the automated features of the software modules are used to accelerate the disaggregation and reaggregation processes of multiple object components.
(3) System and Methods for Elastic Queuing of Software Memory for Use with Modular Program Code Components
Software modules are used in processes of software memory management. In software memory management systems, queuing processes are employed to temporarily store program code and data objects. The queue is a limited state, like a temporary waiting period. The most typical queue process is a “first-in first-out” (FIFO) system in which a data component is placed into software memory and discharged in a specific regular order.
In the present system, modular software allows the queue memory system to be elastic. That is, the queue system elongates and restricts the size of the memory in order to accommodate variable data objects. The software modules analyze the object and anticipate the software memory requirements. The software modules then expand or contract the usable software memory in the queue. One way to perform the elastic process is to use multiple pipelines of access for object storage and retrieval. This model of changing the structure of the elastic queue of software memory optimally manages the object life cycle. By allowing the software memory to adapt its structure periodically, the system is able to perform varied tasks in real time with a finite memory.
(4) Method for Object Encryption with Disaggregated Modular Program Code
Data security is becoming an increasingly important part of data management. Modular software is useful for preserving data security.
Software modules disaggregate objects into object components. One of the advantages of this approach is to integrate encryption features into object components to preserve security and data integrity. The software modules encrypt objects and object components before they store the parts into specific database locations. This encryption process is integrated into the reference of the object parts into the master table. The encryption of the object components acts as a filter that requires the master table key for decoding the object component.
Software modules are used to filter viruses and malicious code at specific intervals. The modules are used to encrypt the object components after they are disaggregated. The encryption codes are integrated into each software module. Therefore, the software module is required to decode and reaggregate the object components as they are reassembled into an effective useful object.
When a virus or malicious code is detected by a software module, the affected object component is isolated and either replaced, destroyed or embargoed.
In another embodiment of the system, the disaggregation of objects by software modules alone suffices to keep data safe because without the intact integrated object the object integrity is lost and the data rendered useless.
In the context of a computer network, software agents facilitate the process of data security by operating from within each specific system node. All objects that pass through each node are screened, assessed and filtered by software modules for security.
Software modules are used to automatically back up data to preserve data integrity. If a virus or malicious code is detected, then the backed up code is reactivated for effective operation.
As the next generation of the Web develops, video objects become increasingly ubiquitous. Software modules are used to organize video objects.
First, software modules analyze video files by category of content and structure of object. The software modules record index markers or tags at specific points in the video object. The software modules then build indices to map out video objects and organize markers to delineate specific video components in each index. The software modules then compare objects in the database to similar markers.
The software modules organize the tags listed in each index and sort the video components based on the tag type and aspect. Since each video component is synopsized with the tag, the reorganization of the tags allows each component to be edited at specific intervals.
The processes of organization, sorting and reorganization of video objects that are facilitated by the software modules include the compression and decompression of object components.
The software modules employ a hierarchical organization system to rank the qualities of the object components. In so doing, the software modules categorize and reorder image scenes of the video objects by reassembling the object components. In effect, the software modules are used to automate editing functions.
Similar processes are used for audio files. Multimedia objects, which integrate video and audio components, are analyzed and organized by software modules. Interactive video objects are organized by using software modules that analyze and reorganize the object components in databases with adaptive feedback.
Modular program code is ideally suited for network computing environments. Modular software operates within specific nodes and hubs within a network. Components of the software modules are mobile and thus interoperate with multiple computer nodes. While the hardware is stationary, the software is flexible, updatable and multifunctional. The ability to modify the composition of software module components allows computer networks to maximize functionality.
Techniques are described to show how modular software is used in solving allocation problems, operating computer network hubs, automating network bandwidth modulation and controlling multiple parallel routers. Techniques are shown for using modular software to solve routing problems in computer networks. Finally, techniques are shown for continuous circulation of modular software components in a computer network, analogous to the interoperation of antibodies in the human immune system, to solve network computing problems.
The system contains several administrative aspects for constant management control of inter-node communications with software modules. The system layers involve hardware, data storage, software and dynamic behaviors.
On the hardware level, layer one consists of semiconductors. Layer two consists of a node in a computer network and layer three consists of a hub in a computer network. At layer four are distributed hubs in a network.
On the data storage level, layer five consists of data objects. Layer six consists of a single database management system and layer seven consists of a distributed database management system in a computer network.
On the software level, layer eight consists of software modules as basic units of program code. Layer nine consists of program code blocks and layer ten consists of program code elements.
On the level of system dynamics, layer eleven consists of an evolving environment. Layer twelve consists of task feedback from the computer network to the environment. Layer thirteen consists of multi-node plasticity and layer fourteen consists of a reconfiguring of network architecture with evolving software modules.
In the distributed computing environment, objects contain data on their source, present location, destination goal and preferred and optimal pathway(s). Objects are disaggregated and object components are stored in and retrieved from various databases in the network. Software modules are used to organize and encrypt the objects and object components and to control the routers and switches that operate the traffic in the system. The software modules use tags and tables to track the objects in various network locations. Software modules interoperate with a meta-table that is used to preserve updated data for locations of object components and encryption.
(2) System and Methods for Solving Allocation Optimization Problems in Computer Networks with Modular Software
One of the key problems in computer science is the problem of parallelization. The problem involves the need to identify the best way to divide tasks in order to solve the problem efficiently with multiple processors. Parallelization is a distributed computing optimization problem. The modular software system offers an ideal way to solve the problem of parallelization.
The software modules first break down tasks for multiple specialized processors to process the tasks. The processors are classified by type in order to solve specific classes of problems. The processors are located in different locations in the distributed network. The software modules use block and element components in order to divide tasks into specific units for easy “digestion” by specific computing processors. ASICs, FPGAs, microprocessors, SoCs, 3D chips and hybrid chips are allocated specific problems that are suited to specific processors. Computer memory components are optimized by the software modules to run efficiently with the computer processors.
The software module system is used to prioritize and reprioritize the computing processes in a heterogeneous distributed computing environment and, ultimately, derives scheduling protocols for specific tasks. The software modules are also used for routing and rerouting the objects and object components to specific processors in the distributed network with the aim to optimize the efficiency of the system. Finally, software modules are used to modulate elastic bandwidth in the distributed system to optimally accommodate the scheduling and routing processes. This model of using the software module system facilitates ubiquitous computing.
Software modules are used to allocate and reallocate object components to multiple pathways in order to initiate, assess and optimize pathway routing in the distributed network to solve parallelization problems.
(3) System for Operating Computer Network Hub with Modular Program Code
Network computing consists of a distributed system of computers that behave as nodes. Some nodes operate as central hubs connecting clusters of nodes and interconnecting between other hubs. The notion of the hub is critical to understanding the architecture of a distributed computing platform. Hubs consist of hardware computer processors, routers and switches for multi-pathway organization in a distributed system. Software modules are useful in generating and organizing program code and object components in networks.
The hub is a main social structure in computer networks. Multiple pathways are generated from each hub. Nodes are converted to virtual hubs as pathway demand increases to a specific threshold and social behaviors are predominant. In this way, ‘new’ hubs scale up and scale down.
While most hubs operate with pre-programmed program code to manage system operations, the present system uses software modules to generate new program code components to solve network and routing problems as they emerge.
Regarding system security, the present system's use of software modules is beneficial because it uses encryption of specific objects (and components) and filters in each hub to maintain security.
When the present system encounters a problem involving hardware, software or data sets in a network hub, the solution generation process involves employing software agents to analyze, model and solve the problem using software module components. The transition process of configuring solutions after problems have been encountered involves a “burst” of hub activity as the hub control system seeks out and builds solutions using software modules.
In general, software modules are used for network pattern analysis. Modules are used to analyze trends of node use and, by using software agents, the present system uses software modules to model network behaviors, including the anticipation of specific network traffic scenarios.
In an additional embodiment of the present invention, software modules are used to facilitate the auctioning of scarce bandwidth at key hubs at peak times. The modules assess the bandwidth limitations and the demand for bandwidth from multiple applications and allocate scarce bandwidth by creating a schedule for prioritizing bandwidth usage. The modules then organize an auction of specific applications according to priority. This auction model represents an application of combinatorial auctions to network hub bandwidth modulation processes.
Blocks of code and code elements are generated at specific specialized hubs. Specialized hubs are used for specific families of code blocks and elements. The location of block and element families changes periodically as the configuration of hubs change priority in the distributed network.
(4) System for Automating Bandwidth Modulation in Computer Networks with Software Modules
Most distributed computer networks are static. They cannot grow without replacing multiple routers to increase capacity. This constraint restricts system development. By contrast, the present system promotes and facilitates dynamic computer network functionality that modulates growth by modulating the bandwidth available in hubs. By modulating bandwidth, system operational capacity is optimized within the constraints of computational economics.
Software modules are used to modulate bandwidth to and from each node. The modules are used to constantly assess and modulate bandwidth utility efficiency. The modules send test signals to constantly scout and police inter-node pathways. Each node then uses modules to select the best pathway option to send and receive data. By using this approach, the modules are able to assess pathway usage as well as node requirements. The modules are used to “grow” new pipelines between nodes on demand to supplement existing pathways; this process allows the overall system to modulate the pathway capacity. Modules are then used to constantly reroute data traffic in the reconstituted network. This model of elastic and plastic distributed computing allows routers within nodes and hubs to solve evolutionary routing optimization problems by re-equilibrating solutions. By using this approach, software modules operate adaptive super-pathways between adaptive super-hubs as well as self-modulating pathways between adaptive nodes.
From the model of adaptive hubs and nodes, and adaptive pathways between nodes, the software modules are used to schedule data object and object component transportation to optimize the overall system load. As the network configuration itself adapts, the data object transportation process is constantly rescheduled and optimized.
Software modules in nodes and hubs are used to activate reorganization processes at specific thresholds of activity. Thresholds are adjusted for action of different levels of operations.
As activity in nodes increases, the threshold for spiking behaviors is controlled by the software modules. The modules assess, schedule, control and organize the bandwidth modulation of each hub and node. From an equilibrium pulse of activity, the modules are used to control the burst of functional activity in each hub and node as it spikes from an initial equilibrium state to a later equilibrium state.
One model of a distributed network eliminates hubs and uses only nodes as components of communication. This model follows the transition from servers (hubs) to PCs (nodes). In this model, all routing is performed from point to point between nodes rather than between hubs (that then use nodes in a second order configuration). In this case, nodes include routers to route data from node to node. However, in this inter-node distributed model, routers need to have parallel routing capability so as to route simultaneously to multiple nodes. Modular code is ideally suited for this inter-node distributed model.
Modular code is used to sort priorities and to disaggregate and recombine module components (blocks and elements) in decentralized point-to-point nodes. The increased functionality of parallel routers using modular software allows the distributed computer network to use multi-pipeline approaches. In effect, the introduction of multiple parallel routers by using modular code in nodes is similar to multiple runways at an airport; however, rather than be restricted to an airport analogy, the present system uses multiple runways in a house's driveway for node-to-node functionality. By increasing functionality in each node, the costs of routing data diminish as the system increases in simplicity without hub system layers.
The advantage of using software modules in node-to-node parallel routers produces advanced network plasticity because nodes are added and removed over time to accommodate system growth. As nodes are added, new pathways are configured by system routers. Software modules are an optimal system component for the control, organization and management of these elastic networks. As the system adds and subtracts nodes, the system rebalances. Each node is constantly updated with code elements to register new nodes and to remove old nodes.
Software modules are used to analyze patterns of network behavior. By analyzing past patterns of behavior, the system is able to identify anomalies in detail and model solutions.
Modules send data to the closest available node in some cases and to the closest available specialized node in other cases. The location options are constantly resorted by the software modules in the parallel routers in order to maintain maximum efficiency.
In addition to applying software modules to the routers in hubs to control network data flow, software modules are used in intra-node databases. The databases in each node are scalable and extensible and modulate with data flow rate changes. Modules are replaced periodically in each node in order to optimize database configuration and usage. Software modules facilitate the process of circulating specific applications in computer networks between the modulated databases by using the parallel routers in each node. From this use of data in node-to-node computer networks by using the modules, databases and routers described in the present system, multi-tenancy processes in cloud computing operations are optimized. The present system describes new methods to optimize operations of a super cloud.
By using software modules, multiple parallel routers in different nodes are able to communicate with each other, create and suppress direct pathways on demand and create multiple pathways simultaneously to promote intra-node multi-tasking mechanisms.
Taken together, the present invention involves composition of operating system components in a distributed computer network.
While modular software is useful in routers, nodes and hubs, it is also useful because it is transportable to other locations. Specific modular code components themselves are routed to different network nodes and computers. The mobility of program code has the advantage that specialized code is transported to specific computers to perform functions rather than regenerating complex code for each new use.
One approach works as specific problems are encountered at a node and the node requests specialized solutions by importing specific program code modules. This is similar to identifying a disease and requesting an effective medicine from another location to solve the problem and restore health. This approach works as code is attracted to a specific node to solve a problem. Further, code blocks and elements are recruited to a specific node from multiple locations. As the software modules solve the node-centric problems, the nodes intensify the process of obtaining more software modules as they need to scale up, and, conversely, slow down the process of using software modules in problem solving.
Another approach pushes program code to specific nodes as updates are automatically dispatched to solve specific problems or to anticipate specific problems.
A third approach uses software modules to organize and reorganize groups of objects and object components to optimize routing in a network. In this approach, travelling salesman problem (TSP) algorithms are applied by software modules to coordinate data object traffic collective behavior. Batches of objects and object components are reorganized at each node for transport to its destination. The software modules are used to identify, separate group, reorganize and reaggregate collectives of data object components in parallel pathways. This process is analogized to individuals and baggage automatically moved through airports to their destinations in the most efficient ways available.
The use of software modules in nodes in the distributed system constructs an active router. In a passive router, pre-programmed code is launched to perform specific functions in a specific prearranged sequence. In an active router, software modules are used to custom configure solutions on demand. The active router effectively transforms the structure of the distributed network itself by reconfiguring each node to modify elastic bandwidth operation in parallel pathways simultaneously in order to adapt to an evolving environment.
Software modules are used in multiple ways in the nodes and hubs of computer networks to promote efficient operation. To maximize efficiency of network operations, the program code components are organized into families in order to effectively apply solutions to functional problems. The code blocks and elements are continuously updatable as they are activated to solve problems.
The software module components are constantly circulated between nodes in a distributed network. The locations of circulating code blocks and elements are tracked by hub (and node) databases.
Program code elements make regular sweeps through the network in order to seek a “fit” in each node to complete tasks. The elements are de-aggregated and re-integrated into different combinations in order to perform new tasks and to solve new problems. The elements are constantly recirculated in order to maximize system efficiency. The advantage of this approach is that the elements are probabilistically closer to key nodes that require their functional utility at key times. In effect, the elements are pushed to specific locations in order to supply the materials for solving problems. In other cases, the nodes are attractors of specialized elements from specific families in order to solve specific classes of problems.
The inspiration for the recirculation of program code elements in a distributed computer network is the human immune system. In this example, antibodies constantly circulate in order to detect antigens and proceed to escalate a set of processes to defeat the invaders.
Similarly, program code elements are able to detect anomalies, anticipate and analyze problems, and model scenarios and build solution options to solve the problems before they escalate. As the problems do escalate, the elements will call for increased software modules to scale up to optimize solutions.
Metaheuristics are learning processes that are integrated into computer systems in order to solve complex optimization problems. Metaheuristics are classified into specific categories of techniques, including swarm intelligence, local search and artificial immune system. Each of these approaches, and their derivatives and hybrids, apply memory to perform functions to solve optimization problems.
Metaheuristics are applied in the present system by integrating program code blocks and elements in software modules for the operation and management of computer systems. The system uses ACO, swarm and local search approaches to solve specific classes of computer optimization problems. Metaheuristics are useful for the coordination and aggregation processes of software module components.
Problem-solving metaheuristics are useful for analyzing optimization problems. The metaheuristic algorithms are broken up into parts and organized with program code blocks and elements by combining and recombining elements into novel configurations within software modules. Each software module is able to represent a specific hybrid metaheuristic custom configured to solve a specific class and type of optimization problem. Finally, since they use reconfigurable code elements, the metaheuristic software modules are adaptive to evolutionary problems.
Ant colony optimization (ACO) is a class of swarm intelligence metaheuristic that computationally emulates ant behaviors using pheromones to perform functions such as foraging. Once a problem is identified by a circulating code element in a computer networking environment, software modules containing the ACO metaheuristic algorithm are activated to solve the problem. The ACO metaheuristic algorithm then seeks to solve the problem by bringing other code elements from libraries to analyze and model the problem and provide solution options that are tested and selected until the problem is solved.
By using the ACO metaheuristic algorithm, routine pathways in a network are strengthened. Plasticity behaviors are promoted by increasing use in regular pathways while less used pathways are diminished. Software modules employing the ACO metaheuristic algorithm patrol the network and analyze the usage of specific pathways.
When the software modules identify a problem in a node or hub, the software modules activate a burst of activity to call more program code blocks and elements to perform tasks to solve the problem, escalating the solutions until the problem is solved. The increase in use of software modules is drawn from a specialized hub organized to address and solve a specific class of problems. The system is designed to promote multiple problem-solving programmes simultaneously by using multiple hubs to supply bursts of software module component usage to solve numerous problems. In some cases, multiple hubs supply software modules on demand to solve complex problems at different locations.
Use of the ACO metaheuristic is particularly useful to organize and manage the operations of collectives of program code elements. After the ACO software module is dispatched to identify and analyze a network anomaly, program code elements are requested from a hub library to solve the problem. Until the problem is solved, the ACO software module manages the increased application of code elements from various locations and guides the management of a solution until an effective solution is designed and applied. Once completed, the ACO software module returns to a particular hub until new anomalies emerge.
Particle swarm optimization (PSO) is a type of swarm intelligence metaheuristic that uses the collective behavior of decentralized autonomous entities to perform a specific function to solve an optimization problem. The swarm computational algorithm is based generally on the behaviors of bees, bird flocking and fish schooling. Like an enzyme, metaheuristic algorithms are used to shortcut solutions to optimization problems. The PSO algorithm is applicable to network computing problems by using software modules.
Groups of program code elements work together to solve problems. Code elements are grouped in libraries that categorize the elements according to type. The elements are requested by specific nodes to solve specific classes of problems. Software agents are used to retrieve software modules with specific elements. Further, elements are requested to refine solutions until problems are solved. Differentiated elements are collected by software modules from different locations in order to solve a problem at a particular node. The software agents, the software modules and the code elements use PSO algorithms to coordinate the collective behavior of the differentiated components in order to solve the problem. The ability to self-organize program code to solve an optimization problem, or to solve multiple simultaneous optimization problems, facilitates the management of automated programming.
In another embodiment of the invention, the system uses stochastic diffusion search (SDS) metaheuristic algorithms. SDS algorithms use memory from different parts of the distributed network and share the data with members by directly transmitting the data to memory in different locations. This model is useful for point-to-point distributed networks and for organizing collectives of software module components and data object components.
In addition to the PSO and SDS metaheuristics, the system also uses hybrid swarm intelligence metaheuristics.
The use of PSO algorithms to solve network computing optimization problems involves the self-generation of software module components, evolutionary programming, program code element reaggregation processes and self-assembly. The collective coordination of elements to resort and recombine by using PSO illustrates the self-assembly operations of the present system.
(3) Self-Organizing Object Components with Modular Code Cooperation
Objects are broken down into smaller units in the present system for easier storage and security. The object components are self-organized by using software modules that automatically decompose, analyze, store, register and retrieve the components. Modular program code is used to perform these self-organizing object component management operations.
Program code components, including blocks and elements, are used to perform multiple computing operations. The code components coordinate their behavior, and cooperate, by using metaheuristic algorithms. Cooperative software components have specialized functions that work together in a division of labor to solve specific classes of problems.
The cooperating code elements analyze objects, separate object components, encrypt, identify database storage locations, tag and record the data storage locations in tables and store and retrieve the components. The use of cooperating code elements and agents are contrasted with competing code components, which are organized in competing teams with time-sensitive objectives.
Software modules are comprised of program code blocks and program code elements. The elements are groups of small sequences of code that perform specific tasks. The aggregation of the elements constitutes a new configuration of software modules that solve different classes of complex problems. The software modules are constantly reorganized by reaggregating the elements. The elements are organized like pieces of an open-ended evolving puzzle. As the problems evolve in a network computing environment, the elements constantly reconfigure to solve them.
The program code elements use swarm metaheuristic algorithms to solve problems. The elements engage in self-organizing collective behaviors that modulate the velocity of aggregation and reaggregation processes to manage different classes of problems. These social and collective behaviors of multiple software modules and code elements represent the backbone of multiple integrated automated network computing operations.
The reaggregation processes of code blocks and elements are performed by modeling the combinations of sets of components in different configurations. While the combination of different blocks and elements is performed to assess optimal aggregation of unique components to solve problems, the system also must identify conflicts between code components so as to prevent incompatibilities between code types.
The use of collective behaviors and reaggregation processes in network computing operations are useful to simultaneously perform multiple parallel tasks.
(5) Plasticity Behaviors in Computer Network with Collectives of Software Modules
Multiple metaheuristics algorithms are used in the present system to manage network computing functions. The combination of metaheuristics algorithms are used to perform self-organizing, adaptive and plasticity operations in a network. In effect, the combination of these processes promotes the view of a super neural network. The methods applied in the present system using software modules transform a distributed computer network into an adaptable circuit.
Unlike a passive computer network, interaction, feedback and experimentation processes using software modules make the present system adaptive and plastic. The system contains evolutionary aspects capable of problem-solving.
In order to analyze system problems and generate system operations to solve the problems, the present system uses modeling resources. Modeling is used to analyze problems and to organize solution options using modular software components. The modeling processes are used to order, aggregate, reaggregate and reconfigure program code components until evolutionary problems are solved.
Software module components are configured in different arrangements in order to perform specific tasks and solve problems. The code blocks and elements are combined into different configurations by aggregating the software components in different ways. The challenge for the system is to identify ways to model the code block aggregation configuration options in order to perform tasks or to solve problems on demand. The challenge is particularly complex in evolutionary environments which require adaptive solutions and reconfigurable software module components.
One way the system is used to organize models of software module component aggregation is to analyze past network patterns and to assess the solutions used successfully to solve problems. These past patterns and solutions are stored in databases.
During periods of system equilibrium when the network utility is minimal, the system focuses on the analytical aspects of modeling and solving problems rather than on the active aspects of engaging in solution generation and application.
Software agents are used to collect data objects to build models to analyze problems. The agents generate and adjust system parameters in the models to assess problems. The agents generate model scenarios based on probabilities. The agents employ software modules to add features to the modeling process. Once the problems are analyzed and scenarios are generated, the agents are used to generate solution options in the model. The solution options are then compared to a criterion for solution selection and the best available solution option is selected and applied to a problem.
Once a solution option is applied, the system develops a schedule of plans to achieve a set of objectives.
Developing analytical models are useful for solving fixed problems. However, complex evolutionary problems, such as those that involve changing and indeterminate variables or environments, require advanced modeling processes. The present system describes methods for the dynamic modeling of solutions to evolutionary problems.
The dynamic modeling processes involve analysis, scenario generation and solution option generation as well as interactive feedback processes. The advanced modeling process uses multiple metaheuristics to identify, analyze and solve complex problems. The software module components are ordered and reconfigured into different combinations by the modeling system. Software agents collect and analyze data for input into the model. The model is used to test different configurations of code blocks and elements to solve problems or to perform tasks.
Since it is dynamic, the advanced model uses interaction between the software module components collective behavior as they self-assemble and the evolving network computing environment. As network computing problems are solved at specific nodes, new problems emerge that require analysis, modeling and feedback interaction until new solutions are generated, and so on. The process of dynamic modeling involves the continual addition to and removal from software modules of code components (blocks and elements). The dynamic modeling system constantly matches evolutionary solutions to evolutionary problems.
(3) Methods for Modeling Modular Software Component Behaviors to Solve Optimization Problems with Local Search Metaheuristics
Local search metaheuristics, developed by Glover, include tabu search (TS) and scatter search (SS) metaheuristics. These local search metaheuristics are optimized to increase efficiency by removing from the remaining search process areas of the domain already searched. The search process involves the storage of past search space in memory, which is useful to prevent a repeat of search space already searched. One inspiration for this computational algorithm is to analogize the process of searching for a lost hiker. Given resource constraints, searchers engage in a search pattern and simply record the areas that they have already searched so as to save time in not inefficiently going over the same terrain again and again.
In the context of the present system, local search metaheuristics (such as TS) are used to eliminate specific program code blocks and elements not to use because they are incompatible, useless or present a conflict with other code. By eliminating specific code components from a prospective solution, the system increases the efficiency of solution generation processes.
As the modeling system experiments with generating specific solutions, and as the solutions are tested and solution options eliminated, these ineffective solution options are stored in a database. The database is accessed by the model as it builds the model solution options so as to eliminate specific code component solution options and combinations from the list of possible solutions. In effect, the system uses the local search metaheuristics to eliminate the least probable solution options. The system prunes the least likely options for completion of a set of software module components into a specific configuration that will solve a problem.
Similarly, the SS metaheuristic is used to identify missing code components that are required to complete a field. In effect, the modeling system uses the local search metaheuristic to complete a picture over time. Rather than eliminate an ineffective component, the system is used to model a correct solution from incomplete information. This same approach is useful to solve problems involving incomplete object components. These applications are useful in cases of resource constraints so as to maximize efficiency.
In another embodiment of the invention, the system uses adaptive memory programming (AMP) metaheuristics algorithms. The system uses AMP to constantly update program code block and element memory and share memory between software module components in real time to produce updated and efficient models. In addition, the system uses hybrid local search metaheuristics for different modeling operations.
The effect of these main approaches to model building applied to software module components is that the system is able to use limited memory to maximize efficiency of problem solving.
Once a model is generated to analyze and solve a problem, the software modules are actively applied to test the model. The network computing environment requires the model to be tested and feedback from the solution option test is recorded. An experimentation process occurs between the model solution option and the module solution's effectiveness at solving the problem. In effect, the system embodies a process for rapid prototyping. These processes. are useful in both static network computing environments and in evolutionary network environments.
In evolutionary network computing environments, the problems themselves evolve, thereby requiring evolutional), solutions. Evolutionary problems in particular require interactive module testing processes in order to effectively solve the problems.
The system uses distributed modeling in order to solve complex problems. The system divides problems into smaller problems in order to accelerate problem solving. In this case, multiple specialized problems in the distributed network are solved by modeling the problems in multiple nodes with software modules.
In some cases, evolutionary hardware is used in specific nodes to accelerate the problem solving and task completion processes. FPGAs, CPLDs, SoCs and hybrid chips are used to reconfigure their hardware components in order to complete rapid prototyping processes. The network configurations that modulate pathway generation are restructured by organizing the software modules to accommodate the plasticity of the system. These dynamic processes are furthered by the dynamic modeling processes.
The system is used to analyze and model the efficient use of software modules in computing networks. Once the model generates, selects and tests solution options, the feedback obtained from the testing process provides data to refine the model and the solution applications.
The model is used proactively to generate predictions of network computing behaviors. The predictions are based in part on probabilities analysis by the modeling system. By projecting anticipations of network behaviors from analysis of past behaviors, the system uses software modules to prevent problems from occurring. The system identifies thresholds of behaviors that are used to activate software modules to perform a task.
By using an active and dynamic modeling process, the system “pre-reacts” based on model predictions. Once specific behavior thresholds are identified and activated, the model stimulates a process of co-evolution of the computer network with the environment. The thresholds are modified so that the system does not over- or under-react. This approach is borrowed from the fine-tuning of the human immune system.
In addition to anticipation of network behaviors, the system anticipates environmental changes. The environmental changes are used to predict network behaviors. The dynamics of multiple environmental, network, modeling and software module behaviors are involved in the complex plasticity processes of the system. The anticipation of environmental events is made by the modeling system within probabilities. Once a threshold of events is achieved, the network activates a reconfiguration based on the model predictions by using the software modules. The plasticity processes are continuous.
Reference to the remaining portions of the specification, including the drawings and claims, will realize other features and advantages of the present invention. Further features and advantages of the present invention, as well as the structure and operation of various embodiments of the present invention, are described in detail below with respect to accompanying drawings.
It is understood that the examples and embodiments described herein are for illustrative purposes only and that various modifications or changes in light thereof will be suggested to persons skilled in the art and are to be included within the spirit and purview of this application and scope of the appended claims. All publications, patents, and patent applications cited herein are hereby incorporated by reference for all purposes in their entirety.
The modular software system interoperates (a) in an integrated circuit, (b) an electronic computer with data storage and (c) a network computing environment. The networking environment enables the multidimensional view of the present modular software system into four main levels and fourteen distinct system layers. The four main levels involve hardware, storage, software and system dynamics.
On the data storage level, there are three layers. These layers consist of data objects on layer five (120), a single database management system on layer six (125) and the distributed database management system on layer seven (130). On the software level, there are three layers. Software modules are on layer eight (135), program code blocks are on layer nine (140) and program code elements are on layer ten (145).
On the system dynamics level, there are four layers. The evolving environment is on layer eleven (150), task feedback from the computer network to the environment is on layer twelve (155), multi-node plasticity is only layer thirteen (160) and the reconfiguring network architecture with evolving software modules is on layer fourteen (165).
In
In
In
In
The present application claims the benefit of priority under 35 U.S.C. §119 from U.S. Provisional Patent Application Ser. No. 61/276,182, filed Sep. 9, 2009, the disclosure of which is hereby incorporated by reference in their entirety for all purposes.
| Number | Date | Country | |
|---|---|---|---|
| 61276182 | Sep 2009 | US |
