KR20010080223A

KR20010080223A - 내장 서브루틴을 수행하는 프로세서 및 그 프로세서 동작시 인트럽트 서비스 방법

Info

Publication number: KR20010080223A
Application number: KR1020017004846A
Authority: KR
Inventors: 새빌레윈드로프엘; 로스케빈
Original assignee: 롤페스 요하네스 게라투스 알베르투스; 코닌클리즈케 필립스 일렉트로닉스 엔.브이.
Priority date: 1999-08-19
Filing date: 2000-07-31
Publication date: 2001-08-22
Also published as: TW518468B; US6493781B1; CN1320243A; JP2003507815A; CN1184571C; EP1127320A1; KR100817947B1; WO2001014977A1

Abstract

프로세서가 서브루틴을 내장하고 서브루틴이 인터럽트를 디스에이이블시키고 인에이블할 때 발생할 수 있는 정보의 손상를 방지하기 위한 방법이 제공된다.

Description

내장 서브루틴을 수행하는 프로세서 및 그 프로세서 동작 시 인트럽트 서비스 방법{SERVICING OF INTERRUPTS WITH STORED AND RESTORED FLAGS}

프로세싱 시스템에서, 예를 들어 메모리와 같은 공유 자원에 대한 다수의 요구를 용이하게 처리하기 위해, 보통 인터럽트 서비스 서브루틴을 사용한다. 대개, 이들 서브루틴은, 현 인터럽트가 완료될 때까지, 후속되는 인터럽트를 디스에이블(disable)시키고 나서 다시 인터럽트를 인에이블(enable)시키는 인스트럭션(instrucitons)을 포함하고 있다. 이러한 디스에이블(disable)/인에이블 (enable) 특징의 기본 목적은 동일한 자원에 대한 요구가 충돌할 때 기존의 정보를 손상하지 않고 이들 요구를 서비스하는 것을 보장하는 것이다.

어떤 상황에서, 각 인터럽트 서브루틴의 시작부분과 끝부분에서 각각 인터럽트를 디스에이블시키고 나서 다시 인에이블시키는 단순한 실행은 정보의 손상를 방지하기에 부적합하다. 예를 들자면, 때때로 제 1 서브루틴 내에 제 2 서브루틴을 내장하도록 하는 것이 바람직할 때가 있는데, 제 1, 2 서브루틴은 각기 자신의 디스에이블/인에이블 인터럽트 인스트럭션을 포함하고 있다. 내장된 제 2 서브루틴의 끝은 인에이블 인터럽트 인스트럭션을 포함하며, 인에이블 인스트럭션에는 제 1 서브루틴으로의 복귀(return)와 제 1 서브루틴의 완료를 초래하는 리턴(return) 인스트럭션이 후속된다. 그러나 내장된 제 2 서브루틴이 자신의 인에이블 인터럽트 인스트럭션을 내리고 있을 때 또 다른 인터럽트 서브스 요구가 대기 중이라면, 이 다른 인터럽트는 제 1 서브루틴이 완료되기 전에 제 3 서브루틴에 의해서 서비스될 수 있다. 만약에 제 3 서브루틴이 제 1 서브루틴에 의해 계속 사용되고 있는 메모리 위치를 공유하고 있다면, 제 3 서브루틴은 이들 공유된 메모리 위치에 있는 정보를 변경하고 본의아니게 손상시킬 수도 있다. 이와 달리, 이들 메모리 위치가 올바르지 않는 정보, 예를 들자면, 제 1 서브루틴에 의해 아직 갱신되지 않은 메모리 어드레스를 포함할 가능성이 있다. 이런 경우, 제 3 서브루틴이 올바르지 않는 어드레스에서 정보를 판독하거나 저장할 가능성이 있다.

이러한 문제들에 대한 알려진 해결책은 내장된 서브루틴을 수행하는 프로세서의 상태에 관련된 프로세서 상태어(processor status word)와 같은 적절한 데이터를 먼저 저장하고, 서브루틴들 중의 어느 하나의 수행을 용이하게 하도록 인터럽트를 디스에이블시킨 후, 저장된 데이터를 판독하고, 인터럽트를 다시 인에이블시키기 전에 프로세서를 좀 더 이전 상태로 복구하는 것이다. 이러한 해결책은 시간과 메모리를 많이 소비한다.

유럽 특허 제 441054 호는 일반적으로 이러한 문제를 논하고 있으며, 해결책으로 인터럽트를 서비스하는 인터럽트 로직, 상태 비트(status bits), 레지스터 뱅크(register banks)의 조합을 제안한다. 좀 더 단순한 해결책을 서비스하는 것이 바람직하다.

발명의 개요

본 발명의 목적은 메모리에 저장된 정보를 손상시키는 문제를 효과적으로 방지할 수 있는 간단한 인터럽트 서비스 방법을 제공하는 것이다.

본 명세서에 사용되는 "메모리"라는 용어는 일반적으로 사용되는 방식으로 해석되면서, 레지스터, RAM, DRAM, ROM, LIFO, FIFO 등과 같은 다양한 종류의 휘발성 및 비휘발성 장치들을 조건 없이 포함한다는 것을 주의하여야 한다.

본 발명에 따르면, 요구된 인터럽트에 응답하여 내장된 서브루틴을 수행할 수 있는 프로세서의 동작에서, 이러한 인터럽트을 서비스하는 방법은

·현 인터럽트 인에이블 상태(a current interrupt enable status)를 나타내는

지시자(indicator)를 서비스하며,

·그 지시자를 포함하는 상태 데이터(status data)를 저장하며,

·그 현 인터럽트 인에이블 상태를 디스에이블 상태에 배치하며,

·그 요구된 인터럽트가 명한 수행을 최소한 개시 하며,

·또 다른 인터럽트 요구를 수용하기 전에,

·상기 저장된 상태 데이터로부터 지시자를 판독고,

·지시자에 의해 지시되는 상태에 현 인터럽트 인에이블 상태를 배치한다.

본 발명은 인터럽트 서비스에 관한 것으로서, 특히 내장된 서브루틴(subroutine)과 관련된 인터럽트 서비스에 관한 것이다.

도 1은 본 발명의 실시예에 따라 인터럽트을 서비스할 수 있는 프로세싱 시스템을 도시하는 도면.

도 2는 본 발명에 따르는 방법의 실시예를 사용하는 동작의 예시적인 시퀀스를 나타내는 표.

도 3은 위 실시예에서 사용된 예시적인 인터럽트 서브루틴을 도시하는 표.

도 1의 프로세싱 시스템은 프로세서(10), 메모리(20), 버스(30)를 포함한다. 예시적인 프로세서(10)는 클럭 펄스(clock pulse)를 사용하여 프로그램 카운터 레지스터에 의해 식별된 인스트럭션을 시퀀스화한다. 대개, 프로그램 카운터 레지스터는 프로세서에 의해서 판독되고 실행될 다음 인스트럭션의 메모리 위치를 포함한다.

프로세서는 인터럽트 서비스 유닛(12), 레지스터 세팅(14), 인스트럭션 디코더(16), 산술 논리 유닛(arithmetic logic unit)(18)을 포함한다. 본 예시적인 실시예에서, 메모리(20)는 특히 서브루틴과 데이터의 저장을 위한 다수의 메모리 위치를 갖는 RAM을 포함한다. 바람직한 실시예에서, 메모리의 일부는 LIFO 스택(stack)(22)으로 이용된다.

프로세서(10)과 메모리(20)는 버스(30)에 연결되어 서로 통신하며 버스에 연결된 다른 하드웨어와 통신한다. 버스는 어드레스, 인터럽트, 판독스트로브(strobe), 기록 스트로브, 디바이스 선택 스트로브 등과 같은 정보를 운송하는 각각의 선을 포함한다.

프로세서(10)의 동작은 프로그램 스트림 내의 인스트럭션 및 인터럽트에 의해서 제어된다. 인터럽트는 버스(30)로부터 수신된 외부 인터럽트일 수도 있고 프로세서 자체 내에서, 예를 들어 프로세서 내에 있는 타이머(도시되지 않음)로부터 발생되는 내부 인터럽트일 수도 있다.

모든 인터럽트는 인터럽트 서비스 유닛(12)에 의해서 서비스되는 데, 이 유닛은 외부 및 내부 인터럽트와 관련된 메모리 위치를 식별하는 어드레스를 생산한다. 어떠한 인터럽트에 대해서도, 유닛(12)은 대응 인터럽트 서브루틴의 메모리(20)내의 위치를 식별하는 어드레스를 생산한다. 바람직하게, 인터럽트 서비스 유닛은 프로그램 할 수 있는 룩업 테이블(look-up table)이나 인코더(양자 모두 본 기술에 잘 알려져 있음)와 같은 어드레스를 생산하기 위한 전용 우선순위-민감 하드웨어(a dedicated priority-sensitive hardware) 구성 요소를 포함한다. 룩업 테이블과 인코더는 속도를 최대화하고, 하위 우선순위 인터럽트 보다 먼저 상위 우선순위 인터럽트의 서비스를 인에이블시킨다.

레지스터 세트(14)는 갱신가능한 메모리 어드레스와 인터럽트 서브루틴에 의해서 만들어지는 변수를 포함하기 위해서 다수의 레지스터를 포함한다. 바람직한 실시예에서, 레지스터 세트(14)는

·각 변수 A0, A1, A2를 홀드(hold)하기 위한 변수 레지스터(140 ,141, 142)와,

·엑세스 메모리(20)에 있는 다음 인스트럭션의 계속적으로 갱신되는 어드레스 PC를 홀드하기 위한 프로그램 카운터 레지스터(143)와,

·이용되기를 기다리는 다수의 정보 단위를 지시하는 카운트를 홀드하는 카운터 레지스터(144)와,

·한 개의 이상의 범용 레지스터(도시되지 않음)와,

·산술 논리 유닛(18)에 의해서 만들어지거나 메모리(20)로부터 판독되는 데이터를 포함하기 위한 한 개 이상의 데이터 레지스터(도시되지 않음)를 포함한다.

인스트럭션 디코더(16)는 산술 논리 유닛(18)에 의해서 메모리(20)로부터 판독된 인스트럭션을 실행될 저레벨 동작 코드로 인스트럭션을 변환하기 위한 시퀀서(sequencer)나 마이크로 시퀀서 같은 통상의 하드웨어 구성요소이다. 산술 논리 유닛 또한 통상의 하드웨어 구성요소이다.

도 2는 본 발명의 바람직한 실시예에 따라 다수의 인터럽트를 서비스함에 있어서, 프로세서(10)에 의해 수행될 순차적인 단계의 전형적인 예를 나타내고 있다. 본 예에서 사용되는 인터텁트 서브루틴은

·정보를 생산하는 생산 정보 서브루틴(a Produce Info Subroutine)과,

·생산 정보 서브루틴에 의해 생산되는 정보를 이용하는 소비 정보 서브루틴(a Consume Info Subroutine)과,

·레지스터(144)내의 카우트를 갱신하는 캥신 카운터 서브루틴(a Update Counter Subroutine)이다.

표에서 각 열의 표제(heading)는 다음과 같다.

·기호 IR은 인터럽트 요구 플래그(flag)의 상태를 나타내는데, "1"은 인터럽트요구가 수신 있는 중임을 나타내고, "0"은 수신되고 있는 인터럽트 요구가 없음을 나타낸다.

·기호 IE는 인터럽트 인에이블 플래그의 상태를 나타내는데, "1"은 플래그가 세팅되었다는 것 즉 인터럽트가 현재 인에이블됨을, "0"은 플래그가 리세트되었다는 것 즉 인터럽트가 현재 디스에이블 됨을 나타낸다.

·"Inst. #"은 현재 프로세서(10)에 의해서 실행되고 있는 인스트럭션의 번호를 나타낸다.

·"Count"는 레지스터(144)에 현재 포함된 개수, 즉 소비되기를 기다리는 이미 생산된 정보 단위의 개수를 나타낸다.

·기호 A0과 A1은 이들 변수의 현재 값을 나타내며, 이 값들은 레지스터 (140,

141)에 각기 저장된다.

도 3은 서브루틴에 포함된 각 인스트럭션이 각 인스트럭션 번호 다음에 오게 되는 예시적인 서브루틴을 도시하고 있다.

이제, 도 3를 참조하여 도 2에 도시된 예를 기술할 것이다. 이 예에서는, 단계 1에 선행하여 인터럽트 인에이블 플래그가 세팅(IE=1)되고, 레지스터(144)의 카운트는 0 값으로 초기화되어, 어떠한 정보도 소비되기를 기다리지 않음을 나타낸다고 가정하고 있다는 점에 주목해야 한다.

단계 1에서, 인터럽트 요구가 수신되어(IR=1) 정보를 생산한다. 프로세서(10)는 프로세서(10)가 자신이 수행 중이던 임의의 루틴으로부터 인터럽트 서브루틴 생산 정보로 스위칭하여 이 요구에 응답한다.

단계 2,3에서, 프로세서는 인터럽트 요구 플래그를 리세트하고, 정보를 생산하여 메모리(20)에 저장하며, 생산 정보 서브루틴의 인스트럭션 #1, #2를 실행한다. 구체적으로,

·단계 2에서, 프로세서는 인터럽트 요구 플래그를 리세트하고(IR=0), 인스트럭션 #1을 실행하는데 즉 레지스터(141)의 변수 A1 값을 1로 같게 세팅한다. (이 때에 변수 A0 값는 불확정이다. )

·단계 3에서, 프로세서는 인스트럭션 #2를 실행하는데, 즉 서브루틴 갱신 카운트를 호출한다.

단계 4 내지 9에서, 프로세서는 호출된 갱신 카운트 서브루틴를 수행한다. 구체적으로,

·단계 4에서, 프로세서는 인스트럭션 #10, 즉 Push & Disable Int. 를 실행한다. 이 인스트럭션에 따라서, 프로세서는 인터럽트 인에이블 플래그의 현 상태(IE=1)를 LIFO 스택에 밀어 넣음으로 먼저 인터럽트 인에이블 플래그의 현 상태를 저장한다. 예를 들어 다른 플래그의 현 상태와 같은 추가 정보를 저장할 필요가 있다면, 이 추가 정보는 이 때에도 역시 상기 스택에 밀어 넣어진다. 다음에, 프로세서는 인터럽트 인에이블 플래그를 리세트하고(IE=0), 이로써 레지스터(144)의 카운트를 갱신하는 것이 완료되기까지 후속되는 인터럽트을 디스에이블시키게 된다.

·단계 5에서, 프로세서는 레지스터(140)의 변수 A0 값을 레지스터(144)의 카운트의 현재 값 즉 A0=0과 같게 세팅함으로써 인스트럭션 #11을 실행한다.

·단계 6에서, 프로세서는 합 A0 + A1 = 1 를 계산하고 그 합을 A0의 새로운 값으로 레지스터(140)에 저장함으로써 인스트럭션 #12를 실행한다.

·단계 7에서, 프로세서는 레지스터 (144)에 있는 A0의 새로운 값을 카운트의 새로운 값, 즉 count=1로 저장함으로써 인스트럭션 #13을 실행한다.

·단계 8에서, 프로세서는 인스트럭션 #14, 즉 Restore Int.를 실행한다. 이 인스트럭션에 따라서, 프로세서는 단계 4에서 인스트럭션 #10이 실행되었을때 LIFO 스택에 저장되었던 인터럽트 인에이블 플래그를 IE=1 상태로 복구한다. (만약 추가 정보가 단계 4에서 저장되었다면, 이 정보는 이 때에는 폐기한다.)

·단계 9에서, 인스트럭션 #15, 즉 Return을 실행한다. 이 인스트럭션에 따라서, 프로세서는 전에 수행되고 있는 서브루틴, 즉 생산 정보 서브루틴으로 복귀한다.

단계 10에서, 프로세서는 생산 정보 서브루틴에서 실행될 다음 인스트럭션, 즉 인스트럭션 #3 Jump to Produce Info을 실행한다. 이는 생산 정보 서브루틴을 간단히 다시 시작하게 한다.

단계 11,12에서, 프로세서는 정보를 생산하여 메모리에 저장하고 생산 정보 서브루틴의 인스트럭션 # 11, #12를 실행한다. 구체적으로,

·단계 11에서, 프로세서는 변수 A1를 1 값으로 다시 초기화함으로써 인스트럭션 #1을 실행한다.

·단계 12에서, 프로세서는 갱신 카운트 서브루틴을 호출함으로써 인스트럭션 #2를 실행한다.

단계 13내지 17에서, 프로세서는 인터럽트 요구가 수신되는 동안 호출된 갱신 카운트 서브루틴의 수행을 착수한다. 구체적으로,

·단계 13에서, 인터럽트 인에이블 플래그의 현 상태(IE=1)를 LIFO 스택에 먼저 저장함으로 인스트럭션 #10, 즉 Push & Disable Int. 를 실행한다. 다음에, 프로세서는 인터럽트 인에이블 플래그를 리세트하므로서(IE=0) 레지스터(144)의 카운트를 갱신하는 것이 완료될 때까지 후속되는 인터럽트를 디스에이블시키게 된다.

·단계 14에서, 프로세서는 변수 A0 값을 카운트 현재 값, 즉 A0=1과 같게 세팅함으로서 인스트럭션 #11을 실행한다.

·단계 15에서, 프로세서는 합 A0 + A1 = 2 을 계산하고 그 합을 A0에 대한 새로운 값으로 레지스터(140)에 저장함으로써 인스트럭션 #12를 실행한다. 본 단계 동안에, 프로세서는 또한 인터럽트 요구를 수신하는데, 인터럽트가 인스트럭션 #14에 따라서 다시 언에이블될 때까지 프로세서는 이 요구를 무시할 것이다.

·단계 16에서, 프로세서는 레지스터(144)내의 A0의 새로운 값을 카운트의 새로운 값, 즉 count=2로 저장함으로써 인스트럭션 #13을 실행한다.

·단계 17에서, 프로세서는 인스트럭션 #10이 마지막으로 실행되었을 때, 단계 13에서 LIFO 스택에 저장된 인터럽트 인에이블 플래그를 상태 IE=1로 복구함으로써 인스트럭션 #14를 실행한다.

단계 18에서, 프로세서는 단계 15에서 수신된 정보를 소비하도록 요구하는 인터럽트 요구에 응답한다. 프로세서는 스위칭함으로써 소비 정보 서브루틴에 응답한다.

단계 19에서, 프로세서는 인터럽트 요구 플래그를 리세트하고 나서(IR=0), 계속해서 소비 정보 서브루틴를 수행한다. 구체적으로,

·단계 19에서, 프로세서는 변수 A0의 값을 카운트의 현 상태 즉, A0=2와 같게 세팅함으로써 인스트럭션 #4를 실행한다.

·단계 20에서, 프로세서는 현재 카운트 값과 동일한 A0의 현재 값을 레지스터(140)로부터 판독함으로써 인스트럭션 #5, 즉 Test A0을 실행한다.

·단계 21에서, 프로세서는 A0 값을 0과 비교함으로써 인스트럭션 #6을 실행하게 된다. 만약 메모리(20)에 있는 어떤 정보도 소비되기를 기다리지 않음을 나타내는 A0=0일 경우라면 프로세서는 소비 정보 서브루틴의 처음으로 돌아간다. 그러나 여기에서는 메모리에 있는 정보 단위 2개가 소비되기를 기다리고 있다는 것을 나타내는 A0=2인 경우이다. 그러므로 프로세서는 저장되었던 정보의 마지막 단위를 소비하고 나서 상기 소비 정보 서브루틴에서 남아있는 인스트럭션을 계속함으로써 카운트를 감소시킨다.

·단계 22에서, 프로세서는 레지스터 141에 있는 변수 A1 값을 -1로 세팅함으로써 인스트럭션 #7을 실행한다.

·단계 23에서, 프로세서는 갱신 카운트 서브루틴을 호출함으로써 인스트럭션 #8을 실행한다.

단계 24내지 28에서, 프로세서는 인터럽트 요구가 수신되는 동안 호출된 갱신 카운트 서브루틴의 실행을 착수하게 된다. 구체적으로,

·단계 24에서, 인터럽트 인에이블 플래그의 현 상태(IE=1)를 LIFO 스택에 먼저 저장함으로써 인스트럭션 #10, 즉 Push & Disable Int. 를 실행한다. 다음에, 프로세서는 인터럽트 인에이블 플래그를 리세트함으로써(IE=0) 레지스터(144)의 카운트를 갱신하는 것이 완료될 때까지 후속되는 인터럽트를 디스에이블시킨다.

·단계 25에서, 프로세서는 변수 A0 값을 카운트의 현재 값 즉, A0=2와 같게 세팅함으로써 인스트럭션 #11을 실행한다. 본 단계 동안에, 프로세서는 인터럽트 요구를 수신하게 되는데 인터럽트가 인스트럭션 #14에 따라서 다시 인에이블될 때까지 프로세서는 이 요구를 무시할 것이다.

·단계 26에서, 프로세서는 합 A0 + A1 = 2 - 1 = 1 을 계산하고 이 합을 A0에 대한 새로운 값으로 레지스터(140)에 저장함으로써 인스트럭션 #12를 실행한다.

·단계 27에서, 프로세서는 A0의 새로운 값을 카운트에 대한 새로운 값, 즉 count=1로 레지스터(144)에 저장함으로써 인스트럭션 #13을 실행한다.

단계 28에서, 프로세서는 인스트럭션 #10이 마지막으로 실행되었을 때 단계 24에서 LIFO 스택에 저장된 인터럽트 인에이블 플래그를 IE=1 상태로 복구함으로써 인스트럭션 #14를 실행한다.

단계 29에서, 프로세서는 단계 25에서 수신된 사전 실행 생산 정보 서브루틴으로 스위칭하도록 요구하는 인터럽트 요구에 응답한다.

단계 30에서, 프로세서는 인터럽트 요구 플래그를 리세트하고(IR=0) 이전의 생산 정보 서브루틴이 단계 17에서 인터럽트 되었을 때 (A0=2, A1=1) 존재했던 A0 , A1의 값을 메모리로부터 인출한다. 다음에, 프로세서는 리턴 인스트럭션, 즉 인스트럭션 #15를 실행하여 이전 생산 정보 서브루틴으로 복귀를 초래한다. 다음에, 프로세서는 생산 정보 서브루틴 내의 다음으로 연속하는 인스트럭션, 즉 인스트럭션 #3을 실행한다.

단계 31에서, 프로세서는 생산 정보 서브루틴의 처음으로 점프(jump)함으로써 인스트럭션 #3을 실행한다.

단계 32, 33에서, 프로세서는 정보를 생산하여 메모리(20)에 저장하고 생산 정보 서브루틴의 인스트럭션 #1, #2를 실행한다. 구체적으로,

·단계 32에서, 프로세서는 변수 A1를 1 값으로 재초기화함으로써 인스트럭션 #1을 실행한다.

·단계 33에서, 프로세서는 갱신 카운트 서브루틴을 호출함으로써 인스트럭션 #2를 실행한다.

단계 34내지 38에서, 프로세서는 또 다른 인터럽트 요구가 수신되는 동안 갱신 카운트 서브루틴의 실행을 다시 착수한다. 구체적으로,

·단계 34에서, 프로세서는 인터럽트 인에이블 플래그의 현 상태(IE=1)를 LIFO 스택에 먼저 저장함으로써 인스트럭션 #10, 즉 Push & Disable Int. 를 실행한다. 다음에, 프로세서는 인터럽트 인에이블 플래그를 리세트함으로써(IE=0), 레지스터(144)의 카운트를 갱신하는 것이 완료될 때까지 후속되는 인터럽트를 디스에이블한다.

·단계 35에서, 프로세서는 변수 A0 값을 카운트의 현재 값, 즉 A0=1과 같게 세팅함으로써 인스트럭션 #11을 실행한다.

·단계 36에서, 프로세서는 합 A0 + A1 = 2 를 계산하고 이 합을 A0에 대한 새로운 값으로 레지스터(140)에 저장함으로써 인스트럭션 #12를 실행한다.

·단계 37에서, 프로세서는 A0의 상기 새로운 값을 카운트의 새로운 값으로(count=2) 레지스터(144)에 저장함으로써 인스트럭션 #13을 실행한다. 본 단계 동안, 프로세서는 인터럽트 요구를 수신받게 되는데, 인터럽트가 인스트럭션 #14에 따라서 다시 인에이블될 때까지 이 요구를 무시할 것이다.

·단계 38에서, 프로세서는 인스트럭션 #10이 마지막으로 실행되었을 때 단계 34에서 LIFO 스택에 저장된 인터럽트 인에이블 요구를 IE=1 상태로 복구함으로써 인스트럭션 #14를 실행한다.

단계 39에서, 프로세서는 단계 37에서 수신된 사전 실행 소비 정보 서브루틴으로 스위칭하도록 요구하는 인터럽트 요구에 응답한다.

단계 40에서, 프로세서는 인터럽트 요구 플래그를 리세트하고(IR=0) 이전의 소비 정보 서브루틴이 단계 28에서 인터럽트 되었을 때 (A0=1, A1=-1) 존재했던 A0 , A1의 값을 메모리로부터 인출한다. 다음에, 프로세서는 리턴 인스트럭션(인스트럭션 #15)을 실행하여 이전 소비 정보 서브루틴으로 복귀를 초래한다. 다음에, 프로세서는 단계 23에서 실행된 인스트럭션 #8 뒤에 오는 소비 정보 서브루틴에 있는 다음 연속하는 인스트럭션을 실행한다.

단계 41에서, 프로세서는 이 서브루틴의 처음으로 점프함으로써 소비 정보 서브루틴에 있는 다음으로 연속하는 인스트럭션을 실행한다.

단계 41 다음에서, 프로세서는 계속 유사한 방식으로 동작할 것이다. 도 2에서 도시된 예시적인 단계는 인터럽 서비스가, 본 발명의 실시예에 따라서, 단순한 방법으로, 적은 인스트럭션으로, 최소한의 정보를 저장함으로, 특정 하드웨어에 대한 필요 없이 얼마나 효과적으로 행해졌는가를 보여주기 위해서 서비스된다.

도 2에서 도시하고 전술한 시퀀스는 오직 본 발명의 이해를 돕기 위해서 제공진 예시적인 실시예이다. 이 시퀀스가 본 발명의 범주를 제한하지 않는다. 예를 들어서, 오직 단일 비트 코드(a single-bit code)가 인터럽트 요구 상태(IR)와 인터럽트 인에이블 상태(IE)에 대해서 사용된다. 그러나 본 기술에서 잘 알려진 것처럼, 몇몇 프로세서만이 다수의 인터럽트 요구에도 동시에 응답할 수 있고, 다중 인터럽트 인에이블 상태도 추적할 수 있다. 이와 동일하게 본 발명도, 예를 들어서 IR과 IE에 대해 각각 다중 비트 코드를 사용함으로써 다수의 요구를 서비스할 수 있고 다수의 상태도 추적할 수 있다. 또한, 본 발명은 예로서 개시된 세 개의 대표적인 서브루틴, 즉 생산 정보, 소비 정보, 갱신 정보 만을 가지고 사용되는 것으로 한정되지 않고 , 인터럽트 요구에 응답하여 내장될 수 있는 다양한 루틴과 서브루틴에도 적용할 수 있다.

Claims

요구되는 인터럽트에 응답하여 내장된 서브루틴을 수행할 수 있는 프로세서의 동작에서 인터럽트를 서비스하는 방법에 있어서,

a. 현 인터럽트 인에이블 상태(a current interrupt enable status)를 나타내는 지시자(IE)를 제공하는 단계와,

b. 상기 지시자를 포함하는 상태 데이터를 저장하는 단계와,

c. 상기 현 인터럽트 인에이블 상태를 디스에이블 상태에 배치하는 단계와,

d. 상기 요구된 인터럽트가 명한 수행을 최소한 개시하는 단계와,

e. 또 다른 인터럽트 요구를 수용하기 전에,

i. 상기 저장된 상태 데이터로부터 상기 지시자(IE)를 판독하는 단계와,

ii. 상기 지시자에 의해 지시되는 상태에 상기 현 인터럽트 인에이블 상태를 배치하는 단계를 포함하는 인터럽트 서비스 방법.
제 1 항에 있어서,

상기 상태 데이터는 오직 상기 지시자로만 이루어져 있는 인터럽트 서비스 방법.
제 1 항에 있어서,

상기 상태 데이터는 상기 상태 데이터를 LIFO 스택(stack)에 밀어 넣음으로써 저장되고, 상기 지시자는 상기 데이터를 상기 스택으로부터 꺼냄으로써(popping) 판독되는 인터럽트 서비스 방법.
제 1 항에 있어서,

상기 지시자가 상기 인터럽트 각각에 대한 현 인터럽트 인에이블 상태를 나타내면서 상기 프로세서는 다수의 인터럽트에 대한 요구을 동시에 수신할 수 있는 인터럽트 서비스 방법.
제 1 항에 있어서,

저장된 정보를 생산하고 소비하기 위해서 , 단계 (e) 아래에, 즉 또 다른 인터럽트 요구를 수용하기 전에,

소비되기를 기다리는 정보의 카운트를 갱신하는 인터럽트 서비스 방법.
제 1 항에 있어서,

상기 현 인터럽트 상태를 상기 상태 지시자에 배치하는 것은 상기 상태 데이터의 나머지를 폐기하는 것을 포함하는 인터럽트 서비스 방법.
요구된 인터럽트에 응답하여 내장된 서브루틴을 수행할 수 있는 프로세서에 있어서, 상기 프로세서는 상기 인터럽트를 서비스하기 위해서,

a. 현 인터럽트 인에이블 상태을 나타내는 지시자(IE)를 서비스하고,

b. 상기 지시자를 포함하는 상기 데이터를 저장하며,

c. 상기 현 인터럽트 인에이블 상태를 디스에이블 상태에 배치하고,

d. 상기 요구된 인터럽트가 명한 수행을 최소한 개시하며,

e. 또 다른 인터럽트 요구를 수용하기 전에,

i. 상기 저장된 상태 데이터로부터 상기 지시자(IE)를 판독하고,

ii. 상기 지시자에 의해 지시된 상태에 상기 현 인터럽트 인에이블 상태를 배치하도록 프로그램된 프로세서.
제 7 항에 있어서,

상기 상태 데이터는 오직 상기 지시자로만 이루어져 있는 프로세서.
제 7 항에 있어서,

상기 상태 데이터는 상기 상태 데이터를 LIFO 스택에 밀어 넣음으로써 저장되고, 상기 지시자는 상기 데이터를 상기 스택으로부터 꺼냄으로써 판독되는 프로세서.
제 7 항에 있어서,

상기 지시자가 상기 인터럽트 각각에 대한 현 인터럽트 인에이블 상태를 나타내면서 상기 프로세서는 다수의 인터럽트에 대한 요구을 동시에 수신할 수 있는 프로세서.
제 7 항에 있어서,

또 다른 인터럽트 요구를 수용하기 전에, 상기 저장된 데이터로부터 상기 지시자(IE)를 판독하도록 프로그램된 프로세서.
제 11 항에 있어서,

상기 상태 데이터는 오직 상기 지시자만으로 이루어진 프로세서.
제 7 항에 있어서,

상기 현 인터럽트 인에이블 상태를 상기 지시자에 의해 지시된 상태에 배치하는 것은 상기 상태 데이터의 나머지를 폐기하는 것을 포함하는 프로세서.