KR100241343B1 - Same-level interrupt execution sequence control method - Google Patents

Same-level interrupt execution sequence control method Download PDF

Info

Publication number
KR100241343B1
KR100241343B1 KR1019970054293A KR19970054293A KR100241343B1 KR 100241343 B1 KR100241343 B1 KR 100241343B1 KR 1019970054293 A KR1019970054293 A KR 1019970054293A KR 19970054293 A KR19970054293 A KR 19970054293A KR 100241343 B1 KR100241343 B1 KR 100241343B1
Authority
KR
South Korea
Prior art keywords
interrupt
same level
time
service routine
processing time
Prior art date
Application number
KR1019970054293A
Other languages
Korean (ko)
Other versions
KR19990033051A (en
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 KR1019970054293A priority Critical patent/KR100241343B1/en
Publication of KR19990033051A publication Critical patent/KR19990033051A/en
Application granted granted Critical
Publication of KR100241343B1 publication Critical patent/KR100241343B1/en

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F13/00—Interconnection of, or transfer of information or other signals between, memories, input/output devices or central processing units
    • G06F13/14—Handling requests for interconnection or transfer
    • G06F13/20—Handling requests for interconnection or transfer for access to input/output bus
    • G06F13/24—Handling requests for interconnection or transfer for access to input/output bus using interrupt
    • G06F13/26—Handling requests for interconnection or transfer for access to input/output bus using interrupt with priority control
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L47/00—Traffic control in data switching networks
    • H04L47/50—Queue scheduling
    • H04L47/62—Queue scheduling characterised by scheduling criteria
    • H04L47/622—Queue service order
    • H04L47/6235—Variable service order

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Networks & Wireless Communication (AREA)
  • Signal Processing (AREA)
  • Bus Control (AREA)

Abstract

본 발명은 동일 레벨 처리불가 시간등록에 의한 인터럽트 실행순서 제어방법에 관한 것으로서, 주기적으로 발생하는 고실시간성 인터럽트 발생시각의 일정 시간전에 다른 동일 레벨의 인터럽트가 발생하면 이의처리를 연기하기 위해 동일레벨 인터럽트의 처리 제한시간을 나타내는 동일레벨인터럽트 처리불가 시간, 상기 특정 인터럽트가 동일레벨인터럽트 처리불가 시간등록/해제를 요구하였을 때 이의 등록/해제요구를 처리하고 인터럽트 발생시 동일레벨의 인터럽트인가를 구별하기 위한 인터럽트 서비스루틴 스터브, 동일레벨 인터럽트 처리불가 시간이 등록된 상태에서 이 제한시간 이내에 다른 동일레벨 인터럽트가 발생하면 인터럽트서비스 루틴 스터브에 의하여 곧이어 발생할 고실시간성 인터럽트의 처리후에 이 인터럽트를 처리하기 위한 작업을 저장하기 위한 인터럽트 작업 큐, 고실시간성 인터럽트 처리루틴의 등록/해제시 인터럽트번호와 동일 레벨인터럽트 처리불가시간정보를 추출하여 등록/해제를 요구하기 위한 인터럽트 서비스 루틴등록/해제프리미티브로 구성된 동일레벨을 갖는 인터럽트 실행순서를 실행함으로써, 동일레벨인터럽트들에서도 실행순서를 부여할 수 있으며, 동일레벨의 다른 인터럽트들 보다 실행의 고실시간성을 부여할수 있고, 발생한 인터럽트에 대하여 선처리할 수 있는 과정을 추가할 수 있으며, 수행의 가장 우선권을 갖는 새로운 인터럽트 작업큐를 생성하는 효과가 있다.The present invention relates to a method for controlling interrupt execution order by registering the same level non-processing time, and if the same level of interrupt occurs a certain time before the time of high real-time interrupt occurrence that occurs periodically, the same level is to delay the processing thereof. Same level interrupt processing time indicating the interrupt processing timeout period, when the specific interrupt requests registration / release of the same level interrupt processing time, it is necessary to handle the registration / cancellation request thereof and to distinguish whether it is the same level interrupt when an interrupt occurs. Interrupt service routine stub, if the same level interrupt processing time is registered, if another same level interrupt occurs within this time limit, the interrupt service routine stub Same as the interrupt service routine registration / release primitive to request the registration / cancellation by extracting interrupt processing non-time information at the same level as the interrupt number when registering / unregistering the interrupt job queue and high-real-time interrupt processing routine for storing the work. By executing the interrupt execution order with the level, the execution order can be given even at the same level interrupts, the real time execution can be given more than other interrupts of the same level, and the preprocessing for the interrupts generated It can be added and has the effect of creating a new interrupt task queue with the highest priority of execution.

Description

동일 레벨 인터럽트 실행순서 제어방법Same level interrupt execution order control method

본 발명은 동일 레벨 인터럽트 처리불가 시간 등록에 의한 인터럽트 실행순서 제어방법에 관한 것이다.The present invention relates to a method for controlling interrupt execution order by registering a level interrupt processing time.

종래의 마이크로 프로세서에는 통상 256개의 인터럽트를 처리할 수 있도록 제작되었으며, 이들 인터럽트들을 통상 7 레벨로 분류하여 우선 순위를 할당하여 우선 순위에 따라 처리 순서를 제어한다.In the conventional microprocessor, 256 interrupts are usually manufactured, and these interrupts are classified into seven levels and assigned priority to control the processing order according to the priority.

이에 따라 하나의 인터럽트 레벨에는 여러 개의 인터럽트가 존재하게 되어 동일 인터럽트 레벨을 갖는 인터럽트는 발생 순서에 따라 순차적으로 처리하게 된다.Accordingly, several interrupts exist in one interrupt level, and interrupts having the same interrupt level are sequentially processed in the order of occurrence.

인터럽트들이 동일 레벨을 갖게 되는 것은 첫째 마이크로 프로세서의 인터럽트 레벨이 인터럽트 전체 갯수 보다 현저하게 작기 때문이고, 둘째 마이크로 프로세서를 사용하여 시스템을 구성하는데 있어서 발생하는 인터럽트들에게 같은 인터럽트 레벨을 할당하여 시스템을 구성하였기 때문이며, 셋째 상기 첫째와 둘째의 원인이 복합적으로 작용하기 때문이다.Interrupts have the same level because the interrupt level of the first microprocessor is significantly less than the total number of interrupts, and the system is configured by assigning the same interrupt level to the interrupts that occur when configuring the system using the second microprocessor. This is because the first and second causes work in combination.

동일 레벨을 갖는 여러 개의 인터럽트들은 발생 순서에 따라 순차적으로 처리하게 된다.Multiple interrupts with the same level are processed sequentially in the order of occurrence.

그러나 동일 레벨을 갖는 인터럽트 중에서도 주기적으로 발생하며, 다른 인터럽트들을 보다 고실시간성(Hard Real-Time) 처리를 요구하는 인터럽트들이 있을 수 있으므로 인해 이들 인터럽트는 상위 레벨의 인터럽트 처리가 없는 한 발생 즉시 처리하여야 하나 동일 레벨을 갖는 인터럽트들이 미리 발생하여 있으면 이들을 모두 순차적으로 처리한 후에야 처리가 됨으로 해서 고실시간성 요구를 만족할 수 없는 문제가 있었다.However, some interrupts with the same level occur periodically, and other interrupts may require higher real-time processing of other interrupts. Therefore, these interrupts should be processed immediately unless they occur. However, if interrupts having the same level have occurred in advance, they are processed only after all of them are processed sequentially, so that there is a problem in that the requirement for high real time cannot be satisfied.

상기 문제를 해결하기 위해 본 발명은 동일 레벨의 인터럽트에 비교하여 상대적으로 고실시간성을 요구하는 인터럽트가 일정하게 주기적으로 발생하는 상황에서 이 인터럽트가 발생하는 시각이 되기 전의 일정 시간 동안 내에 다른 동일 레벨의 인터럽트가 발생하면 이 인터럽트의 수행을 연기시켜 곧 이어 발생할 동일 레벨의 고실시간성 인터럽트가 처리되는 데에 지장을 주지 않도록 제어하는 것을 목적으로 한다.In order to solve the above problem, the present invention provides the same level of interruption within a certain time period before the time when this interrupt occurs in a situation in which an interrupt that requires relatively high real time is periodically generated in comparison with the interrupt of the same level. When the interrupt occurs, the execution of this interrupt is delayed, and the purpose is to control the interruption of processing the same level of high real time interrupt that will occur soon.

도 1a에서 도 1c는 본 발명이 적용되는 동일 레벨 인터럽트 처리불가 시간 등록시 수정처리 구조도,1A to 1C are structural diagrams of modification processing at the same level interrupt non-availability time registration to which the present invention is applied;

도 2는 본 발명에 따른 동일 레벨 인터럽트 처리불가 시간 등록시 인터럽트 처리 흐름도,2 is an interrupt processing flow chart when registering the same level interrupt processing inoperable time according to the present invention;

도 3은 본 발명에 따른 동일 레벨 인터럽트 처리불가 시간 등록 흐름도,3 is a flow chart of the same level interrupt processing time can not register according to the present invention;

도 4는 동일 레벨 인터럽트 처리불가 시간 해제 흐름도.4 is a flowchart for releasing an interrupt level at the same level.

* 도면의 주요부분에 대한 부호의 설명* Explanation of symbols for main parts of the drawings

1 : 발생한 인터럽트 1 2 : 발생한 인터럽트 21: Interrupt 1 occurred 2: Interrupt 2 occurred

3 : 인터럽트 1의 처리 시간 4 : 인터럽트 2의 처리 시간3: Processing time of interrupt 1 4: Processing time of interrupt 2

5 : 인터럽트 1의 발생 시각 6 : 인터럽트 2의 발생 시각5: Interrupt 1 occurrence time 6: Interrupt 2 occurrence time

7 : 인터럽트 2의 동일 레벨 인터럽트 처리불가 시간7: Unavailability time of interrupt processing at interrupt 2

상기 목적을 달성하기 위해 본 발명은 주기적으로 발생하는 고실시간성 인터럽트 발생 시각의 일정 시간 전에 다른 동일 레벨의 인터럽트가 발생하면 이의 처리연기를 위해 동일 레벨 인터럽트의 처리 제한 시간을 나타내는 동일 레벨 인터럽트 처리불가 시간과, 상기 특정 인터럽트가 동일 레벨 인터럽트 처리불가 시간 등록/해제를 요구하였을 때 이의 등록/해제 요구를 처리하고 인터럽트 발생시 동일 레벨의 인터럽트인가를 판별하기 위한 인터럽트 서비스 루틴 스터브와, 동일 레벨 인터럽트 처리불가 시간이 등록된 상태에서 이 제한 시간 이내에 다른 동일 레벨 인터럽트가 발생하면 인터럽트 서비스 루틴 스터브에 의하여 곧 이어 발생할 고실시간성 인터럽트의 처리 후에 이 인터럽트를 처리하기 위한 작업을 저장하는 인터럽트 작업 큐(Queue)와, 고실시간성 인터럽트 처리 루틴의 등록/해제 시 동일 레벨 인터럽트 처리불가 시간 정보를 추가하여 등록/해제를 요구하기 위한 인터럽트 서비스 루틴 등록/해제 프리미티브(Primitive)로 구성된 동일 레벨을 갖는 인터럽트에서의 실행순서 제어방법을 제공하는 것을 특징으로 한다.In order to achieve the above object, the present invention can not process the same level interrupt that indicates the processing time limit of the same level interrupt for the delay of processing if another same level interrupt occurs before a predetermined time of the periodically generated high real time interrupt occurrence time. An interrupt service routine stub for processing the registration / release request and determining whether the interrupt is at the same level when an interrupt occurs when the specific interrupt requests the same level interrupt processing time; An interrupt task queue that stores work for handling this interrupt after the processing of high real-time interrupts that will occur soon after, by the interrupt service routine stub, if another equal-level interrupt occurs within this time limit with time registered. , Execution order control for interrupts with the same level consisting of interrupt service routine registration / release primitives to request registration / cancellation by adding the same level interrupt dead time information when registering / unregistering the high real-time interrupt processing routine. It is characterized by providing a method.

이하 첨부된 도면을 참조하여 본 발명을 상세히 설명하면 다음과 같다.Hereinafter, the present invention will be described in detail with reference to the accompanying drawings.

도 1a에서 1c는 본 발명이 적용되는 동일 레벨 인터럽트 처리불가 시간 등록시 수정처리 구조도로서, 발생한 인터럽트 1, 2(1, 2), 상기 인터럽트 1의 처리 시간(3), 상기 인터럽트 2의 처리 시간(4), 인터럽트 1의 발생 시각(5), 인터럽트 2의 발생 시각(6), 인터럽트 2의 동일 레벨 인터럽트 처리불가 시간 등록에 따른 동일 레벨 인터럽트 처리불가 시간(7)으로 이루어져 있다.1A to 1C are structure diagrams of correcting processing when registering the same level interrupt processing time according to the present invention. The interrupt 1, 2 (1, 2), the processing time 3 of the interrupt 1, and the processing time of the interrupt 2 ( 4) Interrupt 1 generation time (5), Interrupt 2 generation time (6), and Interrupt 2 same level interrupt processing non-operation time (7).

상기 발생한 인터럽트 1(1)은 시스템 운용 중 t1의 시각에 발생한 인터럽트이며, 발생하는 모든 인터럽트들은 시스템에서 할당한 인터럽트 레벨을 갖고 있다.The generated interrupt 1 (1) is an interrupt generated at the time t 1 during system operation, and all interrupts generated have the interrupt level assigned by the system.

또한 상기 발생한 인터럽트 2(2)는 시스템 운용 중 t2의 시각에 발생한 인터럽트로서 인터럽트 1과 동일 레벨을 갖는 인터럽트이다.In addition, the generated interrupt 2 (2) is an interrupt having the same level as interrupt 1 as an interrupt generated at the time t 2 during system operation.

상기 인터럽트 1의 처리 시간(3)은 인터럽트 1(I1)의 인터럽트 서비스 루틴 처리 시간이고, 상기 인터럽트 2의 처리 시간(4)은 인터럽트 2(I2)의 인터럽트 서비스 루틴의 처리 시간이다.The processing time 3 of the interrupt 1 is the interrupt service routine processing time of the interrupt 1 (I 1 ), and the processing time 4 of the interrupt 2 is the processing time of the interrupt service routine of the interrupt 2 (I 2 ).

그리고 인터럽트 1의 발생 시각(5)은 인터럽트 1이 시스템에서 발생한 시각을 나타내며, 인터럽트 2의 발생 시각(6)은 인터럽트 2가 시스템에서 발생한 시각이다.The generation time 5 of interrupt 1 indicates the time when interrupt 1 occurred in the system, and the generation time 6 of interrupt 2 is the time when interrupt 2 occurred in the system.

상기 동일 레벨 인터럽트 처리불가 시간(7)은 상기 인터럽트 2의 인터럽트 서비스 루틴의 등록 시 인터럽트 2가 발생하기 전의 일정 시간 내에 동일 레벨을 갖는 다른 인터럽트가 발생하면 이 인터럽트의 처리를 연기하는 것으로서, 인터럽트 1의 발생에 따라 인터럽트 1의 인터럽트 서비스 루틴의 처리 종료 이전에 인터럽트 2가 발생할 것이므로 먼저 발생한 인터럽트 1의 인터럽트 서비스 루틴의 처리를 연기하여 인터럽트 2의 처리 지연을 방지한다.The same level interrupt processing time 7 is to delay the processing of this interrupt when another interrupt having the same level occurs within a predetermined time before interrupt 2 occurs when the interrupt service routine of interrupt 2 is generated. Interrupt 2 will occur before the interrupt service routine of interrupt 1 is terminated due to the occurrence of the interrupt. Therefore, the processing of the interrupt service routine of interrupt 1 that occurred first is delayed, thereby preventing the delay of interrupt 2 processing.

도 2는 본 발명에 따른 동일 레벨 인터럽트 처리불가 시간 등록시 인터럽트 처리 흐름도로서, 인터럽트가 발생하여 이를 수신하면(S1) 동일 레벨 인터럽트 처리불가 시간의 등록에 따라 생성된 인터럽트 서비스 루틴 스터브에서 현재 발생한 인터럽트가 동일 레벨 인터럽트 처리불가 시간 이내인가를 판단하여(S2) 동일 레벨 인터럽트 처리불가 시간 이내가 아닐 경우, 인터럽트 서비스 루틴을 계속 수행하고(S3), 상기 판단 후 동일 레벨 인터럽트 처리불가 시간 이내에 발생한 것이면, 현재 발생한 인터럽트 서비스 루틴을 인터럽트 작업 큐에 넣어(S4) 이 수행을 인터럽트 2의 인터럽트 서비스 루틴의 수행이 끝날 때까지 연기하는 것을 나타낸다.2 is an interrupt processing flow chart when registering the same level interrupt processing time according to the present invention. When an interrupt is generated and received (S1), an interrupt currently generated by an interrupt service routine stub generated according to the registration of the same level interrupt processing time is generated. It is determined whether it is within the same level interrupt processing inoperable time (S2), and if it is not within the same level interrupt handling inoperable time, the interrupt service routine is continued (S3). The interrupt service routine generated is placed in the interrupt work queue (S4) to defer this execution until the execution of the interrupt service routine of interrupt 2 is completed.

상기 인터럽트 수신(S1)은 인터럽트가 발생하였을 때 이를 수신하는 루틴으로 하드웨어에 의해 발생한 인터럽트를 통상 운영체계(Operating System)가 이를 수신한다.The interrupt reception S1 is a routine for receiving an interrupt when it is generated, and an interrupt generated by hardware is normally received by an operating system.

상기 루틴 스터브에서 현재 발생한 인터럽트가 동일 레벨 인터럽트 처리불가 시간 이내인가의 판단(S2)은 동일 레벨 인터럽트 처리불가 시간의 등록에 따라 생성된 인터럽트 서비스 루틴 스터브에서 현재 발생한 인터럽트가 동일 레벨 인터럽트 처리불가 이내인가를 판별하는 것으로 발생한 인터럽트의 번호로 이를 판별한다.It is determined whether the interrupt currently occurring in the routine stub is within the same level interrupt processing inoperable time (S2). Is the interrupt currently generated in the interrupt service routine stub generated according to the registration of the same level interrupt processing inoperable time within the same level interrupt processing ineffective? This is determined by the number of interrupts generated by determining

인터럽트 서비스 루틴 스터브는 동일 레벨 인터럽트 처리불가 시간의 등록 요구시 운영체계 내부에 생성된다.An interrupt service routine stub is generated inside the operating system upon request for registration of the same level interrupt dead time.

상기 인터럽트 서비스 루틴 계속 수행(S3)은 등록된 동일 레벨 인터럽트 처리불가 시간 이내에 발생한 인터럽트가 아니므로 해서 이 인터럽트의 인터럽트 서비스 루틴이 수행되는 것이다.The interrupt service routine continually performing (S3) is not an interrupt that occurred within the registered same level interrupt processing time, so that the interrupt service routine of this interrupt is executed.

만일 등록된 동일 레벨 인터럽트 처리불가 시간 이내에 발생한 인터럽트이면 이를 즉시 처리하지 않고 인터럽트 작업 큐에 넣어(S4) 지연시켜 곧 이어 발생할 동일 레벨 인터럽트 처리불가 시간을 등록한 인터럽트의 처리 이후에 수행시킨다.If the interrupt is generated within the registered same level interrupt processing time, it is not immediately processed and put into the interrupt work queue (S4), and is delayed.

도 3은 본 발명에 따른 동일 레벨 인터럽트 처리불가 시간 등록 흐름도로서, 사용자가 운영체계에서 동일 레벨 인터럽트 처리불가 시간 등록을 위하여 제공하는 프리미티브에 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간을 이용하여 등록 요구하면(S5), 이를 등록하기 위해 인터럽트 서비스 루틴 스터브가 존재하는지를 판단하여(S6) 인터럽트 서비스 루틴 스터브가 없는 경우 새로 생성하고(S7), 인터럽트 서비스 루틴 스터브에 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간을 등록한다(S8).FIG. 3 is a flow chart of same level interrupt processing time registration according to the present invention, when a user requests registration using an interrupt number and the same level interrupt processing time to a primitive provided by the operating system for registration of the same level interrupt processing time. (S5), it is determined whether an interrupt service routine stub exists to register it (S6), and if there is no interrupt service routine stub, a new one is generated (S7), and the interrupt service routine stub registers the same level interrupt interrupt time as the interrupt number. (S8).

상기 동일 레벨 인터럽트 처리불가 시간을 이용한 등록 요구(S5)는 동일 레벨 인터럽트 처리불가 시간 등록 요구를 수신하는 루틴으로, 사용자가 시스템의 프리미티브에 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간을 이용하여 등록을 요구하면 운영체계 내부에서 수신한다.The registration request (S5) using the same level interrupt processing dead time is a routine for receiving the same level interrupt processing dead time registration request, and the user requests registration by using the same level interrupt processing time as the interrupt number in the primitive of the system. Is received inside the operating system.

상기 인터럽트 서비스 루틴 스터브의 존재 여부 판단(S6)은 해당 인터럽트 레벨의 서비스 루틴 스터브가 존재하는가를 검사하는 루틴이다.The determination of the existence of the interrupt service routine stub (S6) is a routine for checking whether the service routine stub of the corresponding interrupt level exists.

인터럽트 서비스 스터브는 사용자의 동일 레벨 인터럽트 처리불가 시간 등록 요구가 수신되면 인터럽트 번호로 해당 레벨을 알아내어 해당 인터럽트 서비스 루틴 스터브가 있는가를 검사한다.When the interrupt service stub receives the user's request for the same level interrupt dead time registration, the interrupt service stub checks the level by the interrupt number and checks whether there is the corresponding interrupt service routine stub.

만일 동일 레벨 인터럽트 처리불가 시간 등록을 요청한 인터럽트가 없었거나 등록되었던 것이 모두 해제되면 이 인터럽트 서비스 루틴 스터브는 운용체계 내부에서 자동적으로 삭제가 된다.If there are no interrupts that requested the same level interrupt handling time registration or all registered ones are released, the interrupt service routine stub is automatically deleted from the operating system.

상기 인터럽트 서비스 루틴 스터브가 없는 경우 새로 생성(S7)하는 것은 상기 인터럽트 서비스 루틴 스터브의 존재 여부 판단(S6)의 수행 결과 해당 인터럽트 서비스 루틴 스터브가 존재하지 않으면 기본 구조를 갖는 인터럽트 서비스 루틴 스터브를 생성하는 루틴이다.If the interrupt service routine stub does not exist, generating a new one (S7) generates an interrupt service routine stub having a basic structure if the corresponding interrupt service routine stub does not exist as a result of performing the determination of the existence of the interrupt service routine stub (S6). Routine.

상기 인터럽트 서비스 루틴 스터브에 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간의 등록(S8)은 인터럽트 서비스 루틴 스터브에 등록을 요구한 인터럽트 번호로 해당 인터럽트 서비스 루틴과 동일 레벨 인터럽트 처리불가 시간을 등록하는 루틴이다.The registration of the interrupt level at the same level as the interrupt number at the interrupt service routine stub (S8) is a routine for registering the interrupt level at the same level as the interrupt service routine at the interrupt number which requested the registration to the interrupt service routine stub.

인터럽트 서비스 루틴 스터브는 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간이 등록되어 있어 동일 레벨의 인터럽트가 발생하면 발생한 인터럽트 서비스 루틴으로 직접 가지 않고 이 스터브로 이동하여 동일 레벨 인터럽트 처리불가 시간 이내에 이 인터럽트가 발생하였는가를 검사하고, 만일 이 시간 범위 이전에 인터럽트가 발생한 것이면 해당 인터럽트 서비스 루틴으로 이동하게 하고, 이 시간 범위 이내에서 발생한 인터럽트이면 인터럽트 작업 큐에 저장하여 동일 레벨 인터럽트 처리불가 시간을 등록한 인터럽트가 발생하여 처리된 후에 이를 처리하게 한다.The interrupt service routine stub is registered with the interrupt number and the same level interrupt processing time. If an interrupt of the same level occurs, does this interrupt occur within the same level interrupt processing time without going directly to the interrupt service routine that occurred? If the interrupt occurred before this time range, move to the corresponding interrupt service routine. If the interrupt occurred within this time range, it is stored in the interrupt work queue and the interrupt registered with the same level interrupt processing time is generated and processed. To be processed after the

도 4는 동일 레벨 인터럽트 처리불가 시간 해제 흐름도로서, 사용자가 프리미티브에 인터럽트 번호로 동일 레벨 인터럽트 처리불가 시간의 해제를 요구하면(S9) 이를 해제하기 위하여 인터럽트 서비스 루틴 스터브에서 해당 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간을 제거하여 해제하고(S10), 상기 인터럽트 서비스 루틴 스터브에 동일 레벨 인터럽트 처리불가 시간이 등록된 것이 없는가를 판단하여(S11) 마지막 등록을 해제한 경우 해당 인터럽트 서비스 루틴 스터브를 삭제한다(S12).FIG. 4 is a flowchart for releasing the same level interrupt dead time. When the user requests release of the same level interrupt dead time by the interrupt number from the primitive (S9), the interrupt service routine stub and the same level interrupt are interrupted to release the same. After removing the non-processing time (S10), it is determined whether the same level interrupt processing time has been registered in the interrupt service routine stub (S11), and when the last registration is released, the corresponding interrupt service routine stub is deleted ( S12).

상기 도 4에서 동일 레벨 인터럽트 처리불가 시간 해제 요구 수신(S9)은 사용자가 시스템의 프리미티브를 이용하여 인터럽트 번호로 등록된 동일 레벨 인터럽트 처리불가 시간의 해제를 요구하면 이를 수신하는 루틴으로 운영체계 내부에 이를 구현한다.In FIG. 4, the same level interrupt processing time release request receiving operation S9 is a routine for receiving the same level interrupt processing time when the user requests the release of the same level interrupt processing time registered by the interrupt number. Implement this.

그리고 인터럽트 서비스 루틴 스터브에서 해당 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간의 제거와 해제(S10)는 해당 인터럽트 서비스 루틴 스터브에서 인터럽트 번호에 해당되는 동일 레벨 인터럽트 처리불가 시간의 등록을 해제하는 루틴이다.In the interrupt service routine stub, the removal and release of the same level interrupt processing inoperable time as the corresponding interrupt number (S10) is a routine for releasing the registration of the same level interrupt processing inability corresponding to the interrupt number in the corresponding interrupt service routine stub.

상기 인터럽트 서비스 루틴 스터브에 동일 레벨 인터럽트 처리불가 시간이 등록된 것이 없는가의 판단(S11)은 인터럽트 서비스 루틴 스터브에서 모든 등록이 해제되었는가를 검사하는 루틴이다.The determination (S11) of whether or not the same level interrupt processing non-operation time is registered in the interrupt service routine stub is a routine for checking whether all registrations are released in the interrupt service routine stub.

다음 상기 마지막 등록을 해제한 경우 해당 인터럽트 서비스 루틴 스터브의 삭제(S12)는 상기 인터럽트 서비스 루틴 스터브에 동일 레벨 인터럽트 처리불가 시간이 등록된 것이 없는가의 판단(S11) 후 수행 결과에서 모든 등록이 해제되었으면 이 인터럽트 서비스 루틴 스터브를 삭제하는 루틴이다.Next, when the last registration is released, the deletion of the corresponding interrupt service routine stub (S12) is determined if all registrations are released from the execution result after the determination (S11) of whether the same level interrupt processing time is not registered in the interrupt service routine stub. This routine clears the interrupt service routine stub.

상술한 바와 같이 본 발명은 동일 레벨을 갖는 인터럽트들에서의 실행순서를 제어하여 다음과 같은 특유의 효과를 갖는다.As described above, the present invention controls the execution order in interrupts having the same level and has the following unique effects.

첫째, 여러 개의 인터럽트가 동일 레벨에 할당됨으로 인하여 이들 인터럽트 사이에 실행순서를 부여할 수 없었으나, 본 동일 레벨 인터럽트 불가 시간 등록 방법에 의하여 동일 레벨 인터럽트들에서도 실행순서를 부여할 수 있게 된다.First, since several interrupts are assigned to the same level, execution order cannot be given between these interrupts. However, the execution order can be assigned to the same level interrupts by the same level interrupt interrupt time registration method.

둘째, 동일 레벨의 인터럽트들에 비하여 고실시간성을 요구하며 주기적으로 발생하는 인터럽트에게 동일 레벨의 다른 인터럽트들 보다 실행의 고실시간성을 부여할 수 있다.Second, it requires higher real time performance compared to interrupts of the same level, and it is possible to give a high real time execution performance to interrupts that occur periodically than other interrupts of the same level.

셋째, 본 발명으로 운영체계 내에서 인터럽트 발생시 곧 바로 해당 인터럽트 서비스 루틴으로 이동하지 않고 발생한 인터럽트에 대하여 선처리(Preprocessing) 할 수 있는 과정을 추가할 수 있다.Third, according to the present invention, when an interrupt occurs in an operating system, a process capable of preprocessing the interrupt generated without moving to the corresponding interrupt service routine may be added.

넷째, 기존의 운영체계에서 작업들이 우선 순위에 따라 분류되어 수행되기를 기다리는 여러 작업 큐에 대하여 수행의 가장 우선권을 갖는 새로운 인터럽트 작업 큐를 생성하는 효과를 갖는다.Fourth, it has the effect of creating a new interrupt task queue having the highest priority of execution for several task queues waiting for the tasks to be sorted by priority in the existing operating system.

Claims (13)

동일 레벨 인터럽트의 처리 제한 시간을 나타내는 동일 레벨 인터럽트 처리불가 시간, 동일 레벨 인터럽트의 처리불가 시간 등록/해제 요구를 처리하고 인터럽트 발생시 동일 레벨의 인터럽트인가를 판별하는 인터럽트 서비스 루틴 스터브, 인터럽트 처리불가 시간 등록 후 제한 시간 내에 다른 동일 레벨의 인터럽트가 발생하여 인터럽트 서비스 루틴 스터브에 의해 곧 이어 발생할 고실시간성 인터럽트의 처리 후의 인터럽트를 처리하기 위한 작업을 저장하는 인터럽트 작업 큐, 고실시간성 인터럽트 처리 루틴의 등록/해제시 인터럽트 번호와 동일 레벨 인터럽트 처리 블가 시간 정보를 추가하여 등록/해제를 요구하기 위한 인터럽트 서비스 루틴 등록/해제 프리미티브로 구성되어 동일 레벨을 갖는 인터럽트에서의 실행순서를 제어하는 방법에 있어서,Same level interrupt processing time that indicates the processing timeout of the same level interrupt, processing time of same level interrupt processing, interrupt service routine stub that handles the request / release request and determines whether it is the same level interrupt when interrupt occurs, interrupt processing time registration Interrupt job queue, which stores jobs for handling interrupts after the processing of high real-time interrupts that will occur soon after another interrupt of the same level occurs within the next time-out, and is interrupted by the interrupt service routine stub. In the method of controlling the execution order in interrupts having the same level, consisting of an interrupt service routine registration / release primitive for requesting registration / cancellation by adding interrupt information and the same level interrupt processing block time information upon release. , 동일 레벨 인터럽트 처리불가 시간 등록시의 인터럽트를 처리하는 제 1 과정과;A first step of processing an interrupt at the time of registering the same level interrupt processing dead time; 동일 레벨 인터럽트 처리불가 시간 등록을 하는 제 2 과정과;A second step of registering the same level interrupt processing time; 동일 레벨 인터럽트 처리불가 시간을 해제하는 제 3 과정을 포함하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.And a third step of releasing the same level interrupt processing inoperable time. 제 1 항에 있어서, 상기 제 1 과정은The method of claim 1, wherein the first process is 발생한 인터럽트를 수신하여 동일 레벨 인터럽트 처리불가 시간의 등록에 따라 생성된 인터럽트 서비스 루틴 스터브에서 현재 발생한 인터럽트가 동일 레벨 인터럽트 처리불가 시간 이내인가를 판단하는 제 1 단계와;A first step of receiving the generated interrupt and determining whether the interrupt currently generated in the interrupt service routine stub generated according to the registration of the same level interrupt dead time is within the same level interrupt dead time; 상기 판단 후 동일 레벨 인터럽트 처리불가 시간 이내가 아닐 경우, 인터럽트 서비스 루틴을 계속 수행하는 제 2 단계와;A second step of continuing to perform an interrupt service routine if it is not within the same level interrupt processing inoperable time after the determination; 상기 판단 후 동일 레벨 인터럽트 처리불가 시간 이내에 발생한 것이면, 현재 발생한 인터럽트 서비스 루틴을 인터럽트 작업 큐에 넣어(S4) 이 수행을 인터럽트 2의 인터럽트 서비스 루틴의 수행이 끝날 때까지 연기하는 제 3 단계를 포함한느 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.If it occurs within the same level of interrupt processing time after the determination, the third step of putting the current interrupt service routine into the interrupt work queue (S4) and deferring this execution until the completion of the interrupt service routine of interrupt 2 is completed. The same level interrupt execution order control method characterized in that. 제 2 항에 있어서, 상기 제 1 단계는The method of claim 2, wherein the first step 동일 레벨 인터럽트 처리불가 시간의 등록에 따라 생성된 인터럽트 서비스 루틴 스터브에서 현재 발생한 인터럽트가 동일 레벨 인터럽트 처리불가 이내인가를 발생한 인터럽트의 번호 판별하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.A method for controlling the same level interrupt execution sequence, characterized by determining whether an interrupt number generated by the interrupt service routine stub generated according to the registration of the same level interrupt processing time is within the same level interrupt processing is not possible. 제 2 항에 있어서, 상기 제 2 단계는The method of claim 2, wherein the second step 등록된 동일 레벨 인터럽트 처리불가 시간 이내에 발생한 인터럽트가 아닐 경우 인터럽트의 인터럽트 서비스 루틴이 수행하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.A method for controlling the same level interrupt execution sequence, characterized in that the interrupt service routine of the interrupt is performed if the interrupt does not occur within the registered same level interrupt processing time. 제 2 항에 있어서, 상기 제 3 단계는The method of claim 2, wherein the third step 등록된 동일 레벨 인터럽트 처리불가 시간 이내에 발생한 인터럽트이면 이를 즉시 처리하지 않고 인터럽트 작업 큐에 넣고 지연시켜 이어서 발생할 동일 레벨 인터럽트 처리불가 시간을 등록한 인터럽트의 처리 이후에 수행시키는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.If the interrupt occurred within the registered same level interrupt processing time, it is not immediately processed and placed in the interrupt work queue and delayed, so that the same level interrupt processing time to be executed after the processing of the registered interrupt is performed. Control method. 제 1 항에 있어서, 상기 제 2 과정은The method of claim 1, wherein the second process 사용자가 운영체계에서 동일 레벨 인터럽트 처리불가 시간 등록을 위해 제공하는 프리미티브에 인터럽트 번호와 동일 레벨 인터럽트 처리 시간을 이용하여 등록을 요구하는 제 1 단계와;A first step of requesting registration using an interrupt number and the same level interrupt processing time to a primitive provided by the user for registering the same level interrupt non-processing time in an operating system; 상기 제 1 단계 수행 후 요구를 등록하기 위해 인터럽트 서비스 루틴 스티브가 존재하는지 판단하여 인터럽트 서비스 루틴 스터브가 없는 경우 새로 생성하는 제 2 단계와;A second step of judging whether an interrupt service routine Steve exists to register a request after performing the first step and creating a new one if there is no interrupt service routine stub; 상기 제 2 단계 수행 후 인터럽트 서비스 루틴 스터브에 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간을 등록하는 제 3 단계를 포함하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.And a third step of registering an interrupt processing time equal to the interrupt number and the same level interrupt processing time to the interrupt service routine stub after performing the second step. 제 7 항에 있어서, 상기 제 1 단계는8. The method of claim 7, wherein the first step is 사용자가 시스템의 프리미티브에 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간을 이용하여 등록을 요구하면 운영체계 내부에서 수신하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.A method for controlling the same level interrupt execution sequence, which is received by an operating system when a user requests registration by using an interrupt disabling time equal to an interrupt number in a system primitive. 제 7 항에 있어서, 상기 제 2 단계는8. The method of claim 7, wherein the second step is 상기 인터럽트 서비스 루틴 스터브의 존재 여부 판단의 수행 결과 해당 인터럽트 서비스 루틴 스터브가 존재하지 않으면 기본 구조를 갖는 인터럽트 서비스 루틴 스터브를 생성하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.And generating an interrupt service routine stub having a basic structure when the interrupt service routine stub does not exist as a result of the determination of the existence of the interrupt service routine stub. 제 7 항에 있어서, 상기 제 3 단계는8. The method of claim 7, wherein the third step is 인터럽트 서비스 루틴 스터브에 등록을 요구한 인터럽트 번호로 해당 인터럽트 서비스 루틴과 동일 레벨 인터럽트 처리불가 시간을 등록하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.A method for controlling the same level interrupt execution sequence, wherein the same level interrupt processing time as the corresponding interrupt service routine is registered with the interrupt number that has requested registration in the interrupt service routine stub. 제 1 항에 있어서, 상기 제 3 과정은The method of claim 1, wherein the third process is 사용자가 프리미티브에 인터럽트 번호로 동일 레벨 인터럽트 처리불가 시간의 해제를 요구하는 제 1 단계와;A first step of the user requesting the primitive to release the same level interrupt dead time by the interrupt number; 상기 프리미티브에 인터럽트 번호로 동일 레벨 인터럽트 처리불가 시간의 해제를 위해 인터럽트 서비스 루틴 스터브에서 해당 인터럽트 번호와 동일 레벨 인터럽트 처리불가 시간을 제거하여 해제하는 제 2 단계와;A second step of removing the same level interrupt processing time as the interrupt number from the interrupt service routine stub to release the same level interrupt processing time by the interrupt number in the primitive; 상기 인터럽트 서비스 루틴 스터브에 동일 인터럽트 처리불가 시간이 등록된 것이 없는가를 판단하여 마지막 등록을 해제한 경우 해당 인터럽트 서비스 루틴 스터브를 삭제하는 제 3 단계를 포함하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.And a third step of deleting the corresponding interrupt service routine stub if it is determined that the same interrupt processing time is not registered in the interrupt service routine stub and the last registration is cancelled. . 제 11 항에 있어서, 상기 제 1 단계는12. The method of claim 11, wherein the first step is 사용자가 시스템의 프리미티브를 이용하여 인터럽트 번호로 등록된 동일 레벨 인터럽트 처리불가 시간의 해제를 요구하면 운영체계 내부에서 해제 요구를 수신하여 구현하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.If the user requests the release of the same level interrupt processing dead time registered by the interrupt number using the system primitive, the same level interrupt execution sequence control method, characterized in that receiving and implementing the release request in the operating system. 제 11항에 있어서, 상기 제 2 단계는12. The method of claim 11, wherein the second step is 해당 인터럽트 서비스 루틴 스터브에서 인터럽트 번호에 해당되는 동일 레벨 인터럽트 처리불가 시간의 등록을 해제하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.And canceling the registration of the same level interrupt inoperation time corresponding to the interrupt number in the interrupt service routine stub. 제 11 항에 있어서, 상기 제 3 단계는12. The method of claim 11, wherein the third step is 상기 인터럽트 서비스 루틴 스터브에 동일 레벨 인터럽트 처리불가 시간이 등록된 것이 없는가의 판단 후 수행 결과에서 모든 등록이 해제되었으면 이 인터럽트 서비스 루틴 스터브를 삭제하는 것을 특징으로 하는 동일 레벨 인터럽트 실행순서 제어방법.And if all registrations are released from the execution result after determining whether the same level interrupt processing time is not registered in the interrupt service routine stub, deleting the interrupt service routine stub.
KR1019970054293A 1997-10-22 1997-10-22 Same-level interrupt execution sequence control method KR100241343B1 (en)

Priority Applications (1)

Application Number Priority Date Filing Date Title
KR1019970054293A KR100241343B1 (en) 1997-10-22 1997-10-22 Same-level interrupt execution sequence control method

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1019970054293A KR100241343B1 (en) 1997-10-22 1997-10-22 Same-level interrupt execution sequence control method

Publications (2)

Publication Number Publication Date
KR19990033051A KR19990033051A (en) 1999-05-15
KR100241343B1 true KR100241343B1 (en) 2000-02-01

Family

ID=19523224

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1019970054293A KR100241343B1 (en) 1997-10-22 1997-10-22 Same-level interrupt execution sequence control method

Country Status (1)

Country Link
KR (1) KR100241343B1 (en)

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR100812346B1 (en) 2006-02-06 2008-03-11 삼성전자주식회사 Method and Apparatus for Interrupt Handling in Reconfigurable Array

Also Published As

Publication number Publication date
KR19990033051A (en) 1999-05-15

Similar Documents

Publication Publication Date Title
US6820155B1 (en) Interruption managing device and interruption managing method
CA1251868A (en) Dynamic assignment of affinity for vector tasks
US5748959A (en) Method of conducting asynchronous distributed collective operations
US7627705B2 (en) Method and apparatus for handling interrupts in embedded systems
EP0362106A3 (en) Method for scheduling execution of distributed application programs at preset times in an sna lu 6.2 network environment
JP2003046653A (en) Timely shut-down function of real-time work center
US7366814B2 (en) Heterogeneous multiprocessor system and OS configuration method thereof
JPH0675911A (en) On-line processing system and overload suppression processing method
KR100241343B1 (en) Same-level interrupt execution sequence control method
US5758161A (en) Testing method for checking the completion of asynchronous distributed collective operations
JPH02311932A (en) Preference control system
JPS62284437A (en) Task control system
AU714853B2 (en) Job scheduling for instruction processor
JPH09101902A (en) Job scheduling system
JP3005562B1 (en) Task management device and task scheduling method
JP2526399B2 (en) Load balancing method for parallel computers
JP3717722B2 (en) Task management method using memory area of real-time OS
JPH02220138A (en) Interruption protecting system for real time operating system
JPH0451329A (en) Context switching device
JPS6331818B2 (en)
JPH01213738A (en) Transaction control system
JPS63239537A (en) Task control method
WO1992003783A1 (en) Method of implementing kernel functions
JP2822728B2 (en) Computer system
KR940003846B1 (en) Real-time processing scheduling method in electronic exchange

Legal Events

Date Code Title Description
A201 Request for examination
E701 Decision to grant or registration of patent right
GRNT Written decision to grant
FPAY Annual fee payment

Payment date: 20041101

Year of fee payment: 6

LAPS Lapse due to unpaid annual fee