KR101767418B1 - 임베디드 운영체제에서 로직의 우선순위 보장 방법 및 그 장치 - Google Patents

Abstract

본 발명의 일 태양에 따른 임베디드 운영체제에서 로직의 우선순위 보장 방법은, 임베디드 운영체제에서 태스크를 복수개의 로직으로 나누는 단계와 상기 복수개의 로직 중에서 상기 태스크의 제1 우선순위보다 높은 제2 우선순위로 실행되어야 할 특정 로직을 선별하는 단계와 상기 태스크의 수행 중에 상기 제2 우선순위를 가지는 인터럽트를 발생시키는 단계 및 상기 인터럽트에서 상기 선별된 특정 로직을 서브루틴으로 호출하는 단계를 포함할 수 있다.

Description

임베디드 운영체제에서 로직의 우선순위 보장 방법 및 그 장치 {Method and apparatus for guaranteeing priority of logic in an embedded operating system}

본 발명은 임베디드 운영체제에서 로직의 우선순위를 보장하는 방법 및 그 장치에 관한 것이다. 보다 자세하게는 태스크(task)를 구성하는 로직(logic) 중에서 우선순위의 보장이 필요한 특정 로직을 수행하기 위하여, 인위적인 인터럽트(interrupt)를 발생시키는 방법 및 그 방법을 수행하는 장치에 관한 것이다.

임베디드 시스템(embedded system)이란 미리 정해진 특정 기능을 수행하기 위해 컴퓨터의 하드웨어와 소프트웨어 그리고 추가의 기계적 장치나 다른 부분들로 이루어진 전자 제어 시스템을 말한다. 주로, 임베디드 시스템은 특정 기능에 특화된 전용의 시스템으로 설계된다는 점에서 범용적인 목적을 갖는 컴퓨터와 차이점을 가진다.

예를 들면, 자동자의 점화 시스템이나 엔진 제어 시스템 또는 브레이크 시스템 등이 임베디드 시스템의 일부이다. 또는, 생활가전인 텔레비전이나 냉장고, 전자레인지, 세탁기, 카메라 등에도 임베디드 시스템이 포함되어 있다. 나아가, 투석 장치나 인공장기 등과 같은 의료 분야에도 임베디드 시스템이 활용되고 있다.

보다 자세한 예로 세탁기를 살펴보면, 예전의 세탁기는 모터와 간단한 제어 장치를 통해 세탁과 탈수 기능만 갖는 단순한 장치였다 그러나, 최근에는 이러한 기능 외에도 세탁물의 양이나 세탁물의 옷감의 종류, 물의 온도 등을 고려하여 다양하게 세탁 방식을 설정할 수 있도록 되어 있다. 이러한 기능은 예전의 간단한 장치에서는 구현하기 힘든 것들로, 이를 위해서 세탁기에 마이크로프로세서(micro-processor)와 그에 따른 제어 프로그램이 입력된 임베디드 시스템을 내장하게 되었다.

컴퓨터를 구동하기 위한 운영체제로 윈도우(Windows)나 리눅스(Linux) 등이 있는 것처럼 임베디드 시스템을 구동하기 위한 임베디드 운영체제가 있다. 예를 들면 스마트폰(smartphone)에서는 안드로이드(android)와 같은 운영체제가 내장되어 있고, 그 외에도 eCos(The Embedded Configurable Operating System)와 같은 오픈 소스(open source)부터 VxWorks, OSE, VRTX, Nucleus, pSOS, QNX 등의 다양한 임베디드 운영체제가 있다.

대부분의 임베디드 운영체제에서 하나의 태스크는 하나의 우선순위만을 가진다. 즉, 태스크 단위로 우선순위를 정의하고 관리하기 때문에, 경우에 따라서는 중요한 로직을 수행하는 태스크가, 그보다 덜 중요한 로직을 수행하지만 우선순위가 높은 태스크에 의해 수행이 중지되는 경우가 발생할 수도 있다. 이에 하나의 태스크 내에서 서로 다른 우선순위를 가지는 로직을 수행할 수 있는 방법이 요구된다.

본 발명이 해결하고자 하는 과제는 임베디드 운영체제에서 로직의 우선순위를 보장하는 방법 및 그 장치를 제공하는 것이다.

본 발명의 기술적 과제들은 이상에서 언급한 기술적 과제들로 제한되지 않으며, 언급되지 않은 또 다른 기술적 과제들은 아래의 기재로부터 통상의 기술자에게 명확하게 이해될 수 있을 것이다.

상기 기술적 과제를 해결하기 위한 본 발명의 일 태양에 따른 임베디드 운영체제에서 로직의 우선순위 보장 방법은, 임베디드 운영체제에서 태스크를 복수개의 로직으로 나누는 단계와 상기 복수개의 로직 중에서 상기 태스크의 제1 우선순위보다 높은 제2 우선순위로 실행되어야 할 특정 로직을 선별하는 단계와 상기 태스크의 수행 중에 상기 제2 우선순위를 가지는 인터럽트를 발생시키는 단계 및 상기 인터럽트에서 상기 선별된 특정 로직을 서브루틴으로 호출하는 단계를 포함할 수 있다.

일 실시예에서, 상기 특정 로직을 선별하는 단계는, 상기 태스크의 수행시간과 상기 특정 로직의 수행시간을 비교하여 선별 여부를 판정하는 단계를 포함할 수 있다.

다른 실시예에서, 상기 특정 로직을 선별하는 단계는, 상기 태스크의 자원소모와 상기 특정 로직의 자원소모을 비교하여 선별 여부를 판정하는 단계를 포함할 수 있다

또 다른 실시예에서, 상기 특정 로직을 선별하는 단계는, 상기 태스크의 제1 우선순위와 상기 특정 로직이 실행되어야 할 제2 우선순위의 차이를 비교하여 선별 여부를 판정하는 단계를 포함할 수 있다.

또 다른 실시예에서, 상기 특정 로직을 선별하는 단계는, 상기 임베디드 운영체제에 설정된 시나리오에 기반하여 선별 여부를 판정하는 단계를 포함할 수 있다.

또 다른 실시예에서, 상기 제2 우선순위를 가지는 인터럽트를 발생시키는 단계는, 상기 태스크에서 상기 특정 로직을 제외하는 단계 및 상기 태스크에서 상기 제외된 특정 로직이 수행되어야 할 시점에 상기 인터럽트를 발생시키는 단계를 포함할 수 있다.

상기 기술적 과제를 해결하기 위한 본 발명의 다른 태양에 따른 임베디드 운영체제에서 로직의 우선순위 보장 장치 장치는, 인터페이스와 프로세서와 상기 프로세서에 의하여 수행되는 컴퓨터 프로그램을 로드하는 메모리 및 태스크, 인터럽트, 서브루틴을 저장하는 스토리지를 포함할 수 있다. 여기서, 상기 컴퓨터 프로그램은, 임베디드 운영체제에서 상기 태스크를 복수개의 로직으로 나누는 오퍼레이션과 상기 복수개의 로직 중에서 상기 태스크의 제1 우선순위보다 높은 제2 우선순위로 실행되어야 할 특정 로직을 선별하는 오퍼레이션과 상기 태스크의 수행 중에 상기 제2 우선순위를 가지는 상기 인터럽트를 발생시키는 오퍼레이션 및 상기 인터럽트에서 상기 선별된 특정 로직을 상기 서브루틴으로 호출하는 오퍼레이션을 포함할 수 있다.

상기와 같은 본 발명에 따르면, 하나의 태스크에서 서로 다른 우선순위를 가지는 로직을 수행할 수 있다. 이를 통해서 태스크에 할당된 우선순위보다 높은 우선순위를 가지는 태스크나 인터럽트가 발생되더라도 우선순위의 보장이 필요한 특정 로직이 수행 중에 중지되는 것을 방지할 수 있다.

본 발명의 효과들은 이상에서 언급한 효과들로 제한되지 않으며, 언급되지 않은 또 다른 효과들은 아래의 기재로부터 통상의 기술자에게 명확하게 이해 될 수 있을 것이다.

도 1a 내지 도 1b는 종래의 임베디드 운영체제에서 로직의 우선순위를 관리하는 방법을 설명하기 위한 의사코드(pseudocode)이다.
도 2는 종래의 임베디드 운영체제에서 로직의 우선순위를 관리하는 방법을 설명하기 위한 개념도이다.
도 3a 내지 도 3b는 각 서브루틴이 가질 수 있는 우선순위에 대하여 설명하기 위한 의사코드(pseudocode)이다.
도 4a 내지 도 5b는 종래의 임베디드 운영체제에서 로직의 우선순위를 관리하는 방법에 따른 실시예를 설명하기 위한 예시도이다.
도 6 내지 도 7은 본 발명의 일 실시예에 따른 임베디드 운영체제에서 로직의 우선순위를 보장하기 위한 방법의 순서도이다.
도 8은 본 발명의 일 실시예에 따른 임베디드 운영체제에서 로직의 우선순위를 보장하기 위한 방법을 설명하기 위한 의사코드(pseudocode)이다.
도 9a 내지 도 9b는 본 발명의 일 실시예에 따른 임베디드 운영체제에서 로직의 우선순위를 보장하기 위한 방법을 설명하기 위한 예시도이다.
도 10은 본 발명의 일 실시예에 따른 임베디드 운영체제에서 로직의 우선순위를 보장하기 위한 장치의 하드웨어 구성도이다.

이하, 첨부된 도면을 참조하여 본 발명의 바람직한 실시예를 상세히 설명한다. 본 발명의 이점 및 특징, 그리고 그것들을 달성하는 방법은 첨부되는 도면과 함께 상세하게 후술되어 있는 실시 예들을 참조하면 명확해질 것이다. 그러나 본 발명은 이하에서 게시되는 실시예에 한정되는 것이 아니라 서로 다른 다양한 형태로 구현될 수 있으며, 단지 본 실시 예들은 본 발명의 게시가 완전하도록 하고, 본 발명이 속하는 기술 분야에서 통상의 지식을 가진 자에게 발명의 범주를 완전하게 알려주기 위해 제공되는 것이며, 본 발명은 청구항의 범주에 의해 정의될 뿐이다. 명세서 전체에 걸쳐 동일 참조 부호는 동일 구성 요소를 지칭한다.

다른 정의가 없다면, 본 명세서에서 사용되는 모든 용어(기술 및 과학적 용어를 포함)는 본 발명이 속하는 기술 분야에서 통상의 지식을 가진 자에게 공통적으로 이해될 수 있는 의미로 사용될 수 있을 것이다. 또 일반적으로 사용되는 사전에 정의되어 있는 용어들은 명백하게 특별히 정의되어 있지 않는 한 이상적으로 또는 과도하게 해석되지 않는다. 본 명세서에서 사용된 용어는 실시예들을 설명하기 위한 것이며 본 발명을 제한하고자 하는 것은 아니다. 본 명세서에서, 단수형은 문구에서 특별히 언급하지 않는 한 복수형도 포함한다.

명세서에서 사용되는 "포함한다 (comprises)" 및/또는 "포함하는 (comprising)"은 언급된 구성 요소, 단계, 동작 및/또는 소자는 하나 이상의 다른 구성 요소, 단계, 동작 및/또는 소자의 존재 또는 추가를 배제하지 않는다.

이하, 본 발명에 대하여 첨부된 도면에 따라 보다 상세히 설명한다.

도 1a 내지 도 1b는 종래의 임베디드 운영체제에서 로직의 우선순위를 관리하는 방법을 설명하기 위한 의사코드(pseudocode)이다.

임베디드 시스템(embedded system)이란 미리 정해진 특정 기능을 수행하기 위해 컴퓨터의 하드웨어와 소프트웨어 그리고 추가의 기계적 장치나 다른 부분들로 이루어진 전자 제어 시스템을 말한다. 특히, 임베디드 시스템을 구동하기 위한 임베디드 운영체제 중에서 실시간 운영체제(RTOS; real-time operation system)는 정해진 시간 내에 결과를 출력해야 하기 때문에, 마이크로프로세서의 자원을 소모하는 각 태스크(task) 간의 우선순위를 관리하는 것이 매우 중요하다.

일반적으로 임베디드 운영체제에서는 각 태스크 간의 우선순위를 관리하기 위해 스케줄러(scheduler)를 이용한다. 여기서, 스케줄러란 특정 시간에 어떤 태스크가 마이크로프로세서를 사용할지 결정하는 부분으로 임베디드 운영체제의 핵심과도 같다. 스케줄러로 많이 사용되는 알고리즘으로는 크게 4가지를 꼽을 수 있다.

하나는 FIFO(first-in-first-out) 알고리즘으로 각 태스크는 끝날 때까지 수행되고 그 태스크가 끝나면 다음으로 요청을 한 태스크가 시작되는 알고리즘이다. 다만, 요청 순서대로 태스크를 처리하므로 중요한 태스크임에도 요청 순서에서 밀려 나중에 수행될 수 있는 단점이 있다.

다른 하나는 단기 태스크 우선(shortest job first) 알고리즘으로 각 태스크는 끝날 때까지 수행되고 그 태스크가 끝나면 다음에는 태스크가 끝나기까지의 시간이 가장 적은 태스크가 선택되는 알고리즘이다. 다만, 태스크의 수행 시간에 기반하여 태스크를 처리하므로, 수행시간이 긴 태스크의 경우에는 대기시간이 필요이상으로 길어질 수 있는 단점이 있다.

또 다른 하나는 우선순위(priority) 기반 알고리즘으로 각 태스크마다 우선순위를 가지며 다음에 수행할 태스크를 선택할 때 활용한다. 우선순위 기반 스케줄링은 선점형(preemptive)과 비선점형(nonpreemptive)이 있다. 선점형은 수행 중인 태스크보다 우선순위가 높은 태스크가 수행할 준비 상태가 되면, 기존에 수행 중이던 태스크를 멈추고 보다 더 우선순위가 높은 태스크를 수행하는 방식이며, 비선점형은 각 태스크는 끝날 때가지 수행되고 그 태스크가 끝나면 다음으로 우선순위가 높은 태스크가 선택되는 방식이다.

마지막은 라운드 로빈(round robin) 알고리즘으로 각 태스크들이 시간 조각(time slice)이라 불리는 정해진 시간만큼만 수행된다. 그 시간이 지나면 수행 중인 태스크는 정지되고 다음 태스크가 수행되는 방식이다. 모든 태스크가 비슷한 정도의 우선순위를 가진다면 라운드 로빈 알고리즘이 유리할 수 있으나, 각 태스크간의 우선순위 차이가 크다면 중요한 태스크임에도 동일하게 취급된다는 단점이 있다.

대부분의 임베디드 운영체제는 실시간 운영체제라고 해도 과언이 아니며, 실시간 운영체제는 각 태스크의 실시간성을 보장하기 위해 우선순위 관리를 앞서 설명한 알고리즘 중에서 선점형 스케줄링(preemptive scheduling)을 이용하여 수행한다. 즉, 각 태스크마다 우선순위를 정하고, 보다 더 높은 우선순위를 가지는 태스크의 수행 요청이 발생하면, 제어권한을 넘겨주는 방식을 취하고 있다. 그러나, 종래에는 각 태스크마다 또는 각 인터럽트마다 우선순위를 가지고 수행되었기 때문에, 하나의 태스크는 하나의 우선순위만을 가질 수 있다.

도 1a을 참고하면 태스크#1의 의사코드(101)에는 크게 세 덩어리의 로직이 수행되고 있음을 볼 수 있다. 즉, 로직 > 서브루틴#1 > 로직의 순서로 태스크#1이 수행되고 있다. 여기서 태스크#1에 포함된 세 덩어리의 로직은 모두 동일한 우선순위를 가진다. 즉, 태스크#1의 우선순위를 그대로 가지고 로직, 서브루틴#1, 로직이 수행된다. 이는 도 1b의 경우에도 마찬가지이다.

도 1b를 참고하면, 태스크#1의 의사코드(103a)에서 외부의 서브루틴#1의 의사코드(103b)에 정의된 서브루틴#1을 호출(call)하고 있음을 볼 수 있다. 서브루틴#1이 태스크#1의 외부에 별도로 정의된 로직이라고 하더라도, 태스크#1에서 서브루틴#1을 호출할 때에는 태스크#1의 우선순위를 가지고 서브루틴#1을 호출하기 때문에, 서브루틴#1은 태스크#1의 우선순위 아래에서 수행이 된다.

종래에는 이처럼 하나의 태스크는 하나의 우선순위만을 가지고 로직을 수행할 수 있기 때문에, 중요한 로직을 수행하는 태스크가 그보다 덜 중요한 로직을 수행하지만 우선순위가 높은 태스크에 의해 수행이 중지되는 경우가 발생할 수도 있다. 이와 관련해서 각 태스크와 인터럽트의 우선순위가 도시된 도 2를 통해 보다 자세히 살펴보기로 한다.

도 2는 종래의 임베디드 운영체제에서 로직의 우선순위를 관리하는 방법을 설명하기 위한 개념도이다.

선점형 스케줄링에서 우선순위를 가지고 수행될 수 있는 것은 태스크(task) 또는 인터럽트(interrupt)이다. 즉 태스크 스케줄러(111)에는 각 태스크가 특정 우선순위를 가지고 수행을 기다리고 있고, 마찬가지로 인터럽트 테이블(115)에도 각 인터럽트가 특정 우선순위를 가지고 인터럽트 발생을 기다리고 있다.

이해의 편의를 돕기 위하여 우선순위는 1부터 6까지 존재하고 숫자가 작을수록 우선순위가 높은 것으로 가정한다. 즉, 우선순위 1이 가장 높은 우선순위이며 우선순위 6이 가장 낮은 우선순위이다. 도 2의 예에서는 태스크#1과 인터럽트#1이 가장 높은 우선순위인 우선순위 1을 가지고 있고, 태스크#6과 인터럽트#6이 가장 낮은 우선순위인 우선순위 6을 가지고 있다. 이하 우선순위를 기재할 때는 [] 표시와 함께 기재하기로 한다. 우선순위 1은 [1]로 표시하고, 우선순위 6은 [6]으로 표시하도록 한다.

도 2의 예에서는 태스크#1은 [1]의 우선순위를 가지고, 내부적으로 서브루틴#1을 호출한다. 이 경우 서브루틴#1은 태스크#1의 우선순위인 [1]의 우선순위를 가지고 수행된다. 마찬가지로 태스크#2는 [2]의 우선순위를 가지고, 내부적으로 서브루틴#2를 호출한다. 태스크#3의 경우에는 [3]의 우선순위로 서브루틴#3, 서브루틴#4를 호출하며, 태스크#4의 경우에는 [4]의 우선순위로 서브루틴#6을 호출한다. 태스크#5의 경우에는 [5]의 우선순위로 서브루틴#3을 호출하고, 태스크#6의 경우에는 [6]의 우선순위로 서브루틴#5 및 서브루틴#6을 호출한다.

또한 도 2의 예에서 인터럽트#1, 인터럽트#2는 특정 서브루틴을 호출하지 않으나, 인터럽트#3의 경우에는 [3]의 우선순위를 가지고 서브루틴#3을 호출하며, 인터럽트#4의 경우에는 [4]의 우선순위를 가지고 서브루틴#6을 호출한다. 이처럼 태스크와 인터럽트는 우선순위를 가질 수 있으나, 서브루틴의 목록(113)에 포함된 각 서브루틴들은 그 어떤 우선순위도 가지지 않는다. 대신 자신을 호출한 태스크나 인터럽트의 우선순위를 그대로 가지고 수행된다. 이와 같은 서브루틴의 우선순위와 관련하여 도 3a 내지 도 3b를 통해서 보다 자세히 살펴보도록 한다.

도 3a 내지 도 3b는 각 서브루틴이 가질 수 있는 우선순위에 대하여 설명하기 위한 의사코드(pseudocode)이다.

도 3a를 참고하면, 태스크#3의 의사코드(105)에서는 내부적으로 서브루틴#3과 서브루틴#4가 순서대로 호출되는 것을 볼 수 있다. 이처럼 하나의 태스크는 필요에 따라 여러 개의 서브루틴을 호출할 수 있다. 물론 반대로 서브루틴을 하나도 호출하지 않는 경우도 있을 수 있다. 또한 3a의 예에서는 서브루틴#3과 서브루틴#4의 수행 전후로 특정 로직을 수행하는 것처럼 기재하였으나, 반드시 서브루틴의 수행 전후로 특정 로직을 수행해야만 하는 것은 아니다.

여기서, 서브루틴이란 특정 로직을 수행하기 위하여 별도로 만들어진 일련의 코드를 지칭하는 용어로 흔히 함수(function)이라고도 불린다. 서브루틴을 이용하면 코드의 재사용성과 가독성을 높일 수 있다. 즉 서브루틴은 여러 태스크 또는 인터럽트에서 호출될 수 있으므로 자신만의 우선순위를 가지는 것이 아니라, 자신을 호출한 태스크 또는 인터럽트의 우선순위를 상속받아 수행된다. 도 3a의 예에서는 서브루틴#3과 서브루틴#4가 서로 다른 서브루틴임에도 [3]의 우선순위를 가지고 수행될 것이다.

도 3b를 참고하면, 태스크#5의 의사코드(107)에서는 내부적으로 서브루틴#3을 호출한다. 이 경우에 서브루틴#3은 [5]의 우선순위를 가지고 수행될 것이다. 도 3a의 예와 비교해보면 동일한 서브루틴#3이여도 이를 호출하는 태스크에 따라 도 3a의 예에서는 [3]의 우선순위를 가지고 수행되고, 도 3b의 예에서는 [5]의 우선순위를 가지고 수행되는 것을 알 수 있다.

지금까지 도 3a 내지 도 3b를 통해서, 여러 개의 서로 다른 서브루틴이더라도 하나의 태스크 내에서 호출을 하는 경우에는 하나의 우선순위를 가지고 수행되는 것과, 하나의 동일한 서브루틴이더라도 호출하는 태스크에 따라 서로 다른 우선순위를 가질 수 있는 것에 대해서 살펴보았다. 이러한 경우에 발생할 수 있는 문제점에 대해서 도 4a 내지 도 5b를 통해서 보다 자세하게 살펴보도록 한다.

도 4a 내지 도 5b는 종래의 임베디드 운영체제에서 로직의 우선순위를 관리하는 방법에 따른 실시예를 설명하기 위한 예시도이다.

도 4a의 예에서는, [2]의 우선순위를 가지는 태스크#2의 수행 중에, [1]의 우선순위를 가지는 태스크#1의 요청이 있는 경우를 볼 수 있다. 먼저, t1의 시간에 태스크#2의 요청(121)이 들어와 태스크#2의 로직들과 서브루틴이 수행되고 있다. 여기서 태스크#2의 서브루틴#2의 수행 중에 t2의 시간에 태스크#1의 요청(123)이 발생하는 경우, 태스크#1의 우선순위가 태스크#2의 우선순위보다 더 높으므로 태스크#2의 수행은 잠시 중지된다. 대신 보다 더 높은 우선순위를 가지는 태스크#1으로 컨텍스트 스위칭(context switching)이 일어나고, 태스크#1과 서브루틴#1의 수행이 종료된 후에야, 다시 컨텍스트 스위칭(context switching)이 일어나 태스크#2의 남은 서브루틴#2와 로직이 이어서 수행된다.

서브루틴은 특정 우선순위를 가지는 것이 아니라 서브루틴을 호출하는 태스크나 인터럽트의 우선순위를 그대로 따른다고 설명하였지만, 서브루틴 자체가 특정 로직을 가지고 수행되는 것이므로 서브루틴 간의 중요도가 있을 수 있다. 도 2의 예에서 서브루틴#6에서 서브루틴#1로 갈수록 보다 중요한 서브루틴이라고 가정할 때, 도 4a의 경우에는 태스크#2 및 서브루틴#2보다 더 중요한 태스크#1 및 서브루틴#1이 수행되므로 서브루틴#2을 t2의 시간에 잠시 중지를 해도 크게 불합리하지 않다.

도 4b의 예에서는, [1]의 우선순위를 가지는 태스크#1의 수행 중에, [2]의 우선순위를 가지는 태스크#2의 요청이 있는 경우를 볼 수 있다. 먼저, t3의 시간에 태스크#1의 요청(125)이 들어와 태스크#1의 로직들과 서브루틴이 수행되고 있다. 여기서 태스크#1의 서브루틴#1의 수행 중에 t4의 시간에 태스크#2의 요청(127)이 발생하는 경우, 태스크#1의 우선순위가 태스크#2의 우선순위보다 더 높으므로 태스크#2의 수행은 잠시 보류된다. 보다 더 높은 우선순위를 가지는 태스크#1의 수행이 종료된 후에야, 보류된 태스크#2의 서브루틴#2와 로직이 수행된다.

도 4b의 경우에도 태스크#2와 서브루틴#2의 요청에도 불구하고 보다 더 높은 우선순위를 가지는 태스크#1과 서브루틴#1을 먼저 처리하므로, 태스크#1의 수행이 종료된 후에야 태스크#2를 수행해도 크게 불합리하지 않다. 이처럼 태스크와 태스크에서 호출하는 서브루틴이 서로 비슷한 우선순위와 중요도를 가지는 경우에는 기존의 방법으로도 크게 문제될 것이 없다. 다만, 낮은 우선순위를 가지는 태스크에서 더 중요한 서브루틴을 호출하거나, 높은 우선순위를 가지는 태스크에서 덜 중요한 서브루틴을 호출하는 경우에는 문제가 될 수 있다.

