Task migration method and system for heterogeneous environment and medium

Abstract

The invention relates to the technical field of heterogeneous environment task migration, and particularly provides a heterogeneous environment task migration method and system and a medium. According to the method, a uniform data layout and a virtual address space structure are constructed to unify state representation modes among different instruction set architectures; the extensible executable file is expanded on the basis of a fat binary file, and a symbol table is split into a basic symbol table shared across instruction set architectures and an independent extended symbol table of each instruction set architecture; and executing task migration across the instruction set architecture by the runtime environment in combination with the basic symbol table and the extended symbol table based on the migration points and the trigger pages embedded in the construction process. According to the method, the mobility, the cross-platform compatibility and the system analyzability are balanced, and systematic support is provided for task migration in a heterogeneous environment.

Description

Technical Field

[0001] This invention relates to the field of heterogeneous environment task migration technology, specifically to a method, system, and medium for heterogeneous environment task migration. Background Technology

[0002] As computing architectures continue to evolve, modern computing environments are increasingly exhibiting a trend towards heterogeneity. In scenarios such as cloud computing, edge computing, and volunteer computing, multiple different instruction set architectures (ISAs) often coexist, such as x86, ARM, and RISC-V. These heterogeneous nodes differ in computing power, operating systems, runtime environments, and network conditions. While this offers higher cost-effectiveness and flexibility, it also presents new challenges for task distribution, migration, and scheduling.

[0003] Existing technologies primarily rely on executables compiled for a single architecture, which leads to the following problems when migrating tasks across platforms: Lack of unified memory layout and symbol semantics: The binary files of different ISAs differ in memory organization, symbol table structure and task state representation. During migration, additional data structures are required for conversion, which increases overhead and reduces efficiency.

[0004] Insufficient toolchain support: Existing cross-ISA migration research largely relies on invasive modifications to system libraries or runtimes, lacking a general, low-intrusion toolchain to natively support cross-ISA task migration. This not only increases development complexity but also affects system stability and scalability.

[0005] Lack of a unified migration and evaluation platform: Current migration solutions are mostly incompatible implementations, lacking a unified performance benchmark and evaluation framework, making it difficult to systematically compare and optimize different mechanisms and strategies.

[0006] In summary, existing task encapsulation and execution mechanisms cannot simultaneously meet the following three requirements: Provides ISA-adaptive instruction representation; Supports fine-grained task scheduling and runtime state capture; Maintain consistent memory layout and symbolic semantics across ISAs and operating systems.

[0007] In summary, there is an urgent need for a task migration method, system, and medium for heterogeneous environments to solve the problems in existing technologies. Summary of the Invention

[0008] The purpose of this invention is to provide a method, system, and medium for task migration in heterogeneous environments. The specific technical solution is as follows: A method for task migration in heterogeneous environments includes the following steps: S1: Construct a unified data layout and virtual address space; S2: The extensible executable extends the fat binary by splitting the symbol table into a basic symbol table shared across instruction set architectures and an extended symbol table independent of each instruction set architecture. S3: Performs task migration across instruction set architectures based on the base symbol table and extended symbol table.

[0009] Optionally, in S1, a unified data layout is constructed, the process of which includes: During the compilation phase, the compiler and linker are modified to adopt a unified data layout, which includes structure layout, segment layout, page alignment, and stack structure.

[0010] Optionally, in S1, the data layout also includes: The linker stores all migration points in the same section. Migration points provide instruction sequences adapted to different devices, but ensure the semantic and virtual address consistency of the same migration point across different devices, so as to support the runtime environment to quickly identify that the program is at a migration point. Migration points provide the same size and semantics across different instruction set architectures by padding with empty instructions and using equivalent instructions; During register allocation, the compiler's register overflow behavior is utilized to ensure that the same intermediate data overflows to the same location under different instruction set architectures; When performing a migration task, an overflow is actively triggered to write the register contents to the stack, and the register state is restored at the target end according to the mapping relationship.

[0011] Optionally, in S1, a unified virtual address space is constructed, the process of which includes: By using position-independent code and a unified load base address strategy, a consistent memory view is formed across platforms. At runtime, dynamic memory allocation functions are hijacked to ensure that the allocated memory is within the virtual address range that is valid across all instruction set architectures.

[0012] Optionally, in S2, the base symbol table stores consistent symbol information, while the extended symbol table stores addresses, sizes, and metadata specific to each instruction set architecture.

[0013] Optionally, in S2, the file is further divided into an instruction set architecture shared area and an instruction set architecture exclusive area. The instruction set architecture shared area is used to store shared data, and the instruction set architecture exclusive area is used to store machine instructions and specific data in each instruction set architecture.

[0014] Optionally, in S3, task migration is performed, and the process includes: The system automatically identifies and loads the appropriate code and data from the executable file. The current system call interception mechanism unifies the call semantics across different instruction set architectures and operating systems. At predefined migration points, the runtime environment captures migration requests by triggering page access exceptions and exports the task status when migration is required. The task status is transmitted to the target platform via the migration interface, and execution is resumed on the target platform to complete the task migration. During the task migration process, all migration points are stored on consecutive trigger pages. When the program executes to a migration point, it will access the reserved trigger page. When the system is in a state awaiting migration, a page access exception will be triggered, the migration request will be captured, and the migration process will begin. When the system is in a state where migration is not required, the program will continue to execute normally.

[0015] Optionally, in S3, the process of migrating a task and resuming execution on the target platform during task migration includes: Export the process's writable memory pages, file handles, stack pointers, and migration point identifiers, and transfer them to the target platform; The target platform loads the read-only segment, restores the writable memory pages and registers, rebuilds the file handle, and continues execution at the migration point.

[0016] In addition, the present invention also includes a task migration system for heterogeneous environments, comprising: The compilation and unified build module is used to build a unified data layout and virtual address space; An extensible executable file structure adjustment module is used to maintain consistent symbol semantics across ISAs and provide data and instructions adapted to each ISA; The task migration module is used to perform task migrations across instruction set architectures.

[0017] In addition, the present invention also includes a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps of the task migration method for heterogeneous environments as described above.

[0018] The application of the technical solution of the present invention has the following beneficial effects: The method of this invention achieves cross-platform symbol semantic consistency and fast resolution by setting a basic symbol table and an extended symbol table in the executable file and distinguishing between the ISA shared area and the exclusive area, thus avoiding the redundancy and incompatibility problems caused by traditional multi-version binary files.

[0019] The method of this invention ensures memory visibility across different ISA platforms through a unified data layout, position-independent code, and a unified load base address strategy. Figure 1Consistency; combined with the register overflow storage mechanism, cross-platform recovery of register state is achieved, thereby reducing the state transition overhead during the migration process.

[0020] The method of this invention achieves rapid detection and status export of migration requests by inserting predefined migration points into the program and utilizing trigger pages and exception handling mechanisms, thus avoiding complex transformations of arbitrary instruction streams and frequent middleware operations.

[0021] The method of this invention ensures the consistency of external resource status before and after migration through system call interception and forwarding, resource dependency management and migration judgment functions, and automatically prevents migration when non-migratable resources are detected, thus ensuring the stability of the system.

[0022] In addition to the objectives, features, and advantages described above, the present invention has other objectives, features, and advantages. The invention will now be described in further detail with reference to the figures. Attached Figure Description

[0023] To more clearly illustrate the technical solutions of the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0024] Figure 1 This is a flowchart of the steps of the task migration method in a preferred embodiment of the present invention; Figure 2 This is a schematic diagram of an extensible executable file format in a preferred embodiment of the present invention; Figure 3 This is a comparative diagram of the memory layout of the file and the existing executable file in a preferred embodiment of the present invention, wherein (a) represents the address layout of the existing executable file, and (b) represents the address layout of the SEF file in the embodiment of the present invention; Figure 4 This is a schematic diagram of the migration point in a preferred embodiment of the present invention. Detailed Implementation

