CN111880796B - Multi-core model architecture implementation method and system - Google Patents
Multi-core model architecture implementation method and system Download PDFInfo
- Publication number
- CN111880796B CN111880796B CN202010754154.5A CN202010754154A CN111880796B CN 111880796 B CN111880796 B CN 111880796B CN 202010754154 A CN202010754154 A CN 202010754154A CN 111880796 B CN111880796 B CN 111880796B
- Authority
- CN
- China
- Prior art keywords
- core
- model
- connector
- parameter
- component
- 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.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/38—Creation or generation of source code for implementing user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F30/00—Computer-aided design [CAD]
- G06F30/10—Geometric CAD
- G06F30/12—Geometric CAD characterised by design entry means specially adapted for CAD, e.g. graphical user interfaces [GUI] specially adapted for CAD
Abstract
The invention discloses a method and a system for realizing a multi-core model architecture, which are characterized in that a null model with ert.tlc file is created in a visual simulation tool model under MATLAB, a connector parameter component is added into the created null model, a core number parameter for setting a physical core in a multi-core processor corresponding to the connector parameter component is created for the connector parameter in the null model, the connector parameter component is set to generate a code parameter and a connector parameter component name, a user can further refine and decompose the model execution flow of information acquisition, data analysis, data calculation, result evaluation and control output which are sequentially executed on a single-core processor, each execution segment is assigned to each physical core of the multi-core processor to be executed, the advantages of the multi-core processor are fully exerted, the system performance is improved, on the basis of the multi-core model architecture, full-graphical multi-core modeling and executable program generation are realized under MATLAB/Simulink, the difficulty of multi-core application development is reduced, and the development efficiency and the system performance are improved.
Description
Technical Field
The invention belongs to the technical field of processing systems, and particularly relates to a method and a system for realizing a multi-core model architecture.
Background
The simulation design under MATLAB/Simulink is characterized in that a self-contained model template under Simulink is opened, S-FUNCTION is manually written in the template through an existing algorithm component and an algorithm designer to build an application model, simulation is carried out under Simulink, after the simulation is passed, the model is converted into an embedded C code by using a code generation FUNCTION of Simulink, and the generated code is compiled and linked in a third-party integrated development environment to generate an executable program which is downloaded to a target machine to run. When a model built by a user needs to run on a multi-core system (a system consisting of a CPU (central processing unit) comprising a plurality of physical cores, each physical core can run a program), the running physical cores of the built model cannot be specified, the Simulink template used for building the current model cannot provide model building for a multi-core processor (namely cannot specify the core where the model is located), and an automatically generated code of the Simulink template is also for a single-core processor, so that the model driving development requirement of the multi-core processor cannot be met, and the execution capacity is reduced.
Disclosure of Invention
The invention aims to provide a method and a system for realizing a multi-core model architecture, which are used for overcoming the defects of the prior art.
In order to achieve the purpose, the invention adopts the following technical scheme:
a multi-core model architecture implementation method comprises the following steps:
step 1), adding a connector parameter component to an empty model pre-created in a visual simulation tool model under MATLAB;
step 2), setting a core number parameter, a generated code parameter and a connector parameter component name of a connector parameter component in the empty model, and completing the setting of the connector parameter component in the empty model;
and 3) repeating the step 2), setting connector parameter assemblies with the same number as the physical cores of the multi-core processor in the empty model, enabling one connector parameter assembly to correspond to one physical core, then exporting the empty model with the connector parameter assemblies as a template and storing the empty model into an MATLAB path, so that the creation of the multi-core template can be completed, and performing multi-core processing on the generated code by using the multi-core template.
Further, in the step 1), an empty model is created in a visual simulation tool model under MATLAB, and a system target file of the empty model is set to be modified to ert.
Further, specifically, a connector parameter component is selected from a visual simulation tool module library and added to the empty model created in the step 1).
Further, opening a visual simulation tool library browser, selecting a connector parameter component from a module library of the visual simulation tool, and adding the connector parameter component to the empty module created in the step 1).
Further, in step 2), the connector parameter component is set as an atomic unit, a code generated by the connector parameter component is set as a non-reusable code, a function name is set as a user designation, and a file name is set as a user designation.
Furthermore, when the multi-core template is used for multi-core processing of the generated code, multi-core synchronization and scheduling functions are added and stored after the multi-core processor is started, and in the model generation code created by the multi-core template, the model created in each connector parameter component is converted into a corresponding function to be executed.
Further, specifically, a c file and an h file modifying tool for multi-coring codes generated by a model created by using a multi-core template under MATLAB/Simulink are created in MATLAB.
Furthermore, a multi-core template-based model is newly built in MATLAB/Simulink, in the process of building the multi-core model, each connector parameter assembly represents one physical kernel, a user model is built in each connector parameter, a code is generated through a code generator of the model, the generated code is multi-nucleated by using a file modification tool of the multi-core template, and the multi-nucleated code is compiled and linked in a third-party development environment to generate an executable program.
Furthermore, an inter-core communication component is created, the inter-core communication component is added into the Simulink library browser, and inter-core communication is completed through a shared memory.
A multi-core model architecture implementation system comprises a model generation module, a connector parameter component adding module and a multi-core model multi-core implementation module,
the model generation module is used for creating an empty model for generating a tlc file as ert.tlc; the connector parameter component adding module is used for adding a connector parameter component into the created empty model; the model parameter generation setting module is used for creating a core number parameter for setting a physical core in the multi-core processor corresponding to the connector parameter component for the connector parameter in the created empty model, and setting a connector parameter component generation code parameter and a connector parameter component name; and the multi-core model multi-core implementation module is used for exporting the model and storing the model into an MATLAB path, multi-core is carried out on the generated code based on the multi-core template, and the generated code is copied into a third-party development environment to be compiled and linked to generate an executable program.
Compared with the prior art, the invention has the following beneficial technical effects:
the invention relates to a method and a system for realizing a multi-core model architecture, which are characterized in that a hollow model with a system target file of ert.tlc is created in a visual simulation tool model under MATLAB, then a connector parameter component is added into the created hollow model, a model architecture which is in accordance with the specification of the MATLAB/Simulink model is generated by creating a core number parameter for a physical core in a multi-core processor corresponding to the connector parameter component for the connector parameter in the hollow model, setting the connector parameter component to generate a code parameter and a connector parameter component name, and the model architecture can be seamlessly embedded into a MATLAB/Simulink simulation environment for use.
Drawings
FIG. 1 is a flow chart of a method embodied in an embodiment of the present invention.
Fig. 2 is a schematic diagram of null model creation in the embodiment of the present invention.
Fig. 3 is a schematic diagram of a created empty model in the embodiment of the present invention.
Fig. 4 is a schematic diagram of a file naming structure used by the null model in the embodiment of the present invention.
Fig. 5 is a schematic diagram of an adding operation structure of the connector parameter component in the embodiment of the present invention.
FIG. 6 is a diagram illustrating operation of parameter setting of a connector parameter component according to an embodiment of the present invention.
FIG. 7 is a diagram illustrating parameter settings of a connector parameter component according to an embodiment of the present invention.
Fig. 8 is a diagram illustrating the operation of generating code parameter settings by the connector parameter component in an embodiment of the present invention.
Fig. 9 is a diagram illustrating a connector parameter component name setting operation according to an embodiment of the present invention.
Fig. 10 is a diagram illustrating a result of setting parameters of a connector according to an embodiment of the present invention.
FIG. 11 is a diagram of an unttled model after the names of the Subsystem components are modified according to an embodiment of the present invention.
Fig. 12 is a schematic diagram of an operation structure of the export template in the embodiment of the present invention.
Fig. 13 is a schematic diagram of a multi-core template export file according to an embodiment of the present invention.
FIG. 14 is a structural diagram illustrating the creation of a multi-core template according to an embodiment of the present invention.
FIG. 15 is a diagram illustrating a structure of a template selection interface according to an embodiment of the present invention.
FIG. 16 is a block diagram illustrating a code generation and multi-coring operation in accordance with an embodiment of the present invention.
Fig. 17 is a schematic diagram of a system structure according to an embodiment of the present invention.
Detailed Description
The invention is described in further detail below with reference to the accompanying drawings:
as shown in fig. 1, a method for implementing a multi-core model architecture includes the following steps:
step 1), creating an empty model in a visual simulation tool model under MATLAB;
step 2), setting a System Target file (System Target file) used by the empty model created in the step 1) to be ert.tlc;
step 3), adding a connector parameter (Subsystem) component in a visual simulation tool (Simulink) module library into the empty model created in the step 1);
specifically, a Simulink library browser is opened, a connector parameter (Subsystem) component is selected from a common Used Blocks module library of Simulink, and the selected component is added into the empty model created in the step 1);
step 4), setting the attribute of the connector parameter component in the empty model: creating a core number parameter for a connector parameter (Subsystem) component in the null model, wherein the core number parameter is used for setting a physical core in a multi-core processor corresponding to the Subsystem component; setting the attribute of the Subsystem component added in the step 3), and setting the Subsystem component as an atomic unit; setting a code parameter generated by a Subsystem component, setting a code generated by the Subsystem component as a non-reusable code, setting a function name as coreXFun and setting a file name as coreX, wherein X represents a core number parameter; finally, the name of the Subsystem component is modified to be COREX, and X in the name of the Subsystem component is consistent with X in the name of the file; such as: if the name of the Subsystem component is CORE0, setting the name of the function as CORE0Fun and setting the name of the file as CORE0;
specifically, the attribute of the connector parameter (Subsystem) component added in the step 3) is set, and a core number parameter is created for the Subsystem component and is used for setting a physical core in a multi-core processor corresponding to the Subsystem component;
step 5), repeating the steps 3) to 4) according to the number of the physical cores of the multi-core processor to be supported, finishing the addition of the Subsystem components with the number equal to that of the physical cores of the multi-core processor, and performing attribute setting on the added Subsystem components to enable one Subsystem component to correspond to one physical core;
step 6), exporting the empty model provided with the connector parameter components in the step 5) as a template file and storing the template file, finishing the creation of a multi-core template, wherein each component corresponds to a physical core and is called a Subsystem component of COREX in the multi-core template;
step 8), adding the path of the template file exported in the step 7) into the MATLAB path;
step 9), modifying a self-contained bareboard _ srain.tlc and a self-contained bareboard _ mrain.tlc file under MATLAB, adding a multi-core processor for multi-core synchronization and scheduling functions after starting and storing;
step 10), in the model generation code created by adopting the multi-core template, converting the model created in each Subsystem component into a corresponding function for execution;
specifically, the method comprises the following steps: creating a file c and a file h modifying tool in the MATLAB, wherein the file c and the file h modifying tool are used for performing multi-core treatment on codes generated by a model created by adopting a multi-core template under the MATLAB/Simulink; if CORE1 corresponds to a CORE1Fun function, CORE2 corresponds to a CORE2Fun function, if the code is not modified and directly used, the CORE1Fun function can be executed on each CORE, the multi-CORE system hardware provides a method for acquiring the CORE ID by software, the CORE XFun function in the generated code is modified to be called to firstly acquire the CORE ID, then whether the CORE ID is the CORE XFun function to be executed by the CORE is judged, the purpose of executing the corresponding function by each CORE is achieved, if the calling of the CORE1 corresponding function CORE1Fun is modified to be that if the CORE ID is equal to 1, the CORE1Fun function is called, otherwise, the CORE1Fun function is not executed;
step 11), creating an inter-core communication component, and adding the inter-core communication component into a Simulink library browser;
step 12), newly building a model in MATLAB/Simulink, and selecting the template file added in the step 8) from the template required by the newly built model;
step 13), building a multi-core model, wherein each Subsystem component represents a physical kernel, building a user model in each Subsystem, and if inter-core communication is needed, selecting the inter-core communication component added in the step 11) from a Simulink library browser to perform inter-core communication, wherein the inter-core communication component completes the inter-core communication through a shared memory;
step 14), generating codes through a Code generator (Generator Code) of the model, and performing multi-coring on the generated codes by using the file modification tool designed in the step 10);
and step 15), compiling and linking the multi-core codes in a third-party development environment to generate an executable program.
As shown in fig. 17, a multi-core model architecture implementation system includes a model generation module, a connector parameter component addition module, and a multi-core model multi-core implementation module, where the model generation module is configured to create an empty model that generates a tlc file to ert.tlc; the connector parameter component adding module is used for adding a connector parameter component into the created empty model; the model parameter generation setting module is used for creating a core number parameter for setting a physical core in the multi-core processor corresponding to the connector parameter component for the connector parameter in the created empty model, and setting a connector parameter component generation code parameter and a connector parameter component name; and the multi-core model multi-core implementation module is used for exporting the model and storing the model into an MATLAB path, multi-core is carried out on the generated code based on the multi-core template, and the generated code is copied into a third-party development environment to be compiled and linked to generate an executable program. By the technical means, the multi-core model architecture is realized, conforms to MATLAB/Simulink model specifications and can be seamlessly embedded into an MATLAB/Simulink simulation environment for use. On the basis of a multi-core model architecture, by combining a hardware driving component, code automatic generation, code multi-core, compiling and linking, full-graphical multi-core modeling and executable program generation can be realized under MATLBA/Simulink, the difficulty of multi-core application development is reduced, and the development efficiency and the system performance are improved.
The invention realizes the model building and the multi-core code generation supporting a multi-core processor through multi-core mapping, template design, automatic code generation and multi-core code generation, the generated multi-core code can be directly compiled, linked and generated into an executable program through a third-party integrated development environment, the executable program can be operated on the multi-core processor without any modification, and the model built in each Subsystem can be ensured to be operated only on a corresponding physical core when a user builds the model, the invention has no limitation on the number and the type of cores of the multi-core processor, can be applied to a target platform of an SMP processor framework with any number of cores, and the embodiment of the invention is explained by taking a certain multi-core embedded system as an example, the multi-core embedded system adopts a C6678 processor (eight core processor) of TI company, and the specific implementation steps of the multi-core model development by adopting the method of the invention are as follows:
step 1), creating an empty model: opening a Simulink library browser, clicking a Model creating icon (shown in figure 2) on a library browser interface by a left mouse button, selecting a New Model, and creating a null Model named invalid, wherein the specific null Model is shown in figure 3;
step 2), selecting a tlc file of an empty model: under the unsplit model interface created in step 1), selecting Configuration Parameters button of toolbar, appearing a Configuration Parameters dialog box, selecting System target files as ert.tlc and saving, the result is shown in fig. 4;
step 3), adding a Subsystem component into the unsplit model: selecting a Subsystem component from a common Used Block component library in the Simulink library browser to add to the unsplit model, as shown in FIG. 5;
step 4), setting Subsystem component parameters: in an untried model, clicking a Subsystem component by a right mouse button, selecting a Mask- - > Create Mask option, as shown in fig. 6, a Mask Editor dialog box appears, adding a Popup Type parameter in the Mask Editor dialog box, prompting the parameter as a coreId, naming the parameter as a coreId, not checking an Enable checkbox, clicking Type Options of the Mask Editor dialog box by a left mouse button, appearing a Type Options dialog box, setting a coreId parameter value as 0 in the dialog box, indicating that the current Subsystem component corresponds to core0, storing component parameters, and specifically setting the parameter as shown in fig. 7;
step 5), setting a Subsystem component generation code parameter and a Subsystem component name: in the unsplit model, right click the Subsystem component with the mouse, select the Block Parameters option, as shown in fig. 8, appear the Block Parameters dialog box, under the main interface, select the Treat as atomic unit option, as shown in fig. 9, then select the Code Generation interface, set the Function packaging option to the Nonreusable Function, set the Function name option to the User specified, set the Function name to the CORE0 Function, set the File name option to the User specified, set the File name (no extension) to the CORE0, keep the default values of the other options, the Code Generation setting result is shown in fig. 10, modify the Subsystem component name to CORE0;
step 6), setting the attributes of 7 Subsystem components in sequence: the processor in this embodiment is an 8-core DSP processor, and repeats the above steps (3), (4), and (5), and then adds 7 Subsystem components to the unfitled model in sequence, and sets the attribute of each Subsystem component, the value of the coreId parameter in step (4) represents the physical core number corresponding to the Subsystem component, and thus the value should be 1-7, the Function name and the File name (no extension) in step (5) also correspond to different physical core numbers, and thus the values should be set as coreXFun, coreX, and X are arabic numbers from 1 to 7, the name of the Subsystem component modified after the setting is saved is coreX, and X is an arabic number from 1 to 7, and the unfitled model after adding 7 Subsystem components and modifying the names of the Subsystem components is shown in fig. 11;
step 7), storing the untitled model and deriving: saving an unsplit Model, selecting an Export Model to-Template option in a Model interface toolbar, as shown in FIG. 12, at this time, an Export unsplit to Template interface appears, as shown in FIG. 13, setting a Template file name to be exported as multicore. Sltx, and selecting an Export, namely exporting the current Model as a multi-core Template file;
step 8), adding a template file path: selecting a file path setting under a Matlab interface, and adding a path where a multicore.
Step 9), modifying the tlc file: modifying bareboard _ srain.tlc and bareboard _ mrain.tlc files carried by the MATLAB, adding a multi-core processor for multi-core synchronization and scheduling functions after starting and storing;
step 10), designing a code multi-core tool: the method comprises the steps that after a multi-core model built on a multi-core template automatically generates codes by using a code generation tool of MATLAB/Simulink, multi-core differentiation is not carried out, the multi-core model can only run on a single core, and a code multi-core tool needs to be designed to carry out multi-core modification on files c and h named by model names in the automatically generated codes, the model names are modified, and the function calls of core () in the files c and the functions from core1 to core7 are modified in sequence;
step 11), creating an inter-core communication component: c and tlc files are required to be established, and a specific development process can be assisted by MATLAB/Simulink;
step 12), creating a multi-core model: opening a Simulink library browser, selecting From Template in a new Model option of a toolbar, as shown in FIG. 14, wherein a Template selection interface appears, as shown in FIG. 15, selecting a multinuclear Template multinuclear created by us, and clicking a Create Model to Create an empty multinuclear Model, wherein the empty Model is named as multinuclear Model;
step 13), multi-core model building: building a user model in a multicornemodel model by using components in a Simulink library browser, wherein each subsystem represents a physical core, and the model built in each subsystem only runs on the corresponding physical core;
step 14), code generation and multi-coring: selecting a Configuration Parameters button of a toolbar under a multicorneodel model interface, and displaying a Configuration Parameters dialog box, as shown in fig. 16, selecting a System target files as ert.tlc, checking a general Code option, then clicking the general Code by a left mouse button to Generate a Code corresponding to the model, processing a Code multinucleation tool designed in the step 10) on the generated Code to Generate new multicorneodel.c and multicornedel.h files, and covering the original multicornedel.c and multicornedel.h files with the generated Code multinucleation tool;
step 15), executable program generation: and copying the automatically generated files to CCS engineering for compiling and linking, and then generating the executable program running on the multi-core processor.
Claims (9)
1. A multi-core model architecture implementation method is characterized by comprising the following steps:
step 1), adding a connector parameter component to an empty model pre-created in a visual simulation tool model under MATLAB;
step 2), setting a core number parameter, a generated code parameter and a connector parameter component name of a connector parameter component in the empty model, and completing the setting of the connector parameter component in the empty model;
step 3) repeating the step 2), setting connector parameter components with the same number as the physical cores of the multi-core processor in the empty model, enabling one connector parameter component to correspond to one physical core, then exporting the empty model with the connector parameter components as a template and storing the empty model into an MATLAB path, namely completing the creation of a multi-core template, and performing multi-core processing on the generated code by using the multi-core template;
the method comprises the steps of newly building a model based on a multi-core template in MATLAB/Simulink, representing a physical kernel by each connector parameter assembly in the process of building the multi-core model, building a user model in each connector parameter, generating codes through a code generator of the model, carrying out multi-core on the generated codes by using a file modification tool of the multi-core template, compiling and linking the multi-core codes in a third-party development environment, and generating an executable program.
2. The method according to claim 1, wherein in step 1), after creating a null model in the visual simulation tool model under MATLAB, the system target file of the null model is set to ert.
3. The method for implementing the multi-core model architecture according to claim 1, wherein specifically, the connector parameter component is selected from a visual simulation tool module library and added to the empty model created in step 1).
4. The method for implementing the multi-core model architecture according to claim 3, wherein a visual simulation tool library browser is opened, and connector parameter components are selected from a module library of the visual simulation tool and added to the empty model created in step 1).
5. The method according to claim 1, wherein in step 2), the connector parameter component is set as an atomic unit, the code generated by the connector parameter component is set as a non-reusable code, the function name is set as a user specification, and the file name is set as a user specification.
6. The method according to claim 1, wherein when the multi-core template is used to perform multi-core processing on the generated code, the multi-core synchronization, scheduling function and storage are added after the multi-core processor is started, and in the model generation code created by using the multi-core template, the model created in each connector parameter component is converted into a corresponding function for execution.
7. The method for implementing a multi-core model architecture according to claim 6, wherein specifically, a c file and an h file modification tool for multi-coring a code generated by a model created by a multi-core template under MATLAB/Simulink are created in MATLAB.
8. The method of claim 1, wherein the method comprises creating an inter-core communication component, adding the inter-core communication component to a Simulink library browser, and completing inter-core communication through a shared memory.
9. A multi-core model architecture implementation system is characterized by comprising a model generation module, a connector parameter component adding module and a multi-core model multi-core implementation module,
the model generation module is used for creating an empty model for generating a tlc file as ert.tlc; the connector parameter component adding module is used for adding a connector parameter component into the created empty model; the model parameter generation setting module is used for creating a core number parameter for setting a physical core in the multi-core processor corresponding to the connector parameter component for the connector parameter in the created empty model, and setting a connector parameter component generation code parameter and a connector parameter component name; the multi-core model multi-core implementation module is used for exporting a model and storing the model into an MATLAB path, newly building a model based on a multi-core template in MATLAB/Simulink, in the process of building the multi-core model, representing a physical core by each connector parameter assembly, building a user model in each connector parameter, generating a code through a code generator of the model, performing multi-core on the generated code by using a file modification tool of the multi-core template, compiling and linking the multi-core code in a third-party development environment, and generating an executable program.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010754154.5A CN111880796B (en) | 2020-07-30 | 2020-07-30 | Multi-core model architecture implementation method and system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010754154.5A CN111880796B (en) | 2020-07-30 | 2020-07-30 | Multi-core model architecture implementation method and system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111880796A CN111880796A (en) | 2020-11-03 |
| CN111880796B true CN111880796B (en) | 2023-03-14 |
Family
ID=73205822
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010754154.5A Active CN111880796B (en) | 2020-07-30 | 2020-07-30 | Multi-core model architecture implementation method and system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111880796B (en) |
Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2010104997A1 (en) * | 2009-03-12 | 2010-09-16 | Polycore Software, Inc. | Apparatus & associated methodology of generating a multi-core communications topology |
| CN102707952A (en) * | 2012-05-16 | 2012-10-03 | 上海大学 | User description based programming design method on embedded heterogeneous multi-core processor |
| CN102750143A (en) * | 2012-05-31 | 2012-10-24 | 武汉邮电科学研究院 | Digital signal processing (DSP) developing method based on matrix laboratory (MATLAB) component object model (COM) component calling |
| CN104091006A (en) * | 2014-07-01 | 2014-10-08 | 中国北方发动机研究所(天津) | Self-adapting simulation and code generation control method in Simulink |
| CN107203406A (en) * | 2017-06-26 | 2017-09-26 | 西安微电子技术研究所 | A kind of processing method of Based on Distributed storage organization |
| CN109190281A (en) * | 2018-09-19 | 2019-01-11 | 北京润科通用技术有限公司 | A kind of multi-core DSP platform algorithm development method and device |
| CN111309292A (en) * | 2020-02-03 | 2020-06-19 | 西安微电子技术研究所 | MATLAB/Simulink-based full-model executable program construction method |
Family Cites Families (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101826016A (en) * | 2010-05-13 | 2010-09-08 | 天津大学 | Visual modeling and code skeleton generating method for supporting design of multinuclear parallel program |
| US9952837B1 (en) * | 2015-04-01 | 2018-04-24 | The Mathworks, Inc. | Reusable component in a modeling environment |
| CN110674590A (en) * | 2019-10-07 | 2020-01-10 | 中国人民解放军陆军装甲兵学院 | Programming method of real-time simulation program of aircraft based on simulation software Simulink real-time extended RTX |
-
2020
- 2020-07-30 CN CN202010754154.5A patent/CN111880796B/en active Active
Patent Citations (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2010104997A1 (en) * | 2009-03-12 | 2010-09-16 | Polycore Software, Inc. | Apparatus & associated methodology of generating a multi-core communications topology |
| CN102707952A (en) * | 2012-05-16 | 2012-10-03 | 上海大学 | User description based programming design method on embedded heterogeneous multi-core processor |
| CN102750143A (en) * | 2012-05-31 | 2012-10-24 | 武汉邮电科学研究院 | Digital signal processing (DSP) developing method based on matrix laboratory (MATLAB) component object model (COM) component calling |
| CN104091006A (en) * | 2014-07-01 | 2014-10-08 | 中国北方发动机研究所(天津) | Self-adapting simulation and code generation control method in Simulink |
| CN107203406A (en) * | 2017-06-26 | 2017-09-26 | 西安微电子技术研究所 | A kind of processing method of Based on Distributed storage organization |
| CN109190281A (en) * | 2018-09-19 | 2019-01-11 | 北京润科通用技术有限公司 | A kind of multi-core DSP platform algorithm development method and device |
| CN111309292A (en) * | 2020-02-03 | 2020-06-19 | 西安微电子技术研究所 | MATLAB/Simulink-based full-model executable program construction method |
Non-Patent Citations (1)
| Title |
|---|
| xPC实时半物理仿真平台中并行执行模型的设计;张云山;《电子设计工程》;20120920(第18期);全文 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111880796A (en) | 2020-11-03 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US8429627B2 (en) | Asynchronous preemptive edit time semantic analysis of a graphical program | |
| Singh et al. | Kiwi: Synthesis of FPGA circuits from parallel programs | |
| US8150673B1 (en) | Partitioning a model in modeling environments | |
| US8176479B2 (en) | Case structure replacement in a data flow diagram | |
| CN111309292B (en) | MATLAB/Simulink-based full-model executable program construction method | |
| CN110674590A (en) | Programming method of real-time simulation program of aircraft based on simulation software Simulink real-time extended RTX | |
| JPH08202545A (en) | Object-oriented system and method for generation of target language code | |
| Hong et al. | The application guide of mixed programming between MATLAB and other programming languages | |
| US8046202B1 (en) | Generation of intermediate representations based on user specified elements in a graphical model that enable simulation, propagation and code generation | |
| CN110196720B (en) | Optimization method for generating dynamic link library by Simulink | |
| CN113032963A (en) | Simulink model simulation acceleration method and device | |
| CN111650847A (en) | Method for integrating actuator model in aeroengine hardware on loop platform | |
| CN111880796B (en) | Multi-core model architecture implementation method and system | |
| CN116909553A (en) | Page online development and local compiling operation system | |
| CN106970787A (en) | A kind of automobile controller rapid prototyping implementation method | |
| Park et al. | Library support in an actor-based parallel programming platform | |
| CN112579470B (en) | Compiling and linking method and system for debugging dynamic software library | |
| JP2010049439A (en) | System construction method using software model and modeling device | |
| CN113448874A (en) | Method and device for generating unit test script | |
| Hawa | A Graphical User Interface for the ns-3 Simulator | |
| US8694293B2 (en) | Simulation support method, computer-readable storage medium storing simulation support program, and simulation support apparatus | |
| CN107918958B (en) | Visualization and customizable three-dimensional rendering system and method | |
| Burghard et al. | Visualizing multi-dimensional state spaces using selective abstraction | |
| Geng et al. | Embedded C code generation platform for electric vehicle controller | |
| Stuebing | A software engineering environment (SEE) for weapon system software |
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 | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |