CN111563000B - File generation method, intelligent terminal and storage medium - Google Patents
File generation method, intelligent terminal and storage medium Download PDFInfo
- Publication number
- CN111563000B CN111563000B CN202010347465.XA CN202010347465A CN111563000B CN 111563000 B CN111563000 B CN 111563000B CN 202010347465 A CN202010347465 A CN 202010347465A CN 111563000 B CN111563000 B CN 111563000B
- Authority
- CN
- China
- Prior art keywords
- thread
- program
- user program
- file generation
- generation method
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
- G06F11/0706—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment
- G06F11/0715—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment in a system implementing multitasking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
- G06F11/0706—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment
- G06F11/0721—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment within a central processing unit [CPU]
- G06F11/0724—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation the processing taking place on a specific hardware platform or in a specific software environment within a central processing unit [CPU] in a multiprocessor or a multi-core unit
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
- G06F11/0766—Error or fault reporting or storing
- G06F11/0772—Means for error signaling, e.g. using interrupts, exception flags, dedicated error registers
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
- G06F11/0703—Error or fault processing not based on redundancy, i.e. by taking additional measures to deal with the error or fault not making use of redundancy in operation, in hardware, or in data representation
- G06F11/0766—Error or fault reporting or storing
- G06F11/0787—Storage of error reports, e.g. persistent data storage, storage using memory protection
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The application discloses a file generation method, an intelligent terminal and a storage medium, wherein the method comprises the following steps: when a first thread in a plurality of threads in the user program executes an error instruction, the user program triggers the CPU to interrupt so as to execute an interrupt program; the interrupt program searches a first thread for executing the error instruction and records the first thread; the Linux operating system sends the event that the user program executes the error instruction and the ID of the first thread to the user program; and the user program saves the data in the memory address area used by the first thread to a core dump file according to the ID of the first thread. The application only generates the corresponding core dump file for the thread executing the error instruction, greatly reduces the size of the core dump file and is convenient for storing, copying and using the core dump file.
Description
Technical Field
The present application relates to the field of computer applications, and in particular, to a file generating method, an intelligent terminal, and a storage medium.
Background
Linux (kernel of operating system) is a widely used operating system, on which a user's program can be run (for example, a 5G data forwarding plane is used for forwarding a user's data packet in a 5G network, a program implementing the data forwarding plane is called a forwarding program, and this forwarding program may be a user's program), when the user's program executes an erroneous instruction (including the executed instruction being correct but inputting an erroneous parameter), the Linux operating system will be triggered to generate a coredump file, where the coredump file contains information such as dynamic data of all threads of the program when the user's program executes an error; it can be understood that the coredump file is generated by storing the data of all the threads currently running by the user program as a file, and is used for analyzing and positioning the cause of the error of the user program.
It is known that the coredump file stores all memory data during the running of the user program, which results in a coredump file that is very large, usually in the size of several gbytes (e.g., 8 gbytes), and is inconvenient to store, copy, and use such large files.
Accordingly, the prior art is still in need of improvement and development.
Disclosure of Invention
The application mainly aims to provide a file generation method, an intelligent terminal and a storage medium, and aims to solve the problem that a coredump file with large memory is inconvenient to store, copy and use in the prior art.
In order to achieve the above object, the present application provides a file generation method, including the steps of:
when a first thread in a plurality of threads in the user program executes an error instruction, the user program triggers the CPU to interrupt so as to execute an interrupt program;
the interrupt program searches a first thread for executing the error instruction and records the first thread;
the Linux operating system sends the event that the user program executes the error instruction and the ID of the first thread to the user program;
and the user program saves the data in the memory address area used by the first thread to a core dump file according to the ID of the first thread.
Optionally, the file generating method, wherein the user program is composed of a plurality of independent threads.
Optionally, the file generating method, wherein each thread uses a separate memory address area.
Optionally, in the file generating method, the interrupt program is used for controlling the CPU to stop executing the code of the normal program, and jump to execute the code for processing the current emergency.
Optionally, the file generating method, wherein the error instruction includes an instruction to which an error parameter is input.
Optionally, the file generating method, wherein the file generating method further includes:
when a first thread of the plurality of threads in the user program executes an error instruction, the Linux operating system does not directly trigger generation of the core dump file any more.
In addition, to achieve the above object, the present application further provides an intelligent terminal, where the intelligent terminal includes: the file generation device comprises a memory, a processor and a file generation program stored on the memory and capable of running on the processor, wherein the file generation program realizes the steps of the file generation method when being executed by the processor.
In addition, in order to achieve the above object, the present application also provides a storage medium storing a file generation program which, when executed by a processor, implements the steps of the file generation method described above.
In the application, when a first thread in a plurality of threads in a user program executes an error instruction, the user program triggers a CPU to interrupt so as to execute an interrupt program; the interrupt program searches a first thread for executing the error instruction and records the first thread; the Linux operating system sends the event that the user program executes the error instruction and the ID of the first thread to the user program; and the user program saves the data in the memory address area used by the first thread to a core dump file according to the ID of the first thread. The application only generates the corresponding core dump file for the thread executing the error instruction, greatly reduces the size of the core dump file and is convenient for storing, copying and using the core dump file.
Drawings
FIG. 1 is a flow chart of a preferred embodiment of the file generation method of the present application;
FIG. 2 is a schematic diagram of an operating environment of a smart terminal according to a preferred embodiment of the present application.
Detailed Description
In order to make the objects, technical solutions and advantages of the present application more clear and clear, the present application will be further described in detail below with reference to the accompanying drawings and examples. It should be understood that the specific embodiments described herein are for purposes of illustration only and are not intended to limit the scope of the application.
As shown in FIG. 1, the file generation method according to the preferred embodiment of the present application comprises the following steps:
step S10, when a first thread in a plurality of threads in the user program executes an error instruction, the user program triggers the CPU to interrupt so as to execute an interrupt program.
Specifically, the user program can run multiple threads (the thread is the minimum unit of the operation system capable of carrying out operation scheduling, is contained in a process and is the actual operation unit in the process, one thread refers to a single-sequence control flow in the process, multiple threads can be concurrent in one process, each thread can execute different tasks in parallel, the benefit of using multithreaded programming on a multi-core or multi-CPU or a CPU supporting Hyper-threading is obvious, namely, the execution throughput of the program is improved, the multithreading technology is used on a single-CPU single-core computer, the part which is always blocked due to I/O processing and man-machine interaction in the process can be executed separately from the part which is usually blocked in the process, and the special workhorse thread is written to execute intensive computation, so that the execution efficiency of the program is improved.
The first thread refers to one of multiple threads (may be any thread in the multiple threads), that is, when a certain thread of a user program executes an error instruction, a CPU is triggered to interrupt at this time, an interrupt program (also referred to as an interrupt service program, a processor processes an "urgent part" and can be understood as a service, which is implemented by executing a specific program programmed in advance, and this process the "urgent part" is referred to as an interrupt service program, when the CPU is processing internal data, an emergency situation occurs in the outside, and the CPU is required to suspend the current operation to process the emergency, and return to the address where the CPU was originally interrupted after the processing is completed, so as to continue the original operation.
The interrupt program is used for controlling the CPU to stop executing the normal code of the program, and the code for processing the current emergency is skipped to execute, namely, when a certain emergency (for example, an error instruction is executed here), the CPU stops executing the normal code of the program, and the code for processing the emergency is skipped to execute.
Wherein the error instruction includes an instruction to which an error parameter is input. For example, there is 8Gbyte in the memory and the address range is 0-8Gbyte, if an instruction reads the data in the memory with 9Gbyte, this is the wrong instruction, and the blue screen of the windows system is often the result of this wrong instruction.
Step S20, the interrupt program searches and records a first thread executing the error instruction.
Specifically, when the user program triggers a CPU interrupt, after executing the interrupt program, the interrupt program searches for and records the first thread that executes the erroneous instruction (i.e., a thread that executed the erroneous instruction).
Step S30, the Linux operating system sends the event that the user program executes the error instruction and the ID of the first thread to the user program.
Specifically, the Linux operating system (which is a multi-user, multi-task, multi-thread and multi-CPU supporting operating system based on POSIX and Unix; linux is not only stable in system performance, but also is open source software, and a core firewall component of the Linux is efficient in performance and simple in configuration, so that the safety of the system is guaranteed, in many enterprise networks, linux is not only used as a server by network operators for pursuing speed and safety, linux can be used as a server and can also be used as a network firewall), and an event that a user program executes an erroneous instruction and an ID (each thread corresponds to a special ID) of the thread (namely, a certain thread executing the erroneous instruction) are sent to the user program.
Step S40, the user program stores the data in the memory address area used by the first thread into the core dump file according to the ID of the first thread.
Specifically, the user program saves only the data in the memory address area used by the thread (i.e., the thread that executed the erroneous instruction) (each thread uses a separate memory address area) to the core dump file (i.e., coredump file) according to the thread ID (i.e., the thread that executed the erroneous instruction). Further, when a plurality of threads execute wrong instructions, the method is executed one by one according to the sequence.
The Linux operating system sends the event that the user program executes the error instruction and the thread ID to the user program, because only the user program knows which memory addresses are used when the thread runs, and the user program only saves the data of the memory addresses used by the thread to the coredump file.
For example, the user program created 10 threads, thread 1, thread 2, thread 3, thread 4, thread 5, thread 6, thread 7, thread 8, thread 9, thread 10, respectively. Each thread uses independent memory address area 1, memory address area 2, memory address area 3, memory address area 4, memory address area 5, memory address area 6, memory address area 7, memory address area 8, memory address area 9, and memory address area 10, one corresponding to each thread. When the thread 2 executes the error instruction, the Linux operating system sends the event that the user program executes the error instruction and the ID of the thread 2 to the user program, and the user program only saves the data in the memory address area 2 used by the thread 2 to the coredump file (i.e., core dump file).
When a certain thread of the user program executes the error instruction, the Linux operating system is not directly triggered to generate the coredump file (the Linux operating system can not distinguish which data are the data which cannot be used by the thread and can only store all data by one brain), but after the thread ID for executing the error instruction is found out, the event for executing the error instruction and the thread ID are transmitted to the user program for processing, and the user program only stores the data in the memory address area used by the thread into the coredump file according to the thread ID.
Further, as shown in fig. 2, based on the file generation method, the present application further provides an intelligent terminal, which includes a processor 10, a memory 20 and a display 30. Fig. 2 shows only some of the components of the intelligent terminal, but it should be understood that not all of the illustrated components are required to be implemented, and more or fewer components may alternatively be implemented.
The memory 20 may in some embodiments be an internal storage unit of the smart terminal, such as a hard disk or a memory of the smart terminal. The memory 20 may also be an external storage device of the Smart terminal in other embodiments, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash memory Card (Flash Card) or the like. Further, the memory 20 may also include both an internal storage unit and an external storage device of the smart terminal. The memory 20 is used for storing application software installed in the intelligent terminal and various data, such as program codes for installing the intelligent terminal. The memory 20 may also be used to temporarily store data that has been output or is to be output. In one embodiment, the memory 20 has stored thereon a file generation program 40, the file generation program 40 being executable by the processor 10 to implement the file generation method of the present application.
The processor 10 may in some embodiments be a central processing unit (CentralProcessing Unit, CPU), microprocessor or other file generating chip for executing program code or processing data stored in the memory 20, e.g. performing the file generating method, etc.
The display 30 may be an LED display, a liquid crystal display, a touch-sensitive liquid crystal display, an OLED (Organic Light-Emitting Diode) touch, or the like in some embodiments. The display 30 is used for displaying information on the intelligent terminal and for displaying a visual user interface. The components 10-30 of the intelligent terminal communicate with each other via a system bus.
In one embodiment, the following steps are implemented when the processor 10 executes the file generation program 40 in the memory 20:
when a first thread in a plurality of threads in the user program executes an error instruction, the user program triggers the CPU to interrupt so as to execute an interrupt program;
the interrupt program searches a first thread for executing the error instruction and records the first thread;
the Linux operating system sends the event that the user program executes the error instruction and the ID of the first thread to the user program;
and the user program saves the data in the memory address area used by the first thread to a core dump file according to the ID of the first thread.
The user program is made up of a plurality of independent threads.
Each thread uses a separate memory address area.
The interrupt program is used for controlling the CPU to stop executing the normal codes of the program and jumping to execute the codes for processing the current emergency.
The error instruction includes an instruction to which an error parameter is input.
The file generation method further comprises the following steps:
when a first thread of the plurality of threads in the user program executes an error instruction, the Linux operating system does not directly trigger generation of the core dump file any more.
The present application also provides a storage medium storing a file generation program which, when executed by a processor, implements the steps of the file generation method described above.
In summary, the present application provides a file generation method, an intelligent terminal and a storage medium, where the method includes: when a first thread in a plurality of threads in the user program executes an error instruction, the user program triggers the CPU to interrupt so as to execute an interrupt program; the interrupt program searches a first thread for executing the error instruction and records the first thread; the Linux operating system sends the event that the user program executes the error instruction and the ID of the first thread to the user program; and the user program saves the data in the memory address area used by the first thread to a core dump file according to the ID of the first thread. The application only generates the corresponding core dump file for the thread executing the error instruction, greatly reduces the size of the core dump file and is convenient for storing, copying and using the core dump file.
Of course, those skilled in the art will appreciate that implementing all or part of the above-described methods may be implemented by a computer program for instructing relevant hardware (such as a processor, a controller, etc.), where the program may be stored in a computer-readable storage medium, and where the program may include the steps of the above-described method embodiments when executed. The storage medium may be a memory, a magnetic disk, an optical disk, or the like.
It is to be understood that the application is not limited in its application to the examples described above, but is capable of modification and variation in light of the above teachings by those skilled in the art, and that all such modifications and variations are intended to be included within the scope of the appended claims.
Claims (6)
1. A file generation method, characterized in that the file generation method comprises:
when a first thread in a plurality of threads in the user program executes an error instruction, the user program triggers the CPU to interrupt so as to execute an interrupt program;
the interrupt program searches a first thread for executing the error instruction and records the first thread;
the Linux operating system sends the event that the user program executes the error instruction and the ID of the first thread to the user program;
the user program stores the data in the memory address area used by the first thread into a core dump file according to the ID of the first thread;
the user program consists of a plurality of independent threads; each thread uses a separate memory address area.
2. The file generation method according to claim 1, wherein the interrupt program is for controlling the CPU to stop executing the code normally of the program, and to jump to execute the code for handling the current emergency.
3. The file generation method according to claim 1, wherein the error instruction includes an instruction to which an error parameter is input.
4. The file generation method according to claim 1, characterized in that the file generation method further comprises:
when a first thread of the plurality of threads in the user program executes an error instruction, the Linux operating system does not directly trigger generation of the core dump file any more.
5. An intelligent terminal, characterized in that, the intelligent terminal includes: memory, a processor and a file generation program stored on the memory and executable on the processor, which when executed by the processor, implements the steps of the file generation method as claimed in any one of claims 1 to 4.
6. A storage medium storing a file generation program which, when executed by a processor, implements the steps of the file generation method of any one of claims 1 to 4.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010347465.XA CN111563000B (en) | 2020-04-28 | 2020-04-28 | File generation method, intelligent terminal and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010347465.XA CN111563000B (en) | 2020-04-28 | 2020-04-28 | File generation method, intelligent terminal and storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111563000A CN111563000A (en) | 2020-08-21 |
| CN111563000B true CN111563000B (en) | 2023-08-18 |
Family
ID=72071832
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010347465.XA Active CN111563000B (en) | 2020-04-28 | 2020-04-28 | File generation method, intelligent terminal and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111563000B (en) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113220495B (en) * | 2021-05-24 | 2024-04-16 | 浙江大华技术股份有限公司 | Method and device for processing process abnormal event, electronic equipment and storage medium |
Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101989322A (en) * | 2010-11-19 | 2011-03-23 | 北京安天电子设备有限公司 | Method and system for automatically extracting memory features of malicious code |
| CN107357731A (en) * | 2017-07-17 | 2017-11-17 | 福建星瑞格软件有限公司 | Process produces monitoring, analysis and the processing method of core dump problems |
| CN109445877A (en) * | 2018-09-19 | 2019-03-08 | 珠海金山网络游戏科技有限公司 | A method of detection game server multithreading uses same virtual machine |
| CN109582542A (en) * | 2018-12-04 | 2019-04-05 | 中国航空工业集团公司西安航空计算技术研究所 | A kind of method of core of embedded system dump |
| CN110109770A (en) * | 2019-05-06 | 2019-08-09 | Oppo广东移动通信有限公司 | Adjustment method, device, electronic equipment and medium |
| CN110147294A (en) * | 2019-05-23 | 2019-08-20 | Oppo广东移动通信有限公司 | Acquisition methods, device, terminal and the computer readable storage medium of Debugging message |
| CN110262918A (en) * | 2019-06-19 | 2019-09-20 | 深圳市网心科技有限公司 | Process collapses analysis method and device, distributed apparatus and storage medium |
| CN110727566A (en) * | 2019-09-05 | 2020-01-24 | 北京字节跳动网络技术有限公司 | Method, device, medium and electronic equipment for acquiring process crash information |
| CN110928720A (en) * | 2020-02-10 | 2020-03-27 | 北京安博通科技股份有限公司 | Core dump file generation method and device based on Linux system |
Family Cites Families (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US9015534B2 (en) * | 2012-11-08 | 2015-04-21 | Dell Products L.P. | Generation of memory dump of a computer process without terminating the computer process |
-
2020
- 2020-04-28 CN CN202010347465.XA patent/CN111563000B/en active Active
Patent Citations (9)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN101989322A (en) * | 2010-11-19 | 2011-03-23 | 北京安天电子设备有限公司 | Method and system for automatically extracting memory features of malicious code |
| CN107357731A (en) * | 2017-07-17 | 2017-11-17 | 福建星瑞格软件有限公司 | Process produces monitoring, analysis and the processing method of core dump problems |
| CN109445877A (en) * | 2018-09-19 | 2019-03-08 | 珠海金山网络游戏科技有限公司 | A method of detection game server multithreading uses same virtual machine |
| CN109582542A (en) * | 2018-12-04 | 2019-04-05 | 中国航空工业集团公司西安航空计算技术研究所 | A kind of method of core of embedded system dump |
| CN110109770A (en) * | 2019-05-06 | 2019-08-09 | Oppo广东移动通信有限公司 | Adjustment method, device, electronic equipment and medium |
| CN110147294A (en) * | 2019-05-23 | 2019-08-20 | Oppo广东移动通信有限公司 | Acquisition methods, device, terminal and the computer readable storage medium of Debugging message |
| CN110262918A (en) * | 2019-06-19 | 2019-09-20 | 深圳市网心科技有限公司 | Process collapses analysis method and device, distributed apparatus and storage medium |
| CN110727566A (en) * | 2019-09-05 | 2020-01-24 | 北京字节跳动网络技术有限公司 | Method, device, medium and electronic equipment for acquiring process crash information |
| CN110928720A (en) * | 2020-02-10 | 2020-03-27 | 北京安博通科技股份有限公司 | Core dump file generation method and device based on Linux system |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111563000A (en) | 2020-08-21 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| Yang | Avoiding pitfalls when using NVIDIA GPUs for real-time tasks in autonomous systems | |
| US6886081B2 (en) | Method and tool for determining ownership of a multiple owner lock in multithreading environments | |
| US8161453B2 (en) | Method and apparatus for implementing task management of computer operations | |
| US20120324454A1 (en) | Control Flow Graph Driven Operating System | |
| RU2286595C2 (en) | Method for realization of computer multi-task system through virtual organization of thread processing | |
| US8136097B2 (en) | Thread debugging device, thread debugging method and information storage medium | |
| US7971205B2 (en) | Handling of user mode thread using no context switch attribute to designate near interrupt disabled priority status | |
| JPH0683634A (en) | Fault detecting method | |
| JPH11353196A (en) | Governor for time-scheduled process management | |
| CN102567090B (en) | The method and system of execution thread is created in computer processor | |
| US9250960B2 (en) | Planning execution of tasks with dependency resolution | |
| US10417011B2 (en) | Thread-agile execution of dynamic programming language programs | |
| US8756583B2 (en) | Thread-specific event management in a non-stop debugging environment | |
| JP6401235B2 (en) | Operating system support for contracts | |
| Schneider et al. | Migration of automotive real-time software to multicore systems: First steps towards an automated solution | |
| CN111563000B (en) | File generation method, intelligent terminal and storage medium | |
| US7080374B2 (en) | System and method for using native code interpretation to move threads to a safe state in a run-time environment | |
| US9229716B2 (en) | Time-based task priority boost management using boost register values | |
| Resmerita et al. | Applying real-time programming to legacy embedded control software | |
| KR20130051076A (en) | Method and apparatus for scheduling application program | |
| Duell et al. | Requirements for linux checkpoint/restart | |
| US7877629B2 (en) | Facilitating handling of exceptions in a program implementing a M-on-N threading model | |
| WO2013165460A1 (en) | Control flow graph driven operating system | |
| JP5678347B2 (en) | IT system configuration method, computer program thereof, and IT system | |
| JP2019185423A (en) | Execution method for application |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| TA01 | Transfer of patent application right |
Effective date of registration: 20230609 Address after: 518057 area a, 5th floor, Caixun technology building, 3176 Keyuan South Road, Gaoxin community, Yuehai street, Nanshan District, Shenzhen City, Guangdong Province Applicant after: Shenzhen Zhenyou Software Technology Co.,Ltd. Address before: 518057 5 / F and 6 / F, Caixun technology building, 3176 Keyuan South Road, high tech community, Yuehai street, Nanshan District, Shenzhen City, Guangdong Province Applicant before: SHENZHEN GENEW TECHNOLOGY Co.,Ltd. |
|
| TA01 | Transfer of patent application right | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |