Modular computing system and method

Abstract

The invention discloses a modular computing system and method, and belongs to the technical field of modular software development. The system comprises an execution unit which is used for configuring an agent module and is also used for executing a modular calculation task by utilizing a code module and a data set; the data storage and management unit is used for safely storing and managing various data resources and data sets required by modular calculation; and the content management system unit is used for storing and managing the metadata, generating code modules and data sets, grouping the code modules and the data sets according to the permission information, and selecting the code modules and the data sets which are required by the modular calculation task and meet permission compliance requirements through a permission decision tree. According to the method, the problems of license management and privacy security in the modular software development process can be solved, and the modular calculation efficiency, privacy protection, security and license compliance are improved.

Description

Technical Field

[0001] The present invention relates to a modular computing system and method, and belongs to the technical field of modular software development. Background Art

[0002] Modular programming is widely used in the computer industry. By breaking down software into reusable code, functions, scripts, packages, and libraries, developing independent functional modules, and then combining these modules into the required software system, it effectively improves software development efficiency, maintainability, and scalability. Currently, modular programming primarily focuses on software structure, ease of development and maintenance, and improving software reliability and reusability. Relatively speaking, modular programming pays less attention to issues such as security, privacy protection, and licensing compliance.

[0003] The rise of open source software has provided developers with a broad ecosystem of training datasets, algorithms, tools, and digital assets (such as 3D models, modeling programs, and hybrid tools). While these resources have accelerated innovation and development, their integration with proprietary data and software also presents significant challenges. One of the most pressing issues when integrating open source and proprietary assets is the complexity of licensing and compliance management. Open source projects often come with varying usage restrictions, licensing obligations, and attribution requirements. Evaluating and experimenting with open source resources may seem harmless in the early stages of development. However, as the project progresses, the effort required to identify, replace, or isolate technical debt (such as improperly licensed components) can increase significantly. Failure to address these issues promptly can lead to legal risks, intellectual property disputes, and potential financial liabilities throughout the software's lifecycle. Existing modular programming techniques lack the means to address these complex licensing issues.

[0004] Beyond licensing issues, deploying proprietary intellectual property (IP) and sensitive assets in cloud environments—whether for research, testing, or production—raises serious concerns about data security and privacy. Cloud-based solutions often carry additional risks, including higher network latency, increased operating costs, and the risk of unauthorized access. For example, engineers and developers working with 3D data and algorithms often face difficulties testing and debugging models locally due to a lack of robust local computing support. Reliance on cloud-based operating environments further complicates the control of sensitive information and exposes critical assets to third-party infrastructure.

[0005] Furthermore, current modular software development lacks unified tools to seamlessly integrate and manage open source and proprietary resources, as well as flexibly switch between different operating environments. Developers need a secure, adaptable framework that supports both local and cloud computing while ensuring computational efficiency, privacy protection, security, and compliance. Summary of the Invention

[0006] The present invention aims to provide a modular computing system and method, which converts software packages into code modules and data sets based on licensing information, groups the code modules and data sets, selects and executes code modules and data sets suitable for computing tasks based on a licensing decision tree, solves licensing management and privacy and security issues in the modular software development process, and improves modular computing efficiency, privacy protection, security and licensing compliance.

[0007] In order to solve the above technical problems, the present invention adopts the following technical means:

[0008] In a first aspect, the present invention provides a modular computing system comprising:

[0009] an execution unit, configured to be equipped with an agent module and further configured to execute modular computing tasks using code modules and data sets;

[0010] Data storage and management unit, used to securely store and manage various data resources and data sets required for modular computing;

[0011] A content management system unit is used to store and manage metadata, generate code modules and datasets, group code modules and datasets according to licensing information, and select code modules and datasets required for modular computing tasks that meet licensing compliance requirements through a licensing decision tree.

[0012] In combination with the first aspect, further, the system includes multiple code modules and multiple data sets, the code module refers to a discrete, self-contained, executable program unit, and the data set refers to a discrete, self-contained, formatted data set; the code module and data set respectively contain additional fragments, the fragments make at least part of the code module executable, and the fragments make at least part of the data set repackaged and / or formatted.

[0013] In combination with the first aspect, the system further includes a separator; and generating a code module and a data set of additional segments according to the separator includes:

[0014] Get the software package;

[0015] Using a separator to divide the software package into a code segment and a data segment, and searching for license information of the code segment and the data segment;

[0016] Converting the code segment and the data segment into a code module and a data set according to the license information of the code segment and the data segment;

[0017] Attach snippets to code modules and datasets to generate code modules and datasets with attached snippets.

[0018] In combination with the first aspect, the system further includes a license file parser; the license file associated with the code module and the data set is read by the license file parser, and the license status of the code module and the data set is obtained and displayed.

[0019] In combination with the first aspect, further, the content management system unit predefines a license compliance graph based on the license status of the code module and the data set. When a new code module or data set is added to the system, the license compliance graph is automatically updated based on the license status of the new code module or data set.

[0020] In combination with the first aspect, further, the content management system unit is used to generate a permission decision tree, including:

[0021] Obtain the permission logic and multiple permission conditions corresponding to the permission type; convert all permission conditions into nodes on a decision tree according to the permission logic and the order of the multiple permission conditions to obtain a permission decision tree for the permission type.

[0022] In combination with the first aspect, further, the content management system unit is used to group the code modules and data sets according to the licensing information, including:

[0023] Group code modules and datasets by license type, including, but not limited to, GPL license, LGPL license, MIT license, Apache license, BSD license, and proprietary software license;

[0024] Grouping code modules and datasets according to licensing strictness, including weak copyleft, permissive copyleft, and strong copyleft;

[0025] Code modules and datasets are grouped according to their execution environments, which include local computing resources, private cloud computing resources, and public cloud computing resources.

[0026] In combination with the first aspect, further, the content management system unit is configured to select, through a licensing decision tree, code modules and data sets required for modular computing tasks that meet licensing compliance requirements, including:

[0027] Based on the licensing information of the modular computing task, the corresponding licensing decision tree is selected; starting from the top of the licensing decision tree and executing downward, the license compatibility of the code modules and datasets is evaluated; based on the license compatibility evaluation results, the selected code modules and datasets are fine-tuned to obtain the code modules and datasets required for the modular computing task that meet the licensing compliance requirements.

[0028] In a second aspect, the present invention provides a modular computing method, comprising:

[0029] Obtaining a code module and a data set with additional fragments; the fragments making at least a portion of the code module executable, the fragments causing at least a portion of the data set to be repackaged and / or formatted;

[0030] Obtain modular computing tasks and operating environment information;

[0031] Select code modules and datasets based on modular computing tasks and group them;

[0032] According to the licensing information of the modular computing task, the license compatibility of the selected code modules and datasets is evaluated through the corresponding license decision tree, and then the selected code modules and datasets are fine-tuned according to the license compatibility evaluation results;

[0033] Perform modular computing tasks with fine-tuned code modules, datasets, runtime environments, and licenses.

[0034] In conjunction with the second aspect, further, the method for generating a licensing decision tree includes:

[0035] Obtain the permission logic and multiple permission conditions corresponding to the permission type; convert all permission conditions into nodes on a decision tree according to the permission logic and the order of the multiple permission conditions to obtain a permission decision tree for the permission type.

[0036] The following advantages can be obtained by adopting the above technical means:

[0037] This paper proposes a modular computing system and method, providing a new modular computing framework that allows secure, efficient, and license-compliant computing between local devices and cloud environments. Based on licensing information, software packages are converted into code modules and datasets, which are then grouped. Furthermore, a licensing decision tree technique is introduced to evaluate the licensing compatibility of code modules and datasets, completing the structured processing of modular data and programs. This reduces the risks associated with intellectual property protection, licensing complexity, and computing resource optimization during modular software development, while improving the security, efficiency, privacy protection, and licensing compliance of modular software development. BRIEF DESCRIPTION OF THE DRAWINGS

[0038] Figure 1 A schematic structural diagram of a modular computing system provided by the present invention;

[0039] Figure 2 A schematic diagram of the process of generating discrete code modules and data sets in an embodiment of the present invention;

[0040] Figure 3A schematic diagram of a flow chart of a code module and a data set for generating additional segments in an embodiment of the present invention;

[0041] Figure 4 A schematic diagram of the structure of a code module and a data set with a permission status according to an embodiment of the present invention;

[0042] Figure 5 is a schematic diagram of a license compliance graph in an embodiment of the present invention;

[0043] Figure 6 A schematic diagram of code modules and data sets grouped according to license type in an embodiment of the present invention;

[0044] Figure 7 Schematic diagram of code modules and data sets grouped according to license strictness in an embodiment of the present invention;

[0045] Figure 8 A schematic diagram of a process for selecting a code module and a data set according to a computing task in an embodiment of the present invention;

[0046] Figure 9 A schematic diagram of the steps of a modular calculation method provided by the present invention. DETAILED DESCRIPTION

[0047] The following examples are intended to fully disclose the present invention and enable those skilled in the art to fully understand the scope of the present invention. The present invention is not limited to the disclosed illustrative embodiments, but can be implemented in a variety of ways. In addition, the various embodiments provided in this specification may also be combined in the absence of conflicts or contradictions.

[0048] Example 1

[0049] This embodiment introduces a modular computing system, such as Figure 1 As shown, the system primarily consists of an execution unit for executing tasks, a data storage and management unit, and a content management system unit. Each unit in the system operates independently and can be hosted locally (e.g., on a personal computer) or remotely (e.g., in the cloud). The system not only enhances computing efficiency but also provides a robust framework for managing various licensing models and protecting intellectual property. Leveraging its modular architecture and licensing compliance mechanisms, the system enables seamless integration of various software components, reducing the complexity of software deployment and maintenance.

[0050] In the system of the present invention, at least one unit can be virtualized, utilizing shared hardware resources for computation. In some embodiments, the three units can reside on the same device (e.g., a personal computer or server) to optimize performance. In other embodiments, the three units can be distributed across multiple devices to achieve enhanced storage performance, scalability, licensing compliance, and other advantages.

[0051] Execution units are used to perform computational operations (e.g., execute tasks). They can be equipped with agents that facilitate communication and manage the execution of code modules and access to datasets. Execution units can run locally or in the cloud.

[0052] The data storage and management unit is used to securely store and manage various data resources (such as three-dimensional (3D) models, artificial intelligence (AI) training data, and test data, which can be referred to as assets). Assets in the data storage and management unit may be subject to different types of licensing agreements, such as proprietary licenses, open source licenses (including reciprocal and permissive licenses), and subscription-based licenses. Open source licenses include the MIT license, the BSD license, the Apache license, the GPL, and the Creative Commons license. The data storage and management unit can contain multiple data sources, each with its own licensing constraints. The system is configured to ensure that assets are securely stored while being accessible to computing tasks. To improve security and access speed, data resources can be stored on local devices. In addition, some data resources can be stored in the cloud to achieve scalability and distributed computing.

[0053] The content management system unit (hereinafter referred to as the CMS unit) is primarily used to store and manage metadata, including file names, data attributes, and licensing information. The CMS unit may choose not to store private or sensitive data. In some embodiments, the CMS unit can operate in a network environment to manage resource allocation, ensure licensing compliance, enforce patent rights, and efficiently schedule computing resources. In other embodiments, the CMS unit can be deployed in a private infrastructure to meet specific security and operational requirements. The CMS unit can integrate various modules and data from external software communities and internal development to achieve seamless integration and unified management.

[0054] The system of the present invention may also include multiple code modules and multiple data sets, such as Figure 1 Code Module 1, Code Module 2, Code Module M, and Dataset 1, Dataset 2, and Dataset N. The system may also include snippets provided by the code modules and datasets. The additional snippets render at least some of the code modules executable and repackage and / or format at least some of the datasets.

[0055] Fragments contained in or attached to a code module are referred to as "code snippets," while fragments contained in or attached to a dataset are referred to as "data snippets." A code snippet can be considered a small, reusable piece of software or code that performs a specific function or task, thereby enabling the execution of certain software. In some cases, a code snippet can be used as an executable wrapper, encapsulating a software file or code snippet to make it executable. A data snippet can be considered a small, reusable piece of information that repackages or reformats data to meet computing needs.

[0056] like Figure 2 As shown, it is assumed that the software package is a monolithic application or library, which contains components such as code segments and data segments. Code segments are software files that can include various libraries, and data segments are data files that can digitally store, process, and transmit information. Because the code segments and data segments in the software package are tightly coupled and deployed together in a monolithic structure, replacing a component (such as code segment 1) may be difficult. The situation becomes even more complicated and difficult when the code segment is open source software with strict commercial distribution license restrictions. To address this problem, the present invention provides a separator that decomposes the software package and separates it into discrete code modules and data sets.

[0057] A separator can be included in a modular computing system. The separator scans a software package, identifies code segments and data segments within the software package, and decomposes or partitions the software package to separate the code segments and data segments. The separator can be used to iteratively and recursively scan for specific code and data. Furthermore, the present invention can also utilize manual methods to partition software packages.

[0058] After a software package is broken down into smaller modular units—code segments and data segments—then they are converted into discrete code modules and datasets, respectively. Each code module and dataset is discrete, self-contained, executable, and independently run. This allows for easy replacement of code modules or datasets in the event of licensing issues. For example, if a code module or dataset needs to be replaced, it can be removed and replaced without affecting other code modules or datasets. This limits the scope of changes to a single component of the software package.

[0059] Furthermore, after the code modules and datasets are generated, the original software package is converted into a new software package containing the code modules and datasets instead of the original code segments and data segments.

[0060] Each code module and dataset can be assigned a specific purpose and adapted to a specific license, making them easy to reuse and maintain, and bringing more advantages. The above process of converting code segments and data segments into code modules and datasets can be performed by the system or a CMS unit in the system.

[0061] like Figure 3 As shown, the method for generating a code module and a data set with a snippet specifically includes the following steps:

[0062] Step 1: Obtain a software package containing open source software (including open source files, libraries, and specific data sources), proprietary software, and proprietary data.

[0063] Step 2: Search for license information or license statements in the software package. For example, files such as LICENSE.md, LICENSE.txt, or LICENSE.rst can be parsed to extract the license information associated with the open source software. In addition, copyright notices may also be embedded directly in source code files or data files.

[0064] Use separators to divide software packages into code and data segments based on license compliance status.

[0065] Step 3: Identify the license types of the code and data segments. License types may include MIT license, GPL license, or proprietary license. After obtaining the license types of the code and data segments, the system further separates or decomposes the software package into the code and data segments.

[0066] Step 4: Convert the code segments and data segments into code modules and data sets according to the license information. For example, Figure 2 Code segments 1, 2, ..., M are converted into code modules 1, 2, ..., M, respectively; while data segments 1, 2, ..., N are converted into data sets 1, 2, ..., N, respectively. The present invention can convert code segments into code modules in a variety of ways. These code modules can be developed or compiled to adapt to different operating systems.

[0067] Based on a specific license compliance, the system can generate corresponding code modules from code segments with the same compliance, and generate corresponding datasets from data segments with the same compliance. Alternatively, the system can detect the license strictness of code and data segments, separate them from the software package based on the license strictness, and generate code modules and datasets accordingly. License strictness can be expressed as permissive license, weak copyleft, or strong copyleft.

[0068] Step 5: Attach the snippet to the code module and the dataset to generate the snippet-attached code module and dataset.

[0069] The system generates snippets for code modules and datasets, and then attaches the snippets to the code modules and datasets, respectively. In some embodiments, the system attaches a snippet to every code module and every dataset. In other embodiments, the system may attach a snippet to a majority of the code modules and datasets, e.g., at least 50% of the code modules and at least 50% of the datasets.

[0070] As mentioned previously, snippets are designed to package and / or compile the code of a code module or dataset into executable code or formatted data, enabling it to run on an operating system such as Windows, Linux, or Mac. While the code and data segments in a software package cannot be executed independently, code modules with snippets attached can be independently executed and can be easily removed or replaced. Data sets with snippets attached can be independently controlled, directly accessed, and easily removed or replaced when needed.

[0071] In an embodiment of the present invention, the code module is controlled by the execution unit, and the data set is managed by the data storage and management unit. The execution unit may include at least a portion of the code module, and the data storage and management unit may include at least a portion of the data set.

[0072] Since the system of the present invention can run in a local or cloud environment, code modules and datasets can be deployed on a local computer or in the cloud. In some cases, code modules and datasets can be deployed partially locally and partially in the cloud. When enhanced security and privacy protection are required, code modules and datasets can be configured in a local operating environment because it allows users to have full control over proprietary assets and sensitive calculations and avoid external exposure. In addition, local execution can reduce network latency and avoid unnecessary cloud processing costs, providing efficiency advantages. Code modules and datasets can be distributed across cloud resources for parallel execution. The cloud deployment model has advantages for large-scale computing that requires large amounts of processing power, high availability, and scalability. When software execution is modularized in the cloud, it can enhance flexibility, optimize resource allocation, and improve compliance with licensing requirements while leveraging the advantages of distributed computing.

[0073] In embodiments of the present invention, a code module may refer to a discrete, self-contained, executable, and independently manageable program unit that can be executed, linked, or integrated into a larger software system. A dataset may refer to a discrete, self-contained, well-formatted collection of data. Snippets can be configured separately to package code modules and datasets, respectively. In some embodiments, snippets may include an execution function (e.g., C++ main()) to implement initialization and execution. In some cases, a snippet (e.g., Code Segment 2) can be attached to a code module, rendering the code module executable as a binary file within a computer operating system or Python environment. Similarly, a snippet (e.g., Data Segment II) can be attached to a dataset, rendering the dataset repackaged, formatted, accessible, and functional within a computer operating system or Python environment.

[0074] Code modules can originate from code snippets or libraries within a monolithic software package. Code modules enable modular computing and flexible licensing. For example, a code module can run under its own license terms, such as a proprietary license, the MIT license, or the GNU General Public License (GPL). Code modules can run like regular programs, but if they run in command-line mode or interactive GUI mode between users and devices, or between devices, the module's functionality is relatively simple, with very few or no options. In addition, code modules can include static and dynamic libraries. Code modules can be executed on a local computer or in the cloud, and the choice of runtime environment can be determined by factors such as the software's computing requirements, licensing restrictions, and efficiency.

[0075] Code modules can be structured as binaries or scripts, depending on code accessibility, licensing terms, and computing preferences. Because code modules are discrete and independent, certain security-sensitive tasks can run in isolated environments, reducing the risk of unauthorized access to data or data leakage.

[0076] In embodiments of the present invention, the system can enforce licensing compliance by clearly distinguishing between open source and proprietary components. In some embodiments, when the execution environment changes (e.g., from an internal development environment to a public deployment environment), the system can dynamically replace a code module or dataset to meet regulatory compliance requirements. The system can maintain regulatory compliance and verify that software operations remain legal and efficient in any context.

[0077] In some embodiments, code snippets may include clear metadata, simple instructions, and automated check scripts. Metadata describing elements such as version numbers and runtime environment details can help CMS units and agents manage and check whether code modules and / or datasets are compatible or need to be updated.

[0078] In some embodiments, code segments can be configured to adapt to the runtime environment. For example, a code segment can contain code that detects runtime details, such as software library versions, operating system type, and certain hardware information. When the code in the code segment is executed, it can adjust functionality, memory management, or parallel processing strategies based on the detected environment, thereby reducing the need for manual code tuning.

[0079] In some embodiments, code snippets can include built-in licensing rules and tracking capabilities. The snippet can contain logic to enforce usage restrictions, log where and how it's used, and provide a unique numeric ID for tracking changes between different projects. This helps users manage open source licenses and track unauthorized or outdated snippet usage.

[0080] In some embodiments, a data segment can include a built-in data conversion layer. The data segment can be packaged in a common format (such as JSON or XML) and include scripts to parse and map the data, helping users use the data more efficiently.

[0081] In some embodiments, data segments can contain incremental version updates. A data segment consists of an initial dataset and several smaller "update" files that reflect only recent changes. When a data segment is deployed, it enables CMS units, agents, or modules to determine whether to download the entire dataset or only smaller incremental updates based on the current operating environment. This avoids redundant computations, reduces bandwidth usage, and tracks dataset changes over time.

[0082] In some embodiments, the data segment can include a small AI component that generates additional data when needed. For example, if a module detects that there is insufficient data for certain categories, the data segment can suggest or create additional synthetic data, thus keeping the dataset balanced and valid even as circumstances change.

[0083] In the present invention, execution units may include agents that control the execution of code modules and / or access to datasets. Furthermore, agents can communicate with CMS units and share metadata and other information. CMS units can use agents to distribute code modules and datasets while ensuring security, privacy, and licensing compliance. This coordination is crucial for managing operations executed in local or cloud environments. By using agents, the system can dynamically optimize the use of available resources and execute tasks in an efficient and compliant manner.

[0084] In some embodiments, the agent can use a scripting language (e.g., Python) to execute code modules using operating system (OS) commands. Furthermore, code modules may run in a pipelined manner, sharing input and output across various OS storages. In other embodiments, code modules may employ parallelization to accelerate execution, which may require additional OS commands to ensure data integrity. In some cases, code modules can also be executed using a graph model to handle more complex upstream and downstream communication.

[0085] For tasks such as 3D model recoloring, mesh sculpting, or AI data preparation, there's a need to identify suitable modules and datasets. Traditional software packages often rely on monolithic applications, where all software components are tightly coupled, co-deployed, and integrated into a single program. However, with monolithic applications, commercially distributing specialized software using strictly licensed open source programs can be challenging.

[0086] Optionally, the system of the present invention may further include a license file parser. In some cases, the license file parser may be provided together with the separator. The system can read the license files associated with the code modules and data sets through the license file parser and obtain the license status of each component, such as Figure 4 The license status may include license indication information, such as the license name.

[0087] In some cases, the system can display licensing statistics for code modules and datasets in tabular form, as shown in Tables 1 and 2 below. In Table 1, dataset number 3 is named "Texture Image," licensed under the Creative Commons Zero (CC0) license, and is cloud-based open source software. In Table 2, code module number 5 is named "Hole Fillings," licensed under a proprietary license, and hosted on a personal computer.

[0088] Table 1 Dataset licensing statistics

[0089]

[0090] Table 2 License statistics of code modules

[0091]

[0092] The CMS unit of the system of the present invention can organize code modules and datasets according to their license status to facilitate license compliance management of programs and data. Furthermore, the CMS unit can maintain a predefined license compliance map based on software industry standards. When new code modules or datasets are added to the system, the CMS unit can automatically update the license compliance map to incorporate any new license information.

[0093] The embodiment of the present invention takes four types of licenses as examples to explain the license compliance diagram. Figure 5 As shown in the figure, the four license types are MIT, Apache 2.0, AGPLv3 and proprietary license. Figure 5 In the diagram, individual licenses are connected by paths, with arrows on the paths indicating compliance or combination direction. Path 1 connects MIT and Apache 2.0, flanked by two arrows pointing toward these two licenses. These arrows indicate that MIT-licensed code can be combined with Apache 2.0 projects, and vice versa. MIT is a permissive license that allows reuse not only in Apache 2.0 but also in AGPLv3 and proprietary code, the latter two cases being represented by paths 2 and 4. Path 3 indicates that Apache 2.0 is compatible with GPLv3 and AGPLv3 (broadly speaking). When Apache 2.0 code is combined with AGPLv3 code, the combined code is subject to the AGPLv3 copyleft. Path 5 indicates that Apache 2.0 code is compatible with proprietary programs, but proprietary code is incompatible with Apache 2.0 applications. The License Compliance Diagram also includes path 11 attached to each license, indicating that code files or applications with the same license or license compliance can be combined. In some cases, licensing rights may be complicated by patent laws or specific clauses—for example, such clauses may be included in the Apache 2.0 license.

[0094] Table 3 shows example relationships between code modules and datasets that can be used to enforce license compliance. If a code module and a dataset have identical or compatible license compliance requirements, they can be considered a compatible pair. For example, since code module 2 and dataset 3 both meet compliance requirement 3, these two components can be paired and bundled together. Based on the compute use case and available runtime environment, the relationships shown in Table 3 can be used to query CMS units. Using Table 3, the system can dynamically adjust to maintain compliance as the execution context changes. This can improve both legal compliance and operational efficiency.

[0095] Table 3 Compliance relationship between code modules and datasets

[0096]

[0097] In this embodiment of the present invention, to facilitate the search and verification of license compatibility for code modules and datasets, the system generates a licensing decision tree through the CMS unit. After the user identifies a computing task (e.g., repairing a 3D model network) and an operating environment (e.g., a personal computer for prototyping), the user can use the CMS unit to select the appropriate code modules and datasets for the task based on the licensing decision.

