KR20070003765A

KR20070003765A - 운영체제

Info

Publication number: KR20070003765A
Application number: KR1020067008538A
Authority: KR
Inventors: 에리크 레스쿠에트; 블라디미르 그루즈데브
Original assignee: 쟈루나 에스에이
Priority date: 2003-10-01
Filing date: 2004-10-01
Publication date: 2007-01-05
Also published as: JP2007507779A; CN1942859A

Abstract

복수의 다른 운영체제 프로그램을 같은 RISC 컴퓨터에서 동시에 수행할 수 있게 하는 방법으로서, 상대적으로 높은 우선 순위(C5와 같은 실시간 운영체제)를 가지는 제1운영체제를 선택하는 단계, 상대적으로 낮은 우선 순위(리눅스와 같은 범용 운영체제)를 가지는 부수적 운영체제를 적어도 하나 이상 선택하는 단계, 예정된 조건 하에서 상기 운영체제 사이를 교환하여 수행되도록 정해진 공통 프로그램(나노커널과 유사한 하드웨어 자원 디스패처)를 제공하는 단계, 상기 제1운영체제와 부수적 운영체제가 상기 공통 프로그램에 의하여 제어될 수 있도록 조절하는 단계로 구성되는 운영체제.

Description

운영체제{Operating Systems}

본 발명은 운영체제에 관한 것이다. 구체적으로는 본 발명은 복수의 운영체제가 동시에 수행되도록 하기 위한 시스템, 방법, 컴퓨터 프로그램에 관한 발명이다.

일부 컴퓨터 프로그램에서는 프로그램 것들이 정해진 시간 내에 혹은 정해진 시각에 실행되는 것이 매우 중요하다. 그러한 프로그램의 예로서 휴대전화, 사설 전화스위칭기(PBX), 휴대전화 기지국을 제어하는 프로그램들을 들 수 있다. 전형적으로는 이 프로그램들이 외부 이벤트나 상태 변화에 일관된 방식으로, 이벤트가 일어난 그 시각에 또는 그로부터 일정한 시간 내에 반응하여야만 한다. 이를 가리켜 "실시간"으로 작동한다고 일컫는다.

다른 수많은 프로그램의 경우에는 그러나, 프로그램을 실행하는데 드는 시간이 그리 중요하지 않다. 이는 대부분의 컴퓨터 프로그램에 해당되는데, 스프레드시트, 문서 편집기, 급여 관리, 그리고 일반적인 보고·분석용 프로그램이 이에 속한다. 한편 그러한 프로그램 실행에 걸린 정확한 시간은 중요하지 않을지라도, 대부분의 경우 사용자는 가능한 한 더 빠른 실행 속도를 선호한다.

응용 프로그램(applications program)은 그가 실행되는 컴퓨터 내에서 그 컴퓨터와 운영체제를 통하여 상호작용한다. 응용 프로그램용 인터페이스(applications programming interface)를 사용함으로써 이 응용 프로그램을 이동 가능한 형식으로 쓸 수 있으며, 그에 따라 서로 다른 하드웨어 자원을 갖춘 다양한 컴퓨터상에서 실행될 수 있게 된다. 게다가 리눅스나 윈도우즈와 같은 흔한 운영체제는 다중 처리(multi-tasking)을 지원한다. 즉 여러 프로그램들이 동시에 작동하게 하여 준다. 이렇게 하기 위해서 운영체제는 스케줄링 기능을 제공한다. 달리 말하자면, 운영체제는 컴퓨터 자원의 사용량을 다른 프로그램들 사이에서 나눠주고, 스케줄링 알고리즘에 따라 시간을 배분한다. 이러한 종류의 운영체제는 아주 널리 쓰이지만 이들은 실시간 응용 프로그램을 실행하는데 필요한 지원 기능이 마련되어 있지 않기 때문에 제어나 통신 분야의 수많은 용도에는 적합하지 않다.

따라서 그러한 용도를 위하여 실시간 운영체제가 개발되었다. 한 예로써 ChorusOS(Chorus로도 알려졌다)와 그 파생 체제들을 들 수 있다. Chorus는 http://www.experimentalstuff.com/Technologies/ChorusOS/index.html과 Jaluna社 http://www.jaluna.com으로부터 얻을 수 있는 공개 소스 소프트웨어이다.

Chorus를 2001년 8월자 Sun Technical Report, 222쪽 Francois Armand저 "ChorusOS Features and Architecture Overview"가 기술하고 있는데, 이는 http://www.jaluna.com/developer/papers/COSDESPERF.pdf에서 얻을 수 있다.

이들 운영체제는 다른 종류의 프로그램을 수행하는데 쓰일 수 있다. 그러나 사용자가 윈도우즈나 리눅스와 같은 범용 운영체제용으로 작성된 방대한 양의 "기존 사용" 프로그램("legacy" program)들에 대하여 실시간 운영체제에서도 수행가능하도록 고쳐 쓸 필요 없이 실행할 수 있기를 바라는 것은 이해할 수 있는 일이다.

"이중 부팅("dual boot")" 운영체제를 마련하여 사용자가 운영체제를 택일하여 운용하는 것도 가능하지만, "기존 사용" 프로그램을 실시간 프로그램과 동시에 실행하는 것이 바람직한 경우도 많이 있다. 예를 들어 통신망 기반 장비(network infrastructure equipment), 제3세대 휴대전화와 다른 첨단 전화기, 첨단 전자 게임기 등은 실시간 응용 프로그램(예를 들어 게임용 그래픽)과 비실시간 응용 프로그램(게임 내려받기)이 모두 필요할 수 있다.

미국 특허 제5903752호와 제5721922호에서는 실시간 다중 처리 커널(multi-tasking kernel)을 비실시간 운영체제(윈도우즈와 같은)의 인터럽트 처리 환경에 제공함으로써 실시간 환경을 비실시간 운영체제에 도입하려는 시도를 하였다.

널리 사용된 한 가지 방식은 "에뮬레이션"이다. 전형적인 에뮬레이션 프로그램은 실시간 운영체제에서 실행되도록 작성되고, 범용 운영체제에서 작동하도록 짜 여진 다른 프로그램의 각 명령을 해석한 뒤 그에 대응하는 명령들을 실시간 운영체제하에서 수행한다. 그러나 한 명령이 언제나 다수의 명령으로 대체되기 때문에 에뮬레이션은 컴퓨터에 큰 부담을 주고, 수행 속도를 떨어뜨린다. 가상 머신(예를 들어 Java^TM 가상 머신)을 제공하는 방식에서도 비슷한 문제가 일어난다. 가상 머신을 장착한 예로서 유럽 특허 EP 제1059582호와 미국 특허 제5499379, 제4764864호를 들 수 있다.

비슷한 또 기술로서 미국 특허 제5995745호(Yodaiken)이 있다. Yodaiken은 다중 처리 실시간 운영체제가 범용 운영체제를 수행 작업(task)으로서 실행하고 실시간 작업 수행의 필요에 따라 접수(pre-empt)하는 운영체제를 기술한 바 있다.

또 다른 방식은 실시간 운영체제를 범용 운영체제의 한 모듈로서 운용하는 것으로, 유럽 특허 제0360135호와 Electronics誌 1990년 9월 62쪽 기사 "Merging real-tiem processing and UNIX V"(Gosch)에 기재되었다. 이 경우에는 범용 운영체제와 관련된 하드웨어 인터럽트가 실시간 운영체제를 접수하지 못하도록 선택적으로 하드웨어 인터럽트를 금지(mask)한다.

또 방식은 http://opersys.com/ftp/pub/Adeos/adeos.pdf의 백서에 기술된 ADEOS(Adaptive Domain Environment for Operating Systems)다. ADEOS는 무엇보다도, 여러 개의 운영체제를 실행시키지만 마치 리눅스만 설치되어 있는 것과 같이 보이는 효과를 나타내도록 꾀한 나노커널(nanokernel)을 제공한다. ADEOS의 용도로서 주창한 것은 ADEOS를 통하여 인터럽트를 리눅스용 실시간 응용 프로그램 인터페 이스(Real Time Application Interface for Linux, RTAI)인데, 이는 http://www.aero.polimi.it/~rtai/applications를 보면 된다.

유럽 특허 제1054332호는 "스위칭 단위"("switching unit" 완전한 이해할 만큼 충분하게 설명되지 않았음)가 실시간과 범용 운영체제를 실행하는 시스템을 기술한다. 하드웨어 인터럽트는 공통 인터럽트 처리기가 처리하고, 몇몇 실시예에서는 실시간 운영체제가 담당하는데 실시간 운영체제는 이어서 보조(secondary) 운영체제 루틴이 처리할 소프트웨어 인터럽트를 우선 순위를 낮게 부여하여 발생시킨다.

본 발명의 목적은 복수의 운영체제를 다른 용도로 설계된 경우에까지도 동시에 실행하기 위한 개선된 시스템, 방법 및 컴퓨터 프로그램을 제공하는 데에 있다. 특히 본 발명은 운영체제 중 하나(예를 들어 실시간 운영체제)가 방해받지 않고 작업을 수행하고 다른 하나(예를 들어 범용 운영체제)는 컴퓨터의 나머지 자원을 최대한 잘 활용하며 작업을 수행하도록 하는 것을 꾀한다.

따라서 본 발명의 일측면은 복수의 운영체제가 약간 설계 변경을 받고 거기에 공통 프로그램이 주어지되, 그 공통 프로그램에 의하여 그들 사이의 스케줄링 작업이 수행되고, 그들 중 한 운영체제("주운영체제" 또는 "핵심 운영체제")가 다른 운영체제들("보조"나 "비핵심" 운영체제)에 대하여 특혜를 받는 시스템을 제공한다. 더 바람직하게는 본 발명은 하드웨어를 핵심 운영체제에 특혜적으로 할당하며, 핵심 운영체제가 접근(access)하는데 방해가 되는 보조 운영체제(들)의 접근을 인정하지 않는다. 본 발명은 더 바람직하게는 핵심 운영체제 드라이버를 사용하여 공유 자원(shared resources)에 접근하는데, 그것은 설령 보조 운영체제가 그러한 접근을 요하더라도 마찬가지이다. 그러나 미국 특허 제5995745호에서와 같이 핵심 운영체제가 보조 운영체제를 "실행"하는 것은 절대로 아니다. 각 체제는 실행 중에 상대 운영체제를 무시하며 오로지 공통 프로그램(선행기술의 나노커널(nanokernel)에 해당)과 통신하는데 이 프로그램은 핵심 운영체제의 드라이버에 대한 접근을 중개한다.

보조 운영체제들은 인터럽트를 금지하지 못하도록 설계 변경되며 그들의 인터럽트 서비스 루틴은 인터럽트 발생을 가리키는 메시지에 반응하도록 설계 변경되는 것이 바람직하다. 공통 프로그램은 모든 하드웨어 예외(exception)를 주운영체제의 인터럽트 서비스 루틴에 넘김으로써 처리하고, 하드웨어 인터럽트의 대상이 보조 운영체제였던 경우에는 인터럽트 메시지나 고지(notification)를 생성한다. 공통 프로그램의 스케줄링에 따라 보조 운영체제가 할당된 다음 차례에 위 메시지나 고지는 그로 넘겨지고 공통 프로그램은 인터럽트 서비스를 위한 루틴을 호출한다.

따라서 인터럽트 발생시에 보조 운영체제는 주운영체제(혹은 일반적으로 보조 운영체제 중 중요도가 더 높은 것)를 어떤 방식으로도 접수할 수 없는데, 이는 모든 인터럽트가 먼저 주운영체제에 의하여 처리되고 보조 운영체제에 대한 인터럽트는 주운영체제가 작업 수행을 마치고 보조 운영체제에 스케줄링에 따른 차례가 왔을 때에만 인터럽트를 보조 운영체제에 고지하기 때문이다.

이러한 인터럽트 처리는 따라서 주운영체제에 중요한 작업이 없을 때까지 미뤄진다. 그러나 결국 인터럽트 처리가 실행될 때는 보조 운영체제의 루틴들이 실질적으로 거의 변경되지 않은 채로 작동하여 그 결과 그 거동(behaviour)은 보조 운영체제로서 예측되는 바(처리가 연기된 것을 제외하고)대로 움직인다.

시스템 하드웨어

본 운영체제를 적용할 수 있는 컴퓨터(100)는 인텔社 펜티엄 4나 모토로라社파워 PC(실시예에서는 양쪽 모두 구현하였음)와 같은 중앙 처리 장치(CPU, 102), 그와 연결된 읽기 전용 메모리(ROM) 칩(106), CPU와 ROM을 잇는 시스템 버스(104, 제어·데이터·어드레스 버스로 이루어진다), 하나 또는 여러 개의 램(RAM, random access memory) 칩의 뱅크(bank)(108), 디스크 제어 장치(110, 플로피 디스크브, 하드 디스크 드라이브, DVD와 같은 추가적 휴대용 미디어 드라이브에 연결된 IDE나 SCSI 제어기를 예를 들 수 있음), 하나 또는 여러 개의 입출력(I/O) 포트(112, 예를 들어 한 개나 여러 USB 포트 제어장치나 혹은 더하여 프린터 연결용 병렬 포트 제어장치 등), 내외부 주변 장치(예를 들어 PCI 버스) 연결용의 확장 버스(114) 및 여타 시스템 칩(116, 예를 들어 그래픽, 사운드 장치)를 갖추고 있다. 이러한 유형의 컴퓨터의 예로 개인용 컴퓨터, 워크 스테이션을 들 수 있다. 그러나 본 발명을 메인프레임, 제어 시스템에 내장된 마이크로컴퓨터, PDA(이 경우는 앞서 든 장치 중 디스크 드라이버와 같은 것은 빠질 수 있음) 등의 다른 컴퓨터 장치에 적용하는 것도 이하 개시하겠다.

소프트웨어 관리

도 2a를 참조할 때, 도 1의 컴퓨터(100)는 작동 중에 운영체제 커널(202, CPU가 도 1에 보인 다른 장치들에 접근할 수 있도록 출력 루틴을 제공한다), 운영체제 사용자 인터페이스 또는 X 윈도우즈와 같은 표현 층(presentation layer, 204), 미들웨어(middleware) 층(206, TCP/IP 스택과 같은 네트워크 프로토콜과 소프트웨어 제공)과 운영체제 커널(202)를 이루는 API 루틴을 호출함으로써 실행되는 응용 프로그램(208a, 208b)를 포함하는 상주 프로그램을 수행한다.

운영체제 커널은 다양한 작업을 하는데, 특히

＊스케줄링(즉 실행 중인 응용 프로그램 사이에 CPU와 그에 관련된 자원을 분배하는 일);

＊메모리 관리(즉, 각 수행 작업에 메모리를 할당하고 필요한 경우 데이터와 프로그램을 메모리 애드온(add-on)으로부터 디스크 드라이브로 치환(swapping)하는 일);

＊파일 시스템을 제공하는 일;

＊장치에 접근시키는 일(전형적인 예는 드라이버를 통하여);

＊인터럽트 처리;

＊응용 프로그램과 시스템 자원, 사용자들의 상호작용을 가능하게 하는 응용 프로그램용 인터페이스를 제공하는 일;이 있다.

커널은 이른바 Unix용의 단일 커널(monolithic kernel)이어도 무방한데, 이때 장치 드라이버는 커널 자체의 일부를 이룬다. 혹은 커널을 Chorus와 같은 "마이크로커널"로 할 수 있는데. 이 경우는 장치 드라이버가 커널과 별도로 있다.

이제 컴퓨터(100)가 시작되어 사용에 들어가면, ROM(106)에 저장된 부트스트랩(bootstrap) 프로그램이 디스크 제어장치(110)에 접근하여 디스크 영구 저장부로부터 RAM(108)으로 운영체제의 파일 처리 부분을 읽어들이게 되고, 그 다음 운영체제의 나머지 부분을 RAM(108)의 영역에 적재(load)한다. 운영체제는 그 다음 디스크 제어장치(110)를 이용하여 디스크 드라이브로부터 어떠한 응용 프로그램이라도 읽어들이고, 각 프로그램을 위하여 RAM(108)에 공간을 할당한 다음, 각 프로그램을 그 할당된 메모리 공간에 저장한다.

응용 프로그램의 작동시, 운영체제의 스케줄러 부분은 상이한 응용 프로그램들 사이의 CPU 사용량을 분배하여, 스케줄링 방침에 따라 각각이 프로세서 시간을 나눠 가질 수 있게끔 한다. 스케줄러는 또한 잘 안 쓰이는 응용 프로그램이나 데이터를 "밖으로 치환"(swapping out, 즉 그들을 RAM(108)으로부터 제거하여 메모리 공간을 비우고, 이들을 디스크에 저장)함으로써 메모리 자원의 사용을 관리한다.

마지막으로 응용 프로그램은 응용 프로그램용 인터페이스(API)를 구성하는 루틴을 호출하여 입력과 출력 등의 기능을 수행하고, 운영체제의 인터럽트 처리 루틴은 인터럽트와 이벤트들에 응답한다.

도 1은 본 발명이 실행될 수 있는 컴퓨터의 구성 요소를 나타내는 블록도;

도 2a는 선행기술의 소프트웨어 배치도;

도 2b는 본 실시예에 따른 소프트웨어의 배치를 도시하며 그에 대응하는 도면;

도 3은 도 1의 컴퓨터를 위한 도 2b의 소프트웨어를 작성하는 것를 보여주는 흐름도;

도 4는 도 2b의 일부를 이루는 하드웨어 자원 디스패처(dispatcher)의 구성 도;

도 5는 부팅과 초기화에 사용되는 프로그램을 도시한 도면;

도 6은 부팅 또는 초기화 과정에 사용되는 시스템 메모리 이미지를 도시한도면;

도 7은 주운영체제로부터 한 보조 운영체제로 전이하는 과정을 도시한 도면;

도 8은 한 보조 운영체제로부터 주운영체제로 전이하는 과정을 도시한 도면;

도 9a는 본 발명에 따라 서로 다른 운영체제에서 실행되는 응용 프로그램 사 이의 통신을 도시한 도면;

도 9b는 본 발명에 따라 서로 다른 컴퓨터상의 서로 다른 운영체제에서 실행되는 응용 프로그램 사이의 통신을 도시한 도면;

도 10은 주, 보조, 그리고 나노커널(nanokernel) 물리적 주소 공간의 실시예를 도시한 도면;

도 11은 상기 메모리 콘텍스트이 어떻게 제시간에 스위칭되는지를 도시한 도면;

도 12는 상기 나노커널(nanokernel) 콘텍스트의 보이는 부분을 도시한 도면;

도 13은 상기 실행 플로우와 상기 나노커널(nanokernel) 스택이 어떻게 인터럽트 처리와 주 커널 재-진입을 허락하도록 사용되는지 도시한 도면.

상기 첨부된 도면을 참조하면서 본 발명의 실시예들을 기술하기로 한다. 이는 어디까지나 예시일 뿐이다.

바람직한 실시예의 원리 요약

바람직한 실시예에서 도 1의 컴퓨터(100)에 사용될 각 운영체제(201, 202)에는 약간의 설계 변경이 가해지고 낮은 수준의 새 프로그램(400, 여기서 "하드웨어 자원 디스패처"로 명명한다, 비록 운영체제의 커널이 아니지만 때때로 "나노커널(nanokernel)"로 불리기도 한다)이 신설된다. 하드웨어 자원 디스패처(400)는 CPU(102)와 상호작용을 하므로 CPU의 특정 형태에 맞춤식으로 되어 있다. 또한 곧 밝힐 명백한 이유에 따라 설계 변경되는 운영체제(201, 202)의 버전 역시 하드웨어에 따라 맞추게 된다.

하드웨어 자원 디스패처(400)는 그 자체로는 운영체제가 아니다. 디스패체는 응용 프로그램과는 전혀 상호작용하지 않으며, 매우 제한된 기능을 가지고 있다. 디스패처는 비록 대부분의 계산 작업(processing)을 운영체제에 맡기며 프로세서에서 운영체제의 기계어 코드(native code)를 그대로 수행하지만 디스패처가 협동 작업을 하기 위해서는 운영체제를 변경하여야 하므로 가상 머신이나 에뮬레이터(emulator)도 아니다. 디스패처는 아래의 기초적인 기능을 수행한다.

＊복수의 운영체제들 각각을 적재(load)하고 시작;

＊메모리와 다른 시스템 자원을 각 운영체제에 할당;

＊서로 다른 운영체제들의 작동에 대한 스케줄링(즉 그들 사이에 CPU 시간을 분배하고 운영체제 사이에 일어나는 상태 변화를 관리한다);

＊운영체제들이 나누어 사용하여야 하는 시스템 장치들에 간접적으로 접근하는 방식인 "가상화 장치(virtualised device)"를 제공(장치의 "가상화");

＊서로 다른 운영체제상에서 실행되는 응용 프로그램들끼리 통신할 수 있도록 운영체제들 사이에 통신 연결을 제공;

실시예에서 운영체제는 같은 대우를 받지 않는다. 대신 운영체제 중 하나를 핵심 운영체제(이것이 실시간 운영체제가 됨)로 삼으며 나머지 운영체제는 "비핵심" 또는 "보조" 운영체제(이는 리눅스와 같은 범용 운영체제가 됨)가 된다.

하드웨어 자원 디스패처 설계시, 사용가능한 시스템 자원(즉 장치와 메모리)를 기재한 데이터 구조(예를 들어 테이블)가 제공되어, 정적으로 할당(static allocation)할 수 있는 가장 많은 시스템 장치를 운영체제 중 어느 하나나 다른 쪽에 갖추게끔 한다. 예를 들어 병렬 프린터 포트는 범용 운영체제(202)에 정적으로 할당될 수 있고, 이 운영체제는 프린터 출력에 필요한 응용 프로그램을 실행하게 된다. 다른 한편으로 ISDN 디지털 선 어댑터 포트는 통신을 위하여 실시간 운영체제(201)에 영구 할당될 수 있다. 장치를 가능한 한 이렇게 정적으로 할당하는 것은 각 운영체제가 자신의 기존 드라이버를 사용하여 정적으로 할당된 장치를 하드웨어 자원 디스패처를 호출할 필요 없이 접근하는 것이 가능함을 뜻한다. 그러므로 그러한 장치에 접근하는 데에 따른 실행 속도의 저하(가상 머신이나 에뮬레이터와 같이 작동할 경우에 일어날 수 있는)가 없어진다.

반드시 공유되어야 하는 시스템 장치의 경우에 하드웨어 자원 디스패처는 비핵심 운영체제에 의한 장치 사용을 가상화하고 핵심 운영체제에 공급된 드라이버를 사용함으로써 장치에 대한 접근을 수행한다. 마찬가지로 인터럽트 처리에서는 인터럽트가 핵심 운영체제의 인터럽트 루틴으로 넘겨지고, 루틴은 인터럽트를 처리하거나(인터럽트 대상이 핵심 운영체제일 때) 하드웨어 자원 디스패처를 통하여 비핵심 운영체제로 전달된다(인터럽트 대상인 그 운영체제일 경우).

부팅시 하드웨어 자원 디스패처를 먼저 적재(loading)하고, 디스패처는 다시 각각의 운영체제들을 미리 예정된 순서, 핵심 운영체제부터 시작해서 차례로 각 보조 운영체제로 가는 순에 따라 적재(load)한다. 핵심 운영체제는 테이블 기재에 따라 필요한 자원을 배분받으며 작동할 수 있는 고정 메모리 공간을 소유하고 있다. 각 보조 운영체제는 다시 남은 자원으로부터 필요한 자원과 메모리 공간을 할당받는다. 따라서 실시예에서는 각 운영체제에 고유의 메모리 공간을 할당하고 장치의 독점적인 정적할당을 통하여 운영체제가 사용하는 자원들은 가능한 최대의 물리적 거리를 서로 두게 되고 필수적으로 공유하여야 하는 장치들만이 공유된다.

작동시에 하드웨어 자원 디스패처의 스케줄러는 핵심 운영체제가 모든 수행 작업을 마칠 때까지 실행되도록 하여 주며, 그 다음에는 차례로 각 비핵심 운영체제로 제어 기능을 넘겨 다음 인터럽트나 이벤트가 발생할 때까지 실행되게 한다. 그러므로 실시예의 시스템은 핵심 운영체제의 작동이 실질적으로 불변(핵심 체제가 자신의 고유한 드라이버를 사용하고 어떠한 인터럽트나 이벤트 처리에 대해서도 가장 먼저 접근할 수 있으므로)하는 다중 운영체제 환경을 가져다 준다. 보조 운영체제들은 남은 프로세서 시간의 한도 내에서 효율적으로 작동할 수 있는데, 이는 대부분의 경우 그들이 고유한 전용 드라이버와 다수의 시스템 장치에 대해 독점적으로 접근할 수 있기 때문이다. 최종적으로 하드웨어 자원 디스패처는 제한된 기능들 을 처리할 뿐이므로 그 자체가 작은 프로그램이어도 되는데, 이에 따라 시스템 자원이 절약된다.

바람직한 실시예는 또한 만들고 유지하는 데 경제적인데, 이는 이미 특정 컴퓨터(100)에 맞춰진 표준적인 시판 운영체제에 제한적인 변화를 주는 것만으로 족하기 때문이다. 나아가, 운영체제의 변경 사항이 특정한 유형의 컴퓨터(100)와 인터페이스를 이루고 운영체제의 여타 부분과 같이 자주 바뀔 가능성이 적은, 인터럽트 처리나 초기화 시간에서의 컴퓨터 배치(configuration)와 같은 설계특정적(architecture-specific) 파일 처리 관련 문제에 국한되기 때문에 똑같은 운영체제의 새 버전을 다중 운영체제 방식에서 작동하게끔 고쳐 주는데 드는 수고가 거의 없다.

바람직한 실시예의 상세한 설명