[0025] Existing cross-platform execution solutions in heterogeneous computing environments mainly include fat binary file technology and binary translation technology. While fat binary file technology can encapsulate multiple ISA codes within a single executable file, it is only suitable for software distribution and cannot support runtime task migration and dynamic scheduling. Binary translation technology can run programs directly on different ISAs, but the translation process introduces significant performance overhead, resulting in execution efficiency far lower than native execution. Application state capture and transformation technology can unify task state semantics before and after migration, but it requires the runtime environment to analyze the stack structure and store additional metadata, leading to high implementation complexity. Therefore, existing technologies generally suffer from low migration efficiency, implementation complexity, and a lack of unified semantic standards, making it difficult to meet the needs of efficient, low-overhead, and scalable cross-ISA task migration and execution in heterogeneous computing environments.

[0026] To address the aforementioned issues, this invention provides a task migration method for heterogeneous environments. This method constructs a unified data layout and virtual address space; extends the scalable executable file based on the fat binary file; and splits the symbol table into a basic symbol table shared across instruction set architectures and extended symbol tables independent of each instruction set architecture. Cross-instruction set architecture task migration is then performed based on the basic and extended symbol tables. This invention achieves a balance between portability, cross-platform compatibility, and system analyzability, providing systematic support for task migration in heterogeneous environments.

[0027] To enable those skilled in the art to better understand the present invention, the invention will be further described in detail below with reference to the accompanying drawings and specific embodiments. Obviously, the described embodiments are merely some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0028] Example: like Figure 1 As shown, this embodiment provides a task migration method for heterogeneous environments, including the following steps: S1: Construct a unified data layout and virtual address space.

[0029] In this embodiment, the process of constructing a unified data layout includes: During the compilation phase, the compiler and linker are modified to adopt a unified data layout, which includes structure layout, segment layout, page alignment, and stack structure.

[0030] Furthermore, the data layout also includes: The linker stores all migration points in the same section to enable the runtime environment to quickly identify when a program is at a migration point. During register allocation, the compiler's register overflow behavior is utilized to ensure that the same intermediate data overflows to the same location under different instruction set architectures; When performing a migration task, an overflow is actively triggered to write the register contents to the stack, and the register state is restored at the target end according to the mapping relationship.

[0031] It's important to note that during the compiler's register allocation process, a register overflow (spill) occurs when the number of physical registers is insufficient to hold all active variables. In this case, the compiler writes some variable values ​​into memory (usually a stack frame) and loads them back when needed. Different instruction set architectures differ in the number, bit width, and calling conventions of logical register files, therefore, processes need to perform register state transitions when migrating across ISAs.

[0032] However, for the intermediate representation (IR) generated from the same source code, the set of active variables is deterministic and consistent when executing a particular instruction. Based on this characteristic, this embodiment proposes a register mapping mechanism: Unified overflow rules: Define unified register overflow rules for all ISAs during the compilation phase to ensure that the data corresponding to the same IR instruction always overflows to the same logical location (e.g., a fixed offset in the stack frame) on different ISAs.

[0033] Full overflow during migration: At the migration point, the system actively triggers a full overflow, writing the contents of all registers in the source ISA to a reserved register mapping area. This mapping area uses a uniform layout and alignment to ensure consistency across ISAs.

[0034] Target-side recovery: On the target ISA, the compiler automatically selects the necessary portions of the overflowing data from the active variable information analyzed by the compiler. Therefore, this design still allows for a degree of freedom in the machine instructions of each ISA to optimize data loading strategies for the characteristics of different ISA register files.

[0035] In this embodiment, the program does not need to save and translate register states one by one during migration. Instead, it relies on a unified overflow rule and mapping area to complete state export and recovery. This not only reduces the implementation complexity of migration points but also avoids saving additional register mapping information at switching points, thereby improving the efficiency and reliability of migration.

[0036] In this embodiment, the process of constructing a unified virtual address space includes: By using position-independent code and a unified load base address strategy, a consistent memory view is formed across platforms. At runtime, dynamic memory allocation functions are hijacked to ensure that the allocated memory is within the virtual address range that is valid across all instruction set architectures.

[0037] It should be noted that step S1 in this embodiment requires compiling the source code during the compilation stage to generate multi-ISA object files, ensuring the uniformity of data structure layout during program execution.

[0038] S2: The extensible executable extends the fat binary by splitting the symbol table into a base symbol table shared across instruction set architectures and an extended symbol table independent of each instruction set architecture.

[0039] In this embodiment, the basic symbol table stores consistent symbol information, while the extended symbol table stores addresses and sizes specific to each instruction set architecture. Metadata.

[0040] In this embodiment, the extensible executable file adopts an SEF file, which includes a basic symbol table and multiple ISA extended symbol tables. The basic symbol table stores symbol names, types, and attributes that are consistent across ISAs. The ISA extended symbol tables record the address, size, and metadata of the symbols under the corresponding ISA. The file structure also includes unified segment layout information to ensure that the relative addresses of data segments and stack segments are consistent under different ISAs. Through the unified layout design of migration points and translation areas, the file structure can realize the migration function without a migration point table.

[0041] like Figure 2 As shown, the SEF file structure in this embodiment includes a file header, an ISA segment table, ISA segments, and their corresponding section tables at the file level. ISA-independent shared data (such as string constants) is stored in the ISA shared area, while ISA-specific binary instructions and data are stored in their respective ISA exclusive areas. When loaded into memory, the ISA shared area is mapped to the same virtual address, while the ISA exclusive areas are loaded into their respective address spaces. This organization ensures symbol consistency and memory layout consistency across ISAs, thus providing a unified foundation for task migration.

[0042] like Figure 3 As shown, in this embodiment, data segments of different ISAs (such as data segment 0, data segment 1, and data segment 2) are loaded according to a unified segment layout rule in the memory view. Their virtual addresses are determined by the linker, and the starting address of the same data segment is consistent on different ISAs.

[0043] Step S2 in this embodiment further includes dividing the SEF file into an instruction set architecture shared area and an instruction set architecture exclusive area. The instruction set architecture shared area is used to store shared data, and the instruction set architecture exclusive area is used to store machine instructions and specific data in each instruction set architecture.

[0044] This embodiment, through the above-described SEF file structure design, can ensure cross-ISA consistency at both the file level and the memory level, avoiding the overhead of additional memory layout conversion required during migration of traditional multi-version binary files.

[0045] S3: Performs task migration across instruction set architectures based on the base symbol table and extended symbol table.

[0046] In this embodiment, in S3, task migration is performed, and the process includes: The system automatically identifies and loads the appropriate code and data from the executable file. The current system call interception mechanism unifies the call semantics across different instruction set architectures and operating systems. At predefined migration points, the runtime environment captures migration requests by triggering page access exceptions and exports the task status when migration is required. The task status is transmitted to the target platform via the migration interface, and execution is resumed on the target platform to complete the task migration. During task migration, all migration points are stored on consecutive trigger pages. When the program reaches a migration point, it accesses the reserved trigger page. If the system is in a state awaiting migration, a page access exception is triggered, the migration request is captured, and the migration process begins. If the system is in a state where migration is not required, the program continues to execute normally. Since migration points are stored on trigger pages, and the migration process is triggered by accessing these trigger pages, migration can be achieved without introducing a migration point table or similar structure by using a unified internal structure design for migration points and their addresses on different ISAs.

[0047] It should be noted that this embodiment also provides a cross-ISA function call and return conversion mechanism during the task migration process. For example... Figure 4 As shown, this mechanism places the function call and return process on a specific memory page, called the translation area.

[0048] During the compilation phase, each function call creates a corresponding translation region (JT) for the compiler, replacing the function call instructions in the original program with instructions that jump to that JT. For the same call, the JT has the same virtual address across different ISAs. When a function call is executed, the task's control flow is redirected to the JT, and the design of the JT ensures that different ISAs have a consistent return address when calling functions. When the function returns, the task's control flow also passes through the JT before returning to the control flow location corresponding to that ISA.

[0049] During runtime, when the system is in a migrateable state, accessing the translation area will trigger a page access exception (page fault), which will be captured by the middleware and the migration process will be initiated; when the system is in a non-migration state, accessing the translation area will not trigger an exception, and the program will continue to execute normally.

[0050] Compared to the original function call flow, the translation area only introduces two additional jumps and several no-operation instructions. This mechanism enables seamless function-level migration between different ISAs, avoiding complex binary translations of arbitrary instruction streams. Combined with register mapping mechanisms, it ensures the correctness and low overhead of cross-ISA task migration, thereby guaranteeing consistency between cross-ISA function calls and returns.

[0051] Furthermore, during the task migration process, the process of migrating the task and resuming execution on the target platform includes: Export the process's writable memory pages, file handles, stack pointers, and migration point identifiers, and transfer them to the target platform; The target platform loads the read-only segment, restores the writable memory pages and registers, rebuilds the file handle, and continues execution at the migration point.

[0052] Furthermore, to verify the effectiveness of the method in this embodiment, this embodiment also provides a cross-ISA task migration implementation method based on a prototype system.

[0053] This prototype system includes modifications to the LLVM18 compiler, a newly designed assembler and linker, and a runtime environment adapted to this file format. Specifically, the compiler modifications include defining a new Application Binary Interface (ABI) and adding a Pass for negotiating a unified memory layout. The redesigned linker adds the primitives Polarize and Universal to unify the data section views across different ISAs. The runtime environment intercepts system calls, manages resource dependencies, and coordinates state export and recovery during migration. The runtime environment includes a migration management module for transferring task state between the source and target platforms and resuming execution on the target platform. In this prototype system, tasks can be migrated between AMD64, AArch64, and RISC-V64 platforms. During migration, a page access exception is triggered at the migration point, which is captured by middleware and the task state is exported before execution resumes on the target platform. Experimental results show that the prototype system can correctly complete cross-ISA task migration, verifying the feasibility and effectiveness of the method in this embodiment.

[0054] In addition, this embodiment also provides a task migration system for heterogeneous environments, including: The compilation and unified build module is used to build a unified data layout and virtual address space; An extensible executable file structure adjustment module is used to maintain consistent symbol semantics across ISAs and provide data and instructions adapted to each ISA; The task migration module is used to perform task migrations across instruction set architectures.

[0055] In this embodiment, the task migration system also includes a system call interception and forwarding module, a resource management module, and a migration determination module during operation.

[0056] The system call interception and forwarding module is used to unify the call semantics across different ISAs and operating systems.

[0057] The resource management module is used to record and rebuild the external resources that the task depends on during migration.

[0058] The migration determination module is used to automatically determine that a task cannot be migrated when non-migratable resources (such as exclusive hardware devices) are detected, thereby ensuring system stability.

[0059] It should be noted that computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof. These programming languages ​​include object-oriented programming languages—such as Java, Smalltalk, and C++—as well as conventional procedural programming languages—such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0060] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0061] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0062] This embodiment also includes a computer-readable storage medium storing a computer program that, when executed by a processor, implements the steps of the task migration method for heterogeneous environments as described above.

[0063] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., a computer program) for executing the above-described heterogeneous device task migration optimization method. This optimizes the task migration strategy between heterogeneous devices and improves migration efficiency. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as those of the heterogeneous device task migration optimization method provided in the above embodiments, and will not be repeated here.

[0064] The above are only some embodiments of this application and do not limit the patent scope of this application. All equivalent structural transformations made under the technical concept of this application and using the contents of the specification and drawings of this application, or direct / indirect applications in other related technical fields, are included in the patent protection scope of this application.

Claims

1. A task migration method for heterogeneous environments, characterized in that, Includes the following steps: S1: Construct a unified data layout and virtual address space; S2: The extensible executable extends the fat binary by splitting the symbol table into a basic symbol table shared across instruction set architectures and an extended symbol table independent of each instruction set architecture. S3: Performs task migration across instruction set architectures based on the base symbol table and extended symbol table.

2. The task migration method for heterogeneous environments according to claim 1, characterized in that, In S1, a unified data layout is constructed, and the process includes: During the compilation phase, the compiler and linker are modified to adopt a unified data layout, which includes structure layout, segment layout, page alignment, and stack structure.

3. The task migration method for heterogeneous environments according to claim 2, characterized in that, In S1, the data layout also includes: The linker stores all migration points in the same section. Migration points provide instruction sequences adapted to different devices, but ensure the semantic and virtual address consistency of the same migration point across different devices, so as to support the runtime environment to quickly identify that the program is at a migration point. Migration points provide the same size and semantics across different instruction set architectures; During register allocation, the compiler's register overflow behavior is utilized to ensure that the same intermediate data overflows to the same location under different instruction set architectures; When performing a migration task, an overflow is actively triggered to write the register contents to the stack, and the register state is restored at the target end according to the mapping relationship.

4. The task migration method for heterogeneous environments according to claim 3, characterized in that, In S1, a unified virtual address space is constructed, and the process includes: By using position-independent code and a unified load base address strategy, a consistent memory view is formed across platforms. At runtime, dynamic memory allocation functions are hijacked to ensure that the allocated memory is within the virtual address range that is valid across all instruction set architectures.

5. The task migration method for heterogeneous environments according to claim 4, characterized in that, In S2, the base symbol table stores consistent symbol information, while the extended symbol table stores addresses, sizes, and metadata specific to each instruction set architecture.

6. The task migration method for heterogeneous environments according to claim 5, characterized in that, S2 also includes dividing the file into an instruction set architecture shared area and an instruction set architecture exclusive area. The instruction set architecture shared area is used to store shared data, and the instruction set architecture exclusive area is used to store machine instructions and specific data in each instruction set architecture.

7. The task migration method for heterogeneous environments according to claim 6, characterized in that, In S3, the process of performing task migration includes: The system automatically identifies and loads the appropriate code and data from the executable file. The current system call interception mechanism unifies the semantics of system calls across different instruction set architectures and operating systems. At predefined migration points, the runtime environment captures migration requests by triggering page access exceptions and exports the task status when migration is required; The task status is transmitted to the target platform via the migration interface, and execution is resumed on the target platform to complete the task migration. During the task migration process, all migration points are stored on consecutive trigger pages. When the program executes to a migration point, it will access the reserved trigger page. When the system is in a state awaiting migration, a page access exception will be triggered, the migration request will be captured, and the migration process will begin. When the system is in a state where migration is not required, the program will continue to execute normally.

8. The task migration method for heterogeneous environments according to claim 7, characterized in that, In S3, the process of migrating a task and resuming execution on the target platform during task migration includes: Export the process's writable memory pages, file handles, stack pointers, and migration point identifiers, and transfer them to the target platform; The target platform loads the read-only segment, restores the writable memory pages and registers, rebuilds the file handle, and continues execution at the migration point.

9. A task migration system for heterogeneous environments, characterized in that, include: The compilation and unified build module is used to build a unified data layout and virtual address space, and insert migration points and corresponding trigger pages inside the program; An extensible executable file structure adjustment module is used to maintain consistent symbol semantics across ISAs and provide data and instructions adapted to each ISA; The task migration module is used to perform task migrations across instruction set architectures.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the steps of the task migration method for heterogeneous environments as described in any one of claims 1 to 8.

Images