KR20230167901A - Time correction method to ensure periodicity of multi-threaded programs - Google Patents

Time correction method to ensure periodicity of multi-threaded programs Download PDF

Info

Publication number
KR20230167901A
KR20230167901A KR1020220068122A KR20220068122A KR20230167901A KR 20230167901 A KR20230167901 A KR 20230167901A KR 1020220068122 A KR1020220068122 A KR 1020220068122A KR 20220068122 A KR20220068122 A KR 20220068122A KR 20230167901 A KR20230167901 A KR 20230167901A
Authority
KR
South Korea
Prior art keywords
time
cycle
thread
execution
timer
Prior art date
Application number
KR1020220068122A
Other languages
Korean (ko)
Inventor
변무광
Original Assignee
엘에스일렉트릭(주)
Priority date (The priority date 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 date listed.)
Filing date
Publication date
Application filed by 엘에스일렉트릭(주) filed Critical 엘에스일렉트릭(주)
Priority to KR1020220068122A priority Critical patent/KR20230167901A/en
Publication of KR20230167901A publication Critical patent/KR20230167901A/en

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/46—Multiprogramming arrangements
    • G06F9/48—Program initiating; Program switching, e.g. by interrupt
    • G06F9/4806—Task transfer initiation or dispatching
    • G06F9/4812—Task transfer initiation or dispatching by interrupt, e.g. masked
    • G06F9/4831—Task transfer initiation or dispatching by interrupt, e.g. masked with variable priority
    • G06F9/4837—Task transfer initiation or dispatching by interrupt, e.g. masked with variable priority time dependent
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F1/00—Details not covered by groups G06F3/00 - G06F13/00 and G06F21/00
    • G06F1/04—Generating or distributing clock signals or signals derived directly therefrom
    • G06F1/14—Time supervision arrangements, e.g. real time clock
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003—Arrangements for executing specific machine instructions
    • G06F9/30076—Arrangements for executing specific machine instructions to perform miscellaneous control operations, e.g. NOP
    • G06F9/3009—Thread control instructions
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3851—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution from multiple instruction streams, e.g. multistreaming

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Multimedia (AREA)
  • Executing Machine-Instructions (AREA)

Abstract

본 발명은 멀티 스레드 프로그램의 실행 주기 보정 방법에 관한 것으로, a) 스레드 수행의 주기를 설정하는 단계와, b) 스레드 수행시 하드웨어 타이머의 시간 정보를 저장한 CPU의 타이머 레지스터 값을 확인하고, 현재 타이머 레지스터 값과 이전 타이머 레지스터 값의 차인 시간의 차를 구하는 단계와, c) 상기 b) 단계에서 구한 시간의 차를 설정된 상기 주기와 비교하여 지연 발생 여부를 확인하는 단계와, d) 지연이 발생한 경우 주기 시간을 보정하는 단계를 포함할 수 있다.The present invention relates to a method for correcting the execution cycle of a multi-threaded program, which includes a) setting the cycle of thread execution, b) checking the timer register value of the CPU that stores the time information of the hardware timer when the thread is executed, and calculating the time difference between the timer register value and the previous timer register value; c) comparing the time difference obtained in step b) with the set period to determine whether a delay has occurred; and d) determining whether a delay has occurred. In this case, a step of correcting the cycle time may be included.

Description

멀티 스레드 프로그램의 실행 주기 보정 방법{Time correction method to ensure periodicity of multi-threaded programs}{Time correction method to ensure periodicity of multi-threaded programs}

본 발명은 멀티 스레드 프로그램의 실행 주기 보정 방법에 관한 것으로, 더 상세하게는 주기 관리를 위한 시간 보정의 오버 헤드(Over Head)를 줄일 수 있는 방법에 관한 것이다.The present invention relates to a method for correcting the execution cycle of a multi-threaded program, and more specifically, to a method for reducing the overhead of time correction for cycle management.

일반적으로, PLC 등 OS 기반의 플랫폼에서 프로그램을 수행하는 설비들은, 멀티 스레드(Thread)를 지원한다. In general, equipment that executes programs on OS-based platforms such as PLCs support multi-threads.

멀티 스레드는, RTOS, Linux, Windows와 같은 OS기반의 플랫폼에서 구동되는 프로그램으로 수행되어야 하는 작업을, 다수의 실행 단위로 구분하여 CPU 및 자원을 효율적으로 사용할 수 있도록 한다.Multi-threading allows efficient use of CPU and resources by dividing tasks to be performed by programs running on OS-based platforms such as RTOS, Linux, and Windows into multiple execution units.

스레드는 완전한 하나의 프로그램이 실행되는 프로세스와 다르게 부모 프로세스의 전체 복사본을 만들지 않고, 필요한 코드들만 생성하여 동시에 수행한다.Unlike a process in which a complete program is executed, a thread does not create a complete copy of the parent process, but creates only the necessary code and executes it simultaneously.

멀티 스레드는, 개별 스레드의 작업이 병렬처리 되도록 구현될 수 있다.Multi-threading can be implemented so that the work of individual threads is processed in parallel.

스레드는 우선순위(priority) 또는 타임 슬라이싱(time slicing) 기법 등에 의해 주기적으로 수행되며, 우선순위가 낮은 스레드 수행이 가능하도록 슬립(sleep) 함수 호출 등의 방법을 통해 CPU 및 자원을 특정 스레드가 독점하지 않도록 구현된다.Threads are executed periodically using priority or time slicing techniques, and the CPU and resources are monopolized by a specific thread through methods such as calling the sleep function to enable execution of low-priority threads. It is implemented so as not to do so.

정밀한 주기로 제어를 하는 프로그램의 경우 각 스레드의 주기적인 수행이 필수적이며, 스레드의 실행시간을 최소화하여 프로그램의 실시간성을 보장해야 한다. 하지만, 인터럽트 중첩, 스케쥴링 지연 등 다양한 예측하기 어려운 요인으로 인해 주기적인 스레드 실행이 일시적으로 불가할 수 있으며, 최악의 경우 비 주기적인 스레드 실행의 누적으로 인해 프로그램이 구동 불가한 상태가 될 수 있다.In the case of a program that is controlled at a precise cycle, periodic execution of each thread is essential, and the real-time performance of the program must be guaranteed by minimizing the execution time of the thread. However, periodic thread execution may be temporarily impossible due to various difficult-to-predict factors such as interrupt overlap and scheduling delays, and in the worst case, the program may become unrunable due to accumulation of aperiodic thread execution.

이와 같은 스레드의 처리에 대하여, 공개특허 10-2002-0035603(2002년 5월 11일 공개, 컴퓨터 운영 시스템에서 시분하된 애플리케이션 스케쥴링 방법)에는 시분할 시스템이 기재되어 있다.Regarding the processing of such threads, a time-sharing system is described in Publication Patent No. 10-2002-0035603 (published May 11, 2002, time-sharing application scheduling method in a computer operating system).

위의 공개특허에는 운영 시스템에 의해 사용되는 시간은 소비된 결과의 프로세서 시간을 운영 시스템 오버헤드로 간주하기 보다는 어플리케이션 프로세싱 시간으로 취급하는 기술이 기재되어 있다. The above published patent describes a technique in which the time used by the operating system is treated as application processing time rather than considering the resulting processor time consumed as operating system overhead.

이처럼 멀티 스레드의 수행을 위해서는 프로세싱 기간을 정하고, 해당 프로세싱 기간에 순위에 따라 스레드를 수행하고 있다.In order to perform multi-threading like this, a processing period is set, and threads are executed according to their ranks during that processing period.

그러나 다양한 원인에 의한 지연의 발생시, 설정된 프로세싱 주기에 이상이 발생하며, 이를 수정할 수 있는 기법이 요구되었다.However, when delays occur due to various causes, an error occurs in the set processing cycle, and a technique to correct this is required.

이하에서는, 종래 실행 주기와 실행 주기 보정 방법에 대하여 좀 더 구체적으로 설명한다.Below, the conventional execution cycle and execution cycle correction method will be described in more detail.

도 1은 종래 타이머 인터럽트를 이용한 주기 스레드 실행 과정의 예시도이다.Figure 1 is an exemplary diagram of a periodic thread execution process using a conventional timer interrupt.

도 1을 참조하면, 프로세스의 수행 주기를 설정하고, 각 수행 주기마다 정해진 스레드를 수행한다.Referring to Figure 1, the performance cycle of the process is set, and a designated thread is executed for each performance cycle.

좀 더 구체적으로, 타이머 인터럽트(timer interrupt)를 이용한 주기 스레드 실행 방법은, 중앙처리장치(CPU)의 하드웨어 자원인 타이머를 이용하여 일정 주기의 시간이 경과되면 인터럽트를 발생시켜, 인터럽트 처리함수에서 특정 동작을 수행시킬 수 있다.More specifically, the periodic thread execution method using a timer interrupt generates an interrupt when a certain period of time has elapsed using a timer, which is a hardware resource of the central processing unit (CPU), and executes a specific interrupt in the interrupt processing function. Actions can be performed.

인터럽트 처리함수에서 오랜 시간이 소요되는 동작을 실행할 경우 전체적인 시스템의 실시간 성능이 낮아지므로, 직접 동작을 수행하지 않고 주기 스레드를 깨우는 이벤트(event)를 전송하는 형태 구현된다. If an operation that takes a long time is performed in the interrupt processing function, the real-time performance of the overall system is lowered, so it is implemented by sending an event that wakes up the periodic thread without performing the operation directly.

도 1의 네 번째 주기(P4)에 도시한 바와 같이 다른 인터럽트 및 우선순위가 높은 스레드가 CPU를 선점하여 스케쥴링 지연(Latency)이 발생할 수 있다.As shown in the fourth cycle (P4) of FIG. 1, other interrupts and high-priority threads may preempt the CPU, resulting in scheduling latency.

스케쥴링 지연 발생시 일시적으로 스레드의 주기성이 훼손되며, 따라서 프로세스의 지연이 발생되고, 다음 타이머 인터럽트 발생 전까지 처리가 완료되지 않을 경우 연속적으로 처리를 수행하여 CPU를 일시적으로 독점하는 문제를 유발시킨다.When a scheduling delay occurs, the periodicity of the thread is temporarily damaged, resulting in a delay in the process, and if processing is not completed before the next timer interrupt occurs, processing is performed continuously, causing a problem of temporarily monopolizing the CPU.

이는 단순히 작업을 주기적으로 실행할 수 없는 문제가 아닌 전체적인 시스템의 안정성이 저하될 수 있는 원인이 된다.This is not simply a problem where tasks cannot be executed periodically, but it can cause the stability of the overall system to deteriorate.

도 2는 슬립 함수를 이용한 주기 스레드 실행의 시간 보정 전 예시도이다.Figure 2 is an example diagram before time correction of periodic thread execution using a sleep function.

도 2를 참조하면, 설정된 주기에 스레드를 실행하되, 해당 주기에서 스레드의 실행이 완료되면 슬립(Sleep) 함수에 따라 다른 주기까지 슬립 상태를 유지하도록 구성된다.Referring to FIG. 2, a thread is executed in a set cycle, but when execution of the thread is completed in that cycle, the sleep state is maintained until another cycle according to a sleep function.

슬립 함수를 이용한 구현은 여러 방법이 있으며, 도 2에 도시한 예는 스레드 시작 시점에서 OS에 의해 관리되는 시간인 시스템 시간(SYSTEM_TIME)을 읽고, 수행 작업(Processing)을 처리 후, 기 획득한 시스템 시간으로부터 주기 종료 이후 스레드가 깨어나도록 구현한 예를 나타낸다.There are several ways to implement the sleep function, and the example shown in Figure 2 reads the system time (SYSTEM_TIME), which is the time managed by the OS at the start of the thread, processes the work to be performed, and This shows an example of implementing a thread to wake up after the end of the cycle from time to time.

도 2에서 세 번째 주기(P3)에 도시한 바와 같이 다양한 원인에 의하여 지연이 발생한 경우, 역시 스레드의 주기성이 훼손될 수 있으며, 처리 지연에 의해 슬립 함수의 실행 시점이 경과되어 특정한 스레드가 CPU를 독점하는 연속 처리 문제를 발생시킨다.As shown in the third cycle (P3) in FIG. 2, when a delay occurs due to various reasons, the periodicity of the thread may be damaged, and the execution time of the sleep function has passed due to processing delay, causing a specific thread to use the CPU. It causes monopolistic continuous processing problems.

이와 같은 문제점을 해결하기 위하여 종래에는 슬립 함수의 실행 전 시간을 확인하는 방법을 사용한다.To solve this problem, a method of checking the time before execution of the sleep function is conventionally used.

도 3은 슬립 함수를 이용한 주기 스레드 실행에 시간 보정이 더해진 예시도이다.Figure 3 is an example of time correction added to periodic thread execution using a sleep function.

종래에는 지연이 발생한 이후, 특정 스레드의 CPU 독점을 방지하기 위하여 슬립 함수의 호출 전 현재 시간을 확인하여, 슬립 시간을 다시 산정한다.Conventionally, after a delay occurs, the sleep time is recalculated by checking the current time before calling the sleep function to prevent a specific thread from monopolizing the CPU.

이를 좀 더 구체적으로 설명하면, 첫 번째 주기(P1)와 같이 스레드를 수행한 후(Processing), 시스템 시간을 확인(get time)하는 과정을 수행한다.To explain this in more detail, after executing the thread as in the first cycle (P1) (processing), the process of checking the system time (get time) is performed.

이처럼 시스템 시간을 확인하는 과정은 두 번째 주기(P2)에서의 스레드 수행으 호출 시점 경과 여부를 확인한다.In this way, the process of checking the system time checks whether the time of calling the thread execution in the second cycle (P2) has elapsed.

세 번째 주기(P3)에서 우선순위가 높은 다른 스레드 및 인터럽트 등의 처리 지연이 발생하여, 스레드의 호출이 지연됨을 도시하였으며, 네 번째 주기에서 프로세싱이 완료된 상태를 도시하였다.In the third cycle (P3), there is a delay in processing other threads and interrupts with high priority, and the call of the thread is delayed. In the fourth cycle, processing is completed.

네 번째 주기(P4)에서 시간 확인 과정을 통해 지연이 발생함을 확인하고, 연속적인 처리로 인한 CPU 자원 독점을 피하기 위하여 네 번째 주기에서 실행되어야 할 스레드의 프로세싱이 다섯 번째 주기(P5)에서 실행되도록 시간을 보정하게 된다.In the fourth cycle (P4), it is confirmed that a delay occurs through a time check process, and the processing of threads that should be executed in the fourth cycle is executed in the fifth cycle (P5) to avoid monopolization of CPU resources due to continuous processing. Correct the time as much as possible.

이와 같은 종래 시간 보정 기법은 구현이 용이한 반면, 매 프로세싱 마다 시간 확인 함수를 호출해야 하는 단점이 있다.While this conventional time correction technique is easy to implement, it has the disadvantage of having to call a time check function for each processing.

통상 OS에 의해 관리되는 소프트웨어 시간 확인 함수는 함수 호출단계가 많고, OS 내부 구현에 따라 동작이 상이하여 함수 호출에 따른 오버헤드가 많이 발생하게 된다.Typically, the software time check function managed by the OS has many function call steps, and its operation varies depending on the internal implementation of the OS, resulting in a lot of overhead due to function calls.

따라서 종래의 시간 보정 기법은 CPU 오버헤드를 유발하기 때문에 실시간 처리를 요구하는 시스템에 적용이 어렵다는 문제점이 있었다.Therefore, the conventional time correction technique has the problem of being difficult to apply to systems that require real-time processing because it causes CPU overhead.

상기와 같은 종래 기술의 문제점을 감안한 본 발명이 해결하고자 하는 과제는, CPU 오버헤드를 최소화할 수 있는 멀티 스레드 프로그램의 실행 주기 보정 방법을 제공함에 있다.The problem to be solved by the present invention in consideration of the problems of the prior art as described above is to provide a method for correcting the execution cycle of a multi-threaded program that can minimize CPU overhead.

상기와 같은 기술적 과제를 해결하기 위한 본 발명 멀티 스레드 프로그램의 실행 주기 보정 방법은, a) 스레드 수행의 주기를 설정하는 단계와, b) 스레드 수행시 하드웨어 타이머의 시간 정보를 저장한 CPU의 타이머 레지스터 값을 확인하고, 현재 타이머 레지스터 값과 이전 타이머 레지스터 값의 차인 시간의 차를 구하는 단계와, c) 상기 b) 단계에서 구한 시간의 차를 설정된 상기 주기와 비교하여 지연 발생 여부를 확인하는 단계와, d) 지연이 발생한 경우 주기 시간을 보정하는 단계를 포함할 수 있다.The method for correcting the execution cycle of a multi-threaded program of the present invention to solve the above technical problem includes a) setting the cycle of thread execution, and b) a timer register of the CPU storing time information of a hardware timer when the thread is executed. Checking the value, calculating the time difference between the current timer register value and the previous timer register value, c) comparing the time difference obtained in step b) with the set period to check whether a delay has occurred; , d) may include the step of correcting the cycle time when a delay occurs.

본 발명의 실시 예에서, 상기 d) 단계는, 상기 c) 단계에서 지연이 발생한 것으로 판단된 경우, 현재 주기의 스레드 프로세싱이 완료된 시점이 다음 주기의 웨이크 업 시간을 경과했을 때 주기 시간을 보정할 수 있다.In an embodiment of the present invention, in step d), if it is determined that a delay has occurred in step c), the cycle time is corrected when the thread processing of the current cycle is completed and the wake-up time of the next cycle has passed. You can.

본 발명의 실시 예에서, 상기 a) 단계는, OS의 커널을 통해 제공되는 시스템 시간에 기초하여 주기를 설정할 수 있다.In an embodiment of the present invention, step a) may set the cycle based on the system time provided through the kernel of the OS.

본 발명의 실시 예에서, 상기 c) 단계는, 시간의 차가 설정된 주기와 임계값의 합보다 큰 경우 지연 발생으로 판단할 수 있다.In an embodiment of the present invention, in step c), if the time difference is greater than the sum of the set period and the threshold, it may be determined that a delay has occurred.

본 발명의 실시 예에서, 상기 임계값은, 설정된 상기 주기의 10 내지 20%일 수 있다.In an embodiment of the present invention, the threshold may be 10 to 20% of the set period.

본 발명은, 주기적으로 수행되는 스레드의 주기성이 훼손된 즉시 검지하여 이후 주기에서는 다시 스레드의 주기성을 회복할 수 있도록 시간을 보정하되, CPU의 하드웨어 타이머를 이용하여 스레드의 주기성을 확인함으로써, 주기성 확인 과정의 오버헤드를 최소화할 수 있는 효과가 있다.The present invention detects as soon as the periodicity of a periodically executed thread is damaged and corrects the time so that the periodicity of the thread can be restored in the next cycle. By checking the periodicity of the thread using the hardware timer of the CPU, the periodicity confirmation process is performed. It has the effect of minimizing overhead.

오버헤드를 줄임에 따라 본 발명은 실시간 프로세싱이 요구되는 시스템에 적용 가능한 효과가 있다.By reducing overhead, the present invention has the effect of being applicable to systems requiring real-time processing.

도 1은 종래 타이머 인터럽트를 이용한 주기 스레드 실행 과정의 예시도이다.
도 2는 슬립 함수를 이용한 주기 스레드 실행의 시간 보정 전 예시도이다.
도 3은 슬립 함수를 이용한 주기 스레드 실행에 시간 보정이 더해진 예시도이다.
도 4는 본 발명의 바람직한 실시 예의 멀티 스레드 프로그램의 실행 주기 보정 방법의 순서도이다.
도 5는 도 4가 적용되는 시스템 개념 블록 구성도이다.
도 6은 본 발명에 따라 스레드 실행 및 시간 보정의 흐름 예시도이다.Figure 1 is an exemplary diagram of a periodic thread execution process using a conventional timer interrupt.
Figure 2 is an example diagram before time correction of periodic thread execution using a sleep function.
Figure 3 is an example of time correction added to periodic thread execution using a sleep function.
Figure 4 is a flowchart of a method for correcting the execution cycle of a multi-threaded program according to a preferred embodiment of the present invention.
Figure 5 is a system concept block diagram to which Figure 4 is applied.
Figure 6 is an exemplary flow diagram of thread execution and time correction according to the present invention.

본 발명의 구성 및 효과를 충분히 이해하기 위하여, 첨부한 도면을 참조하여 본 발명의 바람직한 실시예들을 설명한다. 그러나 본 발명은 이하에서 개시되는 실시예에 한정되는 것이 아니라, 여러가지 형태로 구현될 수 있고 다양한 변경을 가할 수 있다. 단지, 본 실시예에 대한 설명은 본 발명의 개시가 완전하도록 하며, 본 발명이 속하는 기술분야의 통상의 지식을 가진 자에게 발명의 범주를 완전하게 알려주기 위하여 제공되는 것이다. 첨부된 도면에서 구성요소는 설명의 편의를 위하여 그 크기를 실제보다 확대하여 도시한 것이며, 각 구성요소의 비율은 과장되거나 축소될 수 있다.In order to fully understand the configuration and effects of the present invention, preferred embodiments of the present invention will be described with reference to the attached drawings. However, the present invention is not limited to the embodiments disclosed below, but can be implemented in various forms and various changes can be made. However, the description of this embodiment is provided to ensure that the disclosure of the present invention is complete and to fully inform those skilled in the art of the present invention of the scope of the invention. In the attached drawings, components are shown enlarged in size for convenience of explanation, and the proportions of each component may be exaggerated or reduced.

'제1', '제2' 등의 용어는 다양한 구성요소를 설명하는데 사용될 수 있지만, 상기 구성요소는 위 용어에 의해 한정되어서는 안 된다. 위 용어는 하나의 구성요소를 다른 구성요소로부터 구별하는 목적으로만 사용될 수 있다. 예를 들어, 본 발명의 권리범위를 벗어나지 않으면서 '제1구성요소'는 '제2구성요소'로 명명될 수 있고, 유사하게 '제2구성요소'도 '제1구성요소'로 명명될 수 있다. 또한, 단수의 표현은 문맥상 명백하게 다르게 표현하지 않는 한, 복수의 표현을 포함한다. 본 발명의 실시예에서 사용되는 용어는 다르게 정의되지 않는 한, 해당 기술분야에서 통상의 지식을 가진 자에게 통상적으로 알려진 의미로 해석될 수 있다.Terms such as 'first' and 'second' may be used to describe various components, but the components should not be limited by the above terms. The above terms may be used only for the purpose of distinguishing one component from another. For example, the 'first component' may be named 'the second component' without departing from the scope of the present invention, and similarly, the 'second component' may also be named 'the first component'. You can. Additionally, singular expressions include plural expressions, unless the context clearly dictates otherwise. Unless otherwise defined, terms used in the embodiments of the present invention may be interpreted as meanings commonly known to those skilled in the art.

이하에서는, 도면을 참조하여 본 발명의 일실시예에 따른 멀티 스레드 프로그램의 실행 주기 보정 방법에 대하여 구체적으로 설명한다.Hereinafter, a method for correcting the execution cycle of a multi-threaded program according to an embodiment of the present invention will be described in detail with reference to the drawings.

도 4는 본 발명의 바람직한 실시 예에 따른 멀티 스레드 프로그램의 실행 주기 보정 방법의 순서도이고, 도 5는 도 4가 적용되는 시스템 개념 블록 구성도이며, 도 6은 본 발명에 따라 스레드 실행 및 시간 보정의 흐름 예시도이다.Figure 4 is a flowchart of a method for correcting the execution cycle of a multi-threaded program according to a preferred embodiment of the present invention, Figure 5 is a system concept block diagram to which Figure 4 is applied, and Figure 6 is a thread execution and time correction method according to the present invention. This is an example of the flow.

도 4 내지 도 6을 각각 참조하면, 본 발명 멀티 스레드 프로그램의 실행 주기 보정 방법은,Referring to FIGS. 4 to 6 respectively, the execution cycle correction method of the multi-threaded program of the present invention is,

OS(10)의 시스템 시간을 확인하는 단계(S01)와, 시스템 시간을 기초로 스레드 실행 주기를 설정하는 단계(S02)와, 스레드 실행 주기의 시작에서 CPU(20)의 타이머(30) 시간을 확인하고, 저장하는 단계(S03)와, 웨이크 업(Wake up) 시간을 설정하는 단계(S04)와, 슬립 및 웨이크 업을 수행하는 단계(S05)와, 다음 주기의 시작에서 CPU(20) 타이머(30) 시간을 확인하는 단계(S06)와, 상기 S03 단계에서 저장한 시간(A)과 S06단계에서 확인된 시간(B)의 차(Diff)를 구하는 단계(S07)와, 상기 S07 단계에서 구한 차를 설정된 주기에 비하여 지연되었는지 확인하는 단계(S08)와, S08단계의 확인 결과 지연되지 않았으면 CPU(20)의 타이머 레지스터에 S06단계에서 확인된 시간을 저장하고, S04단계로 귀환하는 단계(S12)와, S08단계의 확인 결과 지연되었으면, OS(10)의 시간을 확인하는 단계(S09)와, OS(10)에서 확인된 시간이 다음 웨이크 업 시간에 비하여 더 큰지 확인하고, 크지 않으면 상기 S12단계를 수행하는 단계(S10)와, S10단계의 확인 결과 OS(10)에서 확인된 시간이 다음 웨이크 업 시간에 비하여 더 크면 시간을 보상하고, S03단계를 재수행하는 단계(S11)를 포함한다.Checking the system time of the OS 10 (S01), setting the thread execution cycle based on the system time (S02), and setting the timer 30 of the CPU 20 at the start of the thread execution cycle. A step of checking and storing (S03), a step of setting a wake up time (S04), a step of performing sleep and wake up (S05), and a CPU 20 timer at the start of the next cycle. (30) A step of checking the time (S06), a step of calculating the difference (Diff) between the time (A) stored in step S03 and the time (B) confirmed in step S06, and in step S07 A step of checking whether the obtained difference is delayed compared to the set period (S08), and if it is not delayed as a result of step S08, storing the time confirmed in step S06 in the timer register of the CPU 20 and returning to step S04. If it is delayed as a result of checking in steps (S12) and S08, check in step (S09) to check the time of the OS (10) and check if the time confirmed in the OS (10) is greater than the next wake-up time, and if not, check if the time confirmed in the OS (10) is greater than the next wake-up time. It includes a step (S10) of performing step S12, and a step (S11) of compensating the time and re-performing step S03 if the time confirmed by the OS 10 is greater than the next wake-up time as a result of checking step S10. do.

이하, 상기와 같이 구성되는 본 발명 멀티 스레드 프로그램의 실행 주기 보정 방법의 구성과 작용에 대하여 보다 상세히 설명한다.Hereinafter, the configuration and operation of the execution cycle correction method of the multi-threaded program of the present invention configured as described above will be described in more detail.

본 발명은 OS(10)에서 수행되는 스레드의 실행에 있어서, 주기를 설정하고, 주기에 맞춰 스레드를 실행하되, 해당 주기에 스레드가 실행될 수 없는 지연의 발생 여부를 CPU(20)의 타이머 레지스터(21)에 저장된 시간 정보를 이용하는 것으로 구체화될 수 있다.In the present invention, in the execution of a thread performed in the OS 10, a cycle is set and the thread is executed according to the cycle, and whether a delay occurs that prevents the thread from being executed in the cycle is detected by using the timer register ( It can be specified by using the time information stored in 21).

OS(10)는 멀티 스레드 프로세싱을 지원하는 모든 종류의 OS가 사용될 수 있으며, CPU(20)는 적어도 타이머 레지스터(21)를 포함하는 것이면 본 발명에 적용될 수 있다.The OS 10 can be any type of OS that supports multi-thread processing, and the CPU 20 can be applied to the present invention as long as it includes at least a timer register 21.

또한, 타이머(30)는 고정밀의 타이머이며, 실질적으로 OS(10)와 CPU(20)에 시간 정보를 제공한다.Additionally, the timer 30 is a high-precision timer and substantially provides time information to the OS 10 and CPU 20.

다만, OS(10)는 다층의 커널(11)을 통해 타이머(30)의 시간을 사용하는 것으로, 시간 확인 함수를 사용하기 때문에 CPU의 오버 해드가 많이 발생하게 된다.However, the OS 10 uses the time of the timer 30 through the multi-layer kernel 11, and uses a time check function, resulting in a lot of CPU overhead.

S01단계 내지 S04단계는 설정 과정이며, 먼저 OS(10)에서 시간 확인 함수를 사용하여 커널(11)을 통해 타이머(30)의 시간을 확인한다. Steps S01 to S04 are a setting process, and first, the OS 10 uses a time check function to check the time of the timer 30 through the kernel 11.

또한, S01단계에서 확인된 시간을 기초로 S02단계에서 스레드의 실행 주기를 설정한다. Additionally, the execution cycle of the thread is set in step S02 based on the time confirmed in step S01.

이때, CPU(20)는 S03단계와 같이 타이머(30)의 시간 정보를 확인하여 타이머 레지스터(21)에 저장한다. 설명의 편의상 S03단계에서 저장된 시간 정보를 'A'라고 한다. 이후 설명될 S06단계의 시간 정보를 'B'라고 칭하지만, 본 발명이 반복되는 과정에서 시간 'B'는 시간 'A'를 대체 갱신하며, 갱신된 시간은 설명의 편의를 위하여 다시 'A'라고 칭해질 수 있다.At this time, the CPU 20 checks the time information of the timer 30 and stores it in the timer register 21 as in step S03. For convenience of explanation, the time information stored in step S03 is referred to as 'A'. The time information in step S06, which will be explained later, is referred to as 'B', but in the process of repeating the present invention, time 'B' replaces and updates time 'A', and the updated time is again referred to as 'A' for convenience of explanation. It can be called.

그 다음, S04단계에서는 웨이크 업 시간을 설정한다.Next, in step S04, the wake-up time is set.

하나의 주기는 스레드가 실행되는 프로세싱 구간과 프로세싱이 완료된 후 다음 주기의 시작까지인 슬립 구간을 포함한다. 슬립 구간을 해제하고 다음 프로세싱의 시작을 알리는 시점의 설정이 웨이크 업 시간으로 정의된다.One cycle includes a processing section in which a thread is executed and a sleep section after processing is completed until the start of the next cycle. The setting of the point in time to release the sleep section and signal the start of the next processing is defined as the wake-up time.

웨이크 업 시간의 설정은 현재 검출된 시간에 S02단계에서 설정된 주기를 더하여 설정될 수 있다.The wake-up time can be set by adding the period set in step S02 to the currently detected time.

이처럼 설정이 완료된 후에는 S05단계와 같이 스레드의 프로세싱, 슬립 및 웨이크 업이 수행된다. After this setting is completed, thread processing, sleep, and wake-up are performed as in step S05.

즉, 도 6의 제1주기(P1)의 과정이 완료되고, 제2주기(P2)가 시작된다.That is, the process of the first cycle (P1) of FIG. 6 is completed, and the second cycle (P2) begins.

제2주기(P2)의 시작에서 S06단계와 같이 CPU(20)에서 타이머(30)의 시간을 확인한다. 이때의 타이머(30) 시간은 다른 타이머 레지스터에 저장될 수 있다.At the start of the second cycle (P2), the CPU 20 checks the time of the timer 30 as in step S06. The time of the timer 30 at this time may be stored in another timer register.

그 다음, S07 단계와 같이 상기 S03단계에서 타이머 레지스터(21)에 저장된 시간(A)과 현재 검출된 타이머(30)의 시간의 차(Diff)를 구한다.Next, as in step S07, the difference (Diff) between the time (A) stored in the timer register 21 in step S03 and the time of the currently detected timer 30 is obtained.

이때 구해진 시간의 차(Diff)는 이상적인 경우, S02단계에서 설정한 주기와 동일해야 한다.In an ideal case, the time difference (Diff) obtained at this time should be the same as the period set in step S02.

지연이 발생한 경우 시간의 차(Diff)는 주기에 비하여 더 크게 된다.When a delay occurs, the time difference (Diff) becomes larger than the period.

이를 확인하기 위하여 S08단계와 같이 시간의 차(Diff)가 주기에 비하여 더 큰지 확인한다.To check this, check whether the time difference (Diff) is greater than the period as in step S08.

좀 더 구체적으로 S08단계는 아래의 수학식 1을 통해 지연 발생 여부를 확인한다.More specifically, step S08 checks whether a delay occurs through Equation 1 below.

[수학식 1][Equation 1]

Diff > (주기+α)Diff > (period+α)

위의 수학식 1에서 Diff는 현재 주기에서 검출된 타이머(30)의 시각(B)에서 이전 주기에서 검출된 타이머(30)의 시각(A)을 뺀 시간이며, 주기는 S02단계에서 설정된 주기이다.In Equation 1 above, Diff is the time obtained by subtracting the time (A) of the timer 30 detected in the previous cycle from the time (B) of the timer 30 detected in the current cycle, and the cycle is the cycle set in step S02. .

α는 허용 오차의 임계값이다.α is the threshold of tolerance.

OS(10)에는 예측 불가한 지연 유발 요소가 다양하게 존재하며, CPU(20)를 독점하지 않는 정도의 지연이 발생될 수 있다. 만약 허용 오차의 임계값을 사용하지 않는 경우, 약간의 주기성 변화에도 시간을 수정해야 하는 문제점을 해소할 수 있도록 허용 오차를 설정할 필요가 있다.There are various unpredictable delay-causing factors in the OS 10, and a delay that does not monopolize the CPU 20 may occur. If the tolerance threshold is not used, it is necessary to set the tolerance to solve the problem of having to correct the time even if the periodicity changes slightly.

α는 CPU를 독점하지 않는 정도의 주기 변화 허용치로 설정될 수 있으며, 구체적으로 설정된 주기의 10 내지 20% 범위에서 설정되는 것이 바람직하다.α can be set to a period change tolerance that does not monopolize the CPU, and is preferably set in the range of 10 to 20% of the specifically set period.

도 6의 제2주기(P2)는 지연이 발생하지 않은 것을 가정한 것이며, 이 경우 S08단계의 판단결과 시간의 차(Diff)가 주기와 임계값의 합보다 크지 않은 것으로 판단된 경우이다.The second period (P2) in FIG. 6 assumes that no delay occurs, and in this case, as a result of the determination in step S08, it is determined that the time difference (Diff) is not greater than the sum of the period and the threshold.

이때에는 S12단계와 같이 CPU(20)의 타이머 레지스터(21)의 값을 갱신하고, S04단계부터 재수행한다.At this time, the value of the timer register 21 of the CPU 20 is updated as in step S12, and the process is re-performed from step S04.

이와 같은 과정을 반복하되, 제3주기(P3)와 같이 지연(Latency)이 발생한 경우, S08단계의 판단결과 시간의 차(Diff)는 주기와 임계값의 합보다 크게 된다.Repeat this process, but if latency occurs as in the third period (P3), the time difference (Diff) as a result of the determination in step S08 becomes greater than the sum of the period and the threshold.

이 경우, S09단계와 같이 OS(10)에서 커널(11)의 시간을 확인하고, S10단계와 같이 시간 보정 여부를 결정한다. S09단계의 OS 시간 확인은 해당 주기에서의 프로세싱이 완료된 후 수행된다.In this case, the OS 10 checks the time of the kernel 11 as in step S09, and determines whether to correct the time as in step S10. The OS time check in step S09 is performed after processing in the corresponding cycle is completed.

S10단계에서는 S09단계에서 검출된 시간이 다음의 웨이크 업 시간을 경과했는지 확인한다. In step S10, it is checked whether the time detected in step S09 has elapsed the next wake-up time.

구체적인 예로서, 제3주기(P3)에서 발생한 지연(Latency)에 의해 제3주기(P3)에서 실행될 스레드의 일부가 제4주기(P4)의 시작점인 웨이크 업 시간을 경과해서도 수행된 경우, S10단계의 판단 결과 주기 시간의 보정이 필요한 것으로 판단될 수 있다.As a specific example, if a part of the thread to be executed in the third cycle (P3) is executed even after the wake-up time, which is the starting point of the fourth cycle (P4), due to the delay that occurred in the third cycle (P3), As a result of the judgment in step S10, it may be determined that correction of the cycle time is necessary.

만약 지연은 발생하였으나, 제3주기(P3)의 프로세스가 제4주기(P4)의 웨이크 업 시간에 맞춰 종료되었다면, 주기를 보정하지 않고 앞서 설명한 S12단계를 재수행할 수 있다.If a delay occurs, but the process of the third cycle (P3) is completed in accordance with the wake-up time of the fourth cycle (P4), step S12 described above can be re-performed without correcting the cycle.

도 6의 제3주기(P3)의 프로세스가 제4주기(P4)의 웨이크 업 시간을 경과한 경우, 제4주기의 나머지 시간은 슬립 상태로 제어되고, 제5주기(P5)의 시작(웨이크 업 시간)에 맞춰 스레드를 실행하는 S11단계의 주기 시간 보정을 하게 된다.When the process of the third cycle (P3) in FIG. 6 has elapsed the wake-up time of the fourth cycle (P4), the remaining time of the fourth cycle is controlled to a sleep state, and the start of the fifth cycle (P5) (wake up time) The cycle time of step S11, which executes the thread according to the up time, is corrected.

이와 같은 과정을 통해 본 발명은 지연의 발생으로 인한 스레드 프로세싱의 지연 발생 및 스레드 주기의 변화에 따른 CPU 자원의 독점 현상 발생을 방지할 수 있다.Through this process, the present invention can prevent delays in thread processing due to delays and monopolization of CPU resources due to changes in thread cycles.

특히, 본 발명에서는 지연의 발생 여부를 OS(10)의 시스템 시간이 아닌 CPU(20)의 타이머 레지스터(21)에 저장된 시간을 이용하기 때문에 오버 헤드의 발생을 최소화할 수 있으며, 실시간 처리 시스템에 적용할 수 있다.In particular, in the present invention, the occurrence of a delay is determined by using the time stored in the timer register 21 of the CPU 20 rather than the system time of the OS 10, so the occurrence of overhead can be minimized and can be used in a real-time processing system. It can be applied.

이상에서 본 발명에 따른 실시예들이 설명되었으나, 이는 예시적인 것에 불과하며, 당해 분야에서 통상적 지식을 가진 자라면 이로부터 다양한 변형 및 균등한 범위의 실시예가 가능하다는 점을 이해할 것이다. 따라서, 본 발명의 진정한 기술적 보호 범위는 다음의 청구범위에 의해서 정해져야 할 것이다.Although embodiments according to the present invention have been described above, they are merely illustrative, and those skilled in the art will understand that various modifications and equivalent scope of embodiments are possible therefrom. Therefore, the true technical protection scope of the present invention should be determined by the following claims.

10:OS 11:커널
20:CPU 21:타이머 레지스터
30:타이머10:OS 11:kernel
20:CPU 21:Timer register
30:Timer

Claims (5)

a) 스레드 수행의 주기를 설정하는 단계;
b) 스레드 수행시 하드웨어 타이머의 시간 정보를 저장한 CPU의 타이머 레지스터 값을 확인하고, 현재 타이머 레지스터 값과 이전 타이머 레지스터 값의 차인 시간의 차를 구하는 단계;
c) 상기 b) 단계에서 구한 시간의 차를 설정된 상기 주기와 비교하여 지연 발생 여부를 확인하는 단계; 및
d) 지연이 발생한 경우 주기 시간을 보정하는 단계를 포함하는 멀티 스레드 프로그램의 실행 주기 보정 방법.a) setting the cycle of thread execution;
b) checking the timer register value of the CPU that stores the time information of the hardware timer when executing the thread, and calculating the time difference between the current timer register value and the previous timer register value;
c) comparing the time difference obtained in step b) with the set period to determine whether a delay has occurred; and
d) A method for compensating the execution cycle of a multi-threaded program, including the step of compensating the cycle time when a delay occurs. 제1항에 있어서,
상기 d) 단계는,
상기 c) 단계에서 지연이 발생한 것으로 판단된 경우,
현재 주기의 스레드 프로세싱이 완료된 시점이 다음 주기의 웨이크 업 시간을 경과했을 때 주기 시간을 보정하는 것을 특징으로 하는 멀티 스레드 프로그램의 실행 주기 보정 방법.According to paragraph 1,
In step d),
If it is determined that a delay has occurred in step c) above,
A method of correcting the execution cycle of a multi-threaded program, characterized in that the cycle time is corrected when the thread processing of the current cycle is completed when the wake-up time of the next cycle has passed. 제1항에 있어서,
상기 a) 단계는,
OS의 커널을 통해 제공되는 시스템 시간에 기초하여 주기를 설정하는 것을 특징으로 하는 멀티 스레드 프로그램의 실행 주기 보정 방법.According to paragraph 1,
In step a),
A method of correcting the execution cycle of a multi-threaded program, characterized by setting the cycle based on the system time provided through the kernel of the OS. 제1항에 있어서,
상기 c) 단계는,
시간의 차가 설정된 주기와 임계값의 합보다 큰 경우 지연 발생으로 판단하는 것을 특징으로 하는 멀티 스레드 프로그램의 실행 주기 보정 방법.According to paragraph 1,
In step c),
A method of correcting the execution cycle of a multi-threaded program, characterized in that it is determined that a delay has occurred if the time difference is greater than the sum of the set cycle and threshold. 제4항에 있어서,
상기 임계값은,
설정된 상기 주기의 10 내지 20%인 것을 특징으로 하는 멀티 스레드 프로그램의 실행 주기 보정 방법.According to paragraph 4,
The threshold is,
A method of correcting the execution cycle of a multi-threaded program, characterized in that it is 10 to 20% of the set cycle.
KR1020220068122A 2022-06-03 2022-06-03 Time correction method to ensure periodicity of multi-threaded programs KR20230167901A (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
KR1020220068122A KR20230167901A (en) 2022-06-03 2022-06-03 Time correction method to ensure periodicity of multi-threaded programs

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1020220068122A KR20230167901A (en) 2022-06-03 2022-06-03 Time correction method to ensure periodicity of multi-threaded programs

Publications (1)

Publication Number Publication Date
KR20230167901A true KR20230167901A (en) 2023-12-12

Family

ID=89159747

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020220068122A KR20230167901A (en) 2022-06-03 2022-06-03 Time correction method to ensure periodicity of multi-threaded programs

Country Status (1)

Country Link
KR (1) KR20230167901A (en)

Similar Documents

Publication Publication Date Title
US8176489B2 (en) Use of rollback RCU with read-side modifications to RCU-protected data structures
US8584138B2 (en) Direct switching of software threads by selectively bypassing run queue based on selection criteria
US6789214B1 (en) Process for reconfiguring an information processing system upon detection of a component failure
US7043729B2 (en) Reducing interrupt latency while polling
CA2385786A1 (en) Method for time partitioned application scheduling in a computer operating system
Huang et al. Improving Wait-Free Algorithms for Interprocess Communication in Embedded Real-Time Systems.
JP2004213637A (en) Method and device managing thread implementation in multithread application
US20110078702A1 (en) Multiprocessor system
US7003610B2 (en) System and method for handling shared resource writes arriving via non-maskable interrupts (NMI) in single thread non-mission critical systems with limited memory space
EP2664989A1 (en) Task scheduling
Socci et al. Time-triggered mixed-critical scheduler on single and multi-processor platforms
US10853133B2 (en) Method and apparatus for scheduling tasks to a cyclic schedule
US20050160425A1 (en) Limitation of the response time of a software process
KR20230167901A (en) Time correction method to ensure periodicity of multi-threaded programs
JP6861275B2 (en) Vehicle control unit
US8095695B2 (en) Control apparatus for process input-output device
JP2001236236A (en) Task controller and its task scheduling method
US11055163B2 (en) Method and device for error handling in a communication between distributed software components
Xu et al. Towards fault-tolerant real-time scheduling in the seL4 microkernel
Marucheck et al. An evaluation of the graceful degradation properties of real-time schedulers
Malhotra et al. A review of fault tolerant scheduling in multicore systems
US20230305872A1 (en) Efficient central processing unit overcommit for virtual machines with symmetric multi-processing
US11048575B2 (en) Method and device for error handling in a communication between distributed software components
KR100930009B1 (en) Method of interrupt processing
JP2008077388A (en) Multiprocessor control system, method and program

Legal Events

Date Code Title Description
E902 Notification of reason for refusal