[0098] The CMS unit proposes a variety of project licensing options. The licensing information corresponding to each licensing option can be converted into a tree structure. Specifically: obtain the licensing logic and multiple licensing conditions corresponding to the licensing type; according to the licensing logic and the order of multiple licensing conditions, convert all licensing conditions into nodes on the decision tree to obtain the licensing decision tree of the licensing type. These licensing decision trees can be displayed on the display. When the user selects a project license, that is, selects a licensing decision tree, the CMS unit can start from the top of the selected licensing decision tree and, based on the licensing combination possibilities described above (for example, using Figure 5 The CMS unit can evaluate license compatibility based on linking, modification, and re-licensing requirements. In some embodiments, a decision diagram can be formed by organizing nodes using a graph structure and displayed to the user to help the user select a license combination.

[0099] The following are six examples of licensing decision trees. Similar strategies can be used for other licensing types:

[0100] 1. GPL (General Public License)

[0101] a. Is it used in combination with other GPL-licensed code?

[0102] i. Yes → Compatible (GPL itself is mandatory)

[0103] ii. No → Check whether other licenses are compatible with the GPL

[0104] 1. LGPL → Compatible if dynamically linked

[0105] 2. Apache 2.0 → Incompatible (patent clause conflicts)

[0106] 3. MIT / BSD → Compatible

[0107] 4. Proprietary license → incompatible

[0108] b. Is relicensing allowed under the GPL?

[0109] i. Yes → Some permissive licenses (such as MIT / BSD) are compatible

[0110] ii. No → Incompatible with any non-GPL code

[0111] 2. LGPL (Lesser General Public License)

[0112] a. Is LGPL-licensed code statically linked?

[0113] i. Yes → A method for replacing the library (or reauthorizing it) must be provided

[0114] ii. No → Compatible with non-GPL code (permissive)

[0115] b. Is it a dynamic link?

[0116] i. Yes → Compatible with most licenses

[0117] ii. No → Re-authorization may be required

[0118] 3. MIT / BSD / Apache 2.0 (Permissive License)

[0119] a. Is it used in combination with other permissive permissions?

[0120] i. Yes → Fully compatible

[0121] ii. No → Other licenses need to be checked

[0122] 1. GPL → Only compatible if the project is licensed under the GPL

[0123] 2. Proprietary license → usually compatible

[0124] 3. CC BY / CC0 → Please confirm whether it is applicable to the software usage scenario

[0125] 4. Proprietary / Commercial License

[0126] a. Does it include open source code?

[0127] i. No → Completely proprietary, no licensing conflicts

[0128] ii. Yes → Check the terms of the open source license used

[0129] 1. GPL → Incompatible unless the entire project is licensed under the GPL

[0130] 2. LGPL → Compatible if dynamically linked

[0131] 3. MIT / BSD / Apache → compatible

[0132] 5. Creative Commons License (CC0, CC BY, CC BY-SA, etc.)

[0133] a. Is it used in software?

[0134] i. Yes → Only CC0 is safe, other versions may conflict

[0135] ii. No → Usually feasible for documents, media, etc.

[0136] 6. Other special license types

[0137] a. AGPL (Affero GPL) → The entire web application must be re-licensed under the AGPL

[0138] b. MPL (Mozilla Public License) → All code modifications must maintain MPL authorization

[0139] c. EPL (Eclipse Public License) → Source code must comply with the terms of the EPL

[0140] Notes:

[0141] The GPL is the most restrictive open source license: it forces all derived code to be re-licensed under the GPL.

[0142] Permissive licenses (such as MIT, BSD, Apache) are highly compatible: they allow free use in both proprietary and open source projects.

[0143] The LGPL offers some flexibility; it is compatible with the GPL but allows dynamic linking with non-GPL software.

[0144] The Creative Commons license family is not designed for software: versions other than CC0 may be incompatible with software licenses.

[0145] A single computational task can be accomplished using a variety of code modules and datasets. For example, for 3D mesh repair, tools such as CGAL (e.g., licensed under the GPL, LGPL, or commercial licenses) and Geogram (e.g., licensed under the BSD-3 license) can be used. Users can also develop custom programs to add to CMS units. Despite being licensed under different agreements, these tools can still be used to perform the same computational task, albeit with varying computational overhead and repair quality.

[0146] In the present invention, both code modules and datasets are subject to licensing requirements. Certain proprietary software offers a high degree of flexibility in distribution and operation, allowing for flexible deployment on personal computers, public cloud platforms, and private cloud environments. Software licensed under permissive open source licenses, such as MIT, offers similar flexibility. GPL-type licenses, on the other hand, are more suitable for back-end service scenarios such as Software as a Service (SaaS), provided the software is not publicly available. The complexity of licensing agreements hinders software development and deployment to a certain extent, creating a need for structured licensing management. In embodiments of the present invention, this structured approach includes not only evaluating the compatibility of different licenses but also grouping code modules and datasets based on their respective licensing information and executing tasks using these modules and datasets. This approach can improve the security and compliance of software resources.

[0147] In order to better meet different needs, the present invention can group code modules and data sets according to license type, such as Figure 6 As shown, there are three groups, corresponding to proprietary software licenses, GPL licenses, and MIT licenses. The proprietary software license group includes code module 11, dataset 11, dataset 12, and dataset 13; the GPL license group includes code module 21, dataset 21, and dataset 22; and the MIT license group includes code module 31, dataset 31, dataset 32, and dataset 33. This grouping approach allows for flexible software distribution without exposing proprietary information or trade secrets. While reducing licensing complexity, these groups can be flexibly deployed and executed on personal computers or in cloud environments, enhancing security and privacy.

[0148] The present invention can also group code modules and data sets based on license strictness, such as Figure 7 As shown in the figure, there are three groups, corresponding to weak copyleft, permissive licensing, and strong copyleft. The weak copyleft group includes code module 41, dataset 41, dataset 42, and dataset 43; the permissive licensing group includes code module 51, dataset 51, and dataset 52; and the strong copyleft group includes code module 61, dataset 61, dataset 62, and dataset 63. In some cases, if there are modules and datasets that require such licensing compliance, additional groups can be created for the network protective category. This further enhances the functionality, security, and privacy protection of the system.

[0149] After code modules and datasets are grouped according to license or license strictness, these groups can be stored in the system or the CMS unit of the system. For example, the system can store some or all modules and datasets (or selected modules and datasets) in their own groups. This can improve the efficiency of module and dataset retrieval.

[0150] Furthermore, the present invention can also group code modules and data sets based on the operating environment, such as local computing resources, private cloud computing resources, and public cloud computing resources. Local computing resources can be based on personal devices (or local servers) and can be used to perform sensitive operations. Therefore, data privacy can be maintained and reliance on cloud-based services can be reduced. It is suitable for tasks involving confidential data, which may be better protected in a controlled and secure local environment. When higher processing power is required or when computing-intensive tasks are to be performed, private or public cloud computing resources may be required. Tasks can be offloaded to private or public clouds, making computing resources scalable and enhancing support for high-performance applications. In addition, compared to the limitations of local computing resources, cloud computing can provide greater capabilities when greater flexibility and scalability are required.

[0151] Since code modules and datasets can be deployed in local or cloud environments, the system's CMS unit can also group code modules and datasets based on licensing requirements and computing requirements, for example, using certain algorithms. This can provide an optimal computing strategy that balances security, privacy, efficiency, and performance.

[0152] In some embodiments, grouping can be implemented within a CMS unit, which maintains relationships between code modules, between datasets, and between code modules and datasets. Furthermore, grouping can be implemented using predefined and adaptively updated graph data structures to facilitate the implementation of analysis and search algorithms. These algorithms can use a combination of breadth-first search (BFS), depth-first search (DFS), or other methods (such as priority queues) to optimize computational performance and legal compliance. Search methods can be optimized based on a variety of conditions.

[0153] Based on the above grouping content, the system of the present invention can select code modules and data sets according to specific computing tasks, such as Figure 8 The specific operations are as follows:

[0154] Step 1: Obtain a computing task. The user can open the CMS interface on a computer monitor. The CMS displays multiple computing tasks, and the user selects a task. Once the user selects a task, the CMS obtains information about the task, including its licensing information.

[0155] Step 2: Obtain code modules and data sets according to computing tasks, and group the code modules and data sets.

[0156] The CMS unit retrieves available code modules and datasets relevant to the computational task from the system. Optionally, the CMS unit can provide a list of code modules and datasets and present this list to the user through its interface. The user can search and select appropriate code modules and datasets from this list. The CMS unit can group the selected code modules and datasets based on their license type (e.g., GPL, BSD, or proprietary license) or other information using a breadth-first search (BFS) or other grouping methods.

[0157] Step 3: Get the operating environment information.

[0158] The user selects an execution environment through the CMS interface. This execution environment can be local, for example, executing tasks on a personal computer, another computer, or a locally installed server. Alternatively, the execution environment can be cloud-based, utilizing remote computing resources. Once the user selects or enters the execution environment information, the CMS unit retrieves the execution environment information. In some cases, a local execution environment is preferable for prototyping tasks.

[0159] Step 4: Fine-tune the code module and dataset selected in step 2 according to the licensing information of the computing task.

[0160] In the present invention, some computing tasks have explicit licensing requirements, and users or CMS units can also select one or more licenses applicable to the computing tasks. Based on the selected licenses, the CMS unit can fine-tune the selected code modules and datasets. Specifically, after a license is selected, the CMS unit searches and verifies the code modules and datasets through the corresponding license decision tree. Starting from the top of the license decision tree and traversing downward to the bottom of the tree, the CMS unit evaluates compatibility scenarios based on linking, modification, and re-licensing requirements, thereby adjusting the code modules and datasets to select those that are more suitable for the computing task and operating environment.

[0161] Alternatively, the present invention may also use Figure 5 The license compliance diagram shown in the figure assists in the assessment of code modules and datasets. This process ensures that the fine-tuned code modules and datasets comply with legal and operational regulations.

[0162] Step 5: Display the selected code module and dataset to the user through the CMS page, and obtain a confirmation message from the user. The confirmation message indicates that the user has approved the selected code module and dataset. In addition, the confirmation message also indicates that the user has approved the selected license.

[0163] Step 6: After resolving the licensing compliance issues, the system executes the computing task using the selected code modules, datasets, runtime environment, and licenses.

[0164] The system of the present invention may also include an intelligent computing switching mechanism. The CMS unit can use this switching mechanism to switch between one execution environment (e.g., a local environment) and another (e.g., a cloud-based environment) to dynamically optimize resource utilization. For example, the CMS unit can use the switching mechanism to inspect and monitor the real-time conditions of both the local and cloud-based execution environments. Specifically, the CMS unit can examine factors such as the current workload, network availability, and cost-effectiveness to determine whether a task should be run locally or moved to the cloud. For example, the CMS unit can flexibly deploy code modules and datasets between execution environments. Furthermore, users can assign module and dataset groups to different execution environments through the CMS graphical user interface or command-line interface. The CMS unit can coordinate the allocation, enabling tasks to execute seamlessly across different platforms. Thus, the system can be configured as a flexible computing platform that dynamically selects an execution environment based on security, privacy, cost, performance, as well as licensing compliance and patent constraints.

[0165] Example 2

[0166] Based on the system introduced in Example 1, this embodiment introduces a modular calculation method, such as Figure 9 As shown, it mainly includes the following steps:

[0167] Step A: Obtain a code module and a data set with an additional fragment. The fragment makes at least a portion of the code module executable and causes at least a portion of the data set to be repackaged and / or formatted.

[0168] Step B: Obtain modular computing tasks and operating environment information.

[0169] Step C: Select code modules and data sets according to modular computing tasks, and group the code modules and data sets.

[0170] Step D: Based on the licensing information of the modular computing task, the license compatibility of the selected code modules and data sets is evaluated through the corresponding license decision tree, and then the selected code modules and data sets are fine-tuned according to the license compatibility evaluation results.

[0171] Step E: Execute modular computing tasks using the fine-tuned code modules, datasets, runtime environment, and licenses.

[0172] In summary of the above embodiments, the present invention introduces a new dimension to modularity, which is not only limited to the code organization level, but also focuses on the security and compliance management of programs and data. The present invention proposes a modular computing framework that allows secure, efficient and license-compliant computing between local devices and cloud environments. By introducing a structured processing method for modular data and programs, the capabilities of software in research, development, testing and production processes are enhanced, while reducing the risks associated with intellectual property protection, licensing complexity and computing resource optimization, and improving the security of modular software development computing. The present invention improves data protection, license integrity and operational flexibility. The framework can efficiently manage and execute computing processes while ensuring intellectual property security. It is applicable to multiple fields including three-dimensional geometric computing, artificial intelligence and enterprise-level generation management.

[0173] Those skilled in the art will appreciate that the embodiments of the present application may be provided as methods, systems, or computer program products. Therefore, the present application may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment combining software and hardware. Furthermore, the present application may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to magnetic disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0174] The present application is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each process and / or block in the flowchart and / or block diagram, as well as the combination of processes and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to produce a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 a process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0175] These computer program instructions may also be stored in a computer readable memory that can direct a computer or other programmable data processing device to work in a specific manner, so that the instructions stored in the computer readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1 a process or multiple processes and / or boxes Figure 1 The function specified in one or more boxes.

[0176] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operational steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing the instructions executed on the computer or other programmable device for implementing the process. Figure 1 a process or multiple processes and / or boxes Figure 1 A step that specifies a function in one or more boxes.

[0177] The above is only a preferred embodiment of the present invention. It should be pointed out that for ordinary technicians in this technical field, several improvements and modifications can be made without departing from the technical principles of the present invention. These improvements and modifications should also be regarded as the scope of protection of the present invention.

Claims

1. A modular computing system, characterized in that: include: an execution unit, configured to be equipped with an agent module and further configured to execute modular computing tasks using code modules and data sets; Data storage and management unit, used to securely store and manage various data resources and data sets required for modular computing; The content management system unit is used to store and manage metadata, generate code modules and datasets, group code modules and datasets according to licensing information, and select code modules and datasets required for modular computing tasks that meet licensing compliance requirements through a licensing decision tree.

2. The modular computing system according to claim 1, wherein: The system includes multiple code modules and multiple data sets, wherein the code module refers to a discrete, self-contained, executable program unit, and the data set refers to a discrete, self-contained, formatted data set; the code modules and data sets respectively contain additional fragments, which make at least part of the code modules executable and the fragments make at least part of the data sets repackaged and / or formatted.

3. The modular computing system according to claim 2, wherein: The system further includes a separator; based on the separator, a code module and a data set for generating additional segments are generated, including: Get the software package; Using a separator to divide the software package into a code segment and a data segment, and searching for license information of the code segment and the data segment; Converting the code segment and the data segment into a code module and a data set according to the license information of the code segment and the data segment; Attach snippets to code modules and datasets to generate code modules and datasets with attached snippets.

