CN114461295A - Method, device, equipment and medium for generating software system based on plug-in sharing - Google Patents
Method, device, equipment and medium for generating software system based on plug-in sharing Download PDFInfo
- Publication number
- CN114461295A CN114461295A CN202111614371.5A CN202111614371A CN114461295A CN 114461295 A CN114461295 A CN 114461295A CN 202111614371 A CN202111614371 A CN 202111614371A CN 114461295 A CN114461295 A CN 114461295A
- Authority
- CN
- China
- Prior art keywords
- plug
- description
- data
- function
- ins
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
- G06F9/44526—Plug-ins; Add-ons
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a software system generating method, a device, equipment and a medium based on plug-in sharing, wherein the method comprises the steps of obtaining a plurality of plug-ins containing interfaces, wherein the interfaces comprise input data, output data and interface functions, and the plug-ins contain function functions; adding a plug-in description for each plug-in, wherein the plug-in description at least comprises an interface description, and the interface description comprises a detailed description of each data and function contained in the interface; formulating an engineering configuration specification, wherein the engineering configuration specification at least comprises a data reference relation among the plug-ins; and generating a shared code according to the data reference relation among the plug-ins and the interface description of the plug-ins, and generating a software system according to the shared code. The invention removes the constraint of uniform naming, the scheme does not limit the naming of the research language, data and function, the plug-in developer can freely program, and a great amount of time required by the developer to learn the specification is saved.
Description
Technical Field
The invention belongs to the technical field of collaborative programming, and particularly relates to a method, a device, equipment and a medium for generating a software system based on plug-in sharing.
Background
In software engineering of parallel computing, the problems encountered by collaborative development are as follows:
(1) the development of large programs needs to be decomposed into various functional modules, and the modules can be matched for use only by following certain specifications. The specifications given by the current solutions, which cannot be universally applied to the general developers, are represented as: it takes a significant amount of time for the programmer to learn the specifications and even completely change the original programming style.
(2) Current solutions, which first address the unified naming convention, require developers to forgo their familiar naming. However, the rules are not comprehensive, are invariable, and reflect only a certain research orientation. For example, CFD is named uniformly using the CGNS specification specified by NASA, and anyone who wants to be familiar with it must spend a lot of time.
(3) Different module programs are written in different teams, and efficient data sharing and function sharing are needed to complete work cooperatively.
(4) If data and functions are shared among modules, protocols need to be established, and communication, conversion or other transmission methods are used, so that computing resources are consumed, and efficiency is low.
In the current parallel computing software engineering, a software system is researched and developed, or each professional is used as a team to jointly research and develop a program, so that the program efficiency is high, and the code reusability is poor; or the specification is established, the development is carried out in modules (plug-ins), but the development limit is large, and the efficiency is greatly lost in cooperation among the plug-ins.
Disclosure of Invention
The invention aims to overcome the defects of the prior art, and provides a method, a device, equipment and a medium for generating a software system based on plug-in sharing, so that plug-in developers can freely program without uniformly learning specifications.
The purpose of the invention is realized by the following technical scheme:
a method for generating a software system based on plug-in sharing, the method comprising:
acquiring a plurality of plug-ins containing interfaces, wherein the interfaces comprise input data, output data and interface functions, and the plug-ins contain function functions;
adding a plug-in description for each plug-in, wherein the plug-in description at least comprises an interface description, and the interface description comprises a detailed description of each data and function contained in the interface;
formulating an engineering configuration specification, wherein the engineering configuration specification at least comprises a data reference relation among the plug-ins;
and generating a shared code according to the data reference relation among the plug-ins and the interface description of the plug-ins, and generating a software system according to the shared code.
Further, the function includes an open function, a close function, a shared function and a recent message function;
the opening function is used for initializing the working environment required by the plug-in;
the closing function is used for releasing the space and the resources distributed by the opening function;
the shared function is used for sharing with other plug-ins;
the recent message function is used to get a detailed information description of the recent run.
Furthermore, the plug-in description also comprises plug-in operation data and description data;
the plug-in running data comprises header file descriptions, and the plug-in running data further comprises function library file descriptions or function source code file descriptions;
the material includes the basic material including title, code, author, development tool, brief description, and summary material including technical, functional, principle and performance specifications used in development.
Further, the plug-in description further comprises an operation example, and the operation example comprises an operation case and a case description; the operation case provides a test engineering case for proving that the plug-in can complete the functions provided by the plug-in, and the case description provides the description of the case and the explanation of the operation result.
Further, the engineering configuration specification further comprises a global data description and a plug-in list.
Further, the data reference relationship between the plug-ins comprises input data, output data or a function.
Further, the data reference relation between the plug-ins is realized through pointers.
In another aspect, the present invention further provides a device for generating a software system based on plug-in sharing, where the device includes:
the system comprises a plug-in acquisition module, a plug-in processing module and a plug-in processing module, wherein the plug-in acquisition module is used for acquiring a plurality of plug-ins comprising interfaces, the interfaces comprise input data, output data and interface functions, and the plug-ins comprise function functions;
the description adding module is used for adding a plug-in description for each plug-in, the plug-in description at least comprises an interface description, and the interface description comprises a detailed description of each data and function contained in the interface;
the system comprises an engineering configuration module, a data processing module and a data processing module, wherein the engineering configuration module is used for formulating an engineering configuration specification, and the engineering configuration specification at least comprises a data reference relation among plug-ins;
and the system generation module is used for generating a shared code according to the data reference relation among the plug-ins and the interface description of the plug-ins and generating a software system according to the shared code.
Optionally, the function included in the plug-in acquired by the plug-in acquisition module includes an open function, a close function, a shared function, and a latest message function;
the opening function is used for initializing the working environment required by the plug-in;
the closing function is used for releasing the space and the resources distributed by the opening function;
the shared function is used for sharing with other plug-ins;
the recent message function is used to get a detailed information description of the recent run.
Optionally, the plug-in description added by the description adding module further includes plug-in operation data and description data;
the plug-in running data comprises header file descriptions, and the plug-in running data further comprises function library file descriptions or function source code file descriptions;
the material includes the basic material including title, code, author, development tool, brief description, and summary material including technical, functional, principle and performance specifications used in development.
Optionally, the plug-in description added by the description adding module further includes an operation example, and the operation example includes an operation case and a case description; the operation case provides a test engineering case for proving that the plug-in can complete the functions provided by the plug-in, and the case description provides the description of the case and the explanation of the operation result.
Optionally, the engineering configuration specification formulated by the engineering configuration module further includes a global data description and a plug-in list.
Optionally, the data reference relationship between the plug-ins formulated by the engineering configuration module includes input data, output data or a function.
Optionally, the data reference relationship between the plugins formulated by the engineering configuration module is implemented by a pointer.
In another aspect, the present invention further provides a computer device, where the computer device includes a processor and a memory, where the memory stores a computer program, and the computer program is loaded by the processor and executed to implement any one of the above-mentioned software system generation methods based on plug-in sharing.
In another aspect, the present invention further provides a computer-readable storage medium, in which a computer program is stored, and the computer program is loaded and executed by a processor to implement any one of the above-mentioned software system generation methods based on plug-in sharing.
The invention has the beneficial effects that:
(1) the technical scheme provided by the invention adopts a method of explaining the data reference relation among the plug-ins in the engineering configuration, removes the constraint of uniform naming, does not limit the naming of research languages, data and functions, enables plug-in developers to freely program, and saves a large amount of time required by the developers to learn the specifications.
(2) The technical scheme provided by the invention ensures that module compiling does not need to consider the sharing problem, the original programming mode is hardly changed, direct address reference is used, and the sharing does not need to consume computing resources.
(3) The technical scheme provided by the invention can enable a large amount of source codes accumulated by a research and development team to have reusability.
Drawings
Fig. 1 is a schematic flowchart of a software system generation method based on plug-in sharing according to an embodiment of the present invention;
FIG. 2 is a schematic diagram of shared data code generation provided by an embodiment of the present invention;
fig. 3 is a schematic diagram illustrating a relationship between variables according to an embodiment of the present invention.
Fig. 4 is a block diagram of a software system generation apparatus based on plug-in sharing according to an embodiment of the present invention.
Detailed Description
The embodiments of the present invention are described below with reference to specific embodiments, and other advantages and effects of the present invention will be easily understood by those skilled in the art from the disclosure of the present specification. The invention is capable of other and different embodiments and of being practiced or of being carried out in various ways, and its several details are capable of modification in various respects, all without departing from the spirit and scope of the present invention. It is to be noted that the features in the following embodiments and examples may be combined with each other without conflict.
All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
In the current parallel computing software engineering, a software system is researched and developed, or each professional is used as a team to jointly research and develop a program, so that the program efficiency is high, and the code reusability is poor; or the specification is established, the development is carried out in modules (plug-ins), but the development limit is large, and the efficiency is greatly lost in cooperation among the plug-ins.
In order to solve the above technical problems, the following embodiments of the present invention, which are based on a plug-in sharing software system generation method, apparatus, device and medium, are proposed.
Example 1
Referring to fig. 1, as shown in fig. 1, a schematic flow chart of a software system generation method based on plug-in sharing provided in this embodiment is shown, where the method specifically includes the following steps:
step S100: the method comprises the steps of obtaining a plurality of plug-ins containing interfaces, wherein the interfaces comprise input data, output data and interface functions, and the plug-ins contain function functions.
Wherein input data (IN): data referenced by the plug-in from outside, for example, a grid coordinate array obtained from outside, must be specified as a pointer.
Output data (OUT): the data generated by the plug-in, for example, the grid initialization plug-in, outputs the grid coordinate array to the outside. The generated data is generated by the plug-in unit and is responsible for releasing cleaning.
Interface function: the plug-in provides externally provided function functions, e.g., the grid initialization plug-in provides externally provided grid processing functions.
The function functions include, as one embodiment, an open function, a close function, a shared function, and a recent message function. The opening function is used for initializing the working environment required by the plug-in, the closing function is used for releasing the space and resources allocated by the opening function, the sharing function is used for sharing with other plug-ins, and the latest message function is used for obtaining the detailed information description of the latest operation.
Step S200: add plug-in description for each plug-in, the plug-in description at least includes interface description, the interface description includes the detailed description for each data, function that the interface contains.
Besides the interface description, the plug-in description also comprises plug-in operation data and description data, the plug-in operation data comprises a header file description, the plug-in operation data further comprises a function library file description or a function source code file description, and the function library file description and the function source code file description can be selected from two.
The material includes the basic material including title, code, author, development tool, brief description, and summary material including technical, functional, principle and performance specifications used in development.
As an embodiment, the plugin descriptions further include an operation example, the operation example provided in this embodiment includes an operation case and a case description, the operation case is a test engineering case providing proof that the plugin can complete the function, and the case description is a description of the case and an explanation of an operation result.
Step S300: and formulating an engineering configuration specification, wherein the engineering configuration specification at least comprises a data reference relation among the plug-ins. In addition to the data reference relationships between plugins, the engineering configuration specification also includes a global data description and a list of plugins.
The plug-ins are independent, some projects develop own codes and describe data of the attributes of the projects, and the data which needs to be shared to the plug-ins is global data. The plug-in list comprises plug-ins used by engineering and interface descriptions of the plug-ins, wherein the interface descriptions comprise input and output data and functional interface functions.
In one embodiment, the data reference relationship between the plugins can be input data of one plugin or output data of another plugin or even a function of one plugin.
In this embodiment, the data reference relationship between the plug-ins can be realized by pointers.
In the step, the global data description and the plug-in list provide basic data, the data reference relation among the plug-ins indicates specific reference relation, and the data reference relation configuration among the plug-ins can realize the sharing of data and function functions without defining standard names.
Step S400: and generating a shared code according to the data reference relation among the plug-ins and the interface description of the plug-ins, and generating a software system according to the shared code.
Specifically, referring to fig. 2, as shown in fig. 2, which is a schematic diagram for generating shared data codes provided by this embodiment, plug-in 1 … … shows that plug-ins N share N plug-ins, and the shared codes between the plug-ins can be generated by using a description of a reference relationship between the plug-ins and an interface description submitted by the plug-ins.
The following illustrates how the shared code is generated by way of example:
there are three existing cards PA, PB, PC, PA has 3 IN parameters (imported data): a. b, c, which are respectively derived from b in the plug-in PB, b and c in PC, then the object code in Fortran format is generated as follows:
it should be noted that, because some parameters in different plug-ins have the same name, the alias processing using syntax can allow the plug-in name and the variable to be connected by double underlining, so as to clearly distinguish the plug-in name from the variable name and avoid duplication of names. In the C + + grammar, similarly, the available namespace, as well as the alias definition grammar, can also generate code that avoids duplicate names.
As can be seen from the above example, the output data of the plug-ins PB and PC are used in the plug-in PA, and variables are also used directly, so that there is no consumption of data transfer and conversion.
If the shared function is a function, the function pointer can be obtained by using the function pointer in the same way, and the function pointer is switched according to the running condition in the program code, so that the function sharing with fine granularity is achieved.
It should be further noted that, for an application scenario where variables such as CFD parallel computation share more, a variable relationship description diagram as shown in fig. 3 may be adopted, and the method also takes the Fortran programming language as an example, where the left side of a "description" column in a table is a parameter and the right side is a plug-in.
Where readpara represents a global parameter, plug-IN writes to a parameter are represented by ">", reads to a parameter are represented by "<", the first write, i.e., the setup parameter (OUT), and subsequent uses, are all the use parameters (IN). Therefore, the visual configuration is made, and the related shared codes are generated according to the shared code generation mode.
Similarly, taking Fortran engineering as an example, in the Fortran engineering, all plug-ins X using shared data and shared function generate an X __ load function, and are sequentially put into a Module having the same name as the engineering name, so as to integrate a file, where the file name is: engineering name _load.f 90.
IN the process of generating the software system, the open function of all the plug-INs X with IN shared data is replaced by the aforementioned Module with the same name as the project name, namely, an X __ load function is added, namely, an initialization function of the shared data is added. For the part which does not use the shared data, the open function is still used and is not changed.
The method for generating the software system based on the plug-in sharing provided by the embodiment adopts a method of explaining the data reference relation among the plug-ins in the engineering configuration, so that the constraint of uniform naming is removed. The module is written without considering the sharing problem, the original programming mode is hardly changed, direct address reference is used, and the sharing does not consume computing resources. The method can make a large amount of source codes accumulated by a research and development team have reusability.
Example 2
Referring to fig. 4, as shown in fig. 4, a block diagram of a software system generating device based on plug-in sharing provided in this embodiment is shown, where the device specifically includes:
the plug-in acquisition module 10 is used for acquiring a plurality of plug-ins comprising interfaces, wherein the interfaces comprise input data, output data and interface functions, and the plug-ins comprise function functions;
the description adding module 20 is used for adding a plug-in description for each plug-in, the plug-in description at least comprises an interface description, and the interface description comprises a detailed description of each data and function contained in the interface;
the engineering configuration module 30 is used for formulating engineering configuration specifications, and the engineering configuration specifications at least comprise data reference relations among the plug-ins;
and the system generation module 40 is used for generating a shared code according to the data reference relation among the plug-ins and the interface description of the plug-ins, and generating a software system according to the shared code.
As an embodiment, the function functions included in the plug-in acquired by the plug-in acquisition module 10 include an open function, a close function, a shared function, and a latest message function;
opening a function for initializing a working environment required by the plug-in;
the closing function is used for releasing the space and the resources distributed by the opening function;
the shared function is used for sharing with other plug-ins;
the last message function is used to get a detailed description of the last run.
As an embodiment, the plug-in description added by the description adding module 20 further includes plug-in operation data and description data;
the plug-in operation data comprises header file description, and the plug-in operation data also comprises function library file description or function source code file description;
the instructions include basic data including names, codes, authors, development tools, and brief descriptions, as well as general descriptions including technical, functional, and conceptual details of development and use.
In one embodiment, the plug-in description added by the description adding module 20 further includes an operation example, and the operation example includes an operation case and a case description; the operation case provides a test engineering case for proving that the plug-in can complete the functions provided by the plug-in, and the case description provides the description of the case and the explanation of the operation result.
In one embodiment, the engineering configuration specification generated by the engineering configuration module 30 further includes a global data description and a list of plug-ins.
In one embodiment, the data reference relationships between plug-ins established by the engineering configuration module 30 include input data, output data, or functional functions.
In one embodiment, the data reference relationship between the plug-ins established by the engineering configuration module 30 is implemented by pointers.
The software system generation device based on plug-in sharing provided by the embodiment adopts a method of explaining the data reference relation among the plug-ins in the engineering configuration, the constraint of uniform naming is removed, the scheme does not limit the naming of the research and development language, data and functions, a plug-in developer can freely program, and a large amount of time required by the developer to learn the specification is saved. The module is written without considering the sharing problem, the original programming mode is hardly changed, direct address reference is used, and the sharing does not consume computing resources. The method can enable a large amount of source codes accumulated by a research and development team to have reusability.
Example 3
The preferred embodiment provides a computer device, which can implement the steps in any embodiment of the method for generating a software system based on plug-in sharing provided in the embodiment of the present application, and therefore, the beneficial effects of the method for generating a software system based on plug-in sharing provided in the embodiment of the present application can be achieved, which are detailed in the foregoing embodiments and will not be described herein again.
Example 4
It will be understood by those skilled in the art that all or part of the steps of the methods of the above embodiments may be performed by instructions or by associated hardware controlled by the instructions, which may be stored in a computer readable storage medium and loaded and executed by a processor. To this end, the embodiment of the present invention provides a storage medium, in which a plurality of instructions are stored, and the instructions can be loaded by a processor to execute the steps of any embodiment of the method for generating a software system based on plug-in sharing provided by the embodiment of the present invention.
Wherein the storage medium may include: read Only Memory (ROM), Random Access Memory (RAM), magnetic or optical disks, and the like.
Since the instructions stored in the storage medium may execute the steps in any one of the embodiments of the method for generating a software system based on plug-in sharing provided by the embodiments of the present invention, the beneficial effects that can be achieved by any one of the methods for generating a software system based on plug-in sharing provided by the embodiments of the present invention can be achieved, for details, see the foregoing embodiments, and are not described herein again.
The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, and any modifications, equivalents and improvements made within the spirit and principle of the present invention are intended to be included within the scope of the present invention.
Claims (10)
1. A software system generation method based on plug-in sharing is characterized by comprising the following steps:
acquiring a plurality of plug-ins containing interfaces, wherein the interfaces comprise input data, output data and interface functions, and the plug-ins contain function functions;
adding a plug-in description for each plug-in, wherein the plug-in description at least comprises an interface description, and the interface description comprises a detailed description of each data and function contained in the interface;
formulating an engineering configuration specification, wherein the engineering configuration specification at least comprises a data reference relation among the plug-ins;
and generating a shared code according to the data reference relation among the plug-ins and the interface description of the plug-ins, and generating a software system according to the shared code.
2. The plug-in sharing based software system generating method according to claim 1, wherein the function includes an open function, a close function, a shared function, and a recent message function;
the opening function is used for initializing the working environment required by the plug-in;
the closing function is used for releasing the space and the resources distributed by the opening function;
the shared function is used for sharing with other plug-ins;
the recent message function is used to get a detailed information description of the recent run.
3. The plug-in sharing based software system generating method according to claim 1, wherein the plug-in description further includes plug-in operation data and description data;
the plug-in running data comprises header file descriptions, and the plug-in running data further comprises function library file descriptions or function source code file descriptions;
the material includes the basic material including title, code, author, development tool, brief description, and summary material including technical, functional, principle and performance specifications used in development.
4. The plug-in sharing based software system generating method of claim 3, wherein the plug-in description further comprises an operation example, the operation example comprises an operation case and a case description; the operation case provides a test engineering case for proving that the plug-in can complete the functions provided by the plug-in, and the case description provides the description of the case and the explanation of the operation result.
5. The plug-in sharing based software system generation method of claim 1, wherein the engineering configuration specification further comprises a global data description and a plug-in list.
6. The plug-in sharing based software system generation method of claim 1, wherein the data reference relationship between the plug-ins includes input data, output data, or a function.
7. The plug-in sharing based software system generation method of claim 1, wherein the data reference relationship between the plug-ins is implemented by pointers.
8. An apparatus for generating a software system based on plug-in sharing, the apparatus comprising:
the system comprises a plug-in acquisition module, a plug-in processing module and a plug-in processing module, wherein the plug-in acquisition module is used for acquiring a plurality of plug-ins comprising interfaces, the interfaces comprise input data, output data and interface functions, and the plug-ins comprise function functions;
the description adding module is used for adding a plug-in description for each plug-in, the plug-in description at least comprises an interface description, and the interface description comprises a detailed description of each data and function contained in the interface;
the system comprises an engineering configuration module, a data processing module and a data processing module, wherein the engineering configuration module is used for formulating an engineering configuration specification, and the engineering configuration specification at least comprises a data reference relation among plug-ins;
and the system generation module is used for generating a shared code according to the data reference relation among the plug-ins and the interface description of the plug-ins and generating a software system according to the shared code.
9. A computer device, characterized in that the computer device comprises a processor and a memory, in which a computer program is stored, which computer program is loaded and executed by the processor to implement the plug-in sharing based software system generating method according to any one of claims 1 to 7.
10. A computer-readable storage medium, in which a computer program is stored, which is loaded and executed by a processor to implement the plug-in sharing based software system generating method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111614371.5A CN114461295A (en) | 2021-12-27 | 2021-12-27 | Method, device, equipment and medium for generating software system based on plug-in sharing |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202111614371.5A CN114461295A (en) | 2021-12-27 | 2021-12-27 | Method, device, equipment and medium for generating software system based on plug-in sharing |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN114461295A true CN114461295A (en) | 2022-05-10 |
Family
ID=81408480
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202111614371.5A Pending CN114461295A (en) | 2021-12-27 | 2021-12-27 | Method, device, equipment and medium for generating software system based on plug-in sharing |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114461295A (en) |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103336760A (en) * | 2013-07-11 | 2013-10-02 | 北京信息科技大学 | Method and device based on reverse engineering for automatically generating software documents |
| CN107479867A (en) * | 2017-06-12 | 2017-12-15 | 百度在线网络技术（北京）有限公司 | Application software plug-in unit operation method and device |
| CN110162310A (en) * | 2018-02-12 | 2019-08-23 | 腾讯科技（深圳）有限公司 | Application program generation method and device, card i/f test method and device |
| CN111596969A (en) * | 2020-05-09 | 2020-08-28 | 中国电子科技集团公司第二十八研究所 | Software architecture method based on microkernel plus plug-in |
| CN112052051A (en) * | 2020-08-31 | 2020-12-08 | 北京嘀嘀无限科技发展有限公司 | Plug-in processing method, device, equipment and storage medium |
-
2021
- 2021-12-27 CN CN202111614371.5A patent/CN114461295A/en active Pending
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN103336760A (en) * | 2013-07-11 | 2013-10-02 | 北京信息科技大学 | Method and device based on reverse engineering for automatically generating software documents |
| CN107479867A (en) * | 2017-06-12 | 2017-12-15 | 百度在线网络技术（北京）有限公司 | Application software plug-in unit operation method and device |
| CN110162310A (en) * | 2018-02-12 | 2019-08-23 | 腾讯科技（深圳）有限公司 | Application program generation method and device, card i/f test method and device |
| CN111596969A (en) * | 2020-05-09 | 2020-08-28 | 中国电子科技集团公司第二十八研究所 | Software architecture method based on microkernel plus plug-in |
| CN112052051A (en) * | 2020-08-31 | 2020-12-08 | 北京嘀嘀无限科技发展有限公司 | Plug-in processing method, device, equipment and storage medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110096338B (en) | Intelligent contract execution method, device, equipment and medium | |
| Beazley | Automated scientific software scripting with SWIG | |
| Mey et al. | Score-P: A unified performance measurement system for petascale applications | |
| JP5818351B2 (en) | Method, program and computer program for computer integration of heterogeneous implicit and explicit processing elements | |
| CN102609243B (en) | Emulating pointers | |
| US20090328016A1 (en) | Generalized expression trees | |
| Hsu et al. | DIF: An interchange format for dataflow-based design tools | |
| Metcalf | The seven ages of fortran | |
| CN105573763B (en) | A kind of Embedded System Modeling method for supporting RTOS | |
| Zaki et al. | Integration of dataflow-based heterogeneous multiprocessor scheduling techniques in gnu radio | |
| CN109558121A (en) | Development approach, device, equipment and the storage medium of interface drive program | |
| CN103268245A (en) | Immediate streamline meteorological data processing method | |
| Abbas et al. | A model-driven framework for security labs using blockchain methodology | |
| Gorostiaga et al. | HStriver: a very functional extensible tool for the runtime verification of real-time event streams | |
| WO2012088510A2 (en) | Co-map communication operator | |
| US20090265688A1 (en) | Circuits and methods for mobility of effectful program fragments | |
| CN111966397A (en) | Automatic transplanting and optimizing method for heterogeneous parallel programs | |
| CN114461295A (en) | Method, device, equipment and medium for generating software system based on plug-in sharing | |
| Pugmire et al. | Fides: a general purpose data model library for streaming data | |
| CN115328679A (en) | Automatic integration method of heterogeneous function library, computing equipment and system thereof | |
| Evangelinos et al. | Web-enabled configuration and control of legacy codes: An application to ocean modeling | |
| Matz et al. | Automated partitioning of data-parallel kernels using polyhedral compilation | |
| Olden | Performance Analysis of SWE Implementations based on modern parallel Runtime Systems | |
| Ng et al. | Protocol-Driven MPI Program Generation | |
| Lu | Developing the distributed component of a framework for processing intensional programming languages |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |