Dynamic loading and unloading method based on multi-core AMP architecture DSP operating system
By using a dynamic image method to load on a single core and execute on multiple cores, the deployment limitations of embedded DSP operating systems under the static image method are solved. This achieves unified allocation of shared memory and separate management of private memory, improving the flexibility and memory utilization efficiency of multi-core DSP operating systems.
Patent Information
- Application Number
- CN202511592712.1
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2025-11-03
- Publication Date
- 2026-02-13
AI Technical Summary
The existing embedded DSP operating system uses a static image approach, which makes application deployment inflexible and makes it difficult to achieve shared resource access and private resource management for multi-core DSP chips.
By employing a dynamic image method, loading on a single core and executing on multiple cores, we achieve unified allocation of shared memory and separate management of private memory. We also utilize symbol relocation and address mapping techniques to generate dynamic modules to support cross-core calls.
It improves the flexibility and memory utilization efficiency of multi-core DSP operating systems, solves the deployment limitations caused by static images, and enables rapid multi-core deployment of application images.
Smart Images
Figure CN121523760A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to an embedded operating system technology, and more particularly to a dynamic loading and unloading method for a multi-core AMP architecture DSP operating system. Background Technology
[0002] In recent years, domestically produced DSP chips and embedded DSP operating systems in the field of digital signal processing have developed rapidly, and their domestically produced software and hardware products have been widely used in underwater acoustic systems, radar equipment, navigation and guidance, image processing, electronic warfare and other fields.
[0003] Based on the hardware architecture characteristics of domestically produced multi-core DSP chips, embedded DSP operating systems mainly adopt the AMP processing mode, meaning that an embedded operating system runs on each core of the DSP chip. Currently, application development for embedded DSP operating systems often uses a static image approach, compiling the application program and operating system into a single image file, which hinders flexible deployment of the application. Summary of the Invention
[0004] To address the issue that while the cores in the AMP architecture used by DSP operating systems are independent, their access to shared peripherals and shared memory is interconnected during actual operation, the dynamic image loading and unloading process needs to properly handle the access relationship between private and shared resources. Therefore, a dynamic loading and unloading method based on a multi-core AMP architecture DSP operating system is proposed. The method is designed to allow dynamic images to be loaded by a single core and accessed by multiple cores. In the dynamic image, shared memory is uniformly allocated among cores, while private memory is separated among cores, thus improving the flexible deployment of dynamic application images.
[0005] The technical solution of this invention is as follows: A dynamic loading / unloading method based on a multi-core AMP architecture DSP operating system includes: Step 1: Transfer the dynamic image to the running multi-core AMP architecture DSP operating system; Step 2: Single-core parsing and loading of the dynamic image; the dynamic image is transferred to the operating system file system through the network service of the running DSP operating system, and the dynamic image is parsed and loaded by a single core; the single core performs system symbol resolution to obtain the symbol address, symbol name, and symbol table information required for dynamic symbol relocation; the symbol table information is re-indexed and sorted to facilitate the use of a binary search mechanism during the relocation process; single-core dynamic image loading, according to the dynamic image segment attribute information, the code segment and global data segment are loaded into the multi-core shared memory, and the private segments of each core are loaded into the private memory of each core; single-core dynamic symbol relocation is the process of connecting symbol references and symbol definitions. Based on the relocation table entries, the type, name, and offset of the symbol to be relocated in the code segment are calculated. The actual address of the symbol in the new symbol table is found using the symbol name. Based on the symbol type and jump address, a new jump instruction can be generated, and finally, a dynamic module is generated. Step 3: Execute the loaded dynamic module functions on multiple cores; the code segment and global data segment in the generated dynamic module are shared by multiple cores, while the private data segment is private to each core, and the relocation of dynamic symbols has been completed; at this point, the function interfaces in the dynamic module can be called and executed on each core; Step 4: Unload dynamic modules on a single core; the process of unloading dynamic modules is the reverse of the loading process, completing the release and reclamation of allocated resources.
[0006] Furthermore, the dynamic image is a dynamically loadable image containing an application, and the dynamic image file is in ELF format; the multi-core AMP architecture is a processor with isomorphic cores, each core running an independent operating system, and each core can access private resources through the local bus and shared resources through the system bus; the operating system is an embedded DSP operating system, where DSP is a digital signal processor; parsing and loading the dynamic image is the process of parsing, loading, and relocating the dynamic image; unloading the dynamic module is the process of unloading the loaded module.
[0007] Furthermore, before a single core loads the private segments of each core, each core needs to complete the mapping from the same logical address space to different physical address spaces and record the offset of each core's different physical address spaces. After the address space mapping is completed, a single core can load the contents of each core's private segments into the physical space of each core according to the mapped space offset, thereby realizing the loading of each core's private segments by a single core.
[0008] Furthermore, dynamic image loading: Extracting useful information from the application image and copying it to the internal space of the operating system, including the code segment, data segment, relocation table, symbol table, and character table segment; the role of the relocation table is to indicate the offset position of the items that need to be relocated in the ELF file, and to perform relocation operations based on the relocation segment and symbol table.
[0009] Furthermore, dynamic symbol relocation involves relocating external symbols used in the dynamic image, which is the process of linking symbol references and symbol definitions. When a function is called in the dynamic image program, the relevant instructions must transfer control flow to the correct target address during execution. The relocation work that occurs after the dynamic image is loaded is based on the code segment and relocation segment of the dynamic image. Using the ELF tool to display the dynamic image segment information of the DSP chip, different loading processes are performed on the multi-core shared segment and private segment in the dynamic image, including the code segment and relocation segment, as well as the symbol table and character table segments that assist in relocation.
[0010] Furthermore, system symbol resolution: This involves resolving the symbol table segment and character table segment in the static image of the operating system within the system symbol table space. Analyzing the symbol table segment and character table segment in the static image of the operating system is essential before dynamic image symbol relocation, as the symbol table information of the embedded DSP operating system must be obtained.
[0011] Furthermore, during the symbol table loading process, the symbol table is reindexed, that is, the symbol name offsets of the symbol table are readjusted according to the ASCII strings to generate a new symbol table. A binary search mechanism is used in the relocation process.
[0012] Furthermore, specifically including: Step 1: Transfer the dynamic image to the running multi-core AMP architecture DSP operating system; First, start and run the multi-core DSP operating system, and upload the dynamic image to the operating system's file system via network service; Based on the multi-core AMP architecture DSP operating system, an embedded operating system instance runs on each core, and the dynamic image is uploaded to the main core operating system's file system; Step 2: Single-core parsing and loading of dynamic images; The multi-core DSP operating system that has been started and is running in Step 1 includes the basic functions of the operating system and symbol table information. The one or more dynamic images uploaded are the actual application images; Before the dynamic images are loaded, the operating system has been started. Parsing and loading the dynamic images means loading the dynamic images into the operating system and enabling it to run independently. In the dynamic image segment information, the code segment .text and the global data segments .const, .ddr_usr, and .shm_unc are multi-core shared segments, while the .far and .fardata segments are core-private segments. Single-core parsing and loading of dynamic images means that the parsing, loading, and relocation of dynamic images are completed by a single core for multi-core access. A single core directly allocates space from the shared memory pool and loads the contents of the multi-core shared segments into the shared memory, realizing multi-core shared access. Based on the information in the relocation segment, the relocation type can be determined, thereby determining the relocation address calculation method. First, the relocation table of the application image is read in, and the index of the corresponding code segment that needs to be relocated is calculated. The code segment that needs to be relocated is then read in according to the index. After the reading is completed, the read relocation table is traversed, and the type, name, and offset of the symbol that needs to be relocated in the code segment are calculated according to the contents of each table entry. Then, the actual address of the symbol in the new symbol table is found using the symbol name. A new jump instruction can be generated according to the symbol type and jump address. This jump instruction replaces the instruction of the code segment offset, so that the execution of the application can jump to the called function during the execution process. Step 3: Multi-core execution of loaded dynamic module functions; After dynamic image parsing and loading in Step 2, a dynamic module is generated. The code segment and global data segment in the dynamic module are shared by multiple cores, while the private data segment is private to each core, and the relocation of dynamic symbols has been completed; At this time, the function interface in the dynamic module can be called and executed on each core. Step 4: Unload dynamic modules on a single core. The process of unloading dynamic modules is the reverse of the loading process, which completes the release and reclamation of allocated resources.
[0013] The beneficial effects of this invention are as follows: 1. This invention enables dynamic loading and unloading of DSP operating systems based on multi-core AMP architecture. It utilizes the MPAX storage protection and address extension units within each core of the DSP chip, effectively solving the problem of loading private segments of each core onto a single core.
[0014] 2. This invention can complete the loading and unloading of dynamic images on a single core and execute the loading module function on multiple cores, which improves the reuse of shared segments in dynamic images and reduces memory waste caused by repeated loading on each core. 3. This invention can solve the deployment limitations of static image loading for application and operating system runtime in multi-core AMP architecture. By loading dynamic application images, it improves deployment flexibility and solves the problem of difficult rapid deployment of application images across multiple cores. Attached Figure Description
[0015] Figure 1 This is a structural diagram of the multi-core AMP architecture DSP operating system of this invention; Figure 2 This is a diagram of the dynamic loading architecture of this invention; Figure 3 This is a flowchart of the symbol table re-indexing process of the present invention; Figure 4 This is a dynamic image segment information diagram according to an embodiment of the present invention; Figure 5 This is a dynamic image mid-section loading space distribution diagram of the present invention; Figure 6This is a flowchart of the dynamic symbol relocation process of the present invention. Detailed Implementation
[0016] The present invention will now be described in detail with reference to the accompanying drawings and specific embodiments. These embodiments are based on the technical solution of the present invention and provide detailed implementation methods and specific operating procedures. However, the scope of protection of the present invention is not limited to the following embodiments.
[0017] A dynamic loading and unloading method based on a multi-core AMP architecture DSP operating system includes the following steps: Step 1: Transfer the dynamic image to the running multi-core AMP architecture DSP operating system; Step 2: Single-core parsing and loading of the dynamic image; Step 3: Execute the loaded dynamic module functions on multiple cores; Step 4: Unload dynamic modules on a single core; The dynamic image is a dynamically loadable image containing an application, and the dynamic image file is in ELF format; The multi-core AMP architecture is a homogeneous processor core. Because there is no shared cache among the multiple cores, each core runs an independent operating system. Each core can access private resources through the local bus and access shared resources through the system bus.
[0018] The operating system is an embedded DSP operating system, where DSP stands for Digital Signal Processor; The process of parsing and loading the dynamic image refers to the parsing, loading, and relocation of the dynamic image.
[0019] The unloading dynamic module is used to uninstall loaded modules.
[0020] The dynamic image is transferred to the operating system's file system through the network service of the running DSP operating system. The dynamic image is parsed and loaded by a single core, which can be analyzed from two dimensions: single-core parsing and single-core loading.
[0021] Dynamic image parsing and loading are performed only on one core of the DSP operating system, typically the main core. A single core performs system symbol resolution to obtain the symbol address, symbol name, and symbol table information required for dynamic symbol relocation; the symbol table information is reindexed and sorted to facilitate the use of a binary search mechanism during the relocation process.
[0022] Single-core dynamic image loading loads code segments and global data segments into multi-core shared memory based on the dynamic image segment attribute information, and loads each core's private segments into its own private memory. Specifically, a single core directly allocates space from the shared memory pool and loads the contents of the multi-core shared segments into the shared memory, enabling multi-core shared access.
[0023] Preferably, before a single core loads the private segments of each core, each core needs to complete the mapping from the same logical address space to different physical address spaces and record the offset of each core's different physical address spaces. After the address space mapping is completed, a single core can load the contents of each core's private segments into the physical space of each core according to the mapped space offset, thereby realizing the loading of each core's private segments by a single core.
[0024] Single-core dynamic symbol relocation is the process of linking symbol references and symbol definitions. Based on the contents of the relocation table, the type, name, and offset of the symbol to be relocated are calculated. The actual address of the symbol in the new symbol table is found using the symbol name. Based on the symbol type and jump address, a new jump instruction can be generated, and finally, a dynamic module is generated.
[0025] The multi-core execution of the loaded dynamic module function in step 3 is as follows: the code segment and global data segment in the generated dynamic module are shared by multiple cores, the private data segment is private to each core, and the relocation of dynamic symbols has been completed; at this time, the function interface in the dynamic module can be called and executed on each core.
[0026] The single-core unloading of dynamic modules in step 4 specifically involves the process of unloading dynamic modules as the reverse of the loading process, which completes the release and reclamation of allocated resources.
[0027] like Figures 1 to 6 As shown, a dynamic loading / unloading method based on a multi-core AMP architecture DSP operating system is provided, including the following steps: Step 1: Transfer the dynamic image to the running multi-core AMP architecture DSP operating system. First, start and run the multi-core DSP operating system, and upload the dynamic image to the operating system's file system via network service; the number of dynamic images uploaded can be single or multiple.
[0028] Typically, the AMP architecture is characterized by processor cores that are either homogeneous or heterogeneous. Each core runs an independent operating system, accessing private resources via the local bus and shared resources via the system bus. Generally, based on their role in the operating system boot process, core 0 is called the master core, and the others are called slave cores.
[0029] Each core of the DSP operating system based on the multi-core AMP architecture runs an instance of the embedded operating system. Dynamic images can be uploaded to the main core operating system's file system, such as... Figure 1As shown. Step 2: Single-core parsing and loading of dynamic images. The multi-core DSP operating system that has been started and is running in Step 1 includes the basic functions of the operating system and symbol table information. The uploaded one or more dynamic images are the actual application images. Before loading the dynamic images, the operating system has been started. Parsing and loading the dynamic images means loading the dynamic images into the operating system and enabling it to run independently. The architecture design of dynamic loading is as follows. Figure 2 As shown.
[0030] System Symbol Resolution: This involves resolving the symbol table segment and character table segment in the static image of the operating system within the system symbol table space. The purpose is to analyze the symbol table segment and character table segment in the static image of the operating system (the original static image is used here because it follows the ELF format, which contains symbol table and character table segments; this static image is the operating system image already running in the DSP, and its symbol information has been loaded into the system symbol table space during the operating system boot loading stage). These two segments respectively store the entry addresses and names of APIs in the static image of the operating system. When loading a dynamic image, it is inevitable to use the functions of the operating system. Therefore, the symbol table information of the embedded DSP operating system must be obtained before the symbol relocation of the dynamic image.
[0031] Considering the real-time requirements of the embedded DSP operating system, to improve the efficiency of relocation, the symbol table is re-indexed during the symbol table loading process. This involves readjusting the symbol name offsets according to the ASCII characters to generate a new symbol table. This allows the use of a binary search mechanism during relocation, significantly reducing search time during dynamic image loading. The symbol table re-indexing process is as follows: Figure 3 As shown.
[0032] The purpose of dynamic image loading is to extract useful information from the application image (ELF file) and copy it to the operating system's internal space, mainly the code segment, data segment, relocation table, symbol table, and character table segment. The relocation table indicates the offset position of the items to be relocated in the ELF file, and the relocation operation is performed based on the relocation segment and symbol table.
[0033] Dynamic symbol relocation refers to the relocation of external symbols used in a dynamic image; it's the process of linking symbol references and symbol definitions. Specifically, when a function is called in a dynamic image program, the relevant instructions must transfer control flow to the correct target address during execution. Therefore, a significant amount of relocation work occurs after the dynamic image is loaded, based on the code segment and relocation segment of the dynamic image. The ELF tool can be used to display the dynamic image segment information of a DSP chip, such as... Figure 4As shown, different loading processes were applied to the multi-core shared segment and private segment in the dynamic image. Segments 5-8 are the code segment and relocation segment, while segments 57-58 are the symbol table and character table segments that assist in relocation.
[0034] In the dynamic image segment information, the code segment (.text) and global data segments (.const, .ddr_usr, .shm_unc, etc.) are shared segments across multiple cores, while the .far and .fardata segments are private segments for each core. Single-core parsing and loading of the dynamic image is mainly reflected in the fact that the parsing, loading, and relocation of the dynamic image are completed by a single core, allowing multi-core access. This greatly reduces the memory waste caused by each core loading the dynamic image. A single core directly allocates space from the shared memory pool and loads the contents of the shared segments into the shared memory, achieving shared access across multiple cores. Specifically, for single-core loading of each core's private segments, each core needs to complete the mapping from the same logical address space to different physical address spaces before loading. After the address space mapping is complete, the single core can load the contents of each core's private segments into the physical space of each core according to the mapped space offset, thus achieving single-core loading of each core's private segments. The segment loading space distribution in the dynamic image is as follows: Figure 5 As shown.
[0035] Based on the information in the relocation segment, the relocation type can be determined, thereby determining the relocation address calculation method. The relocation process is as follows: Figure 6 As shown. First, the relocation table of the application image is read in, and the index of the corresponding code segment that needs to be relocated is calculated. The code segment to be relocated is then read in according to the index. Typically, the relocation table and the code segment to be relocated are adjacent. After the read operation is complete, the relocation table is traversed, and the type, name, and offset of the symbol to be relocated in the code segment are calculated based on the content of each entry. Then, the actual address of the symbol in the new symbol table is found using the symbol name. Based on the symbol type and jump address, a new jump instruction is generated, replacing the instruction at the code segment offset. This allows the application to jump to the called function during execution.
[0036] Step 3: Multi-core execution of loaded dynamic module functions. After dynamic image resolution and loading in Step 2, a dynamic module is generated. The code segment and global data segment in the dynamic module are shared by multiple cores, while the private data segment is private to each core, and the relocation of dynamic symbols has been completed. At this point, the function interfaces in the dynamic module can be called and executed on each core.
[0037] Step 4: Unload dynamic modules on a single core. The process of unloading dynamic modules is the reverse of the loading process, mainly involving the release and reclamation of allocated resources.
[0038] This invention proposes a dynamic loading and unloading method for a DSP operating system based on a multi-core AMP architecture. The design realizes dynamic image loading by a single core and access by multiple cores. In the dynamic image, the shared memory of each core is uniformly allocated, while the private memory of each core is separated.
[0039] On a single core of the DSP chip, the main core is typically selected for dynamic image parsing and loading. In particular, when a single core loads the private segments of each core, each core needs to complete the mapping from the same logical address space to different physical address spaces before loading. After the address space mapping is completed, the single core can load the contents of the private segments of each core into the physical space of each core according to the mapping space offset, thereby realizing the loading of the private segments of each core by a single core.
[0040] The dynamically loaded module functions are executed on multiple cores. The code segment and global data segment in the generated dynamic module are shared by multiple cores, while the private data segment is private to each core, and the relocation of dynamic symbols has been completed. At this time, the function interface in the dynamic module can be called and executed on each core.
[0041] The single-core unloads dynamic modules. The process of unloading dynamic modules is the reverse of the loading process, and it mainly completes the release and reclamation of allocated resources.
[0042] The above-described embodiments are merely one implementation of the present invention, and while the descriptions are specific and detailed, they should not be construed as limiting the scope of the invention. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of the present invention, and these all fall within the protection scope of the present invention. Therefore, the protection scope of this invention should be determined by the appended claims.
Claims
1. A dynamic loading and unloading method based on a multi-core AMP architecture DSP operating system, characterized in that, This includes: Step 1: Transferring the dynamic image to the already running multi-core AMP architecture DSP operating system; Step 2: Single-core parsing and loading of the dynamic image; The dynamic image is transferred to the operating system's file system via the network service of the running DSP operating system, and the dynamic image is parsed and loaded by a single core. A single core performs system symbol resolution to obtain the symbol address, symbol name, and symbol table information required for dynamic symbol relocation; the symbol table information is reindexed and sorted to facilitate the use of a binary search mechanism during the relocation process; Single-core dynamic image loading: Based on the dynamic image segment attribute information, the code segment and global data segment are loaded into the multi-core shared memory, and the private segments of each core are loaded into the private memory of each core. Single-core dynamic symbol relocation: This is the process of linking symbol references and symbol definitions. Based on the relocation table entries, the type, name, and offset of the symbol to be relocated in the code segment are calculated. The actual address of the symbol in the new symbol table is found using the symbol name. Based on the symbol type and jump address, a new jump instruction can be generated, ultimately generating a dynamic module. Step 3: Multi-core execution of the loaded dynamic module functions: In the generated dynamic module, the code segment and global data segment are shared by multiple cores, while the private data segment is private to each core, and the relocation of dynamic symbols has been completed. At this time, the function interfaces in the dynamic module can be called and executed on each core. Step 4: Single-core unloading of the dynamic module: The process of unloading the dynamic module is the reverse of the loading process, completing the release and reclamation of allocated resources.
2. The dynamic loading / unloading method based on a multi-core AMP architecture DSP operating system according to claim 1, characterized in that, The dynamic image is a dynamically loadable image containing an application, and the dynamic image file is in ELF format; the multi-core AMP architecture is a processor with isomorphic cores, each core running an independent operating system, and each core can access private resources through the local bus and shared resources through the system bus; the operating system is an embedded DSP operating system, where DSP is a digital signal processor; parsing and loading the dynamic image is the process of parsing, loading, and relocating the dynamic image; unloading the dynamic module is the process of unloading the loaded module.
3. The dynamic loading / unloading method based on a multi-core AMP architecture DSP operating system according to claim 1, characterized in that, Before a single core loads the private segments of each core, each core needs to complete the mapping from the same logical address space to different physical address spaces and record the offset of each core's different physical address spaces. After the address space mapping is completed, the single core can load the contents of each core's private segments into the physical space of each core according to the mapped space offset, thereby realizing the loading of each core's private segments by a single core.
4. The dynamic loading and unloading method based on a multi-core AMP architecture DSP operating system according to claim 1, characterized in that, Dynamic image loading: Extracts useful information from the application image and copies it to the internal space of the operating system, including the code segment, data segment, relocation table, symbol table, and character table segment. The relocation table tells the offset of the items that need to be relocated in the ELF file, and the relocation operation is performed based on the relocation segment and symbol table.
5. The dynamic loading and unloading method based on a multi-core AMP architecture DSP operating system according to claim 1, characterized in that, Dynamic symbol relocation is the relocation of external symbols used in a dynamic image. It is the process of linking symbol references and symbol definitions. When a function is called in a dynamic image program, the relevant instructions must transfer control flow to the correct target address during execution. The relocation work that occurs after dynamic image loading is based on the code segment and relocation segment of the dynamic image. The ELF tool is used to display the dynamic image segment information of the DSP chip. Different loading processes are performed on the multi-core shared segment and private segment in the dynamic image, including the code segment and relocation segment, as well as the symbol table and character table segment that assist in relocation.
6. The dynamic loading and unloading method based on a multi-core AMP architecture DSP operating system according to claim 1, characterized in that, System symbol resolution: This function resolves the symbol table segment and character table segment in the static image of the operating system within the system symbol table space. It analyzes the symbol table segment and character table segment in the static image of the operating system and must obtain the symbol table information of the embedded DSP operating system before dynamic image symbol relocation.
7. The dynamic loading and unloading method based on a multi-core AMP architecture DSP operating system according to claim 1, characterized in that, During the loading of the symbol table, the symbol table is reindexed, that is, the symbol name offsets of the symbol table are readjusted according to the ASCII strings, and a new symbol table is generated. The binary search mechanism is used in the relocation process.
8. The dynamic loading and unloading method based on a multi-core AMP architecture DSP operating system according to claim 1, characterized in that, Specifically, it includes: Step 1: Transfer the dynamic image to the running multi-core AMP architecture DSP operating system; First, start and run the multi-core DSP operating system, and upload the dynamic image to the operating system's file system via network service; Based on the multi-core AMP architecture DSP operating system, an embedded operating system instance runs on each core, and the dynamic image is uploaded to the main core operating system's file system; Step 2: Single-core parsing and loading of dynamic images; The multi-core DSP operating system that has been started and is running in Step 1 includes the basic functions of the operating system and symbol table information. The one or more dynamic images uploaded are the actual application images; Before the dynamic images are loaded, the operating system has been started. Parsing and loading the dynamic images means loading the dynamic images into the operating system and enabling it to run independently. In the dynamic image segment information, the code segment .text and the global data segments .const, .ddr_usr, and .shm_unc are multi-core shared segments, while the .far and .fardata segments are core-private segments. Single-core parsing and loading of dynamic images means that the parsing, loading, and relocation of dynamic images are completed by a single core for multi-core access. A single core directly allocates space from the shared memory pool and loads the contents of the multi-core shared segments into the shared memory, realizing multi-core shared access. Based on the information in the relocation segment, the relocation type can be determined, thereby determining the relocation address calculation method. First, the relocation table of the application image is read in, and the index of the corresponding code segment that needs to be relocated is calculated. The code segment that needs to be relocated is then read in according to the index. After the reading is completed, the read relocation table is traversed, and the type, name, and offset of the symbol that needs to be relocated in the code segment are calculated according to the contents of each table entry. Then, the actual address of the symbol in the new symbol table is found using the symbol name. A new jump instruction can be generated according to the symbol type and jump address. This jump instruction replaces the instruction of the code segment offset, so that the execution of the application can jump to the called function during the execution process. Step 3: Multi-core execution of loaded dynamic module functions; After dynamic image parsing and loading in Step 2, a dynamic module is generated. The code segment and global data segment in the dynamic module are shared by multiple cores, while the private data segment is private to each core, and the relocation of dynamic symbols has been completed; At this time, the function interface in the dynamic module can be called and executed on each core. Step 4: Unload dynamic modules on a single core. The process of unloading dynamic modules is the reverse of the loading process, which completes the release and reclamation of allocated resources.