도 5a의 예에서는, [5]의 우선순위를 가지는 태스크#5의 수행 중에, [4]의 우선순위를 가지는 태스크#4의 요청이 있는 경우를 볼 수 있다. 먼저, t5의 시간에 태스크#5의 요청(131)이 들어와 태스크#5의 로직들과 서브루틴이 수행되고 있다. 여기서 태스크#5의 서브루틴#3의 수행 중에 t6의 시간에 태스크#4의 요청(133)이 발생하는 경우, 태스크#4의 우선순위가 태스크#5의 우선순위보다 더 높으므로 태스크#5의 수행은 잠시 중지된다. 대신 보다 더 높은 우선순위를 가지는 태스크#4로 컨텍스트 스위칭(context switching)이 일어나고, 태스크#4와 서브루틴#6의 수행이 종료된 후에야, 다시 컨텍스트 스위칭(context switching)이 일어나 태스크#5의 남은 서브루틴#3과 로직이 이어서 수행된다.

얼핏보면 도 4a의 경우와 유사하므로 별 문제가 없어 보인다. 그러나 자세히 살펴보면 [5]의 우선순위를 가지는 태스크#5에서도 서브루틴#3은 태스크#5의 나머지 로직들보다 보다 더 중요한 로직임에도 태스크#5에서 호출되기 때문에 [5]의 우선순위를 그대로 가지게 된다. 이 때문에, 보다 덜 중요한 태스크#4나 서브루틴#6의 수행을 위해 서브루틴#3의 수행이 중지되어야 하는 상황이 발생한다.

물론, 이런 상황을 미연에 방지하기 위하여 태스크#5의 우선순위를 [5]보다 더 높은 우선순위로 설정할 수도 있겠지만, 서브루틴#3외에 태스크#5의 전반적인 로직은 높은 우선순위를 필요로 하지 않는 경우에는 이러한 설정은 낭비가 될 수 있다. 이 때에는 태스크#5의 전반적인 로직은 [5]의 우선순위로 수행하되, 서브루틴#3만 [3]의 우선순위로 수행할 수 있는 스케줄링 방법이 필요하다.

도 5b의 예에서도 도 5a의 예와 마찬가지로, [5]의 우선순위를 가지는 태스크#5의 수행 중에, [4]의 우선순위를 가지는 인터럽트#4의 요청이 있는 경우를 볼 수 있다. 먼저, t7의 시간에 태스크#5의 요청(135)이 들어와 태스크#5의 로직들과 서브루틴이 수행되고 있다. 여기서 태스크#5의 서브루틴#3의 수행 중에 t8의 시간에 인터럽트#4의 요청(137)이 발생하는 경우, 인터럽트#4의 우선순위가 태스크#5의 우선순위보다 더 높으므로 태스크#5의 수행은 잠시 중지된다. 대신 보다 더 높은 우선순위를 가지는 인터럽트#4로 컨텍스트 스위칭(context switching)이 일어나고, 인터럽트#4의 서브루틴#6의 수행이 종료된 후에야, 다시 컨텍스트 스위칭(context switching)이 일어나 태스크#5의 남은 서브루틴#3과 로직이 이어서 수행된다.

이 때에도 5a와 마찬가지로 우선순위의 보장이 필요한 로직이, 태스크로부터 상속받은 우선순위로 인해, 보다 덜 중요한 태스크 또는 인터럽트의 요청으로 수행이 중지되는 상황이 발생한다. 즉, 낮은 우선순위를 갖는 태스크에서 중요한 서브루틴을 수행하고 있는 중에, 높은 우선순위를 갖는 태스크에서 보다 덜 중요한 서브루틴을 수행하려는 경우, 단순히 태스크의 우선순위에 기초한 스케줄링으로 인해 문제가 발생할 수 있다.

도 6 내지 도 7은 본 발명의 일 실시예에 따른 임베디드 운영체제에서 로직의 우선순위를 보장하기 위한 방법의 순서도이다.

도 6을 참고하면, 태스크에서 서로 다른 우선순위를 가지고 로직을 수행할 수 있도록 하기 위해서는 우선, 태스크의 시작과 함께 로직을 수행한다(S1100). 여기서 수행되는 로직은 서브루틴으로 호출되기 전의 전처리 로직으로 필요에 따라서는 생략될 수 있다.

이렇게 특정 로직을 수행하다가, 서브루틴의 수행 차례가 온 경우 해당 서브루틴이 우선순위의 보장이 필요한 서브루틴인지 판단한다(S1200). 만약 우선순위의 보장이 필요하지 않은 서브루틴인 경우에는 종래처럼 태스크에서 해당 서브루틴을 호출하고, 태스크의 우선순위를 상속받아 서브루틴을 수행한다(S1310). 반대로 우선순위의 보장이 필요한 서브루틴인 경우에는 태스크에서 해당 서브루틴을 직접 호출하는 것이 아니라, 인위적으로 인터럽트를 발생시키고(S1360), 해당 인터럽트에서 다시 서브루틴을 호출하는 방식으로 서브루틴를 수행한다(S1370). 태스크에서 인위적으로 발생시킨 인터럽트는 태스크와는 별도로 인터럽트만의 우선순위를 가지기 때문에, 인터럽트에서 호출한 서브루틴은 태스크와는 다른 우선순위를 가질 수 있는 것이다.

인터럽트에 의해서던(1370) 또는 태스크에 의해서던(1310) 호출된 서브루틴의 수행이 종료된 후에는 이어서 태스크의 남은 로직을 수행한다(S1400). 다만, 앞선 전처리 로직처럼 여기의 후처리 로직도 필요에 따라서는 생략해도 무방하다. 즉, 경우에 따라서는 특정 태스크에서는 다른 로직의 수행없이 인터럽트를 발생시키고 해당 인터럽트에서 특정 서브루틴만 수행하고 태스크 자체가 종료되는 경우도 가능할 것이다.

물론 이렇게 특정 태스크에서 다른 로직의 수행없이 인터럽트를 통해 특정 서브루틴만 수행하고 종료되는 경우는 실효성이 없다 할 것이다. 인터럽트를 통해서 특정 서브루틴만 수행하려는 목적은 태스크의 나머지 로직들과는 다른 우선순위를 가지고 특정 서브루틴을 수행하기 위해서이기 때문이다. 즉, 도 5a와 같은 경우에 태스크#5의 일반적인 로직은 [5]의 우선순위를 가지고 수행하면서도, 서브루틴#3은 [3]의 우선순위를 수행하기 위해서 인터럽트를 이용하는 것이다.

그리고 앞서 도 3a에서 하나의 태스크에서 여러 개의 서브루틴을 수행할 수 있는 것도 보았다. 이를 응용하면, 도 6에서는 하나의 서브루틴만 우선순위 보장을 위해 인터럽트를 발생시키는 것처럼 기재되어 있으나, 경우에 따라서는 하나의 태스크에서 순차적으로 여러 개의 인터럽트를 발생시켜 여러 개의 서브루틴을 수행시키는 것도 가능할 것이다. 즉 하나의 태스크를 그 우선순위에 따라 여러 로직을 분리하고, 각각을 여러 인터럽트를 통해서 서브루틴을 수행하는 방식으로 스케줄링 하는 것도 가능할 것이다.

도 7을 참고하면, 우선 태스크를 복수개의 로직으로 나눈다(S2100). 이를 통해서 태스크의 우선순위를 그대로 상속하여 수행될 일반 로직과, 태스크의 우선순위보다 더 높은 우선순위를 가지고 수행될 우선순위의 보장이 필요한 특정 로직을 분리하는 것이다. 선별된 특정 로직을 제외한 나머지가 일반 로직으로서, 서브루틴의 전후를 기준으로 도 6의 S1100 단계 또는 S1400 단계에서 수행될 수 있다.

태스크를 복수개의 로직으로 분리한 후에는 그 중에서 인터럽트를 통해서 실행될 특정 로직을 선별한다(S2200). 인터럽트를 통해서 실행될 특정 로직은 태스크의 우선순위보다는 더 높은 우선순위로 수행되어야 할 만큼 중요한 로직이어야 한다. 특정 로직이 중요한 로직인지 아닌지를 판단하는 기준은 여러가지가 있을 수 있다.

예를 들면, 태스크의 전체 수행시간 중에서 해당 특정 로직의 수행시간을 비교해서 선별 여부를 판정할 수 있다. 만약 태스크의 전제 수행시간 중에서 기 설정된 기준치 이하의 수행시간을 차지하는 특정 로직이라면 인터럽트를 통해서 수행하는게 무의미할 수 있을 것이다. 오히려 인터럽트를 이용하여 해당 특정 로직을 수행하는 과정에서 인터럽트의 발생과 서브루틴의 호출로 인한 오버헤드(overhead)로 손실이 더 큰 경우가 생길 수도 있기 때문이다.

마찬가지로 태스크의 전체 자원소모에 비해서 해당 특정 로직의 자원소모가 어느정도인지 비교해서 선별 여부를 판정할 수 있다. 프로세서의 사용율이라던지, 메모리의 사용율 등을 고려하여 태스크의 전체 자원소모 중에서 기 설정된 기준치 이하의 자원소모를 차지하는 특정 로직이라면 중요도가 상대적으로 낮다고 판단할 수 있기 때문이다.

다른 한 기준으로 태스크의 우선순위와 특정 로직이 수행되어야 할 우선순위와의 차이를 기준으로 선별 여부를 판정할 수 있다. 만약 태스크의 우선순위와 특정 로직이 수행되어야할 우선순위의 차이가 기 설정된 기준치 이하라면 인터럽트를 통해서 별도의 우선순위를 가지고 해당 특정 로직을 수행하지 않더라도 발생할 수 있는 단점이 미미할 수 있을 것이다. 즉, 태스크의 우선순위로도 어느정도 수행이 보장되는 정도라면 굳이 인터럽트를 통해서 수행할 필요가 없을 것이다.

다른 한 기준으로 시나리오에 기반하여 선별 여부를 판정할 수도 있다. 앞서 설명한 것처럼 서브루틴 자체는 우선순위가 없으나, 서브루틴도 결국에는 특정 로직을 수행하기 위한 것으로서 그 로직에 따라 중요도가 다를 수 있다고 언급하였다. 그러므로 사전에 시나리오에 의하여 서브루틴의 중요도를 우선순위로 환산하여 정의를 하고 이를 이용하여 선별 여부를 판정하는 것이다.

예를 들면, 서브루틴#3은 [3]의 우선순위를 가지고 수행되어야 할 서브루틴이라고 사전에 시나리오를 정의해놓으면, [3]보다 낮은 우선순위를 가지는 태스크#4, 태스크#5, 태스크#6에서는 서브루틴#3을 호출할 때, 인터럽트#3을 이용하여 호출하도록 하는 것이다. 물론 [3]보다 높거나 같은 우선순위를 가지는 태스크#1, 태스크#2, 태스크#3의 경우에는 해당 시나리오가 적용되지 않을 것이다.

이러한 시나리오는 사전에 임베디드 운영체제의 설계자에 의해 임베디드 운영체제에 설정될 수 있다. 즉, 이러한 시나리오를 이용하면, 임베디드 운영체제는 실질적으로는 태스크와 인터럽트 및 서브루틴에 우선순위를 정의하여 관리하는 효과를 얻을 수 있다. 이를 통해서, 서브루틴에 종속적인 우선순위를 시나리오에 의해 정의하고 관리할 수 있다.

인터럽트를 통해서 수행될 특정 로직을 선별한 후에는 해당 특정 로직을 수행하기 위해, 별도의 인터럽트를 강제로 발생시킨다(S2300). 이 때 발생되는 인터럽트는 태스크보다는 더 높은 우선순위를 가진 인터럽트로서, 태스크를 대신하여 해당 특정 로직을 수행하게 된다. 즉 태스크 내에서 해당 특정 로직을 수행할 순서에, 태스크에서 직접 그 특정 로직을 수행하는 대신에 인터럽트를 발생시키고 인터럽트에서 서브루틴 호출을 통하여 해당 특정 로직을 수행하는 것이다. 이렇게 특정 로직을 서브루틴 호출을 통하여 별도의 인터럽트에서 수행을 하게 되면 태스크와는 별도의 우선순위를 가질 수 있다.

인터럽트의 준비까지 끝난 후에는 해당 인터럽트를 통해서 특정 서브루틴을 호출한다(S2400). 그러면 해당 특정 로직은 태스크보다 더 높은 우선순위를 가지고 수행되므로, 더 높은 우선순위를 가지는 다른 태스크나 인터럽트에 의해서 수행이 중지되는 경우가 줄어들게 될 것이다.

지금까지 도 6 내지 도 7을 통해서 태스크의 우선순위보다 더 높은 우선순위로 특정 로직을 수행하기 위한 우선순위 보장 방법을 살펴보았다. 하지만, 경우에 따라서는 반대로 태스크의 우선순위보다 더 낮은 우선순위로 수행되어도 무방한 특정 로직을 수행하기 위하여 태스크의 우선순위보다 더 낮은 우선순위를 가지는 인터럽트를 이용할 수도 있을 것이다. 즉 본 발명을 통해서 태스크에 포함된 복수의 로직에 대해 태스크와는 다른 우선순위를 가지고 수행할 수 있으므로, 이를 통해서 태스크의 각 로직을 중요도에 따라 적절히 우선순위를 조절하여 인터럽트를 통해 수행할 수도 있을 것이다.

도 8은 본 발명의 일 실시예에 따른 임베디드 운영체제에서 로직의 우선순위를 보장하기 위한 방법을 설명하기 위한 의사코드(pseudocode)이다.

인터럽트(interrupt)란 태스크를 수행하던 도중 예기치 못한 특수한 상황이 발생하여 작업을 중단하고, 그 특수한 상황을 먼저 처리한 후, 원래의 작업으로 되돌아가 나머지 작업을 계속 수행하게 되는 일련의 과정을 말한다. 인터럽트의 종류는 하드웨어 인터럽트와 소프트웨어 인터럽트가 있다. 그 중에서 소프트웨어 인터럽트를 통해 태스크와는 인위적으로 다른 우선순위를 가지는 인터럽트를 발생시키고 인터럽트를 통해서 특정 서브루틴을 호출하여 수행할 수 있다.

도 8을 참고하면, 도 3b에 비해 수정된 태스크#5의 의사코드(109)는 서브루틴#3을 호출하는 대신에 인위적으로 인터럽트#3을 발생시키고 인터럽트#3을 통해서 서브루틴#3을 수행하는 것을 볼 수 있다. 이렇게 서브루틴#3을 수행하면, 태스크#5는 [5]의 우선순위를 갖더라도, 서브루틴#3은 [3]의 우선순위를 가지고 수행할 수 있다.

도 9a 내지 도 9b는 본 발명의 일 실시예에 따른 임베디드 운영체제에서 로직의 우선순위를 보장하기 위한 방법을 설명하기 위한 예시도이다.

도 9a의 예에서는, [5]의 우선순위를 가지는 태스크#5의 수행 중에, [4]의 우선순위를 가지는 태스크#4의 요청이 있는 경우를 볼 수 있다. 먼저, t9의 시간에 태스크#5의 요청(141)이 들어와 태스크#5의 로직들이 수행되고 있다. 여기서 태스크#5의 로직들이 수행되다가 서브루틴#3의 수행이 필요할 때에는 태스크#5에서 서브루틴#3을 호출하는 것이 아니라 별도의 인터럽트#3을 발생시켜 인터럽트#3에서 서브루틴#3을 수행시킨다. 서브루틴#3의 수행 중에 t10의 시간에 태스크#4의 요청(143)이 발생하는 경우, 태스크#4의 우선순위는 태스크#5의 우선순위보다 더 높지만, 인터럽트#3의 우선순위보다는 낮으므로 인터럽트#3은 중단되지 않고 계속 수행된다. 대신 인터럽트#3의 서브루틴#3의 수행이 종료된 후에야 컨텍스트 스위칭(context switching)이 일어나고, 태스크#4와 서브루틴#6의 수행이 시작된다. 그 후 태스크#4와 서브루틴#6의 수행이 종료된 후에야, 다시 컨텍스트 스위칭(context switching)이 일어나 태스크#5의 남은 로직이 이어서 수행된다.

도 5a와 비교해보면, 중요한 서브루틴#3이 태스크#4의 요청에도 불구하고 수행이 중단되지 않고 계속 수행이 되는 것을 볼 수 있다. 즉, 인터럽트를 이용하여 서브루틴#3을 수행하면 최소한, 서브루틴#3이 그 보다 낮은 우선순위를 가지는 태스크나 인터럽트에 의해서 중지되는 것을 막을 수 있다. 물론, 이렇게 서브루틴#3을 수행하더라도 태스크#5의 나머지 일반적인 로직은 기본적으로 태스크#5의 우선순위에 의해 수행되므로, 서브루틴#3의 수행이 종료되면 태스크#5의 나머지 로직이 수행되는 것이 아니라, 태스크#4의 로직들과 서브루틴#6이 수행된다. 즉, 본 발명은 태스크 내에서 특정 로직만 별도의 우선순위를 가지게 하는 것이 목적이다. 만약 태스크 내의 모든 로직의 우선순위를 변경하고 싶으면 태스크 자체의 우선순위를 변경하면 충분하기 때문이다.

도 9b의 예에서는, 인터럽트를 이용하여 서브루틴을 실행하였음에도, 그보다 더 높은 우선순위를 가지는 태스크에 의해 서브루틴이 중지되는 것을 볼 수 있다. 즉 [3]의 우선순위를 가지는 인터럽트#3의 서브루틴#3의 수행 중에, [2]의 우선순위를 가지는 태스크#2의 요청이 들어오게 되면, 서브루틴#3은 수행이 중지된다. 그리고 태스크#2 및 서브루틴#2의 수행이 종료된 후에야 컨텍스트 스위칭을 통해 남은 서브루틴#3이 마저 수행되고, 다시 태스트#5의 남은 로직들이 수행된다. 즉 서브루틴을 인터럽트에 의해서 수행하더라도 이는 태스크와는 다른 우선순위를 가지게 하는 것일 뿐, 항상 인터럽트를 통해서 수행된 서브루틴이 최상위의 우선순위를 가지고 수행되는 것을 보장하는 것은 아니다.

도 10은 본 발명의 일 실시예에 따른 임베디드 운영체제에서 로직의 우선순위를 보장하기 위한 장치의 하드웨어 구성도이다.

도 10을 참고하면, 임베디드 운영체제에서 로직의 우선순위 보장 장치(10)는 프로세서(510), 메모리(520), 스토리지(560) 및 인터페이스(570)을 포함할 수 있다. 프로세서(510), 메모리(520), 스토리지(560) 및 인터페이스(570)는 시스템 버스(550)를 통하여 데이터를 송수신한다.

프로세서(510)는 메모리(520)에 로드 된 컴퓨터 프로그램을 실행하고, 메모리(520)는 상기 컴퓨터 프로그램을 스토리지(560)에서 로드(load) 한다. 상기 컴퓨터 프로그램은, 태스크 분할 오퍼레이션(521), 특정 로직 선별 오퍼레이션(523), 인터럽트 발생 오퍼레이션(525), 서브루틴 호출 오퍼레이션(527)을 포함할 수 있다.

