Starting method and device, electronic equipment and storage medium

Abstract

The embodiment of the invention provides a starting method and device for an automobile open system architecture classical platform, electronic equipment and a storage medium, and the method comprises the steps: starting a master core and a slave core at the early stage of starting, and respectively initializing local non-cache static random access memories of the master core and the slave core; distributing at least part of starting processes of the hardware module which can be initialized by the slave core agent to the slave core for initialization processing; transferring an initialization proxy product generated by performing initialization processing on the slave core from the local non-cache static random access memory of each core of the slave core to the local non-cache static random access memory of each core of the master core; and performing synchronization processing on the time point at which the slave core performs the transfer of the initialized proxy product. According to the embodiment of the invention, the quick start of the classic platform of the automobile open system architecture can be realized, and the quick start of the ECU is realized.

Description

Technical Field

[0001] The embodiments of the present application relate to the field of automotive electronic technology, and in particular to a startup method, device, electronic device and storage medium of a classic platform of an automotive open system architecture. Background Art

[0002] The startup initialization process of the Autosar CP affects the startup of the electronic control unit (ECU), and the fast startup of the ECU involves the power-on, restart and sleep wake-up of the ECU. It is an important indicator for measuring the system because it is related to the user's vehicle experience, such as Bluetooth key unlocking, light flashing, etc.

[0003] Therefore, how to improve the startup speed of the classic platform of the automotive open system architecture has become a technical problem that needs to be solved urgently.

[0004] Application Contents

[0005] In view of this, the embodiments of the present application provide a method, device, electronic device and storage medium for starting a classic platform of an automotive open system architecture, which can realize the rapid startup of the classic platform of an automotive open system architecture and the rapid startup of an ECU.

[0006] According to a first aspect of an embodiment of the present application, a method for starting an automotive open system architecture classic platform is provided, the method comprising: starting a master core and a slave core in the early stage of startup, and initializing the local per-core non-cached static random access memory of the master core and the slave core respectively; allocating at least part of the startup process of a hardware module that can be initialized by the slave core agent to the slave core for initialization processing; transferring an initialization agent product generated by the initialization processing of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core; and synchronizing the time point when the slave core transfers the initialization agent product.

[0007] In some embodiments of the present application, starting the master core and the slave core in the early stage of startup, and respectively initializing the local per-core non-cached static random access memory of the master core and the slave core, also includes: identifying a hardware module that can be initialized by the slave core agent, and the hardware module that can be initialized by the slave core agent is a module whose initialization process does not depend on other modules and the initialization does not involve strong binding of resources to the master core or any of the slave cores.

[0008] In some embodiments of the present application, at least part of the startup process of the hardware module that can be initialized by the slave core agent is allocated to the slave core for initialization processing, including: recording the starting address of the initialization agent product generated by the slave core for initialization processing in the local per-core non-cached static random access memory of the slave core and the storage length of the initialization agent product.

[0009] In some embodiments of the present application, the initialization agent generated by the initialization processing of the slave core is transferred from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core, and also includes: after transferring the initialization agent generator to the local per-core non-cached static random access memory of the master core, recycling and reusing the storage space from the starting address of the local per-core non-cached static random access memory of the slave core where the initialization agent generator is located to the storage length of the initialization agent generator.

[0010] In some embodiments of the present application, the initialization agent generated by the initialization processing of the slave core is transferred from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core, including: if the chip where the master core is located supports global addresses, the master core directly accesses the local per-core non-cached static random access memory of the slave core to obtain the initialization agent generator; otherwise, the master core accesses the local per-core non-cached static random access memory of the slave core through non-cached global content as an intermediate storage medium to obtain the initialization agent generator.

[0011] In some embodiments of the present application, the time point of transferring the initialization agent generator to the slave core is synchronized, including: if the slave core does not transfer the initialization agent generator to the master core, the master core performs busy waiting through the inter-core synchronization mechanism until receiving the initialization agent generator transferred by the slave core, and the master core executes other actions in the action list; if the slave core does not transfer the initialization agent generator to the master core, the master core executes other actions in the action list.

[0012] According to a second aspect of an embodiment of the present application, a startup device for an automotive open system architecture classic platform is provided, the device comprising: a startup module, used to start a master core and a slave core in the early stage of startup, and initialize the local per-core non-cached static random access memory of the master core and the slave core respectively; a processing module, used to allocate at least part of the startup process of the hardware module that can be initialized by the slave core agent to the slave core for initialization processing; a transfer module, used to transfer the initialization agent product generated by the initialization processing of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core; a synchronization module, used to synchronize the time point of the transfer of the initialization agent product to the slave core.

[0013] According to a third aspect of an embodiment of the present application, an electronic device is provided, comprising: a processor, a communication interface, a memory and a communication bus, wherein the processor, the memory and the communication interface communicate with each other through the communication bus; the memory is used to store at least one executable instruction, and the executable instruction enables the processor to execute operations corresponding to the startup method of the automotive open system architecture classic platform as described in the first aspect.

[0014] According to a fourth aspect of an embodiment of the present application, a computer storage medium is provided, on which a computer program is stored. When the program is executed by a processor, the method for starting the automotive open system architecture classic platform as described in the first aspect is implemented.

[0015] According to a fifth aspect of an embodiment of the present application, a computer program product is provided, comprising computer instructions, wherein the computer instructions instruct a computing device to perform operations corresponding to the diagnostic method based on a service-oriented architecture as described in the first aspect of the embodiment.

[0016] According to the above technical scheme, the startup scheme of the automotive open system architecture classic platform of the embodiment of the present application starts the master core and the slave core in the early stage of startup, and initializes the local per-core non-cached static random access memory of the master core and the slave core respectively, so as to allocate at least part of the startup process of the hardware module that can be initialized by the slave core agent to the slave core for initialization processing. The embodiment of the present application transfers the initialization agent product generated by the initialization processing of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core, and synchronizes the time point of the transfer. The embodiment of the present application can realize the rapid startup of the automotive open system architecture classic platform, and then realize the rapid startup of the electronic control unit. Without affecting the actual vehicle function, the startup time of the electronic control unit will be greatly shortened, which provides a guarantee for the sleep and rapid wake-up of the whole vehicle. BRIEF DESCRIPTION OF THE DRAWINGS

[0017] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings required for use in the embodiments or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0018] Figure 1 A schematic diagram of the implementation of the launch of the classic platform of the automotive open system architecture for related technologies;

[0019] Figure 2 A flowchart of a method for starting a classic platform of an automotive open system architecture applicable to an embodiment of the present application;

[0020] Figure 3 A schematic diagram of a method for starting a classic platform of an automotive open system architecture applicable to an embodiment of the present application;

[0021] Figure 4 A schematic diagram of implementing step S2 of a method for starting a classic platform of an automotive open system architecture applicable to an embodiment of the present application;

[0022] Figure 5 A flowchart of step S3 of a method for starting a classic platform of an automotive open system architecture applicable to an embodiment of the present application;

[0023] Figure 6 A flowchart of step S4 of a method for starting a classic platform of an automotive open system architecture applicable to an embodiment of the present application;

[0024] Figure 7 A flowchart of a method for starting a classic platform of an automotive open system architecture applicable to another embodiment of the present application;

[0025] Figure 8 A structural diagram of a startup device for an automotive open system architecture classic platform applicable to an embodiment of the present application. DETAILED DESCRIPTION

[0026] In order to enable those skilled in the art to better understand the present application, the technical solutions in the embodiments of the present application will be clearly and completely described below in conjunction with the drawings in the embodiments of the present application. Obviously, the described embodiments are part of the embodiments of the present application, rather than all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by ordinary technicians in the field without creative work are within the scope of protection of the present application.

[0027] To facilitate subsequent explanations, the technical terms used in this application are defined.

[0028] Initialization agent generated: The product of the module being transferred to other slave cores to complete initialization and finally handed over to the master core. The initialization agent generated includes: handle, module status, etc.