4. The modular computing system according to claim 1, wherein: The system includes a license file parser; the license file associated with the code module and the data set is read by the license file parser, and the license status of the code module and the data set is obtained and displayed.

5. The modular computing system according to claim 1, wherein: The content management system unit predefines a license compliance graph according to the license status of code modules and data sets, and automatically updates the license compliance graph according to the license status of the new code module or data set when a new code module or data set is added to the system.

6. The modular computing system according to claim 1, wherein: The content management system unit is used to generate a permission decision tree, including: Obtain the permission logic and multiple permission conditions corresponding to the permission type; convert all permission conditions into nodes on a decision tree according to the permission logic and the order of the multiple permission conditions to obtain a permission decision tree for the permission type.

7. The modular computing system according to claim 1, wherein: The content management system unit is used to group code modules and data sets according to licensing information, including: Group code modules and datasets by license type, including, but not limited to, GPL license, LGPL license, MIT license, Apache license, BSD license, and proprietary software license; Grouping code modules and datasets according to licensing strictness, including weak copyleft, permissive copyleft, and strong copyleft; Code modules and datasets are grouped according to their execution environments, which include local computing resources, private cloud computing resources, and public cloud computing resources.

8. The modular computing system according to claim 1, wherein: The content management system unit is used to select code modules and data sets required for modular computing tasks and meeting licensing compliance requirements through a licensing decision tree, including: Based on the licensing information of the modular computing task, the corresponding licensing decision tree is selected; starting from the top of the licensing decision tree and executing downward, the license compatibility of the code modules and datasets is evaluated; based on the license compatibility evaluation results, the selected code modules and datasets are fine-tuned to obtain the code modules and datasets required for the modular computing task that meet the licensing compliance requirements.

9. A modular computing method, characterized in that: include: Get the code modules and datasets for the attached snippets; The segment causes at least a portion of the code module to be executable, and the segment causes at least a portion of the data set to be repackaged and / or formatted; Obtain modular computing tasks and operating environment information; Select code modules and datasets based on modular computing tasks and group them; According to the licensing information of the modular computing task, the license compatibility of the selected code modules and datasets is evaluated through the corresponding license decision tree, and then the selected code modules and datasets are fine-tuned according to the license compatibility evaluation results; Perform modular computing tasks with fine-tuned code modules, datasets, runtime environments, and licenses.

10. The modular computing method according to claim 9, characterized in that: The methods for generating a licensing decision tree include: Obtain the permission logic and multiple permission conditions corresponding to the permission type; convert all permission conditions into nodes on a decision tree according to the permission logic and the order of the multiple permission conditions to obtain a permission decision tree for the permission type.

Images