태스크 분할 오퍼레이션(521)은 스토리지(560)의 태스크 정보(561)를 참고하여, 태스크를 복수개의 로직으로 나눌 수 있다. 이를 통해서 태스크의 우선순위를 상속하여 수행할 일반 로직과, 우선순위 보장이 필요한 특정 로직을 선별할 수 있다.

특정 로직 선별 오퍼레이션 (523)은 태스크 분할 오퍼레이션(521)에서 나눈 각 로직에 대해서 로직의 수행시간, 자원소모, 해당 로직의 수행이 필요한 우선순위 등을 기준으로 중요한 로직을 선별할 수 있다.

인터럽트 발생 오퍼레이션(525)은 특정 로직 선별 오퍼레이션(523)에서 선별된 특정 로직에 대해 태스크의 우선순위를 상속하여 수행하는 대신에 인터럽트(563)의 우선순위를 상속하여 수행될 수 있도록 태스크 내에서 해당 선별된 로직이 수행될 시점에 별도의 인터럽트(563)를 발생시킨다. 이 때 발생된 인터럽트(563)는 특정 로직의 우선순위를 보장하기 위한 인터럽트(563)로서 태스크보다 더 높은 우선순위를 가지는 것이 특징이다.

서브루틴 호출 오퍼레이션(527)은 스토리지(560)의 서브루틴(569)을 참고하여 태스크에서 해당 특정 로직을 수행하는 대신에, 인터럽트를 통해서 해당 특정 로직을 서브루틴으로 호출한다. 이를 통해서, 최소한 특정 로직이 다른 태스크나 인터럽트로 인해 수행이 중지되는 상황을 사전에 줄일 수 있다.

도 10의 각 구성 요소는 소프트웨어(Software) 또는, FPGA(Field Programmable Gate Array)나 ASIC(Application-Specific Integrated Circuit)과 같은 하드웨어(Hardware)를 의미할 수 있다. 그렇지만, 상기 구성 요소들은 소프트웨어 또는 하드웨어에 한정되는 의미는 아니며, 어드레싱(Addressing)할 수 있는 저장 매체에 있도록 구성될 수도 있고, 하나 또는 그 이상의 프로세서들을 수행시키도록 구성될 수도 있다. 상기 구성 요소들 안에서 제공되는 기능은 더 세분화된 구성 요소에 의하여 구현될 수 있으며, 복수의 구성 요소들을 합하여 특정한 기능을 수행하는 하나의 구성 요소로 구현될 수도 있다.

이상 첨부된 도면을 참조하여 본 발명의 실시예들을 설명하였지만, 본 발명이 속하는 기술 분야에서 통상의 지식을 가진 자는 본 발명이 그 기술적 사상이나 필수적인 특징을 변경하지 않고서 다른 구체적인 형태로 실시될 수 있다는 것을 이해할 수 있을 것이다. 그러므로 이상에서 기술한 실시예들은 모든 면에서 예시적인 것이며 한정적이 아닌 것으로 이해해야만 한다.

Claims (7)

1. 태스크 단위로 우선순위 기반의 선점형 스케줄링을 수행하는 임베디드 운영체제에서, 하나의 태스크를 복수개의 로직으로 나누되, 상기 복수개의 로직은 상기 태스크의 제1 우선순위에 따라 실행되는 것인, 단계;
   상기 복수개의 로직 중에서 상기 태스크의 제1 우선순위보다 높은 제2 우선순위로 실행되어야 할 특정 로직을 수행시간 및 자원소모 중 적어도 하나를 기준으로 선별하는 단계;
   상기 선별된 특정 로직에 상기 제2 우선순위를 할당하기 위해서, 상기 태스크의 수행 중 상기 선별된 특정 로직이 실행되는 시점에 상기 제2 우선순위를 가지는 인터럽트를 인위적으로 발생시키는 단계; 및
   상기 인터럽트에서 상기 선별된 특정 로직을 서브루틴으로 호출하여 상기 선별된 특정 로직을 상기 제2 우선순위로 실행하는 단계를 포함하되,
   상기 복수개의 로직 중에서 상기 특정 로직을 제외한 로직은 상기 제1 우선순위에 따라 실행되는 것인,
   임베디드 운영체제에서 로직의 우선순위 보장 방법.
2. 제1항에 있어서,
   상기 특정 로직을 수행시간 및 자원소모 중 적어도 하나를 기준으로 선별하는 단계는,
   상기 태스크의 수행시간과 상기 특정 로직의 수행시간을 비교하여 선별 여부를 판정하는 단계를 포함하는,
   임베디드 운영체제에서 로직의 우선순위 보장 방법.
3. 제1항에 있어서,
   상기 특정 로직을 수행시간 및 자원소모 중 적어도 하나를 기준으로 선별하는 단계는,
   상기 태스크의 자원소모와 상기 특정 로직의 자원소모를 비교하여 선별 여부를 판정하는 단계를 포함하는,
   임베디드 운영체제에서 로직의 우선순위 보장 방법.
4. 삭제
5. 삭제
6. 삭제
7. 인터페이스와 프로세서;
   상기 프로세서에 의하여 수행되는 컴퓨터 프로그램을 로드하는 메모리; 및
   태스크, 인터럽트, 서브루틴을 저장하는 스토리지를 포함하되,
   상기 컴퓨터 프로그램은,
   태스크 단위로 우선순위 기반의 선점형 스케줄링을 수행하는 임베디드 운영체제에서, 하나의 태스크를 복수개의 로직으로 나누되, 상기 복수개의 로직은 상기 태스크의 제1 우선순위에 따라 실행되는 것인, 오퍼레이션;
   상기 복수개의 로직 중에서 상기 태스크의 제1 우선순위보다 높은 제2 우선순위로 실행되어야 할 특정 로직을 수행시간 및 자원소모 중 적어도 하나를 기준으로 선별하는 오퍼레이션;
   상기 선별된 특정 로직에 상기 제2 우선순위를 할당하기 위해서, 상기 태스크의 수행 중에 상기 선별된 특정 로직이 실행되는 시점에 상기 제2 우선순위를 가지는 상기 인터럽트를 인위적으로 발생시키는 오퍼레이션; 및
   상기 인터럽트에서 상기 선별된 특정 로직을 상기 서브루틴으로 호출하여 상기 선별된 특정 로직을 상기 제2 우선순위로 실행하는 오퍼레이션을 포함하되,
   상기 복수개의 로직 중에서 상기 특정 로직을 제외한 로직은 상기 제1 우선순위에 따라 실행되는 것인,
   임베디드 운영체제에서 로직의 우선순위 보장 장치.

Images