[0029] Local Per-Core Non-Cacheable SRAM: Each core has an identical high-speed memory very close to itself, without cache, which means that the current core can directly access it, and the performance is the same as L1 cache. Automotive multi-core MCU chips, such as S32G, TC3xx, etc., each core has an identical SRAM. Using the same local address, each core accesses its corresponding SRAM. For example: when reading the contents of this SRAM through the same address, each core reads different contents.

[0030] Master core / slave core: The core responsible for the overall process of the action list is the same core as the flash drive core. Relative to the master core, all other cores are slave cores.

[0031] See also Figure 1 , the process of starting and initializing the multi-core automotive open system architecture classic platform: the master core (Master) Core0 performs initialization processing, including: driver initialization, underlying initialization code, etc., and is responsible for starting other slave cores (Slave) Cores. The startup time of the master core and the slave core is more than 31ms, and the slave cores are in an inactive state for more than 35ms before being started. This causes the startup time of the automotive open system architecture classic platform to be long, which further affects the startup time of the electronic control unit.

[0032] The power-on, restart and sleep-wake-up of the ECU are important indicators for measuring the system, because they are related to the user's vehicle experience, such as Bluetooth key unlocking, light flashing, etc. The startup initialization process of the classic platform of the automotive open system architecture affects the startup of the ECU.

[0033] In order to solve the above technical problems, the present application embodiment provides a method for starting a classic platform of an automotive open system architecture, see Figure 2 , methods include:

[0034] Step S1: Start the master core and the slave core in the early stage of startup, and initialize the local per-core non-cached static random access memory of the master core and the slave core respectively.

[0035] Specifically, see Figure 3, start the master core Core0 and the slave core Core1 - Core n (n is a natural number) at the early stage of startup, that is, the slave core does not need to wait for the master core to start. When the master core Core0 starts, its local non-cached static random access memory per core is initialized, and the slave cores are started at an earlier stage. When the slave cores are started, their local non-cached static random access memory per core also needs to be initialized.

[0036] Step S2: Allocate at least part of the startup process of the hardware module that can be initialized by the slave core agent to the slave core for initialization processing.

[0037] Specifically, for the convenience of description, two cores, a master core Core0 and a slave core Core1, are exemplarily used to describe the allocation of hardware modules.

[0038] exist Figure 1 In the illustrated solution, hardware modules Action 1 to Action 12 that can be initialized by the slave core agent run on the main core Core0.

[0039] In the embodiment of the present application, Actions 1 to 8, 11 are run on the main core Core0;

[0040] Actions 9 and 10 are run on slave core Core 1.

[0041] The allocation of hardware modules Action 1 to Action 12 is shown in Table 1. Table 1 is only an illustration of the embodiment of the present application and is not a limitation of the embodiment of the present application.

[0042] Table 1

[0043]

[0044] Step S3: transferring the initialization agent generated by the initialization process of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core.

[0045] For example, see Figure 4 , the slave core Core1 transfers the contents of section 0x60000000~0x60000020 to section 0x60000000~0x60000020 of the master core Core0; the slave core Core2 transfers the contents of section 0x60000030~0x60000040 to section 0x60000040~0x60000040 of the master core Core0.

[0046] In a specific implementation of the first embodiment of the present application, step S3 further includes:

[0047] The starting address of the initialization agent generated by the slave core during the initialization process in the local per-core non-cache static random access memory of the slave core and the storage length of the initialization agent generated are recorded.

[0048] Specifically, after the slave core initializes its assigned hardware module, since it is necessary to transfer the generated initialization proxy product from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core, the slave core records the starting address (Sec_i) of the local per-core non-cached static random access memory where the initialization proxy product to be transferred is located and the storage length (Len_i) of the initialization proxy product.

[0049] The embodiment of the present application facilitates the transfer of the initialization proxy generated from the core through the above method, and all cores do not need to disable the cache, which will not cause non-cached data operations throughout the life cycle of the system, and will not cause a sudden drop in system performance. The embodiment of the present application elegantly solves the problem of cache consistency in inter-core communication.

[0050] In a specific implementation of the first embodiment of the present application, step S3 further includes:

[0051] After the initialization agent generator is transferred to the local non-cached static random access memory of each core of the master core, the storage space from the starting address of the local non-cached static random access memory of each core of the slave core where the initialization agent generator is located to the storage length of the initialization agent generator is recycled and reused.

[0052] In the embodiment of the present application, the local per-core non-cached static random access memory in the slave core can be recycled after the initialization proxy generation is transferred, without the need to permanently place the initialization proxy generation in the non-cached memory area, which will not result in non-cached data operations throughout the life cycle of the system and will not cause a sudden drop in system performance.

[0053] In the specific implementation of the first embodiment of the present application, see Figure 5 , step S3, comprising:

[0054] Step S31: If the chip where the master core is located supports global addresses, the master core directly accesses the local per-core non-cached static random access memory of the slave core to obtain the initialization proxy generator.

[0055] Step S32: If the chip where the master core is located does not support global addresses, the master core uses the non-cached global content as an intermediate storage medium to access the local per-core non-cached static random access memory of the slave core to obtain the initialization proxy generator.

[0056] The embodiment of the present application adopts different transfer methods according to different chips and can be adapted to various chips. After the embodiment of the present application is successfully transferred, because the variables on the local non-cached static random access memory of each core have the same virtual storage address on all cores, and it is non-cached memory, and the speed is several times faster than ordinary static random access memory, the main core can be used immediately.

[0057] Step S4: Synchronize the time point at which the slave core performs the transfer of the initialization agent product.

[0058] In the specific implementation of the first embodiment of the present application, see Figure 6 , step S4, comprising:

[0059] Step S41: If the slave core has not transferred the initialization agent generated object to the master core, the master core performs busy waiting through the inter-core synchronization mechanism until the initialization agent generated object transferred from the slave core is received, and the master core executes other actions in the action list.

[0060] Step S42: If the slave core does not transfer the initialization agent generated to the master core, the master core executes other actions in the action list.

[0061] Specifically, see Figure 3 When the master core Core0 executes to the time point synchronize1, there are two possibilities: the slave core Core1 has not yet transferred the initialization proxy generator to the master core Core0 or the slave core Core1 has transferred the initialization proxy generator to the master core Core0.

[0062] Since the local per-core non-cached static random access memory of the main core Core0 has been initialized to 0 when the main core Core0 is started, it can be distinguished which of the above situations it belongs to. If the slave core Core1 has not yet transferred the initialization proxy generator to the main core Core0, the main core Core0 starts busy waiting through the inter-core synchronization mechanism (for example: spinlock) until it receives the initialization proxy generator transferred completely from the slave core Core1. After the main core Core0 receives the initialization proxy generator transferred completely from the slave core Core1, it continues to execute other actions in the action list. If the slave core Core1 transfers the initialization proxy generator to the main core Core0, the main core Core0 does not need any special operation and continues to execute other actions in the action list.

[0063] The embodiment of the present application elegantly solves the problem of cache consistency in inter-core communication through synchronization of the above time points.

[0064] In the specific implementation of the first embodiment of the present application, see Figure 7 , step S1, before that also includes:

[0065] Step S0: Identify hardware modules that can be initialized by slave core agents. Hardware modules that can be initialized by slave core agents are modules whose initialization process does not depend on other modules and whose initialization does not involve strong binding of resources to the master core or any slave core.

[0066] The embodiments of the present application identify hardware modules that can be initialized independently, thereby allocating the initialization of these hardware modules to slave cores for initialization processing, thereby making full use of the slave cores and reducing the initialization time.

[0067] The embodiments of the present application can realize the rapid startup of the classic platform of the automotive open system architecture, and then realize the rapid startup of the electronic control unit. Without affecting the actual vehicle functions, the startup time of the electronic control unit will be greatly shortened, providing a guarantee for the sleep and rapid wake-up of the entire vehicle.

[0068] In the specific implementation of the first embodiment of the present application, the slave core of the present application only executes the initialization of the corresponding module and does not proxy the services of subsequent modules. The startup time of the electronic control unit will be greatly shortened without affecting the overall performance of the system.

[0069] Device

[0070] See also Figure 8 The embodiment of the present application also provides a startup device for a classic platform of an automotive open system architecture, the device comprising:

[0071] The startup module 801 is used to start the master core and the slave core in the early startup period, and initialize the local per-core non-cached static random access memory of the master core and the slave core respectively.

[0072] The processing module 802 is used to allocate at least part of the startup process of the hardware module that can be initialized by the slave core agent to the slave core for initialization processing.

[0073] The transfer module 803 is used to transfer the initialization agent generated by the initialization processing of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core.

[0074] The synchronization module 804 is used to synchronize the time point at which the slave core transfers the initialization agent generated object.

[0075] The embodiments of the present application can realize the rapid startup of the classic platform of the automotive open system architecture, and then realize the rapid startup of the electronic control unit. Without affecting the actual vehicle functions, the startup time of the electronic control unit will be greatly shortened, providing a guarantee for the sleep and rapid wake-up of the entire vehicle.

[0076] Computer storage media

[0077] In this embodiment, a computer-readable storage medium is provided, storing instructions for causing a machine to execute a diagnostic method based on a service-oriented architecture as described herein. Specifically, a system or device equipped with a storage medium can be provided, on which a software program code that implements the functions of any of the above embodiments is stored, and a computer (or CPU or MPU) of the system or device reads and executes the program code stored in the storage medium.

[0078] In this case, the program code read from the storage medium itself can implement the function of any one of the above embodiments, so the program code and the storage medium storing the program code constitute part of the present application.

[0079] The storage medium embodiments for providing the program code include a floppy disk, a hard disk, a magneto-optical disk, an optical disk (such as CD-ROM, CD-R, CD-RW, DVD-ROM, DVD-RAM, DVD-RW, DVD+RW), a magnetic tape, a non-volatile memory card, and a ROM. Alternatively, the program code can be downloaded from a server computer by a communication network.

[0080] Computer program product

[0081] In this embodiment, a computer program product is provided, including computer instructions, which instruct a computing device to perform any corresponding operation in the above-mentioned multiple method embodiments.

[0082] It should be pointed out that, according to the needs of implementation, the various components / steps described in the embodiments of the present application can be split into more components / steps, or two or more components / steps or partial operations of components / steps can be combined into new components / steps to achieve the purpose of the embodiments of the present application.

[0083] The above-mentioned method according to the embodiment of the present application can be implemented in hardware, firmware, or implemented as software or computer code that can be stored in a recording medium (such as a CD ROM, RAM, floppy disk, hard disk or magneto-optical disk), or implemented as a computer code originally stored in a remote recording medium or a non-temporary machine-readable medium downloaded through a network and to be stored in a local recording medium, so that the method described herein can be stored in such software processing on a recording medium using a general-purpose computer, a special-purpose processor or programmable or special-purpose hardware (such as an ASIC or FPGA). It can be understood that a computer, a processor, a microprocessor controller or programmable hardware includes a storage component (e.g., RAM, ROM, flash memory, etc.) that can store or receive software or computer code, and when the software or computer code is accessed and executed by a computer, a processor or hardware, the method described herein is implemented. In addition, when a general-purpose computer accesses the code for implementing the method shown here, the execution of the code converts the general-purpose computer into a special-purpose computer for executing the method shown here.

[0084] It should be noted that in the description of this application, the terms "first" and "second" are only used to facilitate the description of different components or names, and cannot be understood as indicating or implying a sequential relationship, relative importance, or implicitly indicating the number of the indicated technical features. Therefore, the features defined as "first" and "second" may explicitly or implicitly include at least one of the features.

[0085] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as those commonly understood by those skilled in the art to which this application belongs. The terms used herein in the specification of this application are only for the purpose of describing specific embodiments and are not intended to limit this application.

[0086] It should be noted that although the specific embodiments of the present application are described in detail in conjunction with the accompanying drawings, this should not be construed as limiting the scope of protection of the present application. Within the scope described in the claims, various modifications and variations that can be made by those skilled in the art without creative work still fall within the scope of protection of the present application.

[0087] The examples of the embodiments of the present application are intended to concisely illustrate the technical features of the embodiments of the present application so that those skilled in the art can intuitively understand the technical features of the embodiments of the present application, and are not intended to be improper limitations of the embodiments of the present application.

[0088] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit it. Although the present application has been described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. However, these modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the embodiments of the present application.

Claims

1. A method for starting a classic platform of an automotive open system architecture, the method comprising: Starting the master core and the slave core in the early stage of startup, and respectively initializing the local per-core non-cached static random access memory of the master core and the slave core; Allocating at least part of the startup process of the hardware module that can be initialized by the slave core agent to the slave core for initialization processing; Transferring the initialization agent generated by the initialization processing of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core; The time point at which the slave core transfers the initialization agent generated is synchronized.

2. The method according to claim 1, wherein: The method of starting the master core and the slave core in the early stage of startup and respectively initializing the local per-core non-cached static random access memory of the master core and the slave core may also include: Identify a hardware module that can be initialized by the slave core agent, where the hardware module that can be initialized by the slave core agent is a module whose initialization process does not depend on other modules and whose initialization does not involve strong binding of resources to the master core or any of the slave cores.

3. The method according to claim 1 or 2, wherein: The step of allocating at least part of the startup process of the hardware module that can be initialized by the slave core agent to the slave core for initialization processing also includes: Record the starting address of the initialization agent generated by the slave core during the initialization process in the local per-core non-cached static random access memory of the slave core and the storage length of the initialization agent generated.

4. The method according to claim 3, wherein: The transferring of the initialization agent generated by the initialization processing of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core also includes: After transferring the initialization agent generator to the local per-core non-cached static random access memory of the master core, the storage space from the starting address of the local per-core non-cached static random access memory of the slave core where the initialization agent generator is located to the storage length of the initialization agent generator is recycled and reused.

5. The method according to claim 4, wherein: The transferring of the initialization agent generated by the initialization processing of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core includes: If the chip where the master core is located supports global addresses, the master core directly accesses the local per-core non-cached static random access memory of the slave core to obtain the initialization agent generator; Otherwise, the master core uses the non-cached global content as an intermediate storage medium to access the local per-core non-cached static random access memory of the slave core to obtain the initialization agent generator.

6. The method according to claim 5, wherein: The synchronous processing of the time point of transferring the initialization agent generated by the slave core includes: If the slave core does not transfer the initialization proxy generated object to the master core, the master core performs busy waiting through an inter-core synchronization mechanism until the initialization proxy generated object transferred by the slave core is received, and the master core executes other actions in the action list; If the slave core does not transfer the initialization agent product to the master core, the master core executes other actions in the action list.

7. A startup device for a classic platform of an automotive open system architecture, the device comprising: A startup module, used for starting the master core and the slave core in the early stage of startup, and respectively initializing the local per-core non-cached static random access memory of the master core and the slave core; a processing module, configured to allocate at least part of the startup process of the hardware module that can be initialized by the slave core agent to the slave core for initialization processing; A transfer module, used for transferring the initialization proxy generated by the initialization processing of the slave core from the local per-core non-cached static random access memory of the slave core to the local per-core non-cached static random access memory of the master core; The synchronization module is used to synchronize the time point at which the slave core transfers the initialization agent generated product.

8. An electronic device comprising: A processor, a communication interface, a memory and a communication bus, wherein the processor, the memory and the communication interface communicate with each other via the communication bus; The memory is used to store at least one executable instruction, and the executable instruction enables the processor to execute an operation corresponding to the startup method of the automotive open system architecture classic platform as described in any one of claims 1-6.

9. A computer storage medium having a computer program stored thereon, wherein when the program is executed by a processor, the method for starting the automotive open system architecture classic platform as claimed in any one of claims 1 to 6 is implemented.

10. A computer program product, comprising computer instructions, wherein the computer instructions instruct a computing device to execute operations corresponding to the startup method of the automotive open system architecture classic platform according to any one of claims 1 to 6.

Images