이 실시예에서 컴퓨터(100)는 인텔 386계열 프로세서(예를 들어 펜티엄 프로세서)와 모토롤라 파워PC 750(RISC, reduced instruction set computer) 컴퓨터(단계 302)이다. 핵심 운영체제(201)는 C5 운영체제(ChorusOS 체제의 제5세대 공개 소스 버전인 Jaluna-1의 실시간 마이크로커널, 공개 소스로 다음 주소에서 무료로 내려받기, http://www.jaluna.com)이다.

단계 306에서 Chorus운영체제 커널(201)은 다중 운영체제 방식하에서 작동하 도록 조절되는데 이는 새로운 플랫폼에 이식하는 일(즉 CPU는 같지만 시스템 장치들은 다른 새 컴퓨터에서 실행가능하도록 새 보드 지원 패키지(BSP, board support package)를 쓰는 일)과 마찬가지 방식으로 다뤄진다. 부팅과 초기화 순서(initialization sequence)는 실시간 운영체제를, 그 자신이 스스로 시작하지 않고, 하드웨어 자원 디스패처가, 그 운영체제에 할당된 메모리 공간에서, 시작할 수 있도록 조절된다. 초기화 순서의 하드웨어 검색 단계계는 핵심 운영체제가 다른 보조 운영체제에 할당된 하드웨어 자원에 접근하지 못하게끔 조절된다. 초기화 순서에서 하드웨어 자원 디스패처를 통하여 정적 하드웨어 할당 테이블 내용을 파악하고 디스패처가 사용 가능한 장치들을 감지하게 된다.

트랩 호출(trap call, 2012)은 상태를 감지하고 그에 따른 어떠한 조치를 요구하기 위하여 핵심 운영체제에 추가된다. 여기서 트랩 호출이란 컴퓨터로 하여금 현재 콘텍스트(context, 즉 레지스터들의 상태)을 저장하고 새로운 콘텍스트을 적재(load)하도록 하는 호출을 말한다. 가상 메모리 주소지정이 쓰였을 때는 따라서 주소 포인터는 바뀌게 된다. 예를 들어 실시간 운영체제(201)이 종착점에 도달(그리고 프로세서 자원을 사용할 필요가 없어져)한 때는 제어 기능이 다시 하드웨어 자원 디스패처에 되돌려지고, "유휴(idle)" 트랩 호출을 발하여 보조 운영체제를 시작할 수 있다. 많은 프로세서들은 "정지(halt)" 명령을 가지고 있다. 몇몇 경우에 감독자 수준의 코드(예를 들어 응용 프로그램이 아니라 운영체제)만이 그러한 "정지" 명령을 포함할 수 있다. 이 실시예의 경우 모든 운영체제에서 "정지" 명령이 삭제되고 "유휴" 루틴(예를들어 수행 쓰레드)로 바뀌는데, 이 루틴이 호출되면 "유휴" 트랩 호출을 하게 된다.

몇몇 BSP 드라이버는 보조 운영체제를 위한 공유 장치를 가상화하는데 하드웨어 자원 디스패처를 보조하기 위하여 특별히 맞춰졌다. 운영체제로서는 입출력(I/O) 버스에 대한 접근을 제공하는 것처럼 보이는 "가상" 드라이버(2014) 새로 추가되어 버스로 하여금 데이터를 작성할 수 있게 한다. 실제로 가상 버스 드라이버(2014)는 메모리를 통신 매개 수단으로 사용한다. 가상 버스 드라이버는 개인 메모리(private memory 입력 데이터용) 얼마간 수출하고 다른 운영체제가 수출한 메모리(출력 데이터용)를 수입한다. 이렇게 하여 운영체제(201, 혹은 그 운영체제에서 실행되는 응용 프로그램)는 다른 운영체제로(또는 그 안에서 실행되는 응용 프로그램) 마치 서로 다른 컴퓨터 장치에서 실행되고 실제 I/O 버스로 연결된 두 운영체제 사이처럼 데이터를 넘길 수 있다.

보조 운영체제(202)는 커널 버전이 2.4.18인 리눅스로 선택하였다(단계 308). 단계 310에서 상기 보조 운영체제(202)는 다중 운영체제 환경에서 기능할 수 있도록 변경되는데, 다중 운영체제 환경은 새로운 하드웨어 설계물로 처리한다. 단계 306에서와 같이, 부팅과 초기화 순서는 변경되는데, 보조 운영체제를 하드웨어 자원 디스패처가 시작할 수 있게 하고 보조 체제가 하드웨어 자원 디스패처 테이블에서 다른 운영체제에 할당된 것으로 명시한 하드웨어 자원들에 접근하지 못하도록 변경된다. 단계 306에서처럼 트랩 호출(2022)이 추가되어 하드웨어 자원 디스패처로 제어 기능이 넘겨진다.

공유 시스템 자원용의 고유(native) 드라이버는 하드웨어 자원 디스패처에 의하여 가상화된 장치들(인터럽트 제어기, I/O 버스 브리지, 시스템 타이머, 실시간 클럭)를 다루는 새 드라이버(2028)로 교체된다. 이들 드라이버는 도 1의 컴퓨터(100)의 해당 장치에 대한 몇 가지 연산을 수행하기 위하여, 하드웨어 자원 디스패처의 가상 장치 처리기(416)를 호출한다. 하드웨어 자원 디스패처의 그러한 가상 장치 처리기(416) 각각은 핵심 운영체제의 "동료(peer)" 드라이버 루틴과 짝지어지는데, 이 루틴은 시스템 장치와 직접 상호작용하도록 마련되었다. 따라서 가상 장치 처리기에 대한 호출은 실제 장치에 대한 접근을 위해 해당 가상화 장치용의 핵심 운영체제 동료 드라이버로 연계(relay)된다. 단계 306과 같이 해당 가상 I/O 버스에 대한 읽고 쓰기용(read and write) 드라이버(2024)가 제공되어 운영체제간 통신을 할 수 있다.

보조 운영체제의 인터럽트 서비스 루틴은 해당 가상 인터럽트(하드웨어 자원 디스패처의 인터럽트 처리 루틴(412)에 발한 호출의 형태)에 대응하는 각각의 가상 인터럽트 서비스 루틴(2026)을 제공하기 위하여 변경되는데. 그에 의하여 실제 인터럽트나 이벤트에 반응하지 않게 된다. 보조 운영체제의 루틴(인터럽트 서비스 루틴 포함) 역시 하드웨어 인터럽트의 금지(masking, 적어도 핵심적인 연산을 제외한 모든 루틴에 대하여)를 해제하도록 바뀐다. 그리하여 핵심 운영체제(201)가 보조 운영체제(202와 여타)들을 접수할 수 있게 된다. 다시 말해서, 가상 인터럽트에 대한 보조 운영체제의 응답 자체가 핵심 운영체제(201)에 대한 실제 인터럽트에 의하여 차단될 수 있다. 이에는 전형적으로 다음의 경우들이 속한다.

＊금지(mask)하거나 금지 해제하는 이벤트(프로세서 수준의 인터럽트);

＊금지 상태를 저장하고 복원하는 이벤트;

＊인터럽트 원인을 파악하는 작업(인터럽트 제어 장치);

＊소스 수준(인터럽트 제어 장치)에서 인터럽트의 금지 또는 금지 해제.

공유 하드웨어 장치(I/O 버스 브리지, 시스템 콘솔, 시스템 타이머와 실시간 클럭)에 접근하기 위하여 새 가상 장치 드라이버(2028)이 추가된다. 이들 드라이버는 컴퓨터(100)의 해당 장치로부터 데이터를 읽고 장치에 데이터를 써 넣기 위하여 하드웨어 자원 디스패처의 가상 장치 처리기(416)를 호출한다.

이러한 기능을 가질 수 있도록 본 실시예에서 리눅스 커널(2070)은 가상 하드웨어 자원 디스패처 구조 서브트리(I-386과 파워PC 다양한 버전용의 nk-i386과 nk-ppc)를 추가하여 변경되는데, 이 때 소수의 변경된 파일도 추가된다. 변경되지 않은 파일은 기존 형태 그대로 재사용된다. 원래의 서브트리는 유지되지만 사용되지는 않는다.

단계 312에서 하드웨어 자원 디스패처(400)가 작성된다. 하드웨어 자원 디스패처는 다음의 기능을 하는 루틴(도 4 참조)을 제공하는 프로그램 코드를 갖춘다.

＊자신을 부팅하고 초기화하는 기능(402);

＊하드웨어 자원(포트와 같은 장치)의 리스트와 각 자원이 해당 운영체제에 유니크하게 배당된 사항을 나타내는 할당 항목(allocation entry)을 담은 테이블을 저장하는 기능(403);

＊하드웨어 자원 디스패처 할당(allocation) 테이블을 완성하는 핵심 운영체제를 부팅하고 초기화하는 기능(404);

＊보조 운영체제들을 부팅하고 초기화하는 기능(406);

＊운영체제 사이의 스위칭(switching) 기능(408);

＊운영체제 사이의 스케줄링 기능(410);

＊인터럽트 처리(412, 실시간 운영체제 인터럽트 서비스 루틴을 사용하고 필요한 경우 보조 운영체제의 가상 인터럽트 서비스 루틴에 데이터를 공급);

＊각 운영체제로부터의 트랩 호출을 처리하는 기능(414);

＊공유 장치들에 대한 보조 운영체제의 접근을 처리하는 기능(416);

＊가상 I/O 버스상에서 운영체제간의 통신을 처리하는 기능(418).

이하, 실시예들에서는 디스패처가 버그 제거 프레임워크도 제공할 수 있다.

운영체제 스위칭기 ( operating system switcher,408)

한 운영체제에서 다른 운영체제로 스위칭하기 위해서 운영체제 스위칭기(408)는 현재 실행 중인 운영체제의 "콘텍스트(context)"-레지스터 값과 같은 상태 변수 집합의 현재값-을 저장하고, 다른 운영체제의 저장된 콘텍스트을 복원하며 상기 다른 운영체제가 바로 그 전 상태에서 작업 수행을 재개하는 호출을 하도록 설정된다. 프로세서가 메모리의 한 부분이나 가상 혹은 간접 주소 지정 테크닉을 사용하는 때에는 현 메모리 공간에 대한 포인터를 저장하는 데이터 구조나 레지스터에서 따라서 치환(swapping) 일어난다. 예를 들어 각 운영체제는 그러한 서로 다른 메모리 공간에서 작동하는데, 이 메모리 공간은 그 공간에 대한 포인터 값을 포함하는 콘텍스트에 의하여 정의된다.

구체적으로 스위칭기는,

＊현재 운영체제가 유휴 상태에 들어가면 현 운영체제로부터 스케줄링 상 다음으로 예정된 운영체제로 명시적(explicit) 스위칭 기능(예를 들어 트랩 호출)을 수행; 그리고,

＊하드웨어 인터럽트가 일어나면 보조 운영체제로부터 핵심 운영체제로 암시적(implicit) 스위칭 기능을 수행;한다.

스위칭 기능은 이하 기술하는 것처럼 트랩 호출이나 실제 혹은 가상 인터럽트시에도 일어날 수 있다.

스케줄러(410)

스케줄러(410)는 한 운영체제를 마치고 나서 어느 보조 운영체제(보조 운영 체제가 여럿일 때)로 스위칭할지를 선택함으로써 각 운영체제에 사용 가능한 프로세서 시간의 일부를 할당한다. 본 실시예에서 운영체제는 고정된 우선 순위 스케줄링에 따라 선택된다. 시간 공유(time sharing)나 프로세서 시간 최소분률 보증 방식(guaranteed minimum percentage)에 따른 선택 기준을 제시하는 다른 실시예도 이하 검토한다. 그러나 각 경우에 핵심 운영체제는 유휴 상태에 있을 때에만 접수당한다.

다음의 실시예에서 핵심 운영체제는 스케줄러(410)에 명시적으로 보조 운영체제가 자신을 접수할 수 있는 시간을 알려서 핵심 운영체제에서 수행되고 있는 작업보다 더 높은 우선순위로 보조 운영체제가 작업 수행을 할 수 있도록 모든 보조 운영체제가 CPU에 접근하는 것을 얼마간 허용할 수 있다. 따라서 한 실시예에서 핵심 운영체제의 인터럽트 서비스 루틴은 접수당하지 않기 때문에 그 결과 핵심 운영체제가 외부 이벤트나 실시간 클럭이 제공하는 타이밍 신호에 언제나 응답할 수 있게 되어 실시간 작동을 유지하게 된다.

가상화 프로세서 예외의 처리

하드웨어 자원 디스패처는 다음과 같이 프로세서 예외(일례로 CPU 인터럽트 또는 코프로세서 인터럽트)를 처리하도록 마련되었다.

＊먼저 핵심 운영체제를 통하여 프로세서 예외를 인터셉트;

＊다음으로 하나 또는 여럿의 보조 운영체제에 그에 상응하는 가상 예외를 고지하고, 해당 보조 운영체제를 스케줄러가 다음에 호출할 때 그 데이터를 저장하 며, 해당 보조 운영체제에서 대응하는 가상 인터럽트 서비스(2026)를 호출;

＊마지막으로 보조 운영체제에서 발생한 미결 가상 예외를 모두 금지하거나 금지 해제;한다.

가상화된 예외는 전형적으로 다음과 같이 두 경우에 쓰인다.

＊첫째로 보조 운영체제에 하드웨어 장치 인터럽트(비동기(asynchronous) 프로세서 예외의 형식으로 배달됨)를 전달하는 경우;

＊둘째로 운영체제간 교차 인터럽트, 즉 한 운영체제에 의하여 상대방 인터럽트(비동기 예외의 형식으로 배달됨)용으로 생성된 인터럽트를 구현하는 경우

트랩 호출 처리기(414)

다음 기재를 읽으면 트랩 호출 처리기의 작동 원리가 명백해질 것이다. 처리기의 주된 목적은 한 운영체제가 정지(그리고 따라서 CPU 자원을 쓸 필요 없을 때)되었을 때 스케줄러와 스위칭기가 운영체제를 다른 것으로 바꿀 수 있게 하는 데 있다. 부가적인 목적인 시스템 콘솔과 같은 하드웨어 자원 디스패처를 후속 실시예들에서 논할 방식과 같이 버그 제거용으로 쓰기 위하여 호출하는 데 있다.

가상화 장치(416)

앞서 밝힌 바와 같이 각 운영체제는 각 공유 장치(예를 들어 인터럽트 제어기, 버스 브리지, 시스템 타이머, 실시간 클럭)마다 디바이스 드라이버를 제공하여 그 장치에 대한 동료 수준(peer level) 드라이버 집단을 형성한다. 실시간 운영체제는 실제로 해당 장치에 접근하는 데 쓰이는 드라이버를 제공하고, 나머지 체제는 가상 장치 드라이버를 제공한다.

하드웨어 자원 디스패처의 공유 장치 처리기(416)는 각 장치를 위하고 그 장치의 모든 동료 장치(peer device)가 접근할 수 있는 저장된 데이터 구조를 공급한다. 해당 장치에 접근할 때나 혹은 이미 접근한 때에는 그 장치 드라이버가 접근한 세부 기록을 가지고 해당 데이터 구조에 저장된 자료를 갱신한다. 동료 드라이버들은 교차 인터럽트(앞서 설명한 바대로)를 사용하여 해당 데이터 구조가 막 갱신되었다는 이벤트를 다른 동료 드라이버에 고지하는 신호를 보낸다.

인터럽트 제어 장치에 접근하는데 쓰이는 드라이버는 앞서 설명한 가상화 예외 메카니즘을 사용하여 아래와 같이 하드웨어 인터럽트를 처리한다.

＊핵심 운영체제 장치 드라이버는 하드웨어 인터럽트를 처리하고 보조 운영체제의 동료 드라이버에게 가상화된 예외로서 전달;

＊보조 운영체제는 그 가상화된 예외를 금지하거나 금지 해제하는 루틴(앞서 설명)을 사용하여 인터럽트를 허용(enable)하거나 허용하지 않는다.

I/O 버스와 그 브리지를 공유하는 것은 그에 연결된 장치들이 모두 같은 운영체제에 할당되지 않았을 필요하다. 따라서 장치를 할당할 때 가능한 한 같은 I/O 버스에 연결된 장치들은 같은 운영체제에 할당한다. 반드시 공유해야 하는 경우는 자원 할당 테이블(404)이 버스에 대한 자원(주소 공간, 인터럽트 라인, I/O 포트) 할당을 가리키는 디스크립터(descriptor) 데이터를 저장하여 어느 운영체제가 어느 자원을 가지는지 가리켜 준다.

실시예의 구현

최종적으로 단계 314에서 하드웨어 자원 디스패처와 운영체제를 위한 프로그램 코드는 도 1의 컴퓨터(100)와 함께 제공되는 배분 가능한 이진 컴퓨터 프로그램 제품으로 변환 컴파일(compile)을 거친다.

본 발명의 한 측면으로서 공급할 수 있는 것은 개발 환경 제품(development environment product)으로서, 사용자로 하여금 사용할 서로 다른 운영체제들을 직접 선택할 수 있고 각 운영체제용의 응용 프로그램을 선택하고 개발할 수 있게 하며, 응용 프로그램과 운영체제를 양도 가능한 제품으로 통합하고, 운영체제를 부팅하며, 수행 가능한 응용 프로그램 2진수 코드를 개시할 수 있는 컴퓨터 프로그램이다. 이는 www.jaluna.com에서 구할 수 있는 C5 개발 환경에 기초하였고 또 그와 유사하다.

부팅과 초기화시 실시예의 작동

도 5에 따른 본 실시예의 부팅과 초기화 process는 아래와 같이 이루어진다.

ROM(106)에 저장된 부트스트래핑용 프로그램(4022, trampoline)이 전원 공급되면 가장 먼저 수행되고, 이 프로그램은 다시 하드웨어 자원 디스패처 프로그램(400)의 나머지 부분을 메모리에 설치하는 프로그램(4024)를 시작하는데. 이 프로그램은 또 디스패처를 시작하여 시스템 이미지 배치를 기술하는 데이터 구조(아래 설명)를 한 인수(argument)로 넘기게 된다.

하드웨어 자원 디스패처는 시스템 콘솔로 사용될 수 있는 직렬 회선(serial line)을 초기화한다. 이어서 핵심 운영체제부터 시작하여 각 운영체제에 차례로 메모리 공간(운영체제 환경)을 할당한다. 하드웨어 자원 디스패처는 따라서 제2수준의 시스템 커널 부트 로더(second level system kernel loader)로 작용한다.

각 운영체제 커널은 이어서 자신의 초기화 것에 접어들어 자원 할당 테이블(404)에 남아 있는 자원 중에서 자신이 독점할 자원들을 선택하고 초기 서비스와 응용 프로그램들을 시작한다.

도 6은 시스템 이미지를 형성하는 메모리 주소 할당의 사례를 도시한다. 하드웨어 자원 디스패처와 운영체제가 변형 컴파일(compile)될 때 메모리 내의 특정 위치가 할당한다. 도 6에 나타낸 바처럼, 메모리 내의 이들 위치의 모임이 시스템 이미지를 규정한다. 시스템 이미지는 하드웨어 자원 디스패처(602)가 위치한 제1 메모리 뱅크(bank)(602), 실시간 운영체제가 위치한 제2 메모리 뱅크(bank)(604), 보조 운영체제가 위치한 제3 메모리 뱅크(bank)(606), 그리고 이 실시예에서는 보 조 운영체제(리눅스)의 루트 파일 시스템을 담은 RAM 디스크가 위치한 제4 메모리 뱅크(bank)(608)로 구성된다.

시스템 이미지는 영구 저장장치(즉 휴대전화나 PBX와 같은 전형적인 실시간 장치를 위한 읽기 전용 메모리)에 저장된다. 남은 메모리 뱅크(bank)는 각 운영체제가 응용 프로그램을 적재(load)하고 실행할 수 있는 환경으로서 각 운영체제에 할당된다.

운영체제 콘텍스트을 위한 메모리 할당

부팅되는 동안, 각 운영체제는 자신의 설정에 따라 필요한 총 메모리 용량을 만족하기 위하여 그에 맞는 메모리 공간을 할당한다. 메모리 뱅크(bank)를 운영체제에 할당한 이후에는 운영체제 자체의 물리적 메모리 관리 지침(management scheme)을 통하여 관리한다. 운영체제는 모든 다른 메모리를 무시한다.

가상 메모리 할당

각 운영체제는 하드웨어 자원 디스패처나 서로를 간섭하지 못하도록 각각 별도의 가상 메모리 공간이 할당 받는다. 각 운영체제의 사용자 주소 공간(즉, 레인지(range))과 관리자(supervisor) 주소 공간(즉 레인지)은 서로 다른 메모리 관리 장치(MMU, memory management unit) 콘텍스트 식별자(identifier, ID)을 할당받는데, 이들은 주소가 겹치는 서로 다른 가상 메모리 공간을 구별할 수 있게 하여 준 다. MMU 콘텍스트 ID는 운영체제가 변환 컴파일(compile)될 각 운영체제에 지정된다.(도 3의 단계 314)

이러한 해결책을 쓰면 하드웨어 자원 디스패처가 서로 다른 운영체제 사이를 스위칭할 때 변환 캐시(translation cache, TLB)를 디스크로 내보낼(flush) 필요가 없고 따라서 시간을 절약하게 된다. 대신 다른 운영체제 사이를 스위칭하는 작업은 현재 기능중인 운영체제의 MMU 콘텍스트 ID를 저장하고, 바꿀 운영체제의 기존 MMU 콘텍스트 ID를 기억해 내는 것으로 이루게 된다.

입/출력 장치의 할당

앞서 설명한 것처럼 할당 테이블(404)은 각 운영체제에 어떠한 장치가 유니크하게 할당되는지 가리켜 준다. 게다가 테이블(404)은 그러한 장치에 어느 입/출력 자원(직접 메모리 접근(direct memory access, DMA) 장치, 입/출력 포트, 인터럽트 등)이 할당되었는지 가리켜 주므로 이들 자원을 이해관계가 갈리지 않게 사용할 수 있게 한다. 전형적으로는 많은 장치들이 복제(duplication)되는바, 이 방식으로 발생할 수 있는 이해관계의 상충을 상당히 줄일 수 있다.

분배 방식은 운영체제 설정 지침(예를 들어 C5의 경우, 장치들은 장치 트리에 명시된다)에 바탕을 둔다. 부팅시 장치를 운영체제에 할당하고, 또 부팅의 순서대로 할당이 일어나므로 핵심 운영체제는 테이블(404)에 기재된 가용 자원에 대한 첫 번째 선택권을 가지며, 보조 운영체제들은 차례로 남은 자원들을 할당받는다. 각 운영체제가 초기화되면서 각 체제는 이 장치들을 감지하고 하드웨어 자원 디스 패처의 간섭을 받지 않은 채 장치에 고유한 드라이버를 사용한다.

보조 운영체제의 핫( hot ) 재부팅

현 실시예에서는 다른 운영체제를 계속 실행하면서 보조 운영체제를 재부팅(예를 들어 시스템 장애때문에)할 수 있다. 시스템 자원을 분리하였으므로 보조 운영체제의 시스템 장애(crash)는, 그 보조 운영체제의 재부팅과 마찬가지로, 핵심 운영체제(또는 다른 보조 운영체제)의 계속된 실행을 방해하지 않는다.

본 실시예에서 하드웨어 자원 디스패처에 대한 운영체제의 “중단”과 “시작” 트랩 호출은 핵심 운영체제로부터 보조 운영체제를 종료하고 다시 시작하는 것을 돕는다. 덧붙여서 하드웨어 자원 디스패처는 부팅시 원래의 시스템 이미지 사본을 하드웨어 자원 디스패처에 할당된 메모리 내의 영구 메모리에 저장한다. 한 예제로서 이 실시예의 핫(hot) 재부팅은 다음과 같이 관리된다.

처음 부팅할 때, 하드웨어 자원 디스패처는 해당 보조 운영체제 메모리 이미지의 사본을 저장한다. 핵심 운영체제는 보조 운영체제의 작동을 주기적으로 감시하기 위한 소프트웨어 감시 드라이버 루틴(예를 들어 보조 운영체제의 연속적인 작동을 점검하기 위하여 타임아웃을 설정하고 보조 운영체제에서 실행 중인 동료 드라이버가 유도한 이벤트를 기다리기)을 가지고 있다.

핵심 운영체제가 보조 운영체제의 작업 수행 실패나 중지를 감지하면 하드웨어 자원 디스패체에게 (그 보조 운영체제의) “중단” 그리고 그 다음에 “시작” 트랩 호출을 하게 된다. 하드웨어 자원 디스패처는 그 보조 운영체제의 시스템 이미지 사본을 복원하고 메모리로부터 재부팅하여 그 보조 운영체제를 재부팅한다. 실시예의 검사 결과 리눅스 보조 운영체제는 잠금(locking up) 후 몇 초안에 재부팅할 수 있음을 알 수 있었다.

한편으로 핫 재부팅은 Chorus 운영체제의 방식으로부터 개선한 것인데, Chorus 체제의 방식은 예를 들어 F. Hermann Abrossimov, J.C. Hugly 外 1996년 8월 Chorus Sytstems Inc. 기술 보고서 14쪽 “Fast Error Recovery in CHORUS/OS. The Hot-Restart Technology"에 기재되어 있고, 이는 http://www.jaluna.com/developer/papers/CSI-TR-96-34.pdf에서 얻을 수 있다.

실행 시간( Run - time ) 작동

설치와 부팅 후 본 실시예의 작동에 대해서 자세하게 설명한다.

부팅과 초기화가 된 뒤 실시간 운영체제는 하나 또는 여러 개의 응용 프로그램(207, 예를 들어 UDP/IP 스택, Universal Datagram Protocol/Internet Protocol)을 수행하고 보조 운영체제는 몇 개의 응용 프로그램(208a, 208b, 예를 들어 문서 편집기와 스프레트시트)을 수행한다. 실시간 운영체제 마이크로커널(201)과 보조 운영체제 커널(202)은 하드웨어 자원 디스패처와 하드웨어 자원 디스패처 인터페이스를 통하여 통신하는데, 인터페이스는

＊운영체제 콘텍스트(즉 운영체제를 스위칭하기 위하여 저장하고 복원하여야 되는 상태 변수의 모임)과 하드웨어 저장소(repository)를 나타내는 데이터 구조

＊운영체제 환경에서 수행되는 함수의 모임

＊하드웨어 자원 디스패처 환경에서 수행되는 트랩 호출 루틴의 모임을 갖추고 있다.

운영체제 중 어느 쪽도 프로세서 시간을 요하지 않는 때(예를 들어 양쪽 모두 “유휴” 상태에 도달한 때)에는 하드웨어 자원 디스패처(400)가 핵심 운영체제의 유휴 스레드(thread)로 스위칭하는데, 여기서 다음 인터럽트나 이벤트를 기다리게 된다. 따라서 핵심 운영체제의 서비스 루틴은 핵심 운영체제로 먼저 스위칭할 필요 없이 곧바로 인터럽트를 처리할 수 있다. 이 과정에서 언젠가는 인터럽트나 이벤트가 일어난다. 예를 들어 데이터 포트에서 패킷(packet)을 수신하면 UDP/IP 스택을 수행하는 실시간 운영체제가 인터럽트를 처리할 수 있게 된다. 반대로 사용자는 키보드나 마우스를 조작하여, 인터럽트로 하여금 문서 편집기(208)와 상호작용하는 보조 운영체제(202)의 GUI를 작동하게끔 할 수 있다. 혹은 시스템 클럭이 미리 예정된 시간이 경과하여 응용 프로그램이 작업 재수행을 개시하여야 함을 알리거나 해당 운영체제가 기능을 수행하여야 한다고 가리켜 줄 수도 있다.

핵심 운영체제는 그 다음, 아래에 설명된 대로 서비스 루틴을 인터럽트에 대하여 가동한다.

인터럽트와 이벤트 처리

이미 핵심 운영체제에 진입하지 못했다면, 하드웨어 자원 디스패처 인터럽트 처리기(412)는 운영체제 스위칭기(408)을 호출하여 핵심 운영체제로 스위칭하고 그 다음 핵심 운영체제(201)의 인터럽트 처리 루틴(412)를 호출한다. 핵심 운영체제에 고유하게 설계된 장치나, 미리 예정된 특정한 값을 가지는 공유장치에서 비롯되었기 때문에 인터럽트가 핵심 운영체제에 대한 것인 경우, 핵심 운영체제 인터럽트 서비스 루틴은 그 처리에 필요한 조치를 취한다. 그렇지 않은 경우, 제어 기능은 하드웨어 자원 디스패처로 다시 넘어간다.

핵심에서 보조 운영체제로의 스위칭

도 7을 참조할 때, 이 실시예에서 시스템은 핵심 운영체제(201)에서 응용 프로그램(207a)의 스레드(702)를 실행하고 있다. 인터럽트가 일어나면 핵심 운영체제 인터럽트 서비스 루틴(ISR, 704)이 인터럽트를 서비스한다. 완료시에는 제어 기능이 다시 스레드(702)와 핵심 운영체제(201) 스케줄러가 수행하는 나머지 스레드 중 어느 것으로라도 넘어가게 된다. 모든 스레드의 처리가 끝나면, 핵심 운영체제는 수행을 마치고 자신의 "유휴" 스레드 스케줄링을 시작한다. 그에 따라 핵심 운영체제의 "유휴" 함정 루틴은 하드웨어 자원 디스패처(400)에 "유휴" 트랩 호출을 발하게 된다. 하드웨어 자원 디스패처는 그 다음 다음의 기능의 루틴을 수행한다.

＊인터럽트 처리기(412)에 현재 가상 인터럽트를 저장되어 있으면 처리기(412)는 이들을 보조 운영체제로 전달한다.

＊하드웨어 자원 디스패처 운영체제 스케줄러(410)는 작업을 수행할 해당 보 조 운영체제(202)를 선택한다. 운영체제 스위칭기(408)는 핵심 운영체제 콘텍스트 저장부(708)에 있는 현재 콘텍스트(전형적으로는 프로세서 MMU와 상태 레지스터, 명령과 스택 포인터들)을 저장한다. 그리고 나서 스위칭기는 저장된 해당 보조 운영체제의 작업 수행 콘텍스트(708)을 찾아내어 관련 레지스터상에 기록한다.

＊해당 보조 운영체제에 대한 가상 인터럽트가 있는 경우는, 인터럽트 처리기(412)가 그 보조 운영체제의 유관 인터럽트 처리 루틴(ISR, 710)을 호출하는데, 이 루틴은 인터럽트를 서비스하고, 완료시에는 그 보조 운영체제의 스레드(712) 작업 수행의 최종 상태로 복귀한다.

인터럽트 처리기(412)가 현재 아무 미결 인터럽트를 가지지 않은 경우에, 하드웨어 자원 디스패처 운영체제 스위칭기(408)는 보조 운영체제로 하여금 복원된 운영체제 콘텍스트 내에 저장된 프로그램 카운터 값(program counter value)를 사용하여 인터럽트 직전 상태, 이 경우는 해당 스레드(712)부터 작업 수행을 재개하도록 한다.

따라서 핵심 운영체제(201)가 어떤 기능을 수행한 뒤(자신의 서비스나 응용 프로그램를 서비스하거나 또는 다른 운영체제에 대한 인터럽트를 서비스한 뒤), 하드웨어 자원 디스패처는 스케줄러(410)가 정하는 데에 따라 다음 보조 운영체제(202)로 제어 기능을 넘긴다.

인터럽트시 보조에서 핵심 운영체제로의 스위칭

도 8을 참조할 때, 보조 운영체제에서 핵심 운영체제로의 스위칭 과정을 이 하 개시한다. 이 경우 시스템은 핵심 운영체제(202)에서 실행되는 응용 프로그램(208a)의 스레드(712) 작업을 수행하고 있다.

하드웨어 인터럽트가 일어나면, 하드웨어 자원 디스패처는 운영체제 스위칭기를 작동시켜 콘텍스트 저장부(708)에 해당 보조 운영체제 콘텍스트을 저장한다. 디스패처는 콘텍스트 저장부(706)로부터 상태 변수값을 복원하여 주 운영체제(201)로 스위칭하고, 주운영체제(201)의 인터럽트 서비스 루틴을 호출한다. 인터럽트 서비스를 마친 뒤, 주운영체제(201)의 스케줄러는 제어 기능을 인터럽트 서비스 루틴(704)로부터 기존에 수행되고 있던 스레드(704)(혹은 수행될 스레드) 아무나로 넘기게 된다.

인터럽트 서비스 루틴과 모든 스레드를 처리한 뒤, 주운영체제(201)는 제어 기능을 하드웨어 자원 디스패처로 넘기고, 디스패처는 도 7에서 논의한 방식으로 주운영체제(201)로부터(콘텍스트 저장부(706)에 상태 변수를 저장) 선택한 보조 운영체제(202)(콘텍스트 저장부(708)로부터 상태 변수를 찾아냄)로 스위칭한다.

운영체제간 통신-가상 버스(418)

가상 버스 루틴은 각 운영체제의 가상 버스 드라이버와 협력한다. 가상 버스 루틴은 compact PCI(cPCI) 백플레인(backplane)에 플러깅(plugging)한 cPCI 보드와 유사한, 운영체제 사이를 연결하는 물리적 버스를 에뮬레이션을 수행한다. 각 운영체제는 이 가상 버스의 가상 버스 브리지 장치에 대한 드라이버 루틴을 제공받아, 운영체제와 그 응용 프로그램이 원시(raw) 데이터 전송으로부터 완전한 IP 프로토콜 스택에 이르기까지 원하는 어떠한 프로토콜과도 통신할 수 있게 하여 준다.

*하드웨어 자원 디스패처 가상 버스는 위에서 이미 설명한 공유 메모리와 시스템 교차 인터럽트 원리에 그 바탕을 둔다. 자세히는 가상 버스 루틴(418)이 C5 buscom DDI:syscom을 에뮬레이션 수행하는데, 이는 가상 버스 브리지를 공유하는 장치를 규정하여 가상 버스를 통한 메모리 수출(공유)과 다른 운영체제를 향하는 교차 인터럽트의 발생을 가능하게 한다.

각 보조 운영체제의 각 가상 버스 드라이버는 스타트업 타임(startup time)이 되면 하드웨어 자원 디스패처 하드웨어 저장소에 그러한 가상 버스 브리지를 만든다. 이렇게 함으로써 드라이버는 자신의 개인 메모리의 한 영역을 수출(공유)하고, 자신의 호스트 시스템 내에서 인터럽트를 제기하는 수단을 제공한다.

따라서 제1 운영체제의 가상 버스 드라이버는 보조 운영체제로 데이터를

＊보조 운영체제의 동료 가상 드라이버가 수출하는 메모리에 기록하고 그 다음,

＊그 보조 운영체제의 동료 버스 드라이버에게 데이터 사용이 가능하다고 알리는 교차 인터럽트를 일으켜서 데이터를 전송한다.

반대 방향(들어오는 방향)으로는 가상 버스 드라이버에 그러한 데이터가 자신의 고유한 수출 메모리 영역에 저장되었다는 교차 인터럽트를 수신되면, 가상 버스 드라이브는 들어오는 데이터 업스트림(upstream, 그 대상 응용 프로그램이나 루틴이 사용할)을 전파한다.

도 9a를 참조할 때, 같은 운영체제(202)에서 실행 중인 다른 응용 프로그램(208b)와 통신할 응용 프로그램(208a)는 그 운영체제를 통하여 통신이 가능하다. 한 운영체제(201)에서 실행 중인 응용 프로그램(207b)이 다른 운영체제(202)에서 실행 중인 다른 응용 프로그램(208b)와 통신할 경우는 자신의 운영체제의 API를 사용하여 그 가상 버스에 데이터를 기록하여 통신할 수 있는데, 그 운영체제는 가상 버스 드라이버 루틴을 사용하여 데이터를 다른 운영체제(202)로 넘기며, 그 다른 운영체제(202)는 응용 프로그램(208b)에 대한 자신의 가상 버스 드라이버로부터 데이터를 전파한다.

도 9b를 참조할 때, 이 배치를 제1 운영체제와 제2 운영체제가 각각 다른 컴퓨터(101,102)에서 실행 중인 환경으로 옮기는 데 필요한 변경은 조금뿐이다. 다만 운영체제들이 가상 버스 드라이버 대신 실제 버스(103)용 드라이버를 사용하도록 운영체제가 사용하는 드라이버를 바꿔 주어야 할 뿐이다. 그러므로 시스템은 자신이 작동하는 하드웨어와 더욱 무관하게 된다.

하드웨어 자원 디스패처 가상 버스 사이의 통신은 응용 프로그램도 이용 가능하지만, 운영체제 커널이 여러 개의 운영체제에 배분되는 서비스를 구현하는 것을 서로 도울 수 있도록 운영체제 커널 사이에도 이용 가능하다. 이러한 "스마트"형 배분 서비스에는 운영체제 핫 재부팅(앞서 설명)에 쓰이는 소프트웨어 감시와 배분되는 네트워크 프로토콜 스택이 속한다.

버그 제거

바람직한 실시예에서 하드웨어 자원 디스패처는 버그 제거 장치로서 작용하는 제2의 작동 모드가 있다. 본 실시예 제2모드에서 하드웨어 자원 디스패처는 직렬 통신선을 통하여 다른 컴퓨터("호스트" 머신)에서 실행 중인 버그 제거 소프트웨어와 통신할 수 있다. 이러한 버그 제거 프로그램은 높은 수준의 그래픽 사용자 인터페이스(GUI)를 제공하여 하드웨어 자원 디스패처를 원격 조정한다. 하드웨어 자원 디스패처의 가상화 예외 메카니즘은 규정된 예외를 인터셉트하기 위하여 사용된다. 사용자는 그 다음 하드웨어 자원 디스패처가 프로세서 예외시 어떻게 거동하는지를 설정하고 제어할 수 있으며 코드 에러, 여타 시스템 에러 또는 문제들을 진단할 수 있도록 머신과 시스템 상태 변수를 표시하게 할 수 있다.

사용자는 그러한 프로세서 예외 하나 또는 여러 개를 운영체제가 하드웨어 자원 디스패처를 트랩 호출하는 바탕으로 선택할 수 있다. 선택된 예외에 기초하여 작업 수행 도중 예외가 일어나면 운영체제는 중단되고 하드웨어 자원 디스패처에 대한 트랩 호출을 수행하는데, 디스패처는 다시 현 콘텍스트을 저장하고 호스트 머신의 버그 제어 프로그램과 상호작용할 수 있게끔 작용한다. 사용자는 이제 상태 변수들의 현재 상태(스택 포인터, 프로그램과 주소 카운터 등) 및/또는 선택한 메모리 블록의 내용을 표시하게 할 수 있다. 사용자는 어떤 특정 유형의 예외들이 버그 제거 대상인 특정 운영체제에 트랩(trap)되거나, 발생하는 즉시 아무 운영체제에라도 트랩되도록 할지를 명시할 수 있다. 이에 대응하여 트랩 호출은 모든 운영체제나 아니면 단 한 운영체제에만 구현된다. 사용자는 어느 특정 유형의 예외를 작업 수행이 재개될 때 운영체제에 정상적으로 전달할지 무시할지를 명시할 수도 있다.

하드웨어 자원 디스패처는 자신의 고유한 환경에서 작동하므로 운영체제의 버그를 제거하는 데에 있어서 그 운영체제가 직접 하는 경우보다 훨씬 더 많이 제거할 수 있다. 버그 제거 장치 역할을 하는 하드웨어 자원 디스패처와 버그 제거 대상인 운영체제 사이에는 어떠한 코드도 공유하지 않는다는 점이 중요하다. 이 때문에 예를 들어 예외 벡터 또는 인터럽트 서비스 루틴과 같은 커널 저수준(low level) 코드까지 버그 제거가 가능하다.

본 실시예에 따른 전체(호스트/타겟) 버그 제거 구조(architecture)의 다른 측면들은 Chorus와 C5의 버그 제거 시스템의 경우와 비슷하며, 이들에 대해서는 http://www.jaluna.com/doc/c5/html/DebugGuide/book1.html에서 얻을 수 있는 Jaluna社 발간 "C5 1.0 Debugging Guide"에 그 기재가 있다.

보안 구조( secure architecture )

위에 설명한 본 발명의 실시예가 보안 구조를 위한 견고한 바탕이 된다는 것는 분명할 것이다. 이것은 사용자가 비보안성 응용 프로그램을 실행하는 것이 전형적인 보조 운영체제는 명시된 시스템 자원으로부터 절연되어 있고, 그 자원에 대한 접근은 오로지 하드웨어 자원 디스패처(와 주운영체제의 드라이버)를 통하여서만 이루어지기 때문이다. 따라서 주운영체제에서 다음 예와 같은 보안성 응용 프로그램을 실행할 수 있다. 암호화/암호 해제, 암호 처리된 파일에 대한 접근 허가, 패스워드와 다른 접근 정보의 관리·저장·공급, 저작권 관련 자료의 접근과 재생에 대한 관리·장부 작성 등. 보조 운영체제에서 실행 중인 응용 프로그램은 그 운영체제에 할당되지 않은 시스템 자원에 접근할 수 없으며, 또 운영체제들이 서로 다른 메모리 콘텍스트(즉 서로 다른 공간에 대한 서로 다른 주소 지정 포인터)에서 실행 중인 때에는 보조 운영체제에서 실행 중인 응용 프로그램이 주운영체제에서 작동 중인 다른 응용 프로그램을 방해하여 그 작동의 보안성을 취약하게 하는 일은 할 수 없다.

본 섹션(section)에서는, 일례로 감소된 명령 설정 컴퓨터 (RISC, reduced instruction set computer)와 같은, 파워 PC ("PPC") 구조에 관한 발명을 설명할 것이다. 이 잘 알려진 구조 배경기술의 이해를 돕기 위해, 이하의 참조를 포함했다:

"PowerPC Microprocessor Family: The Programming Environments for 32-Bit Microprocessors-Software Reference Manual" (published by IBM Publication Number: G522-0290-01 Revision Date: 02/21/00

다음의 주소에서 다운로드 받을 수 있다:

http://www.ibm.com/chips/techlib/techlib.nsf/techdocs/852569B20050FF778525699600719DF2

이하, 하드웨어 자원 디스패처(despatcher)는 (비제한 sense 안에서) 나노커널(nanokernel)로서 설명된다. 본 섹션(section)은 상기 나노커널(nanokernel) 이행의 PPC 특유의 관점, 특히, 상기 나노커널(nanokernel) 환경의 초석인 상기 나노커널(nanokernel) 실행에 초점을 맞춘다.

본 섹션(section)은 상기 메모리 관리 장치(MMU)와 마찬가지로 이 운영체제에 걸쳐서 상기 중앙 처리 장치와 코프로세싱 장치 (CPU와 FPU)를 동시에 공유하는 다중의 독립된 운영체제를 실행할 수 있는 상기 나노커널(nanokernel) 실행를 이행하기 위해 상기 파워 PC 프로세서 구조가 어떻게 이용되는지를 설명한다.

이는 또한, 상기 나노커널(nanokernel) 실행가 상기 하드웨어 인터럽트를 어떻게 처리하는지 설명한다. 특히, 주 운영체제를 향한 하드웨어 인터럽트를 붙잡고 진행시키기 위한 메커니즘과 보조 운영체제에 제공된 소프트웨어 인터럽트 메커니즘을 설명한다.

본 명세서에서 상기 나노커널(nanokernel)이 단일프로세서(uniprocessor) 컴퓨터에서 작동하고 있다고 가정한다는 것을 유의해야하며, 따라서 대칭형 멀티 프 로세서(SMP, symmetrical multi-processor) 구조와 관련 있는 관점은 여기에서 언급되지 않는다.

개요( Overview )

가상 주소 공간( Virtual Address Spaces )

파워 PC 구조에서 나노커널(nanokernel)은 항상 효과적인 (물리적) 주소 공간에서 작동한다. 즉, MMU는 항상 비허용(disable)되고, 나노커널(nanokernel) 코드가 실행될 때 상기 프로세서는 리얼 모드에서 실행된다.

이 설명에서 상기 메모리 콘텍스트 용어는 파워 PC 가상 주소 변환 콘텍스트을 가리킨다:

＊세그먼트 레지스터에 명시된 16 가상 세그먼트 식별자(VSID, virtual segment identifiers)의 한 세트

＊페이지 테이블 엔트리(PTE, page table entries)의 한 세트

＊BAT 레지스터에 명시된 블럭 주소 변환의 한 세트

일반적으로, 사용자 모드를 지원하는 운영체제는 개인 사용자 가상 주소 공간을 처리할 수 있게끔 다중 메모리 콘텍스트을 (사용자 process당 하나) 새로 만든다. 상기 커널은 사용자 process로부터 다른 것으로 바꿀 때마다 상기 메모리 콘텍스트을 변경한다. 또한 상기 운영체제 커널은 유일한 관리자 주소 공간을 처리한다. 사용자와 관리자 가상 주소는 파워 PC 구조에 절대 겹치지 않는다.

상기 관리자 주소 공간 매핑은 정적이거나 동적일 수 있다. 상기 정적 매핑은 시스템 초기화 시간에 만들어지고, 물리적 허용 메모리를 (전체적으로 또는 부분적으로) 전형적으로 나타낸다. 이 같은 매핑은 1 대 1 또는 커널 가상(KV) 매핑이라 불리고, 일반적으로 파워 PC 블럭 주소 변환 메커니즘 (PowerPC Block Address Translation mechanism, BAT)을 사용한다. ㅂ특히, 상기 KV 매핑은 상기 커널 코드, 데이터 그리고 bss 섹션(section)을 담당한다. 동적 매핑은 동적으로 적재(load)된 커널 모듈이나 동적으로 할당된 (비연속적인) 메모리 덩어리에 접근하기 위한 수단으로 실행 시간에 만들어진다.

메모리 콘텍스트의 세 종류는 나노커널(nanokernel) 환경: 주 메모리 콘텍스트, 보조 메모리 콘텍스트, 그리고 나노 커널에서 두드러진다.

상기 주 메모리 콘텍스트은 현재 주 커널로 사용된 메모리 콘텍스트이다. 위에서 언급한 바와 같이, 주 운영체제가 사용자 주소 공간을 지원하는 경우, 주 커널로 사용된 다중 메모리 콘텍스트이 있을 수 있지만, 상기 관리자 주소 공간은 유일하다. 상기 나노커널(nanokernel)이 사용자 매핑에 대해 관여하지 않기 때문에, 상기 주 메모리 콘텍스트은 상기 나노커널(nanokernel) 투시도와 다르고 정적으로 이루어지며, 동적 관리자 매핑은 주 커널에 의해 확립된다.

상기 보조 메모리 콘텍스트은 상기 보조 커널로 사용된 메모리 콘텍스트이다. 한번 더 제2 운영체제가 사용자 주소 공간을 지원하는 경우, 보조 커널로 사용된 다중 메모리 콘텍스트이 있을 수 있지만 상기 관리자 주소 공간은 오직 하나만 있다. 따라서, 상기 보조 메모리 콘텍스트은 상기 나노커널(nanokernel) 투시도(주 어진 보조 커널을 위한)와 다르고 그것의 관리자 메모리 콘텍스트에 포함된다.

상기 나노커널(nanokernel) 그 자체는 위에서 정의한 바와 같이 실제로 메모리 콘텍스트을 이용하는 것이 아니며, 그보다는 상기 파워 PC 프로세서의 효과적인 (물리적) 주소 공간을 이용한다. 그러나, 상기 나노커널(nanokernel) 주소 공간은 모든 다른 메모리 콘텍스트과 다르고, 따라서 고유한 것으로 고려될 수 있다.

예를 들어, 나노커널(nanokernel) 콘솔에 I/O 동작을 수행하기 위해 보조 커널이 나노커널(nanokernel)에 의해 처리되는 인터럽트, 트랩 또는 예외(exception) 이벤트로서 접수될 때, 상기 나노커널(nanokernel) 코드를 실행하는데 상기 나노커널(nanokernel) 메모리 콘텍스트이 주로 이용된다. 상기 나노커널(nanokernel) 메모리 콘텍스트은 또한, 보조 실행 환경을 상기 주 실행 환경 및 그 반대로 스위칭하도록 허용하는 중간의 주소 공간으로도 사용된다. 상기 파워 PC 프로세서가 예외 처리를 위해 실재 실행 모드로 스위칭되므로 상기 나노커널(nanokernel) 메모리 콘텍스트과 같이 상기 프로세서 물리적 주소 공간을 사용하는 것은 자연스럽고 효과적인 접근이라는 것을 주목하라.

도 10은 나노커널(nanokernel) 물리적 주소 공간과 마찬가지로 주, 그리고 보조 가상 주소 공간의 실시예를 보여준다.

본 실시예에서, 물리적 메모리의 크기는 128 megabyte이다. 상기 주 커널은(C5 마이크로커널과 같이) 0에서부터 시작하는 상기 자명한 1 대 1 (KV) 매핑을 이용하고, 상기 보조 커널은 (리눅스 커널과 같이) 0xc0000000에서부터 시작하는 변경된 1 대 1 (KV) 매핑을 이용한다.

도 11은 상기 메모리 콘텍스트이 어떻게 제시간에 스위칭되는지를 보여준다. 최초에, 보조 운영체제는 보조 메모리 콘텍스트에서 동작하고 있다. t0의 시간에, 상기 현재 보조 커널은 나노커널(nanokernel) 콘솔로 문자열을 출력하기 위해서 상기 나노커널(nanokernel)에 트랩한다. 이 트랩은 현재 메모리 콘텍스트을 나노커널(nanokernel) 메모리 콘텍스트으로 스위칭한다. [t0, t1] 동안, (상기 나노커널(nanokernel) 메모리 콘텍스트에서 작동하는) 상기 나노커널(nanokernel)은 상기 나노커널(nanokernel) 콘솔로 문자열을 출력한다. t1의 시간에, 상기 나노커널(nanokernel)은 상기 보조 메모리 문맥으로 되돌아가는 상기 보조 커널로 돌아간다. t2의 시간에, 상기 보조 운영체제를 동작하는 동안 인터럽트가 발생한다. 상기 인터럽트는 상기 현재 메모리 콘텍스트을 상기 나노커널(nanokernel) 메모리 콘텍스트으로 스위칭하고, 상기 나노커널(nanokernel) 인터럽트 처리기를 호출한다. 상기 인터럽트를 상기 주 커널로 전송하기 위해서, t3의 시간에 상기 나노커널(nanokernel)은 상기 나노커널(nanokernel) 메모리 콘텍스트을 상기 주 메모리 콘텍스트으로 스위칭하고, 상기 주 인터럽트 처리기를 호출한다. t4의 시간에 상기 인터럽트 요구를 처리하는 동안, 상기 주 커널은 나노커널(nanokernel) 콘솔에 메세지를 출력하기 위한 방법을 기록하는 상기 나노커널(nanokernel)을 호출한다.

t6 시간에 상기 인터럽트 요구를 처리할 때까지, 상기 나노커널(nanokernel)은 t5의 시간에 상기 문자열 입력 트랩 호출에서 상기 주 커널로 돌아간다. 이 순간, 상기 주 커널은 상기 인터럽트 처리기에서 돌아오고, 상기 나노커널(nanokernel)은 인터셉트 된 보조 운영체제로 되돌아 가 그것의 실행을 지속한다. 그런 스위칭은 상기 주 메모리 콘텍스트에서 시작하고, 상기 중간의 나노커널(nanokernel) 콘텍스트을 통과하면서, t7의 시간에 결국 상기 보조 메모리 콘텍스트에서 끝이난다.

나노커널 불러들임과 접수 ( Nanokernel Invocation and Preemption )

나노커널(nanokernel)은 trap을 통해 명시적으로 또는 처리기를 통해 절대적으로 호출된다. 전자의 경우에, 우리는 운영체제 커널이 나노커널(nanokernel)을 호출한다고 말했다. 후자의 경우에, 우리는 상기 나노커널(nanokernel)이 운영체제를 접수한다고 말한다. 나노커널(nanokernel)은 항상 상기 관리자 주소 공간에서 실행하는 특권이 있는 코드로부터 호출된다는 점을 강조하는 것이 중요하다. 반면, 상기 나노커널(nanokernel)은 커널 제어 하에서 작동하는 사용자 process와 마찬가지로 상기 커널 그 자체로서 접수할 수 있다.

사실, 상기 나노커널(nanokernel)이 상기 주 커널을 접수하도록 허용하는 것은 바람직하지 않고 반 직관적인 것이며, 부동소수점 장치 공유를 제외하고는 (아래에 논의된 바와 같이) 그와 같은 동작을 하지 않는다. - 느린 부동 소수점 스위칭에 의해 나타난 스위칭 시간의 절약은 종종 일어나는 접수의 문제점을 메우기에 충분하다.

일단 시스템이 부팅되고, 우선 상기 나노커널(nanokernel)이 활성화되고 주 커널과 보조 커널의 실행을 시작한다. 우선 상기 초기화 것가 완료되고, 상기 나노커널(nanokernel)은 수동적인 역할을 수행한다. 이는 상기 나노커널(nanokernel)에 서 실행된 상기 코드가 (트랩에 의해) 상기 나노커널(nanokernel)을 명백히 호출하는 상기 주 커널 및 보조 커널에 의하여 또는 대외적으로 동기(즉, 예외(exception))와 비동기(즉, 인터럽트) 이벤트를 발생시킴으로써 가동된다는 뜻이다.

파워 PC 구조에서, 상기 나노커널(nanokernel)의 호출과 접수를 위해 사용된 메커니즘은 주 운영체제와 보조 운영체제를 위해 사용된 것과 동일하다. 실행 환경의 면에서, 상기 나노커널(nanokernel)은 파워 PC의 리얼 모드에서 실행되는 것과 같이 상기 주 커널과 보조 커널로부터 완전히 분리되어있다. 그것은 "null" 메모리 콘텍스트 (물리적 주소 공간) 과 다른 관리자 스택을 사용한다. 상기 주 운영체제(MMU 허용)와 상기 나노커널(nanokernel)(MMU 비허용(disable)) 사이에는 상기 커널 오작동을 방어하기 위한 몇몇의 보호를 제공하는 장벽이 있다. 그러나 각각의 커널은 여전히 관리자 주소 공간안에서 특별한 코드를 실행하기 때문에 그러한 보호는 절대적이지 않고, 따라서 상기 나노커널(nanokernel) 뿐 아니라 상기 주 커널도 여전히 부술 수 있다는 것을 주지하라.

나노커널 불러들임( Nanokernel Invocation )

상기 주 커널과 보조 커널은 트랩 호출 메커니즘을 이용한 상기 나노커널(nanokernel)을 호출한다. 상기 파워 PC sc와 trap 명령은 상기 나노커널(nanokernel)에 의한 프로그램과 시스템 호출 예외의 인터셉트를 제거하기 위해 사용되지 않는다. 이는 작동 오버헤드를 운영체제 커널에 의해 간혹 사용되는 이 예 외의 처리 내에 유입한다.

대신, 일반적으로 파워 PC 프로세서에서 사용되지 않는 몇몇의 예외 벡터는 (상기 운영체제 트랩 호출 사용을 제거하는) 나노커널(nanokernel) 트랩 호출 전용이다. 이 예외 벡터들은 실재 예외가 발생할 때와 같은 상태 내에서 파워 PC 프로세서를 넣는 주 또는 부 커널 예외 환경 안에서 실행하는 작은 소프트웨어 루틴을 통해 호출되고 상기 rfi 명령을 사용하는 적절한 벡터로 점프한다. 상기 커널은 적절하게 수정된다. 즉, 상기 나노커널(nanokernel) 호출 메커니즘은 상기 주 커널 또는 보조 커널의 지배를 받아 트리거 된 소프트웨어 예외를 시뮬레이팅 함으로써 현존하는 설정된 파워 PC 예외를 확장한다.

아래의 예외 벡터들은 나노커널(nanokernel) 트랩 호출에 이용된다:

Ox2000 유휴, 나노커널(nanokernel) 스케줄러 호출

Ox2100 이행 정지를 위해 나노커널(nanokernel) 디버그 에이전트(agent)를 호출

Ox2200 나노커널(nanokernel) 콘솔 IO 서비스를 호출

Ox2300 시스템 교차-인터럽트를 트리거

Ox2400 시스템 재부팅

Ox2500 만약에 있다면 미결 가상 예외를 처리 (보조만)

Ox2600 시스템 정지 (보조만)

나노커널(nanokernel) 호출은 다음과 같은 약속과 프로세서 상태에 따라 만 들어진다:

＊변화는 비허용(disable)된다. (리얼 모드로 스위칭)

＊인터럽트는 프로세서 수준에서 비허용(disable)된다.

＊caller r20은 sprg0에 저장된다.

＊caller r21은 sprg1에 저장된다.

＊caller msr은 r20에 저장된다.

＊caller 반환 주소(실행하기 위한 다음 명령)는 r21에 저장된다.

＊부-트랩의 수는 r9에 저장된다. (다중 함수 호출을 위해)

나노커널 접수 ( Nanokernel Preemption )

나노커널(nanokernel)은 파워 PC 예외/인터럽트 벡터를 인터셉트함으로써 운영체제를 접수한다. 상기 파워 PC 구조는 상기 예외 벡터가 위치한 주소를 구성하기 위한 어떠한 메커티즘(하나의 베이스 레지스터와 같이)도 제공하지 않지만, 상기 물리적 ㄱ공간(RAM 내의 0x00000000에서)의 앞 단이나 상기 물리적 공간(일반적으로 ROM 내의 0x00000000에서)의 마지막 megabyte의 첫 페이지에 위치하도록 실시한다. 그러므로, 상기 나노커널(nanokernel)은 상기 파워 PC 실재 예외 백터를 소유하고, 상기 고유 시스템 처리기를 호출하거나 상기 예외를 인터셉트하기 위해 간접적인 함수 포인터의 배열(하나의 예외 처리기 테이블)을 이용하며, 대신 나노커널(nanokernel) 처리기를 실행한다. 운영체제가 상기 나노커널(nanokernel)에 의해 접수될 때, 상기 프로세서 상태는 붙들린 예외 (리얼 모드)에 의해 자동적으로 변화된다. 또한, 사기 나노커널(nanokernel) 처리기는 그것만의 환경 안에서 작업을 실행하기 위해서나 다른 운영체제로 직접적으로 스위칭하기 위해 다른 메모리 콘텍스트과 관리자 스택으로 스위칭할 수 있다.

상기 나노커널(nanokernel)이 상기 예외를 상기 고유 커널 처리기로 단지 전송만 할 때 상기 프로세서 상태를 잃지 않고 간접적인 호출을 이행하기 위해, 상기 레지스터 내용을 수정해야 한다. 따라서 상기 나노커널(nanokernel)은 커널 예외 처리기를 호출할 때 레지스터의 이용에 관한 다음의 약속을 제공해야 한다. (예외 엔트리에서의 상태와의 차이점만을 언급할 것이다.)

＊r20은 sprg0 스크래치 레지스터에 저장된다.

＊r21은 sprg1 스크래치 레지스터에 저장된다.

＊1r은 r20 레지스터에 저장된다.

＊r21은 상기 예외 테이블 인텍스와 함께 적재(load)된다. (예외의 수는 *4)

＊1r은 상기 커널 예외 처리기의 주소와 함께 적재(load)된다.

주 접수 ( Primary Preemption )

상기 나노커널(nanokernel)은 상기 주 운영체제를 오직 드문 경우에만 접수한다. 일반적으로, 상기 예외는 단지 인터셉트된(FPU와 AltiVec 유효하지 않은 예외) 유효하지 않은 코-프로세싱 장치를 관리하는데만 이용된다. 이 예외들은 다음에 설명할 느린 방법 안에 있는 커널 사이를 공유하는 장치를 처리하기 위해 나노커널(nanokernel)을 이용한다.

보조 접수( Secondary Preemption )

상기 코-프로세싱 예외에 덧붙이면, 보조 운영체제는 또한 인터럽트(비동기 예외)가 발생할 때 접수된다. 그러한 경우, 상기 인터럽트 벡터는 상응하는 (보조 예외 테이블에 인스톨된) 나노커널(nanokernel) 처리기에 의해 인터셉트된다. 상기 나노커널(nanokernel)은 곧 상기 주 메모리 콘텍스트과 스위칭하고 (상기 주 예외 처리기 테이블에 인스톨된) 이 인터럽트를 위해 관련된 주 커널 처리기를 호출한다.

커널 콘텍스트( Kernel Context )

나노커널(nanokernel) 데이터는 두 개의 카테고리로 분할될 수 있다: 범용 데이터와 커널-당 데이터. 상기 범용 데이터는 상기 커널-당 데이터가 주어진 주 커널이나 보조 커널과 관련된 상태를 유지하는 동안 상기 나노커널(nanokernel) 상태 (예를 들어, 상기 나노커널(nanokernel) 메모리 콘텍스트)를 유지한다.

상기 커널 콘텍스트은 두 부분으로 구성된다: 보이는 부분과 숨겨진 부분. 상기 보이는 부분은 공용이고 나노커널(nanokernel) 인터페이스에 가담한다. 상기 커널 콘텍스트의 이 부분은 앞으로 나노커널(nanokernel) 인터페이스와 관련된 섹션(section)에서 좀 더 자세히 설명할 것이다. 상기 숨겨진 부분은 커널에 보이지 않고 상기 나노커널(nanokernel) 실행에 의해 내부적으로 사용된다.

나노커널 실행 인터페이스( Nanokernel Executive Interface )

본 chapter에서는 상기 주 커널과 보조 커널에 전파된 나노커널(nanokernel) 실행 인터페이스에 대해 설명한다. 그러한 인터페이스는 나노커널(nanokernel) 방법과 마찬가지로 커널과 상기 나노커널(nanokernel) (즉, 보이는 커널 콘텍스트) 사이에 공유된 데이터 구조에 있다.

가시 커널 콘텍스트( Visible Kernel Context )

도 3는 상기 커널 콘텍스트의 보이는 부분을 나타낸다.

상기 커널 콘텍스트의 보이는 부분에서 모든 참조는 물리적 주소를 통해 만들어진다는 것을 유의하라. 커널은 참조된 객체에 접근하기 위해서 그러한 물리적 주소를 (KV 매핑으로부터) 가상 주소로 변환해야 한다. 단지 두 개의 커널 구성을 보여준다: 주와 부.

hdls □ 필드(field)는 커널 예외 처리기를 향한 포인터의 배열이다. 이 배열은 예외 번호에 의해 인덱스된다. 이 배열에 있는 각각의 엔트리는 관련된 예외에 인터셉트하기 위해 상기 커널 고유 예외 처리기 또는 나노커널(nanokernel) 처리기에 직접 설정될 수 있다. 후자의 경우 상기 커널 고유 예외 처리기 포인터는 hdls□ 필드(field)에 위치한다.

상기 pending (미결) VEX와 enabled (허용) VEX 필드(field)는 가상 예외(exception)의 현재 상태를 반영한다. 상기 주 커널 예외(exception)가 상기 나노커널(nanokernel)에 의해 가상화된 것이 아니므로, 이 필드(field)들은 주 문맥에 불필요하다는 것을 유의하라. 상기 가상화된 예외(exception) 메커니즘은 보조 커널 예외(exception) 모델과 함께 앞으로 더욱 상세히 설명될 것이다.

상기 boot info(부트 정보) 필드(field)는 BIOS에 의해 주어진 부트 매개변수를 가리킨다. 이 필드(field)는 읽기 전용이다.

그러한 데이터 구조는 인수를 통과한 모든 펌웨어를 향한 포인터와 마찬가지로 다양한 프로세서 정보를 포함한다.

cmd _ line start와 size 매개변수는 부트 시간 매개변수를 명시하는 부트 명령어 라인을 지시한다. 그러한 매개변수는 부트 로더에 주어지거나 상기 나노커널(nanokernel) 환경을 통과해 지나간다. 상기 명령어 라인은 커널 특성이고 사기 커널 콘텍스트에 위치한다. 상기 나노커널(nanokernel)은 오로지 상응하는 커널과 관계있는 매개변수만을 포함한 커널 특성 명령어 라인을 새로 만들기 위해서 상기 초기의 (다중-시스템) 명령어 라인을 분석한다.

RAM info ( RAM 정보) 필드(field)는 RAM 기술 테이블을 가리킨다. 이 테이블은 읽기 전용이다. 상기 RAM 기술 테이블은 모든 커널에 의해 공유된 범용 데이터이다. RAM 소스가 커널을 통해 어떻게 할당됐는지를 보여준다.

dev info ( dev 정보) 필드(field)는 나노커널(nanokernel)에 의해 추출된 가상의 장치 리스트를 가리킨다. 이 필드(field)는 보조 커널을 위해서는 읽기 전용이고 주 커널을 위해서는 읽고 쓰기용이다. 상기 장치 리스트는 범용이고 모든 커널에 의해 공유된다. 리스트에 있는 가상 장치 각각은 나노커널(nanokernel)에 의해 명시된 데이터 구조로 나타내어진다. 일반적으로 상기 나노커널(nanokernel)에 의해 정의된 규칙을 사용한 주 동료 드라이버와 보조 동료 드라이버 양쪽 모두 이 데이터 구조로 접근한다. 상기 보조 종료 드라이버가 실재 장치 대신 가상 장치를 이용해 클라이언트 역할을 수행할 동안, 상기 주 동료 드라이버는 상기 가상 장치를 지원하는 서버 역할을 수행한다. 이 리스트는 오직 주 커널에 의해 생성된다. (그리고 변경된다.) 보조 커널은 이 리스트를 단지 읽을수만 있도록 허용한다.

pending XIRQ (미결 XIRQ ) 필드(field)는 미결된 교차 인터셉트를 명시한다. 이 필드(field)는 나노커널(nanokernel) 그 자체만으로 사용되지 않는다. 상기 교차 인터럽트 스위칭에서 상기 주 커널과 보조 커널을 돕기 위해 상기 콘텍스트 구조에 의해 호스트 된다. 상기 교차 인터럽트 배달 전용의 프로세서 예외(exception)는 오직 한 개이다. pending XIRQ (미결 XIRQ ) 필드(field)는 32(교차 인터럽트 소스당 한 개의 비트)까지 교차 인터럽트의 수를 확장하는 것을 허용한다. 교차 인터럽트 비트는 상기 소스 커널 (즉, 인터럽트를 가로질러 송신하는 커널)에 의해 설정되고, 상기 목적 커널 (즉, 상기 교차 인터럽트를 수신하는 커널) 에 의해 재설정된다.

ID 필드(field)는 유일한 커널 식별자를 포함한다. 이 필드(field)는 읽기 전용이다. 식별자 0은 상기 나노커널(nanokernel) 그 자체에 할당되고, 1은 상기 주 커널에 할당된다. 상기 커널 식별자는 상기 나노커널(nanokernel) 인터페이스에 있는 상기 나노커널(nanokernel)을 가리킨다. 예를 들어, 상기 커널 식별자는 주어진 커널 (예를 들어, RAM 기술 테이블에 있는 메모리 덩어리)로 할당된 자원에 부가하도록 사용된다.

running (실행) 필드(field)는 상응하는 커널의 상태: 실행(1) 또는 정지(0)를 명시하는 시스템 식별자 비트 필드(field)를 가리킨다. 이 필드(field)는 읽기 전용이다. 상기 나노커널(nanokernel)은 관련있는 상기 커널을 개시하기 전에 이 flag를 설정하고, 상기 커널이 한 번 정지하면 flag를 clear한다. 커널이 재부팅될 때, 상기 running(실행) flag는 처음에는 clear 되고, 곧 설정된다. 어떤 커널도 실행 동료 커널 전체를 찾아내기 위해 상기 running (실행) flag를 분석할 수 있다. 상기 주 커널의 running (실행) 비트는 언제나 설정된다는 것을 유의하라.

ctx root와 last 필드(field)는 처음 (나노커널(nanokernel) 그 자체)과 마지막의 유효 커널 콘텍스트을 가리킨다. 상기 ctx 크기 필드(field)는 숨겨진 부분을 포함하는 커널 콘텍스트 구조의 전체 크기를 명시한다. 이 필드(field)들은 상기 커널 콘텍스트을 관리하는 필요한 정보들과 함께 제공한다.

shared memory (공유된 메모리) 필드(field)는 공유된 메모리의 pool을 가리킨다. 그것은 주로 주 커널이 모든 커널 사이에서 공유된 데이터를 저장하기 위해 메모리를 할당함으로써 이용된다.

나노커널 방법( Nanokernel Methods )

나노커널(nanokernel)은 두 그룹의 방법을 제공한다: 콘솔 I/O 작동과 실행 작동. 상기 콘설 I/O 그룹은 커널이 상기 나노커널(nanokernel) 콘솔 직렬 회선으로/으로부터 특성을 송신/수신하도록 허용한다. 본 명세서는 특히 더욱 또는 덜 범용인 상기 콘솔 I/O 방법에 초점을 맞추기보다는 파워 PC 구조 특성인 상기 실행 방법에 초점을 맞춘다.

CPU 예외 처리기의 인스톨 ( Install CPU exception handler )

예외 벡터 코드를 파워 PC 예외 벡터로 직접 인스톨하는 것 대신, 커널은 주어진 프로세서 예외에 처리기를 부착하기 위한 이 나노커널(nanokernel) 방법을 호출해야 한다. 상기 예외의 수와 상기 커널 처리기 코드의 물리적 주소는 매개변수와 같이 지나간다. 상기 예외의 수는 상기 커널 처리기 포인터가 저장된 상기 커널 콘텍스트의 hdls□ 예외 처리기 테이블을 인덱스하기 위해 사용된다.

상기 나노커널(nanokernel)은 후에 상응하는 예외를 추가적인 간접적인 호출의 최고 오버헤드와 함께 상기 커널로 직접적으로 상승시키게끔 상기 테이블 엔트리 값을 이용할 수 있다. 이 방법은 상기 커널(상기 나노커널(nanokernel)에 의해 인터셉트 되지 않은)에 의해 직접적으로 처리된 예외에 사용된다.

VEX 의 인스톨 ( Install virtualized exception handler ( VEX ))

이 방법은 커널 예외 처리기를 나노커널(nanokernel)에 의해 가상화된 예외에 부착하는데 이용된다. 그러한 예외는 상기 나노커널(nanokernel)에 의해 인터셉트되고 연기된 실재 파워 PC 예외에 상응하는 가상 예외이거나 상기 나노커널(nanokernel)에 의해 일으켜진 논리 이벤트이다.

상기 VEX의 수와 상기 커널 처리기 코드의 물리적 주소는 매개변수로서 지나간다. 상기 VEX의 수는 상기 커널 처리기 포인터가 저장된 상기 커널 콘텍스트에 있는 가상화된 예외 처리기 테이블의 vexhdls □를 인텍스하는데 사용된다.

유휴( Idle )

상기 나노커널(nanokernel)은 유휴 루프 내에서 커널에 의해 호출되어야 하는 유휴 방법을 제공한다. 상기 유휴 방법은 다음 인터럽트까지 할 일이 없는 커널을 호출하는 상기 나노커널(nanokernel) 정보를 제공한다.

상기 유휴 방법 호출은 다음의 실행할 준비가 된 보조 커널 (또는 어떤)과 스위칭된 시스템 또는 모든 보조 커널이 유휴일 때 상기 주 유휴 방법으로부터의 복귀로 결정된다. 상기 유휴 방법은 어떤 매개변수도 가지고 있지 않다.

재부팅 ( Restart )

상기 나노커널(nanokernel)은 보조 커널을 재부팅하기 위해 보조 커널 뿐만 아니라 상기 주 커널에 의해 호출될 수 있는 재부팅 방법을 제공한다.

상기 방법 매개변수는 재부팅된 커널의 식별자를 명시한다. 상기 나노커널(nanokernel)은 상기 커널 수행을 정지하고, 그것의 사본으로부터 상기 커널 이미지를 복원하며, 최종적으로 최초의 엔트리

하나의 보조 커널은 그만의 식별자와 함께 재부팅 트랩을 호출함으로써 그 자신을 재부트(reboot)할 수 있음을 유의하라.

보조 정지 (Secondary Halt)

상기 정지 트랩은 상기 나노커널(nanokernel)에 의해 보조 커널로 제공된다. 그러한 트랩은 그것이 정지될 때 보조 커널에 의해 호출된다. 상기 나누커널은 상기 나노커널(nanokernel) 스케줄러(schedular)에 의해 스위칭된 이 커널을 제거하기 위해 상기 caller 커널을 비 실행 상태로 만들어야 한다.

하나의 정지된 커널은 위에서 설명한 재부팅 나노커널(nanokernel) 방법에 의해 다시 시작될 수 있다.

주 실행 환경 ( Primary Execution Environment )

기본적으로, 상기 주 커널은 상기 고유 실행 환경에서 실행된다. 파워 PC 프로세서 상의 상기 나노커널(nanokernel) 수행은 상기 주 운영체제 특성(성능, 인터럽트 대기시간, 접수 대기시간)으로의 상기 나노커널(nanokernel) 환경의 충돌을 최소화하려고 노력한다. 상기 주 운영체제는 일반적으로 실시간 운영체제이기 때문이고, 다른 (보조) 운영체제가 동일한 프로세서 상에서 동시에 작동하고 있다고 하더라도 상기 주 커널의 작용이 변화하지 않도록 유지하는 것이 중요하다.

초기화 ( Initialization )

상기 나노커널(nanokernel)은 처음 비허용(disable) MMU와 함께, 즉, 상기 물리적 공간에서 상기 부트 로드에 의해 시작된다. 기본적으로, 상기 나노커널(nanokernel) 초기화 코드는 상기 물리적 메모리에서 (상기 주 커널 코드/데이터/bss 섹션을 포함하는) 상기 주 메모리 뱅크(bank)와 다른 뱅크(bank)를 인스톨하 고 상기 주 엔트리 포인트로 점프한다.

상기 주 커널로 점프하기 전에, 상기 나노커널(nanokernel)은 시스템 특성 함수를 호출함으로써 상기 주 커널 콘텍스트을 초기화한다. 이 함수는 적어도 상기 나노커널(nanokernel) 콘텍스트의 숨겨진 부분에 설정되어 있어야 한다.: 상기 커널 엔트리 포인트를 향한 srr0 레지스터 이미지와 상기 시스템 커널에 의해 예기된 초기 값을 향한 srr1 레지스터 이미지.

코-프로세싱 (FPU) 장치 예외를 제외한 상기 예외 처리기 테이블(상기 커널 콘텍스트의 hdls □ 필드(field))에 있는 모든 엔트리는 상기 나노커널(nanokernel) 버그 제거 에이전트(agent) 엔트리 포인트를 가리킨다.

상기 나노커널(nanokernel) 초기화 코드는 상기 데이터 섹션에 위치한 분할된 정적 나노커널(nanokernel) 스택을 이용해 실행된다. 상기 주 커널로 점프할 때, 이 스택은 여전히 유효하다. 그럼에도 불구하고, 상기 주 커널은 가능한 빨리 그 만의 스택과 스위칭되어야 하며, 이후에는 이 나노커널(nanokernel) 스택을 절대 사용해서는 안된다. 상기 나노커널(nanokernel) 스택은 다음 장에서 설명하듯이 보조 호출과 접수를 처리하기 위해 초기화 것 뿐만 아니라 실행시간에도 사용된다.

상기 주 커널로 점프할 때, 상기 r3 레지스터는 상기 커널 콘텍스트을 가리키고 상기 커널 콘텍스트에 설정된 srr1 이미지와 함께 상기 msr 레지스터는 적재(load)된다. 일반적으로, 프로세서 인터럽트는 상기 주 초기화 것의 초기에는 비허용(disable)된다. 상기 주 커널은 보통 일단 중대한 초기화 것가 완료되면 인터럽트를 가능하게 한다.

상기 초기화 것 동안, 상기 주 커널은 일반적으로 처리기를 상기 프로세서와 가상화된 예외에 부착하기 위해 상기 나노커널(nanokernel) 방법을 호출한다. 마침내, 상기 주 커널은 상기 유휴 loop로 들어가고 상기 나노커널(nanokernel) 유휴 방법을 호출한다.

상기 유휴 방법이 처음 호출될 때, 상기 나노커널(nanokernel)은 상기 주 커널이 그의 실행 환경을 완전히 초기화하고 상기 초기화 뒷것까지 나아갈 것이 고려된다.

그러한 초기화 뒷것에서, 상기 나노커널(nanokernel)은 다음 장에서 설명한 바와 같이 상기 보조 커널 콘텍스트을 초기화한다. 일단 초기화 뒷것가 완료되면, 상기 나노커널(nanokernel)은 작동할 준비가 된 보조커널을 스위칭하거나 모든 보조 커널이 유휴라면 상기 주 유휴 방법으로부터 되돌아 오게 하기 위해 스케줄러를 호출한다.

상기 나노커널(nanokernel)은 상기 주 커널이 범용 공유된 데이터 구조: 상기 RAM 디스크립터(descriptor)와 상기 가상 장치 리스트,를 초기화하도록 요구한다. 그러한 초기화는 상기 유휴 방법이 호출되기 전에 완료되어야 한다. 이 순간 후에 보조 커널은 상기 범용 공유된 데이터 구조에 접근할 수 있기 때문에 이 요구는 자연스럽다.

특히, 상기 주요 커널은 상기 보드에서 사용가능한 상기 물리적 메모리를 찾아내고 상기 RAM 디스크립터(descriptor)에서 자유로운 물리적 메모리 덩어리를 기록하기 위해 책임지고 있다.

주 BSP(Board Support Package)에 의하면, 상기 주 커널은 드라이버를 감지한 나노커널(nanokernel)을 시작해야 하고, 바로, 상기 가상 장치 리스트를 차지해야 한다. 그러한 가상 장치들은 보조 커널로 제공되고 그러므로 상기 첫 보조 커널이 시작되기 전 만들어져야 한다.

인터셉트된 예외( exception ) ( Intercepted Exceptions )

기본적으로, 상기 나노커널(nanokernel)은 상기 주 운영체제가 상기 프로세서에서 실행되고 있을 때 발생하는 예외(exception)를 인터셉트하지 않는다. 모든 프로그래밍 예외(exception), 트랩, 그리고 인터럽트는 고유의 주 처리기에 의해 처리된다. 상기 주 저-수준 처리기는 파워 PC 구조의 약속을 호출하는 나노커널(nanokernel) 예외 처리기를 따르기 위해 수정될 필요가 없다.

위의 규칙에 따른 예외(exception)는 코-프로세싱 장치 에뮬레이션과 관련 있는 프로그래밍 예외(exception)이다:

＊예외가 유효하지 않은 부동 소수점 (FPU)

＊예외가 유효하지 않은 벡터 장치 (AltiVec VU)

이 예외들은 앞으로 설명되는 것과 같은 코-프로세싱 장치 공유의 느린 메커니즘을 이행하기 위해 나노커널(nanokernel)을 이용한다.

또다른 특별한 경우는 상기 주 운영체제의 호스트를 기초로 해 원격조정 시스템 버그 제거를 제공하기 위한 상기 나노커널(nanokernel)에 삽입할 수 있는 버그 제거 에이전트(agent)(agent)이다. 이 경우, 상기 버그 제거 에이전트 (agent)(agent)는 보통, (예를 들어, 한개의 명령 trace)을 디버깅하기 위해서나 에러 (예를 들어, 페이지 결함)를 프로그램하기 위한 것 중 하나와 관련있는 몇몇의 동기 예외(exception)를 인터셉트한다. 그러나 그러한 버그 제거 에이전트(agent) 설계는 본 발명의 범위에서 벗어난다.

전달된 인터럽트 ( Forwarded Interrupts )

하나의 보조 운영체제가 상기 프로세서에서 실행되는 동안 인터럽트가 발생할 때, 상기 인터럽트는 상기 주 운영체제로 전달된다. 그러한 인터럽트 전달 과정은 이하의 주된 것를 통해 진행된다.

＊인터럽트는 상기 나노커널(nanokernel)에 의해 인터셉트 되는 것(보조 커널 콘텍스트에 있는 hdls □ 테이블의 상응하는 엔트리는 나노커널(nanokernel) 처리기를 가리킨다);

＊접수된 보조 커널의 실행이 중지되고 상기 나노커널(nanokernel)이 상기 주 실행 환경과 스위칭되는 것;

＊상기 나노커널(nanokernel)이 인터럽트를 주 커널로 트리거하는 것 (주 커널 콘텍스트에 있는 hdls □ 테이블의 상응하는 엔트리에게 제의)

그러한 방법에서 상기 상응하는 주 저-수준 인터럽트 처리기는 (상기 주 실행 환경 내에서) 상기 인터럽트를 처리하기 위해 호출된다. 상기 인터럽트가 한 번 처리되면, 상기 주 커널은 rfi 명령을 실행하는 상기 나노커널(nanokernel)로 돌아간다.

상기 주 인터럽트 처리기로부터 돌아온 뒤, 상기 나노커널(nanokernel)은 실행시키기 위한 다음 보조 운영체제를 결정하기 위해 상기 스케줄러(schedular)를 호출한다. 상기 접수된 보조 시스템은 인터럽트 다음에 지속 될 필요는 없다는 것을 유의하라. 또다른 (높은 순위의) 보조 시스템은 상기 인터럽트를 이유로 동작할 준비를 할 수 있다.

보조 실행 환경 ( Secondary Execution Environment )

기본적으로, 상기 보조 커널 실행 환경은 상기 인터럽트 관리를 제외한 고유의 실행 환경에 완전히 닫혀있다. 상기 나노커널(nanokernel) 환경은 보조 운영체제를 완전히 접수할 수 있게 만들기 위해 상기 인터럽트 관리의 고유 메커니즘을 수정한다. 상기 나노커널(nanokernel) 구조로 이식된 보조 커널은 프로세서 수준에서 더이상 인터럽트를 비허용(disable)시키지 않고, 그보다는 상기 나노커널(nanokernel)에 의해 제공된 메커니즘 (적, 가상 예외(exception))을 금지하는 소프트웨어 인터럽트를 사용한다. 인터럽트는 더이상 그러한 보조 커널에 의해 직접적으로 처리되지 않고, 그보다는 상기 나노커널(nanokernel)에 의해 인터셉트되고 상기 주 커널로 전달되며, 곧 단지 연기된 방법으로 상기 보고 커널에 의해 부수적으로 처리된다.

초기화 ( Initialization )

상기 나노커널(nanokernel)은 주 뱅크(bank)와 함께 초기화 시간에 상기 보 조 메모리 뱅크(bank)를 인스톨한다. 한편, 보조 커널의 상기 최종 초기화는, 특히 상기 커널 콘텍스트 셋업(setup)에서, 초기화 뒷것까지 연기된다.

이 것에서, 상기 나노커널(nanokernel)은 보조 메모리 뱅크(bank)의 사본을 유지하기 위해 메모리를 할당한다. 그러한 사본은 곧 재부팅 시간에 보조 시스템의 초기 이미지를 복원하는데 사용된다. 상기 보조 시스템 재부팅은 부수적이고 상기 물리적 메모리 소비를 감소하기 위해서 억제할 수 있다.

상기 보조 커널 콘텍스트은 상기 시스템 엔트리 지점에 의해 예기된 콘텍스트을 초기화하는 시스템 특성 루틴을 호출함으로써 셋업(setup)된다. 코-프로세싱 (FPU) 장치와 상기 인터럽트 엔트리를 제외한 상기 예외 처리기 테이블(상기 커널 콘텍스트의 hdls□ 필드(field))에 있는 모든 엔트리는 나노커널(nanokernel) 버그 제거 에이전트(agent) 엔트리 지점을 가리킨다. 이것들은 다음 섹션에 설명한 것과 같이 상응하는 보조 예외를 인터셉트하는데 사용된 나노커널(nanokernel) 특성 처리기를 가리킨다.

상기 나노커널(nanokernel)은 이전에 상기 커널 콘텍스트의 숨겨진 부분에 있는 상기 시스템 특성 루틴에 의해 셋업(setup)된 초기 수행 콘텍스트을 스위칭함으로써 보조 커널을 내보낸다.

상기 주 커널과 유사한, 상기 커널 콘텍스트의 물리적 주소는 인수(전달 약속은 시스템 특성이다)로 전달된다. 한편, 상기 주 커널과는 달리, 상기 인터펍트는 상기 보조 커널 초기화 것동안 조차 프로세서 수준 (MSR[EE]이 설정된다) 상기 인터럽트를 허용한다. 상기 보조 커널 초기화 코드는 상기 주 시스템에 의해 완전히 접수된다는 것을 유의해야한다. 이는 특히 보조 운영체제가 재부팅될 때 상기 주 운영체제를 방해하지 않기 위해서 중요하다.

허용된 하드웨어 인터럽트에도 불구하고, 상기 가상화된 예외(exception)는 (하드웨어 예외(exception)에 상응하는) 보조 커널이 시작되면 비허용(disable)된다. 따라서, 인터럽트는 결정적인 초기화 것의 말미에 있는 상기 보조 커널에 의해 명시적으로 허용되는 동안 상기 나노커널(nanokernel)에 의해 전달된다. 상기 소프트웨어 인터럽트 금지 메커니즘은 (가상 예외(exception)를 기초로한) 앞으로 더욱 상세히 설명하도록 하겠다.

상기 스택 포인터는 보조 커널이 시작되면 유효하지 않게 된다. 일반적으로, 상기 보조 커널은 초기화 코드를 실행하기 위해 데이터 섹션에 위치한 정적 초기화 스택을 이용한다.

상기 초기화 것 동안, 상기 주 커널과 유사한, 보조 커널은 일반적으로 처리기를 파워 PC와 가상화된 예외에 부착하기 위해 상기 나노커널(nanokernel) 트랩을 호출한다. 최종적으로 상기 보조 커널은 상기 유휴 loop로 들어가고 상기 나노커널(nanokernel) 유휴 트랩을 호출한다.

인터셉트된 예외 ( intercepted exceptions )

하나의 보조 예외(exception)로 인터셉트하기 위해, 상기 나노커널(nanokernel)은 그만의 처리기를 향한 포인터를 상기 보조 커널 콘텍스트에 있는 hdls □ 예외 처리기의 상응하는 엔트리에 인스톨한다. 따라서, 그러한 예외(exception)가 발생하면, 상기 예외 벡터는 상기 나노커널(nanokernel) 처리기에 상기 보조 메모리 콘텍스트을 저장하고 상기 예외를 처리하는 것을 제의한다.

모든 인터셉트된 예외(exception)는 인터럽트, 트랩, 그리고 프로그래밍 예외(exception)(결점)와 같이 원시 상태에 따라 분류될 수 있다.

상기 나노커널(nanokernel)은 상기 주 커널로 전달될 때 모든 하드웨어 인터럽트(금지되지 않은 인터럽트(NMI)를 포함하는)를 인터셉트한다.

상기 나노커널(nanokernel)은 주 커널로 전달하기 위해 모든 파워 PC 인터럽트 (비동기 예외)를 인터셉트 한다:

＊Reset(재설정)

＊장치 점검

＊시스템 관리

＊외부 인터럽트

＊기능 모니터

＊감쇠기

＊열

또한, 두 개의 나노커널(nanokernel) 트랩은 중요한 기능이고 특히 보조 커널을 위해 처리된다.

처음의 나노커널(nanokernel) 트랩은 주 커널로 교차 인터럽트를 송신한다. 상기 나노커널(nanokernel) 처리는 하드웨어 인터럽트보다는 소프트웨어 인터럽 트에 상응하는 주 커널로 전달된 상기 예외를 제외한 인터럽트 트랩과 동일하다.

두 번째 나노커널(nanokernel) 트랩은 미결 가상 예외(exception)를 처리하기 위해 보조 커널에 의해 호출된다. 이 트랩들은 소프트웨어 인터럽트 금지 메커니즘에 가담하고, 이는 가상 예외(exception)를 나타내는 다음 섹션에 좀 더 자세히 설명하겠다.

상기 주 커널과 유사한, 상기 나노커널(nanokernel)은 일반적으로 이하 설명된 몇몇의 특별한 경우를 제외하고는 프로그래밍 예외(exception)를 인터셉트하지 않는다:

＊예외가 유효하지 않은 부동 소수점 (FPU)

＊예외가 유효하지 않은 벡터 장치 (AltiVec VU)

이 예외들은 다음에 설명할 느린 방법 안에 있는 커널 사이를 공유하는 장치를 처리하기 위해 나노커널(nanokernel)을 이용한다.

또 다른 특별한 경우는 상기 주 운영체제의 호스트를 기초로 해 원격조정 시스템 버그 제거를 제공하기 위한 상기 나노커널(nanokernel)에 삽입할 수 있는 버그 제거 에이전트(agent)(agent)이다. 이 경우, 상기 버그 제거 에이전트(agent)(agent)는 보통, 특징 (예를 들어, 한개의 명령 trace)을 디버깅하기 위해서나 에러 (예를 들어, 페이지 결함)를 프로그램하기 위한 것 중 하나와 관련있는 몇몇의 동기 예외(exception)를 인터셉트한다.

가상 예외( virtual exceptions )

가상 예외(exception)(VEX)는 커널이 예외(exception)를 보조 커널로 우송하고 그것을 다른 방법으로 전달하는 것을 허용하는 상기 나노커널(nanokernel)에 의해 제공되는 메커니즘이다. 특히, 상기 VEX 메커니즘은 보조 커널을 위해 하드웨어 인터럽트를 소프트웨어 인터럽트로 대신하기 위한 사기 파워 PC 나노커널(nanokernel) 구조에서 사용된다.

상기 VEX 인터페이스는 상기 커널 콘텍스트에 위치한 두개의 필드(field)로 구성된다: 미결과 허용. 이 필드(field)들은 오직 보조 커널 콘텍스트에 대해서만 의미가 있지만 상기 주 커널과 보조 커널 양쪽 모두에 의해 접근된다. 모든 가상 예외(exception)는 상기 미결 (또는 허용) 필드(field) 내에서 상기 비트의 위치에 의해 자연스럽게 열거된다. 따라서, 전체적으로 상기 파워 PC 구조(상기 pending(미결) 필드(field)와 enabled(허용) 필드(field)는 32 비트 정수 값이다.) 상의 상기 나노커널(nanokernel)에 의해 지지되는 32 가상 예외(exception)가 있다.

아래의 표는 가상 예외(exception)가 어떻게 실재 가상 예외(exception)에 매핑되는지 보여준다.

가상 예외(exception)	실재 예외(exception)	비고
0	0x2	장치 점검
1	0x1	재설정
2	0x14	SMI
3	0x5	외부 인터럽트
4	0x2e	기능 모니터
5	0x9	감쇠기
6	0x17	열
7	0x23	XIRQ
8	0x21	버그 제거기
31	-	실행

0부터 16까지의 가상 예외(exception)는 파워 PC 인터럽트에 매핑되었다. 상기 가상 예외(exception) 7은 교차 인터럽트를 상기 보조 커널로 전달하는데 사용된 상기 예외(exception) 벡터 0x23에 매핑되었다. 9부터 30까지의 가상 예외(exception)는 현재 사용되지 않고 미래의 확장을 위해 연기된다. 가상 예외(exception) 31은 어떠한 실재 예외(exception)와도 일치하지 않고, 사실상 상기 커널이 유휴인지 감지하기 위한 상기 나노커널(nanokernel)에 의해 내부적으로 사용된 유사 가상 예외(exception)이다. 그러한 유사 가상 예외(exception)가 어떻게 작동하는지는 앞으로 자세히 설명할 것이다.

다중의 가상 예외(exception)는 동일한 시간에는 미결일 수 있지만 오직 한개의 가상 예외(exception)만이 처리될 수 있고, 모든 가상 예외(exception)는 그것의 수에 따라 우선순위가 조정된다. 가장 높은 순위는 장치 점검에 할당되고 가장 낮은 우선 순위는 실행(Running)에 할당된다.

하나의 보조 콘텍스트의 상기 pending(미결) 필드(field)는 일반적으로 상기 가상 PIC 장치를 위한 드라이버를 제공하는 상기 주 커널에 의해 업데이트 된다. 그러한 드라이버는 일반적으로 상기 pending(미결) VEX 필드(field) 내에서 적절한 비트를 조정함으로써 가상 예외(exception) (인터럽트)를 보조 커널로 운송한다.

상기 enabled(허용) VEX 필드(field)는 가상 예외(exception)를 허용 또는 비허용(disable)하기 위해 상기 보조 커널에 의해 업데이트된다. 상응하는 비트가 enabled(허용) VEX 필드(field)에 설정된다면, 주어진 가상 예외(exception)는 허 용된다. 상기 enabled(허용) VEX 필드(field)를 이용해, 보조 커널은 인터럽트를 보호하는 결정적인 섹션을 수행한다. 달리 말해, 보조 커널은 더이상 비허용(disable)/허용 프로세서에 MSR[EE]과 MSR[ME] 비트를 사용하기보다는 그것의 커널 콘텍스트의 상기 enabled(허용) VEX 필드(field)를 수정한다.

하나의 주어진 가상 예외(exception)는 만약 그것이 동시에 미결되고 허용된다면 상기 나노커널(nanokernel)에 의해 전달된다. 상기 나노커널(nanokernel)은 상기 보조 예외(exception) 처리기에 점프하기 전에 상응하는 미결 비트를 재설정한다.

하나의 보조 커널을 파워 PC 나노커널(nanokernel) 구조에 이식할 때, 저-수준 예외 처리기는 상기 하드웨어 인터럽트 금지 메커니즘을 대신하는 상기 소프트웨어 인터럽트 금지 메커니즘을 고려하기 위해서 수정되어야 한다. 보조 커널을 실행할 때 공유된 자원 (스크래치 레지스터)를 저장하는, 중요한 섹션을 요구하는 프로세서 상태인 저-수준 예외 처리기 코드를 제외한 프로세서 수준에서 상기 하드웨어 인터럽트는 언제나 허용되어야 한다. 그리하여 상기 나노커널(nanokernel) 환경에서, 보조 운영체제는 상기 주 운영체제에 의해 충분히 접수될 수 있게 된다; 그러한 저-수준 예외 코드가 상태를 저장할 때인 짧은 기간을 제외하고 접수가능하다.

하나의 가상 예외(exception)는 비허용(disable) 상태 동안 상기 부 커널에 의해 운송될 수 있다. 이 경우, 상기 예외(exception)는 상기 보조 커널로 전달되지 않고, 오히려 상기 예외(exception)가 다시 재-허용될 때까지 미결을 유지한다. 따라서, 가상 예외(exception)가 보조 커널에 의해 재-허용될 때, 가상 예외(exception)가 미결이더라도 점검이 만들어져야 한다. 만약 상기 점검이 능동적이라면, 상기 보조 커널은 그러한 미결 가상 예외(exception)를 처리하기 위해 상기 나노커널(nanokernel)을 호출해야 한다. 그러한 점검은 "처리 미결 가상 예외" 트랩 (나노커널(nanokernel) 특성 벡터 0x2500)에 의해 만들어진다.

일반적으로, 보조 커널은 이하 두 개의 경우에 있어서 가상 예외(exception)를 재-허용한다;

＊가상 예외(exception)가 코드의 결정적인 섹션을 보호하기 위해 상기 보조 커널에 의해 미리 비허용(disable)될 때;

＊가상 예외(exception)가 프로세서 예외 저-수준 처리기를 처리하는 동안 비허용(disable)될 때

나노커널 ( nanokernel ) 재-진입 ( Nanokernel Re - Entrance )

상기 나노커널(nanokernel)은 대부분 나노커널(nanokernel) 안으로의 재-진입을 예방하기 위해 프로세서 수준에서 비허용(disable) 된 인터럽트와 함께 실행된다. 또 한 편으로는, 몇몇의 나노커널(nanokernel) 호출은 긴 시간을 소요하고, 따라서 상기 나노커널(nanokernel)은 상기 주 인터럽트 대기 시간을 짧게 유지하기 위해서 그러한 긴 작동을 실행할 때 인터럽트를 허용해야 한다.

긴 나노커널(nanokernel) 작동에는 두 종류가 있다:

＊동기식 콘솔 출력

상기 작동 존속기간은 직렬 회선의 속도에 달려있다. 예를 들어, 9600 baud 비율 라인에서, 단일 문자 출력은 1ms를 잡을 것이다.

＊보조 커널 재부팅

상기 작동 존속기간은 사본으로부터 복원된 상기 커널 이미지의 크기에 달려있다.

위에 나열한 모든 작동에 대해, 상기 나노커널(nanokernel)은 인터럽트를 허용하고 따라서 상기 주 커널로부터 재-진입한다. 한편, 다른 보조 커널이 상기 주 인터럽트 처리기로부터 되돌아올 때 다른 보조 커널이 예정되는 것을 막기 위해, 인터럽트가 허용되는 동안 상기 나노커널(nanokernel) 스케줄러(schedular)는 호출되지 않는다. 달리 말해, 상기 나노커널(nanokernel)은 오직 상기 주 커널에 의해서만 접수될 수 있지만 (하나의 인터럽트의 결과로서) 보조 커널로부터의 재-진입은 금지된다. 그러한 제한은 나노커널(nanokernel)이 상기 보조 실행 환경을 위해 범용 자원을 이용하는 것을 허용한다. 예를 들어, 인터셉트된 예외(exception)에 사용된 TSS 데이터 구조는 범용이고 모든 보조 커널에 걸쳐 공유된다.

이상의 논의는 상기 주 커널 또는 보조 커널에 의해 호출된 트랩의 결과인 상기 나노커널(nanokernel) 메모리 콘텍스트 안에 있는 코드를 실행하는 동안 상기 나노커널(nanokernel)이 프로세서 인터럽트를 허용하는 것이 가능하다는 것을 보여준다. 즉, 상기 나노커널(nanokernel)은 그만의 호출 처리기를 작동하는 동안 주 인터럽트 처리기로의 스위칭을 지원해야 한다.

상기 나노커널(nanokernel) 콘텍스트은 0 식별자 값(ID 필드(field))을 가 진다. 그 값은 인터럽트 상의 주 커널로 스위칭될 때 상기 나노커널(nanokernel) 실행 콘텍스트 (숨겨진 부분에서) 저장하는데 사용된다. 그것은 또한 (hdls □ 테이블 안에서) 나노커널(nanokernel) 특성 인터럽트 처리기 포인터를 저장하는데 사용된다. 이렇게 하여, 인터럽트는 상기 나노커널(nanokernel) 코드가 작동중일 때도 "현재" 실행중인 커널 콘텍스트을 통해 벡터될 수 있다. 또한, 상기 나노커널(nanokernel) 관리자 스택은 주 커널 재-진입에 재쓰기 된 다른 경우라면 상기 나노커널(nanokernel)과 주 커널 콘텍스트의 일부와 마찬가지로 중요한 공유된 프로세서 자원을 밀어넣는데 사용된다.

상기 나노커널(nanokernel)은 나노커널(nanokernel)에 있는 인터럽트를 처리하고 상기 주 커널에 의해 처리된 상기 인터럽트의 말미에서 나노커널(nanokernel)의 인터럽트된 코드로 되돌아 가기 위해 루틴의 인터럽트 프롤로그/에필로그 한 쌍을 이용한다. 상기 루틴의 프롤로그/에필로그 한 쌍은 나노커널(nanokernel) 트랩을 호출했던 마지막 커널에 의존한 것과는 다르다는 것을 유의하라. 물론 상기 스택으로 밀어 넣어져야 하는 정보의 종류와 양은 상기 주 트랩 콜러나 보조 트랩 콜러와 같지는 않다.

상기 인터럽트 프롤로그 루틴은 상기 나노커널(nanokernel) 인터럽트 처리기이다. 그것은 상기 나노커널(nanokernel) 콘텍스트에 있는 hdls □ 예외 처리 테이블의 인터럽트 엔트리의 전체에 부착된다. 이 처리기는 다음과 같은 움직임을 실행한다:

＊상기 커널 콘텍스트의 일부를 스택 상의 인터럽트 프레임에 저장,

＊주 커널 재-진입을 처리하도록 현재 값과 함께 커널 콘텍스트을 업데이트,

＊적절한 에필로그 루틴으로 돌아가도록 srr0 레지스터 값을 수정,

＊상응하는 주 커널 인터럽트 처리기와 스위칭.

상기 인터럽트 에필로그 루틴은 주 커널 인터럽트 처리(rfi)로부터 되돌아올 때 호출된다. 상기 나노커널(nanokernel) 스케줄러를 호출하지 않고 상기 나노커널(nanokernel)의 인터럽트딘 실행 콘텍스트을 복원하도록 사용되며, 다음과 같은 것로 진행된다.

＊커널 콘텍스트으로부터 현재 상태를 복원,

＊(상기 프롤로그 루틴에 의해 저장된) 상기 인터럽트 스택 프레임으로부터 커널 콘텍스트을 복원,

＊인터럽트 된 코드로 복귀

상기 나노커널(nanokernel) 인터럽트 스택 프레임은 다음과 같은 정보를 저장하도록 사용된다:

＊상기 나노커널(nanokernel) 콘텍스트의 중요한 부분의 사본: lr, r1, r2, srr0, srr1 레지스터,

＊마지막 트랩 caller (하나의 주 또는 보조 커널 콘텍스트을 향한 포인터).

＊만약 마지막 caller만이 주라면: 상기 주 커널 콘텍스트의 중요한 부분의 사본: r1, r2, srr0, srr1 레지스터.

상기 나노커널(nanokernel)은 인터럽트를 허용/비허용(disable)하도록 사용된 한 쌍의 함수를 정의한다. 이 함수들은 각각 상기 스택과 트랩 엔트리에서 조직 적으로 저장되지 않은 나노 커널 실행 콘텍스트의 추가적인 부분 안에서 저장되고 복원된다.

인터럽트를 허용할 때, 상기 나노커널(nanokernel)은 다음과 같은 것로 진행된다:

＊스택 안에서 (sprg0-3) 스크래치 레지스터를 저장,

＊스택 안에서 현재 한 쌍의 인터럽트 프롤로그/에필로그를 저장,

＊트랩 콜러(주 또는 보조)에 따른 현재 한 쌍의 인터럽트 프롤로그/에필로그 루틴을 저장,

＊프로세서 수준(MSR[EE] 비트를 설정)에서 인터럽트를 허용.

인터럽트를 비허용(disable)할 때, 상기 나노커널(nanokernel)은 다음과 같은 것로 진행된다:

＊프로세서 수준(MSR[EE] 비트를 clear)에서 인터럽트를 비허용(disable),

＊스택으로부터 현재 한 쌍의 인터럽트 프롤로그/에필로그를 복원,

＊스택으로부터 (sprg0-3) 스크래치 레지스터를 복원.

도 4는 상기 실행 플로우와 상기 나노커널(nanokernel) 스택이 어떻게 인터럽트 처리와 주 커널 재-진입을 허락하도록 사용되는지 보여준다.

스케줄러( Scheduler )

운영체제 스케줄러(schedular)의 주된 역할은 다음에 실행될 작업을 선택하는 것이다. 상기 나노커널(nanokernel)이 운영체제의 실행을 제어하기 때문에, 상 기 나노커널(nanokernel) 스케줄러(schedular)는 다음에 실행될 운영체제를 선택해야 한다. 다시 말해, 상기 나노커널(nanokernel)은 전체 시스템에 부수적인 스케줄링 수준을 추가하는 것이다.

상기 나노커널(nanokernel) 구조에서, 상기 주 운영체제는 보조 운영체제에 비해 높은 우선순위 순위를 가지고, 상기 주 운영체제가 오직 유휴 loop에 있을 때에만 상기 CPU가 보조 운영체제에 주어진다. 상기 주 커널은 접수할 수 없고, 상기 유휴 loop에 호출된 상기 유휴 방법을 통해 상기 나노커널(nanokernel) 스케줄러(schedular)를 명시적으로 호출한다고 말할 수 있다. 일단 보조 운영체제를 실행할 때 인터럽트가 발생하면, 상기 주 커널 인터럽트 처리기가 호출된다. 그러한 인터럽트는 상기 주 커널 투시도로부터 상기 유휴 loop를 실행하는 배경 스레드를 접수한다. 상기 인터럽트가 한번 처리되고 모든 관계된 작업이 완료되면, 상기 주 커널은 다음이 실행할 보조 운영체제를 결정하기 위해 상기 나노커널(nanokernel) 스케줄러(schedular)를 호출하는 나노커널(nanokernel)로 되돌아간다. 상기 커널은 단지 상기 인터럽트에 의해 상기 주 커널 투시도로부터 접수된 배경 스레드로 되돌아간다. 상기 보조 활동은 상기 주 커널을 위해 투과되고 상기 주 운영체제의 거동(behaviour)을 변화시키지 않는다.

상기 나노커널(nanokernel)은 다른 스케줄링 방법을 수행할 수 있다. 그러나 디폴트에 의해 알고리즘을 기초로한 우선순위가 사용된다. 동일한 우선순위 수준에서, 상기 나노커널(nanokernel)은 round-robin 스케줄링 방법을 이용한다. 주어진 보조 커널 우선순위는 시스템 이미지 형성 시간에 정적으로 구성된다.

상기 스케줄링 방법이 수행되는 것 무엇이든, 상기 스케줄러(schedular)는 주어진 보조 운영체제가 작동할 준비가 되었는지 감지해야 한다. 이 조건은 상기 커널 콘텍스트의 상기 미결 VEX와 enabled(허용) VEX 필드(field) 사이에서 비트의 논리와 작동에 의해 산출된다.

위에 설명된 것과 같이, 미결 VEX와 enabled(허용) VEX 쌍에 있는 각각의 비트는 가상 예외(exception)를 나타낸다. 작동할 준비가 된 기준을 재표현함으로써, 금지되지 않은 미결 가상 예외(exception)가 적어도 하나 이상 있다면 보조 운영체제는 작동할 준비 상태에 있다고 말할 수 있다.

일반적으로 하드웨어와 소프트웨어 (교차) 인터럽트에 매핑된 모든 가상 예외(exception) 사이에, 상기 커널이 현재 유휴인지를 (실행) 반영하는 고유 가상 예외(exception)가 있다.

상기 running(실행) 비트는 보조 커널이 상기 유휴 방법을 호출하는 각각의 시간에 pending(미결) VEX 필드(field)에서 clear되고, 상기 running(실행) 비트는 가상 예외(exception)가 상기 보조 커널로 전달되는 각각의 시간에 pending(미결) VEX 필드(field)에서 설정된다.

상기 running(실행) 비트는 보통 실행되는 보조 커널을 위해 enabled(허용) VEX 필드(field) 내에 설정된다. 상기 나노커널(nanokernel)은 보조 커널이 시작될 때 이 비트를 설정하고 그것은 보조 커널이 정지할 때 이 비트를 재설정한다. 상기 보조 커널은 가상 예외(exception)에 매핑된 인터럽트가 금지된/금지되지 않은 때에 상기 running(실행) 비트를 절대 clear 할 수 없다.

하나의 외부 에이전트(agent)(agent)는 보조 커널 콘텍스트 내에서 상기 enabled(허용) VEX 필드(field)를 clear/복원함으로써 보조 커널 실행을 연기/재개할 수 있음을 유의해라. 이 특징은 주 커널 작업과 마찬가지로 스케줄링 방법 에이전트(agent)(agent)가 상기 나노커널(nanokernel) 밖에서 수행될 수 있는 가능성을 열어준다. 또한, 이는 보조 커널이 상기 주 커널의 꼭대기 상의 작업과 같이 실행될 수 있도록 버그 제거 에이전트(agent)(agent)를 허용한다. 그러한 보조 버그 제거 에이전트(agent)(agent)의 이점은, 상기 주 운영체제에 의해 제공된 모든 서비스가 버그 제거에 유용해진다는 점이고, 상기 보조 커널 버그 제거는 상기 주 운영체제 상에 실행되는 결정적인 작업과 동시에 완료될 수 있다는 점이다.

교차 인터럽트 ( Cross Interrupts )

이 섹션에서는 주로 상기 나노커널(nanokernel) 교차 인터럽트 케머니즘과 관계있는 (전 섹션에 이미 주어진)정보를 통합할 것이다.

여기서는 아래와 같은 두 종류의 교차 인터럽트가 논의될 것이다:

＊하나의 보조 커널로 송신된 교차 인터럽트

＊하나의 주 커널로 송신된 교차 인터럽트

하나의 교차 인터럽트를 목적 보조 커널로 송신하기 위해 소스 터널은 우선, 상기 목적 커널 콘텍스트의 미결(pending) XIRQ에 있는 상기 교차 인터럽트 소스에 상응하는 비트를 설정한다. 그 다음 상기 소스 커널은 상기 교차 인터럽트 VEX를 상기 목적 커널 콘텍스트의 미결(pending) XIRQ에 있는 상응하는 비트를 설 정한 상기 목적 커널로 발송한다. 상기 교차 인터럽트 처리기가 상기 나노커널(nanokernel)에 의해 한 번 호출될 때, 그것은 상기 미결(pending) XIRQ 필드(field)를 점검하고, 상기 미결(pending) 교차 인터럽트 소스에 상응하는 비트를 clear하며, 최종적으로 이 소스에 부착된 처리기를 호출한다. 소스와 목적 커널 둘 다 상기 미결(pending) XIRQ 필드(field)를 업데이트하기 위해 원자 명령을 사용한다. 소스 커널의 두 타입: 주와 부 모두 동일한 알고리즘을 사용한다는 것을 유의하라.

상기 주 커널로 교차 인터럽트를 송신하기 위해, 보조 커널은 우선 상기 목적 커널 콘텍스트의 미결(pending) XIRQ에 있는 상응하는 비트를 설정한 상기 목적 커널로 발송한다. 그 다음, 상기 보조 커널은 상기 XIRQ 트랩을 실행하는 상기 나노커널(nanokernel)을 호출한다. 상기 나노커널(nanokernel)은 상기 보조 커널을 곧바로 접수하고, 상기 미결(pending) XIRQ 필드(field)를 점검하는 상기 주 저-수준 교차 인터럽트 처리기를 호출하며, 상기 미결(pending) 교차 인터럽트 소스에 상응하는 비트를 clear하고, 최종적으로 이 소스에 부착된 처리기를 호출한다.

상기 교차 인터럽트 0을 커널이 사용해서는 안된다. 이 인터럽트는 정지된 커널은 시작되도록 또는 실행된 커널은 정지되도록 커널을 고지할 수 있게 상기 나노커널(nanokernel)을 보류한다. 다시 말해, 상기 교차 인터럽트 0은 상기 범용 시스템 구성이 변경되게 실행 커널을 고지해야 한다. 이는 상기 커널 콘텍스트에 의해 가리켜진 상기의 실행 비트 필드(field)가 커널 콘텍스트에서 변경되는 각각의 시간에 모든 실행 커널로 넓게 해당된다.

코-프로세싱 장치 관리 ( Co - processing Units Management )

코-프로세싱 장치 (FPU, SIMD 장치)는 일반적으로 상기 나노커널(nanokernel) 환경에서 실행하는 모든 운영체제에 의해 공유된 계산 자원이다. 다음부터는 부동 소수점 장치 (FPU)가 실시예로 보여진다. 그러나 AltiVec 벡터리얼 계산 장치(SIMD)와 같은 다른 코-프로세싱 장치는 동일한 방법으로 관리된다.

파워 PC 구조에서, 상기 나노커널(nanokernel)은 느린 방법에 의해 코-프로세싱 장치의 공유를 관리한다. 이는, 예를 들어 운영체제로부터 다른 운영체제로의 스위칭이 발생할 때, 상기 FPU 가 새롭게 스케줄링 된 운영체제를 대신해 곧바로 주어지지 않고, 상기 FPU 콘텍스트의 스위칭은 상기 새롭게 스케줄링 된 운영체제가 실제로 부동 소수점 명령을 실행하고 부동 소수점 레지스터에 접근할 때까지 연기된다는 뜻이다.

알고리즘을 발송하는 그러한 느린 FPU는 나노커널(nanokernel)이 상기 시스템 스위칭 시간을 감소시키도록 허용한다. 이는 FPU가 일반적으로 인터럽트 수준에서 사용되지 않으므로 상기 주 인터럽트 대기시간을 감소하는데 특히 중요하고, 따라서 보조 운영체제를 접수하고 주 인터럽트 처리기를 호출하기 위해 FPU 레지스터를 저장하고 복원하는 것은 일반적으로 불필요하다.

상기 나노커널(nanokernel)은 현재 FPU를 사용하는 상기 커널의 콘텍스트을 가리키는 FPU 소유자 범용 변수를 처리한다. FPU 소유자가 없을 경우, 상기 FPU 소유자 콘텍스트은 0로 설정된다. FPU 콘텍스트은 상기 커널 콘텍스트의 숨겨진 부분에 위치한다. 상기 커널이 FPU의 소유자가 아닐 때 그러한 콘텍스트은 상기 FPU 엔진의 상태(즉, 부동 소수점 레지스터와 상태)를 유지한다. 명백히, 상기 FPU 소유자의 상태는 상기 FPU 엔진 하드웨어에 의해 보호된다. 상기 나노커널(nanokernel)이 상기 FPU 소유자를 변경할 때, 상기 FPU 상태는 오래된 FPU 콘텍스트으로 저장되고 새로운 FPU 콘텍스트으로부터 복원된다.

상기 나노커널(nanokernel)은 FPU가 FPU 소유자가 아닌 것을 사용할 때 예외(exception)를 호출하기 위해 MSR 레지스터의 부동 소수점 무효 (FP) 비트를 사용한다. 상기 MSR 레지스터 이미지는 상기 커널 콘텍스트의 숨겨진 부분에 가담한다. 상기 MSR[FP] 비트는 이전의 소유자 콘텍스트 안에서 clear 되고, FPU 스위칭 시간에 새로운 소유자 콘텍스트에서 설정된다. 상기 FP 비트는 그것이 설정되는 FPU 소유자를 제외한 모든 커널 콘텍스트에서 clear 된다. 이는 상기 FPU 소유자가 고유의 방법으로 이 예외를 처리할 동안 모든 FPU 소유자가 아닌 것들을 위해 상기 나노커널(nanokernel)이 유효하지 않은 부동 소수점 예외 (0x8)를 인터셉트하도록 허용한다.

하나의 FPU 스위칭은 "FP를 허용하지 않는" 예외 인터셉트할 때 (이는 운영체제 커널의 수정을 요구한다.) 발생한다. 두 커널 사이로 상기 FPU 엔진을 스위칭하기 위해, 상기 나노커널(nanokernel)은 현재 FPU 소유자를 내보내고 새로운 FPU 소유자를 할당한다.

현재 FPU 소유자를 내보내기 위해, 상기 나노커널(nanokernel)은 상기 MSR[FP] 비트의 현재 상태와 함께 상기 커널 콘텍스트 안에 현재 FPU 상태를 저장 하고, 상기 MSR 레지스터 이미지에 있는 FP 비트를 clear 한다. 또한, 상기 나노커널(nanokernel)은 FP를 허용하지 않는 예외 (0x8)을 인터셉트하기 위해 그것만의 예외 처리기를 커널 콘텍스트에 있는 hdls □ 예외 처리기 테이블의 적절한 엔트리로 인스톨한다. 상기 고유 예외 처리기 포인터는 saveHdls □ 테이블 상기 커널 콘텍스트의 숨겨진 부분까지 저장된다.

하나의 새로운 FPU 소유자를 할당하기 위해서, 상기 나노커널(nanokernel)은 상기 커널 콘텍스트으로부터 FPU 상태를 복원하고, 상기 FP 비트의 이전에 저장된 상태를 상기 MSR 이미지 안으로 복원시킨다. 또한, 고유의 예외 처리기는 FPU를 소유하는 동안 고유의 방법으로 FP를 허용하지 않는 예외를 처리하기 위해 saveHdls □ 테이블로부터 상기 커널 콘텍스트의 hdls □ 테이블 안으로 복원시킨다.

상기 나노커널(nanokernel)이 느린 FPU 스위칭을 수행하기 위해 MSR 레지스터의 FP 비트를 사용하기 때문에, 커널은 그것이 FPU의 소유자가 아닌 동안 (고유의 FP를 허용하지 않는 예외 처리기의 밖에서) 이 비트의 상태를 변경하는 것이 허용되지 않는다. 특히, 이는 상기 FPU 에뮬레이션이 상기 나노커널(nanokernel) 구조로 이식된 나노커널(nanokernel)로 지지되지 않는다는 것을 의미한다.

일반적으로 운영체제 커널은 또한 프로세서 사이에서의 느린 FPU 스위칭을 이행하기 위해 MSR 레지스터의 FP 비트를 사용한다는 것을 유의하라. 상기 MSR 레지스터 이미지가 상기 커널 콘텍스트에 가담하므로 시스템 스위칭에서 저장되고 복원되고, 상기 고유 FPU 관리는 상기 나노커널(nanokernel) 환경에서 거의 변하지 않고 유지될 수 있다.

동일한 메커니즘이 몇몇의 파워 PC 프로세서 실시 (AltiVec)의 벡토리얼 게산 장치에 사용된다. 그 경우 MSR 레지스터의 상기 VU 비트는 FPU를 위한 FP 비트와 동일한 역할을 수행한다. 또한, 상기 벡터를 허용하지 않는 예외 (vector 0x0f20)은 느린 방법에 있는 상기 SIMD 장치의 실행 콘텍스트 스위칭에 인터셉트 된다.

다른 측면들과 실시예들

전술한 실시예는 다만 사례일 뿐이고 많은 다른 실시예가 가능하다는 것은 명세서 서두에서부터 분명할 것이다. 앞서 언급한 운영체제, 플랫폼과 프로그래밍 기법은 자유로이 변경될 수 있다. 당업자에게 자명한 모든 다른 변경, 치환이나 다양한 버전은 다음의 청구항에 기재되었는지 여부에 무관하게 본 발명의 범위에 속한다고 판단하여야 한다. 의심스러운 경우를 방지하게 위하여, 본 명세서에 기재된 모든 신규한 내용과 그 조합에 대한 권리의 보호를 구하는 바이다.

본 발명은 복수의 운영체제를 한 컴퓨터 내에서 운용하는 데에 있어서 시스템 자원을 절약하고, 통상적으로 시판되는 운영체제 프로그램에 제한적인 변화를 가하는 것만으로도 설치 가능하고 운영체제의 새 버전을 다중 운영체제 방식에서 작동하게끔 고치는 수고가 거의 들지 않는 컴퓨터의 다중 운영체제 운용 방식을 제공한다.

Claims

상대적으로 높은 우선 순위를 가지는 제1 운영체제를 선택하는 것;

상대적으로 낮은 우선 순위를 가지는 제2 운영체제를 적어도 하나 이상 선택하는 것;

미리 예정된 조건 하에서 상기 운영체제들 사이를 스위칭하도록 정해진 공통 프로그램을 제공하는 것; 그리고

상기 제1 운영체제와 제2 운영체제가 상기 공통 프로그램에 의하여 제어될 수 있도록 조절하는 것;

을 포함하는 복수의 다른 운영체제가 동시에 동일 컴퓨터에서 수행될 수 있도록 하는 방법.
제1항에 있어서, 상기 운영체제 사이의 스위칭은 예외 벡터를 이용해 상기 공통 프로그램을 불러들이는 것을 포함하는 방법.
제2항에 있어서, 예외 벡터를 트랩 호출로의 할당을 구비하고, 그로 인해 트랩 호출 메커니즘을 이용하는 상기 공통 프로그램의 불러들임을 허용하는 방법.
제2항 또는 제3항에 있어서, 상기 제1 또는 제2 운영체제는 예외 벡터 호출에 의해 상기 공통 프로그램을 불러들이는 방법.
제4항에 있어서, 상기 공통 프로그램을 불러들이도록 예외 벡터를 호출하는 것이 외부 이벤트에 의해 야기된 호출을 시뮬레이트하는 방법.
제1항 내지 제5항 중 어느 한 항에 있어서, 상기 공통 프로그램은 예외나 인터럽트 벡터를 인터셉트함으로써 상기 제1 또는 제2 운영체제를 접수하는 방법.
제6항에 있어서, 예외를 인터셉트하도록 포인터의 배열을 포함하는 예외 처리기 테이블을 이용하는 것과, 상기 제1 또는 제2 운영체제를 접수하기 위해 예외 처리기 프로그램을 활성화하는 것을 더 포함하는 방법.
제1항 내지 제7항 중 어느 한 항에 있어서, 상기 공통 프로그램은 리얼 모드에서 작동가능한 방법.
제8항에 있어서, 상기 공통 프로그램에 의해 상기 제1 또는 제2 운영체제를 접수하고, 상기 제1 또는 제2 운영체제를 접수할 때 리얼 모드로 전환하는 것을 포함하는 방법.
제8항에 있어서, 상기 제1 또는 제2 운영체제에 의해 상기 공통 프로그램을 불러들이고, 상기 공통 프로그램을 불러들일 때 리얼 모드로 전환하는 것을 포함하는 방법.
제1항 내지 제10항 중 어느 한 항에 있어서, 장치의 상태를 저장하는 서브루틴의 상기 동작 동안을 제외한 상기 제2 운영체제의 상기 작동을 통해 하드웨어 인터럽트를 허용하는 것을 포함하는 방법.
제1항 내지 제11항 중 어느 한 항에 있어서, 상기 제1 운영체제는 실시간 운영체제인 방법.
제1항 내지 제12항 중 어느 한 항에 있어서, 상기 제2 운영체제는 비실시간 범용 운영체제인 방법.
제1항 내지 제13항 중 어느 한 항에 있어서, 상기 제2 운영체제는 리눅스 또는 그릴 이용한 다양한 버전인 방법.
제1항 내지 제14항 중 어느 한 항에 있어서, 상기 공통 프로그램은 상기 운영체제 사이를 스위칭하는데 필요한 처리장치의 상태를 저장하고 그 저장된 버전으로부터 복원하도록 정해진 방법.
제1항 내지 제15항 중 어느 한 항에 있어서, 상기 제2 운영체제의 프로세서 예외 상황은 상기 공통 프로그램이 가상 방식으로 처리하는 방법.
제1항 내지 제16항 중 어느 한 항에 있어서, 상기 공통 프로그램은 몇 가지의 프로세서 예외를 인터셉트하고 또한 그 예외 서비스를 제공하기 위하여 상기 제 1 운영체제의 예외 처리 루틴을 호출하도록 정하여진 방법.
제17항에 있어서, 상기 제2 운영체제의 프로세서 예외는 가상 예외로 고지되는 방법.
제18항에 있어서, 상기 공통 프로그램은 미결인 상기 가상 예외에 대응하는, 제2 운영체제의 예외 처리 루틴을 호출하도록 정하여진 방법.
제1항 내지 제19항 중 어느 한 항에 있어서, 상기 운영체제들 각각이 독점적으로 작동할 수 있는 독립된 메모리 공간을 각각 제공하는 것가 추가되는 방법.
제1항 내지 제20항 중 어느 한 항에 있어서, 상기 운영체제들 각각이 상기 컴퓨터에서 독점적으로 접근할 수 있는 제1입력장치 및/또는 제1출력장치를 각각 제공하는 것을 더 포함하는 방법.
제21항에 있어서, 상기 운영체제들 각각이 상기 제1입력장치 및/또는 제1출력장치를 접근할 때 원시 루틴를 실질적 변화 없이 사용하는 방법.
제1항 내지 제22항 중 어느 한 항에 있어서, 상기 운영체제 각각이 접근을 공유하는 제2입력장치 및/또는 제2출력장치를 제공하는 것을 더 포함하는 방법.
제23항에 있어서, 모든 운영체제는 제1 운영체제의 상기 루틴을 사용하여 상기 제2입력장치 또는 제2출력장치를 접근하는 방법.
제24항에 있어서, 상기 공통 프로그램은 상기 제2 운영체제의 작동을 제어하기 위한 트랩 호출 메카니즘 및/내지 제2 운영체제의 상태 변화를 제1 운영체제에 고지하기 위한 이벤트 메카니즘을 제공하는 방법.
제1항 내지 제25항 중 어느 한 항에 있어서, 상기 운영체제들과 공통 프로그램은 프로그램 코드로 통합하는 것을 더 포함하는 방법.
제1항 내지 제26항 중 어느 한 항에 있어서, 상기 운영체제들과 공통 프로그램을 컴퓨터 장치의 영구 메모리상에 내장(embedding)하는 것을 더 포함하는 방법.
제1항 내지 제27항 중 어느 한 항의 상기 방법에 기재된 상기 것들을 수행하기 위한 코드를 포함하는 개발 키트 컴퓨터 프로그램 결과.
제36항에 따라 통합된 코드를 포함하는 컴퓨터 프로그램 결과.
상대적으로 높은 우선 순위를 가지는 제1 운영체제,

상대적으로 낮은 우선 순위를 가지는 제2 운영체제,

미리 예정된 조건 하에서 상기 운영체제 사이를 스위칭함으로써 상기 운영체제들을 동시에 작동하도록 마련된 공통 프로그램;

을 포함하고, 컴퓨터 프로그램 코드를 실행시키며 중앙처리장치, 메모리 장치와 입/출력장치를 포함하는 컴퓨터 시스템.
제30항에 있어서, 제1항 내지 제27항 중 어느 한 항의 방법을 이용하여 상기 제1 운영체제와 제2 운영체제를 동시에 작동하도록 마련된 컴퓨터 시스템.
상기 컴퓨터가 감소된 명령 설정(RIS, Reduced Instruction Set) 구조를 포함하는 제1항 내지 제31항 중 어느 한 항의 상기 시스템, 결과 또는 방법.