KR102175999B1 - 컴퓨터 시스템에서의 입출력 완료 방법 및 이를 위한 컴퓨터 시스템 - Google Patents

Abstract

본 발명은 컴퓨터 시스템에서의 입출력 완료 방법 및 이를 위한 컴퓨터 시스템에 관한 것으로, 본 발명의 일 실시예에 따른 컴퓨터 시스템에서의 입출력 완료 방법은, 발생된 입출력 요청의 크기에 대응되는 버킷을 통해 상기 발생된 입출력 요청을 관리하는 단계, 상기 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하는 단계, 상기 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하는 단계, 및 상기 설정된 버킷별 슬립 타임을 기초로 하여 상기 발생된 입출력 요청을 처리하는 단계를 포함한다.

Description

컴퓨터 시스템에서의 입출력 완료 방법 및 이를 위한 컴퓨터 시스템{I/O COMPLETION METHODS IN COMPUTER SYSTEM AND COMPUTER SYSTEMS THEREFOR}

본 발명은 컴퓨터 시스템에서의 입출력 완료 방법 및 이를 위한 컴퓨터 시스템에 관한 것이다.

종래 리눅스는 크게 세 가지 종류의 I/O 완료 처리 방식을 지원한다.

도 1은 종래의 I/O 완료 처리 방식을 나타낸 도면이다.

첫 번째로 인터럽트 방식(Interrupt-based I/O service, ⓐ)이 도 1의 (a)에 도시되어 있다. 인터럽트 방식은 모든 I/O 요청을 비동기적으로 처리한다. 저장장치 내부에서 I/O 데이터를 처리하는 동안 해당 I/O 요청을 제출한 프로세스는 I/O 처리가 완료될 때까지 슬립(Sleep)상태에 진입하고 이때, CPU 스케줄러는 해당 태스크를 다른 CPU로 위임하거나 전력 소모를 줄이기 위한 저전력 모드로 변경한다. 이후 I/O 요청 처리가 완료되면 CPU는 인터럽트로 중지된 태스크를 다시 수행하도록 한다. 해당 기법은 적은 CPU 자원을 요구하긴 하지만 높은 I/O 응답시간을 보여준다.

두 번째, 폴링 방식(Polling-based I/O service, ⓑ)이 도 1의 (b)에 도시되어 있다. 폴링 방식은 이전 인터럽트 방식과 달리 운영체제가 쉬지 않고 저장장치의 I/O 요청 완료 여부를 확인한다. 해당 방식은 컨텍스트 스위치(context switch) 혹은 슬립(Sleep)모드로의 진입을 하지 않는다. 따라서 시스템의 I/O 반응속도를 낮추고 처리량을 높이는 데 효과적이다. 그러나 CPU가 계속적으로 저장장치를 체크하기 때문에 상당한 CPU 자원 소모가 발생한다.

마지막으로 하이브리드 폴링 방식(hybrid polling-based I/O service, ⓒ)이 존재한다. 하이브리드 폴링 방식은 도 1의 (c)에 도시되어 있다. 이는 폴링 방식의 높은 CPU 사용률을 낮추기 위해 고안되었다. I/O 서비스를 수행하는 초기에 슬립 상태로 진입하고 일정 시간 뒤에 깨어나 폴링 방식과 같이 저장장치의 I/O 요청 처리 여부를 확인한다. 따라서 폴링 방식에 비해 낮은 CPU 사용률로 I/O 응답시간을 충분히 낮출 수 있다. 하지만, 하이브리드 폴링 방식 또한 큰 크기의 I/O 요청을 처리할 때는 인터럽트 방식과 비슷한 수준의 I/O 응답시간을 보이면서도 그에 비해 훨씬 높은 CPU 사용률을 보이는 단점이 존재한다.

최근 비휘발성 메모리 기술이 크게 발전하면서 종래 저장장치에 보다 상당히 높은 성능을 지닌 초고성능 저장장치가 출시되고 있다. 예컨대, 인텔의 3DXPoint나 삼성의 Z-NAND가 등장하였다. 이를 기반으로 종래 낸드 플래시 메모리 기반의 SSD(solid-state drive)보다 월등히 높은 성능을 지닌 초고성능 저장장치가 출시되고 있다.

하지만, 종래 운영체제는 이와 같은 최신 저장장치의 높은 성능을 충분히 활용하지 못하고 있다. 종래 컴퓨터 시스템 운영체제는 HDD(hard-disk drive)나 플래시 메모리기반의 SSD(solid-state drive)를 기반으로 설계되었기 때문에 최신 저장장치의 높은 성능을 충분히 활용하지 못하고 있다. 이에, I/O 완료 처리 방식으로 폴링 방식이 제안되었으나 해당 방식은 상당히 많은 CPU 자원이 요구된다는 단점이 존재한다. 최신 초고성능 저장장치 기반의 컴퓨터 시스템에서 I/O 응답시간을 낮추기 위한 종래 기법들은 CPU 자원을 상당히 많이 사용해야 하는 제약이 있다.

본 발명의 실시예들은 낮은 CPU 자원을 사용하면서도 초고성능 저장장치의 성능을 충분히 활용할 수 있는, 컴퓨터 시스템에서의 입출력 완료 방법 및 이를 위한 컴퓨터 시스템을 제공하고자 한다.

본 발명의 실시예들은 초고성능 저장장치의 성능을 충분히 활용하여 낮은 I/O 응답시간을 보장하면서도 CPU 자원을 적게 사용할 수 있는, 컴퓨터 시스템에서의 입출력 완료 방법 및 이를 위한 컴퓨터 시스템을 제공하고자 한다.

본 발명의 일 실시예에 따르면, 컴퓨터 시스템에서의 입출력 완료 방법에 있어서, 발생된 입출력 요청의 크기에 대응되는 버킷을 통해 상기 발생된 입출력 요청을 관리하는 단계; 상기 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하는 단계; 상기 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하는 단계; 및 상기 설정된 버킷별 슬립 타임을 기초로 하여 상기 발생된 입출력 요청을 처리하는 단계를 포함하는, 컴퓨터 시스템에서의 입출력 완료 방법이 제공될 수 있다.

상기 발생된 입출력 요청을 관리하는 단계는, 상기 발생된 입출력 요청의 크기를 확인하고, 복수의 버킷 중에서 상기 확인된 입출력 요청의 크기에 대응되는 어느 하나의 버킷을 통해 상기 발생된 입출력 요청을 관리할 수 있다.

상기 발생된 입출력 요청을 관리하는 단계는, 블록 계층에서 상기 발생된 입출력 요청의 크기를 확인할 수 있다.

상기 발생된 입출력 요청을 관리하는 단계는, 상기 발생된 입출력 요청에서 읽기 요청에 대한 버킷과 쓰기 요청에 대한 버킷으로 나누어서 관리할 수 있다.

상기 입출력 요청의 처리 시간을 계산하는 단계는, 상기 버킷에서 관리된 이전 입출력 요청의 평균 처리 시간을 계산할 수 있다.

상기 버킷별 슬립 타임을 설정하는 단계는, 상기 계산된 이전 입출력 요청의 처리 시간에 따라 프로세서의 슬립 타임의 비율을 설정할 수 있다.

상기 버킷별 슬립 타임을 설정하는 단계는, 상기 계산된 이전 입출력 요청의 처리 시간이 증가하면, 프로세서의 슬립 타임의 비율을 높게 설정할 수 있다.

상기 발생된 입출력 요청을 처리하는 단계는, 상기 설정된 버킷별 슬립 타임을 기초로 하여 프로세서 슬립 동작을 수행하고, 상기 설정된 버킷별 슬립 타임이 종료되면 폴링 동작을 수행하여 입출력 요청의 완료 여부를 확인할 수 있다.

상기 발생된 입출력 요청을 처리하는 단계는, 상기 설정된 버킷별 슬립 타임이 존재하지 않으면, 인터럽트 방식으로 입출력 요청의 완료 여부를 확인할 수 있다.

한편, 본 발명의 다른 실시예에 따르면, 컴퓨터 시스템에서의 입출력 요청을 처리하는 저장 장치; 적어도 하나의 프로그램을 저장하는 메모리; 및 상기 저장 장치 및 상기 메모리와 연결된 프로세서를 포함하고, 상기 프로세서는, 상기 적어도 하나의 프로그램을 실행함으로써, 발생된 입출력 요청의 크기에 대응되는 버킷을 통해 상기 발생된 입출력 요청을 관리하고, 상기 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하고, 상기 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하고, 상기 설정된 버킷별 슬립 타임을 기초로 하여 상기 발생된 입출력 요청을 처리하는, 입출력 완료를 위한 컴퓨터 시스템이 제공될 수 있다.

상기 프로세서는, 상기 발생된 입출력 요청의 크기를 확인하고, 복수의 버킷 중에서 상기 확인된 입출력 요청의 크기에 대응되는 어느 하나의 버킷을 통해 상기 발생된 입출력 요청을 관리할 수 있다.

상기 프로세서는, 블록 계층에서 상기 발생된 입출력 요청의 크기를 확인할 수 있다.

상기 프로세서는, 상기 발생된 입출력 요청에서 읽기 요청에 대한 버킷과 쓰기 요청에 대한 버킷으로 나누어서 관리할 수 있다.

상기 프로세서는, 상기 버킷에서 관리된 이전 입출력 요청의 평균 처리 시간을 계산할 수 있다.

상기 프로세서는, 상기 계산된 이전 입출력 요청의 처리 시간에 따라 프로세서의 슬립 타임의 비율을 설정할 수 있다.

상기 프로세서는, 상기 계산된 이전 입출력 요청의 처리 시간이 증가하면, 프로세서의 슬립 타임의 비율을 높게 설정할 수 있다.

상기 프로세서는, 상기 설정된 버킷별 슬립 타임을 기초로 하여 프로세서 슬립 동작을 수행하고, 상기 설정된 버킷별 슬립 타임이 종료되면 폴링 동작을 수행하여 입출력 요청의 완료 여부를 확인할 수 있다.

상기 프로세서는, 상기 설정된 버킷별 슬립 타임이 존재하지 않으면, 인터럽트 방식으로 입출력 요청의 완료 여부를 확인할 수 있다.

한편, 본 발명의 다른 실시예에 따르면, 프로세서에 의해 실행 가능한 적어도 하나의 프로그램을 포함하는 비일시적 컴퓨터 판독가능 저장 매체로서, 상기 적어도 하나의 프로그램은 상기 프로세서에 의해 실행될 때, 상기 프로세서로 하여금: 발생된 입출력 요청의 크기에 대응되는 버킷을 통해 상기 발생된 입출력 요청을 관리하고, 상기 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하고, 상기 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하고, 상기 설정된 버킷별 슬립 타임을 기초로 하여 상기 발생된 입출력 요청을 처리하게 하는 명령어들을 포함하는, 비 일시적 컴퓨터 판독 가능한 저장 매체가 제공될 수 있다.

본 발명의 실시예들은 낮은 CPU 자원을 사용하면서도 초고성능 저장장치의 성능을 충분히 활용할 수 있다.

본 발명의 실시예들은 초고성능 저장장치의 성능을 충분히 활용하여 낮은 I/O 응답시간을 보장하면서도 CPU 자원을 적게 사용할 수 있다.

본 발명의 실시예들은 클라우드 또는 데이터센터와 같이 사용하는 사용자들이 많아 CPU 자원 사용율을 높을 필요가 있는 경우 대용량 데이터베이스 검색시 높은 I/O 처리 성능을 보장하면서도 CPU 자원을 적게 소모할 수 있다.

본 발명의 실시예들은 CPU 자원을 확보하면서도 낮은 응답시간을 보일 수 있기 때문에 다수 사용자가 존재하면서 빠른 읽기 응답시간이 요구되는 환경(예, DBMS)에 적합하다고 할 수 있다.

도 1은 종래의 I/O 완료 처리 방식을 나타낸 도면이다.
도 2는 본 발명의 일 실시예에 따른 입출력 완료를 위한 컴퓨터 시스템의 구성도이다.
도 3은 본 발명의 일 실시예에 따른 컴퓨터 시스템에서의 입출력 완료 방법에 대한 흐름도이다.
도 4는 본 발명의 다른 실시예에 따른 I/O 요청의 크기 및 버킷 설정을 위한 흐름도이다.
도 5는 본 발명의 다른 실시예에 따른 입출력 요청 완료 방법에 대한 전체 흐름도이다.
도 6 내지 도 9는 본 발명의 일 실시예와 종래의 하이브리드 폴링 방식 간의 실험 결과를 나타낸 도면이다.

본 발명은 다양한 변경을 가할 수 있고 여러 가지 실시예를 가질 수 있는바, 특정 실시예들을 도면에 예시하고 상세하게 설명하고자 한다.

그러나 이는 본 발명을 특정한 실시 형태에 대해 한정하려는 것이 아니며, 본 발명의 사상 및 기술 범위에 포함되는 모든 변경, 균등물 내지 대체물을 포함하는 것으로 이해되어야 한다.

제1, 제2 등의 용어는 다양한 구성요소들을 설명하는데 사용될 수 있지만, 상기 구성요소들은 상기 용어들에 의해 한정되어서는 안 된다. 상기 용어들은 하나의 구성요소를 다른 구성요소로부터 구별하는 목적으로만 사용된다. 예를 들어, 본 발명의 권리 범위를 벗어나지 않으면서 제1 구성요소는 제2 구성요소로 명명될 수 있고, 유사하게 제2 구성요소도 제1 구성요소로 명명될 수 있다. 및/또는 이라는 용어는 복수의 관련된 기재된 항목들의 조합 또는 복수의 관련된 기재된 항목들 중의 어느 항목을 포함한다.

어떤 구성요소가 다른 구성요소에 "연결되어" 있다거나 "접속되어" 있다고 언급된 때에는, 그 다른 구성요소에 직접적으로 연결되어 있거나 또는 접속되어 있을 수도 있지만, 중간에 다른 구성요소가 존재할 수도 있다고 이해되어야 할 것이다. 반면에, 어떤 구성요소가 다른 구성요소에 "직접 연결되어" 있다거나 "직접 접속되어" 있다고 언급된 때에는, 중간에 다른 구성요소가 존재하지 않는 것으로 이해되어야 할 것이다.

본 출원에서 사용한 용어는 단지 특정한 실시예를 설명하기 위해 사용된 것으로, 본 발명을 한정하려는 의도가 아니다. 단수의 표현은 문맥상 명백하게 다르게 뜻하지 않는 한, 복수의 표현을 포함한다. 본 출원에서, "포함하다" 또는 "가지다" 등의 용어는 명세서상에 기재된 특징, 숫자, 단계, 동작, 구성요소, 부품 또는 이들을 조합한 것이 존재함을 지정하려는 것이지, 하나 또는 그 이상의 다른 특징들이나 숫자, 단계, 동작, 구성요소, 부품 또는 이들을 조합한 것들의 존재 또는 부가 가능성을 미리 배제하지 않는 것으로 이해되어야 한다.

다르게 정의되지 않는 한, 기술적이거나 과학적인 용어를 포함해서 여기서 사용되는 모든 용어들은 본 발명이 속하는 기술 분야에서 통상의 지식을 가진 자에 의해 일반적으로 이해되는 것과 동일한 의미를 가지고 있다. 일반적으로 사용되는 사전에 정의되어 있는 것과 같은 용어들은 관련 기술의 문맥상 가지는 의미와 일치하는 의미를 가진 것으로 해석되어야 하며, 본 출원에서 명백하게 정의하지 않는 한, 이상적이거나 과도하게 형식적인 의미로 해석되지 않는다.

이하, 첨부한 도면들을 참조하여, 본 발명의 바람직한 실시예를 보다 상세하게 설명하고자 한다. 본 발명을 설명함에 있어 전체적인 이해를 용이하게 하기 위하여 도면상의 동일한 구성요소에 대해서는 동일한 참조부호를 사용하고 동일한 구성요소에 대해서 중복된 설명은 생략한다.

도 2는 본 발명의 일 실시예에 따른 입출력 완료를 위한 컴퓨터 시스템의 구성도이다.

도 2에 도시된 바와 같이, 본 발명의 일 실시예에 따른 컴퓨터 시스템(100)은 프로세서(110), 메모리(120) 및 저장 장치(130)를 포함한다. 그러나 도시된 구성요소 모두가 필수 구성요소인 것은 아니다. 도시된 구성요소보다 많은 구성요소에 의해 컴퓨터 시스템(100)이 구현될 수도 있고, 그보다 적은 구성요소에 의해서도 컴퓨터 시스템(100)이 구현될 수 있다.

이하, 도 2의 컴퓨터 시스템(100)의 각 구성요소들의 구체적인 구성 및 동작을 설명한다.

저장 장치(130)는 컴퓨터 시스템(100)에서의 입출력 요청(I/O request)을 처리한다.

메모리(120)는 적어도 하나의 프로그램을 저장한다. 메모리(120)는 저장 장치(130)와 데이터 버스(Data bus)를 통해 연결된다. 메모리(120)는 I/O 요청의 크기별로 구분된 복수 개의 버킷을 포함할 수 있다.

프로세서(110)는 저장 장치(130) 및 메모리(120)와 연결된다. 프로세서(110)는 메모리(120)와 제어 버스(Control bus)를 통해 연결된다. 프로세서(110)는 적어도 하나의 프로그램을 실행함으로써, 발생된 입출력 요청의 크기에 대응되는 버킷을 통해 그 발생된 입출력 요청을 관리하고, 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하고, 그 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하고, 그 설정된 버킷별 슬립 타임을 기초로 하여 발생된 입출력 요청을 처리한다.

일례로, 입출력 읽기 동작(I/O read operation)이 발생하는 경우를 설명하기로 한다. 프로세서(110)는 입출력 읽기 동작이 발생하는 것을 확인한다. 그리고 프로세서(110)는 입출력 크기 별로 버킷(Bucket)을 구분한다. 이어서, 프로세서(110)는 버킷별 평균 입출력 처리 시간을 계산한다. 그리고 프로세서(110)는 입출력 완료 방식을 결정한다. 예를 들면, 입출력 완료 방식에는 프로세서 슬립 유무 및 프로세서 슬립 시간 등이 포함될 수 있다. 이후, 프로세서(110)는 저장 장치(130)에 접속하여 입출력 요청 완료 여부를 확인할 수 있다. 예를 들면, 프로세서(110)는 프로세서 슬립 이후, 슬립이 완료되면 폴링(Polling) 동작을 수행하여 입출력 요청 완료 여부를 확인할 수 있다. 또는 프로세서(110)는 인터럽트(Interrupt) 동작을 수행하여 입출력 요청 완료 여부를 확인할 수 있다.

실시예들에 따르면, 프로세서(110)는 발생된 입출력 요청의 크기를 확인하고, 복수의 버킷 중에서 확인된 입출력 요청의 크기에 대응되는 어느 하나의 버킷을 통해 발생된 입출력 요청을 관리한다.

실시예들에 따르면, 프로세서(110)는 블록 계층에서 상기 발생된 입출력 요청의 크기를 확인할 수 있다.

실시예들에 따르면, 프로세서(110)는 발생된 입출력 요청에서 읽기 요청에 대한 버킷과 쓰기 요청에 대한 버킷으로 나누어서 관리할 수 있다.

실시예들에 따르면, 프로세서(110)는 버킷에서 관리된 이전 입출력 요청의 평균 처리 시간을 계산할 수 있다.

실시예들에 따르면, 프로세서(110)는 계산된 이전 입출력 요청의 처리 시간에 따라 프로세서(110)의 슬립 타임의 비율을 설정할 수 있다.

실시예들에 따르면, 프로세서(110)는 계산된 이전 입출력 요청의 처리 시간이 증가하면, 프로세서(110)의 슬립 타임의 비율을 높게 설정할 수 있다.

실시예들에 따르면, 프로세서(110)는 설정된 버킷별 슬립 타임을 기초로 하여 프로세서 슬립 동작을 수행하고, 그 설정된 버킷별 슬립 타임이 종료되면 폴링 동작을 수행하여 입출력 요청의 완료 여부를 확인할 수 있다.

실시예들에 따르면, 프로세서(110)는 설정된 버킷별 슬립 타임이 존재하지 않으면, 인터럽트 방식으로 입출력 요청의 완료 여부를 확인할 수 있다.

이와 같이, 본 발명의 일 실시예에 따른 컴퓨터 시스템(100)에서의 프로세서(110)는 운영체제의 I/O 요청 처리 과정에서 I/O 요청 크기를 추적하여 이를 기반으로 적절한 슬립(sleep) 타임을 설정할 수 있다. 일례로, 프로세서(110)는 슬립 타임을 설정하기 위한 I/O 요청 크기는 크게 16개의 버킷(bucket)으로 나누어 비슷한 크기를 지닌 I/O 끼리 각각의 버킷에 수집할 수 있다. 프로세서(110)는 이를 기반으로 버킷 별 적절한 슬립 타임을 설정할 수 있다. 각각의 I/O 요청은 각기 다른 슬립 타임 후에 폴링 방식으로 동작한다. 본 발명의 일 실시예에 따른 컴퓨터 시스템(100)은 위 과정을 통해 인터럽트 방식의 낮은 CPU 사용률과 폴링 방식의 높은 I/O 처리 성능이라는 두 가지 장점을 동시에 제공할 수 있다.

상기와 같이, 본 발명의 일 실시예에 따른 컴퓨터 시스템(100)은 입출력 완료 방법을 통해서 앞서 언급한 인터럽트 방식과 폴링 방식, 두 방식 모두의 장점을 지닌 I/O 완료 처리 방법을 제공하고자 한다. 우선적으로 각 I/O 처리 완료 방식을 비교 분석한 결과, 작은 크기의 I/O 요청에 대해서는 폴링 방식이 높은 I/O 처리 성능을 보인다는 것을 확인하였다. 큰 크기의 I/O 요청에 대해서는 모든 I/O 처리 완료 방식들이 비슷한 I/O 처리 성능을 보이지만 인터럽트 방식만이 훨씬 낮은 CPU 자원 사용률을 보이는 것을 확인하였다. 따라서 본 발명의 일 실시예에서는 I/O 요청 크기에 따라 I/O 완료 방식을 적절하게 변경 및 적용하고자 한다.

본 발명의 일 실시예에 따른 컴퓨터 시스템(100)에서의 프로세서(110)는 I/O 서비스를 시작하자마자 일정 시간 동안 슬립(sleep) 모드에 진입하고, 그 후에 저장 장치(130)가 I/O 요청을 처리 완료하였는지 지속적으로 확인하는 폴링(polling) 동작을 수행할 수 있다. 기본적으로 리눅스 커널은 하이브리드 폴링 방식을 적용할 경우, 이전의 I/O 요청을 처리하는 시간의 평균에 대해 절반의 시간을 슬립하도록 한다. 이 경우, 모든 I/O 요청의 크기에 대해 평균적인 처리 시간을 계산하는 것은 적절한 슬립 타임을 설정하는데 비효율적이다. 왜냐하면, 작은 크기 (예컨대, 512 byte)의 처리 시간과 큰 크기 (예컨대, 128 KB)의 I/O 처리 시간은 큰 차이가 있기 때문이다. 그러므로 본 발명의 일 실시예에 따른 컴퓨터 시스템(100)에서 동작하는 리눅스 커널은 I/O 요청을 크기별로 복수 개(예컨대, 16개)의 버킷으로 나누어 각각 관리하는 정책을 사용한다. 각 버킷은 비슷한 크기의 I/O 요청에 대한 정보만을 수집하며 의미 있는 평균 I/O 처리 시간을 도출하도록 한다. 각 I/O 요청마다 버킷을 결정하는 방식은 아래의 [수학식 1] 및 [수학식 2]와 같다. 읽기 요청(Read request)은 [수학식 1]과 같이 나타날 수 있고, 쓰기 요청(Write request)은 [수학식 2]와 같이 나타날 수 있다.

여기서, bucket은 버킷의 번호, size는 I/O 요청의 크기를 나타낸다.

예를 들어, 4KB (4096B)의 읽기 요청이 발생하면 [수학식 1] 및 [수학식 2]에 따라 6번 버킷에 해당 I/O 요청을 처리하는 데 걸린 시간이 집계된다. 본 발명의 일 실시예는 이러한 방식의 슬립 타임 결정을 통해 적은 CPU 자원으로도 I/O 응답시간을 낮출 수 있다.

이에, 본 발명의 일 실시예에서는 각 버킷 별 슬립 타임을 변경 및 적용하여 이에 따라 인터럽트 방식(긴 슬립 타임의 하이브리드 폴링 방식) 혹은 폴링 방식(짧은 슬립 타임의 하이브리드 폴링 방식)과 매우 비슷하게 동작할 수 있다. 본 발명의 일 실시예에 따른 컴퓨터 시스템(100)은 분석 실험 결과를 기초로, 4 KB부터 12 KB까지의 I/O 요청에 대해서는 이전 I/O 처리 시간의 50% 시간 동안만 슬립 하도록 동작하고, 12 KB부터 46 KB의 I/O에 대해서는 70% 시간 동안만 슬립 하도록 동작하고, 46 KB부터 128 KB의 I/O에 대해서는 폴링 동작 없이 인터럽트와 같이 동작할 수 있다.

도 3은 본 발명의 일 실시예에 따른 컴퓨터 시스템에서의 입출력 완료 방법에 대한 흐름도이다.

단계 S101에서. 본 발명의 일 실시예에 따른 컴퓨터 시스템(100)은 발생된 입출력 요청의 크기를 확인한다.

단계 S102에서. 컴퓨터 시스템(100)은 발생된 입출력 요청의 크기에 대응되는 버킷을 통해 발생된 입출력 요청을 관리한다. 여기서, 컴퓨터 시스템(100)은 발생된 입출력 요청의 크기를 확인하고, 복수의 버킷 중에서 상기 확인된 입출력 요청의 크기에 대응되는 어느 하나의 버킷을 통해 상기 발생된 입출력 요청을 관리할 수 있다. 컴퓨터 시스템(100)은 블록 계층에서 상기 발생된 입출력 요청의 크기를 확인할 수 있다. 컴퓨터 시스템(100)은 발생된 입출력 요청에서 읽기 요청에 대한 버킷과 쓰기 요청에 대한 버킷으로 나누어서 관리할 수 있다.

단계 S103에서. 컴퓨터 시스템(100)은 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산한다. 여기서, 컴퓨터 시스템(100)은 버킷에서 관리된 이전 입출력 요청의 평균 처리 시간을 계산할 수 있다. 컴퓨터 시스템(100)은 버킷에서 관리된 이전 입출력 요청의 평균 처리 시간뿐만 아니라 다른 연산 조합을 통해 이전 입출력 요청의 처리 시간을 계산할 수 있다.

단계 S104에서. 컴퓨터 시스템(100)은 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정한다. 여기서, 컴퓨터 시스템(100)은 계산된 이전 입출력 요청의 처리 시간에 따라 프로세서(110)의 슬립 타임의 비율을 설정할 수 있다. 컴퓨터 시스템(100)은 계산된 이전 입출력 요청의 처리 시간이 증가하면, 프로세서(110)의 슬립 타임의 비율을 높게 설정할 수 있다.

단계 S105에서. 컴퓨터 시스템(100)은 설정된 버킷별 슬립 타임을 기초로 하여, 발생된 입출력 요청을 처리한다. 여기서, 컴퓨터 시스템(100)은 설정된 버킷별 슬립 타임을 기초로 하여 프로세서 슬립 동작을 수행하고, 그 설정된 버킷별 슬립 타임이 종료되면 폴링 동작을 수행하여 입출력 요청의 완료 여부를 확인할 수 있다. 컴퓨터 시스템(100)은 설정된 버킷별 슬립 타임이 존재하지 않으면, 인터럽트 방식으로 입출력 요청의 완료 여부를 확인할 수 있다.

한편, 본 발명의 다른 실시예에 따른 입출력 요청 완료 처리 방법을 통해 앞서 언급한 인터럽트 방식과 폴링 방식, 두 방식 모두의 장점을 지닌 I/O 처리 완료 방법을 제공할 수 있다. 실험을 통한 분석 결과, I/O 요청의 크기별로 적합한 I/O 완료 처리 방식이 다름을 확인하였다. 이에 하기의 도 4에서는 I/O 요청 별로 각각의 크기를 확인하고 비슷한 크기를 지닌 I/O 요청들을 버킷을 통해 관리하는 동작의 흐름도를 나타낸다. 이어 도 5에서는 도 4에서 설정한 버킷을 기반으로 CPU 슬립 타임을 설정하고 이에 따른 전체적인 흐름을 나타낸다. 이와 같이, 컴퓨터 시스템(100)은 다른 실시예에 따라 I/O 요청의 크기를 소형의 I/O 요청, 중형의 I/O 요청 및 대형의 I/O 요청 중 어느 하나의 I/O 요청으로 분류하고, I/O 요청의 크기별 버킷을 기반으로 프로세서 슬립 타임을 서로 다르게 설정할 수 있다. 이에 따른 다른 실시예는 도 4 및 도 5를 참조하여 설명하기로 한다.

도 4는 본 발명의 다른 실시예에 따른 I/O 요청의 크기 및 버킷 설정을 위한 흐름도이다.

단계 S201에서, 컴퓨터 시스템(100)은 I/O 요청 발생을 확인한다.

단계 S202에서, 컴퓨터 시스템(100)은 블록 계층에서 I/O 요청의 크기를 확인한다.

단계 S203에서, 컴퓨터 시스템(100)은 I/O 요청의 크기가 4 KB 이상이고 12 KB 미만인지를 확인한다.

단계 S204에서, 컴퓨터 시스템(100)은 I/O 요청의 크기가 4 KB 이상이고 12 KB 미만이면, 해당 I/O 요청은 소형의(Small-sized) I/O 버킷을 통해 관리한다.

단계 S205에서, 컴퓨터 시스템(100)은 I/O 요청의 크기가 4 KB 이상이고 12 KB 미만이 아니면, I/O 요청의 크기가 12 KB 이상이고 46 KB 미만인지를 확인한다.

단계 S206에서, 컴퓨터 시스템(100)은 I/O 요청의 크기가 12 KB 이상이고 46 KB 미만이면, 해당 I/O 요청은 중형 크기(Middle-sized)의 I/O 버킷을 통해 관리한다.

단계 S207에서, 컴퓨터 시스템(100)은 I/O 요청의 크기가 12 KB 이상이고 46 KB 미만이 아니면, I/O 요청의 크기가 46 KB 이상인지를 확인한다.

단계 S208에서, 컴퓨터 시스템(100)은 I/O 요청의 크기가 46 KB 이상이면, 해당 I/O 요청은 대형 크기(Large-sized)의 I/O 버킷을 통해 관리한다. 반면, 컴퓨터 시스템(100)은 I/O 요청의 크기가 46 KB 이상이 아니면, 해당 작업을 종료한다.

단계 S209에서, 컴퓨터 시스템(100)은 각 버킷을 통해 I/O 요청을 관리한 후, 각 버킷별 평균 I/O 서비스 타임을 계산하고 저장한다.

이와 같이, 본 발명의 일 실시예에 따른 컴퓨터 시스템(100)은 먼저 I/O 요청의 크기를 확인한다. 이때, 컴퓨터 시스템(100)은 I/O 요청의 크기가 4KB 이상이고 12 KB 미만인 경우에는 소형의 I/O 버킷에서 관리하도록 한다. 컴퓨터 시스템(100)은 비슷하게 크기가 12 KB 이상이고 46 KB 미만인 경우에는 중형의 I/O 버킷, 46 KB 이상의 경우에는 대형의 I/O 버킷에서 관리하도록 한다. 컴퓨터 시스템(100)은 각 버킷 별로 관리하는 I/O 요청의 처리 시간(서비스 타임)을 계산 및 기록하여 버킷별로 평균적인 I/O 요청 처리 시간을 도출할 수 있다.

도 5는 본 발명의 다른 실시예에 따른 입출력 요청 완료 방법에 대한 전체 흐름도이다.

단계 S301에서, 컴퓨터 시스템(100)은 I/O 요청 발생을 확인한다.

단계 S302에서, 컴퓨터 시스템(100)은 블록 계층에서 I/O 요청의 크기 및 해당 버킷을 확인한다.

단계 S303에서, 컴퓨터 시스템(100)은 해당 I/O 요청이 소형의 I/O 버킷에 속하는지를 확인한다.

단계 S304에서, 컴퓨터 시스템(100)은 해당 I/O 요청이 소형의 I/O 버킷에 속하면, 소형의 버킷에 속한 I/O 요청들의 평균적인 처리시간의 50% 동안을 CPU 슬립 타임으로 설정한다.

단계 S305에서, 컴퓨터 시스템(100)은 해당 I/O 요청이 소형의 I/O 버킷에 속하지 않으면, 해당 I/O 요청이 중형의 I/O 버킷에 속하는지를 확인한다.

단계 S306에서, 컴퓨터 시스템(100)은 해당 I/O 요청이 중형의 I/O 버킷에 속하면, I/O 요청의 슬립 타임을 평균 서비스 타임의 70%로 설정한다.

이후, 단계 S307에서, 컴퓨터 시스템(100)은 앞서 계산된 슬립 타임만큼 CPU는 슬립 후, I/O 요청 완료 여부를 확인하기 위해 폴링 동작을 수행한다.

한편, 단계 S308에서, 컴퓨터 시스템(100)은 해당 I/O 요청이 중형의 I/O 버킷에 속하지 않으면, 해당 I/O 요청이 대형의 I/O 버킷에 속하는지를 확인한다.

단계 S308에서, 컴퓨터 시스템(100)은 해당 I/O 요청이 대형의 I/O 버킷에 속하면, 해당 I/O 요청은 인터럽트 방식으로 처리한다. 반면, 컴퓨터 시스템(100)은 해당 I/O 요청이 대형의 I/O 버킷에 속하지 않으면 해당 작업을 종료한다.

이와 같이, 본 발명의 일 실시예에 따른 프로세서(110)는 I/O 요청이 발생하면, 도 4에서 보듯 각각의 I/O 요청에 대한 크기와 해당 I/O 요청이 어느 버킷에서 관리되는지를 결정한다. 그 후, 프로세서(110)는 버킷 별로 CPU 슬립 타임을 설정한다. 만약에 소형의 I/O 요청에 대응하는 버킷이라면, 프로세서(110)는 CPU 슬립 타임을 소형의 I/O 요청에 대응하는 버킷의 평균 I/O 처리 시간의 50%로 설정한다. 예를 들어, 소형의 I/O 버킷의 평균 I/O 처리 시간이 10ns로 계산된다면, 프로세서(110)는 해당 버킷에 해당하는 I/O 요청을 처리할 때 5ns만큼 우선적으로 슬립한다. 그 후에 프로세서(110)는 폴링 동작을 수행하여 저장 장치(130)가 동작을 완료하였는지 지속적으로 확인한다. 프로세서(110)는 이처럼 적절한 CPU 슬립 타임을 설정함으로써 CPU 자원을 효율적으로 사용하면서 성능 또한 높게 유지할 수 있도록 한다. 프로세서(110)는 마찬가지로 중형의 I/O 버킷의 경우에 CPU 슬립 타임을 평균 I/O 처리 시간의 70%로 설정하여 소형의 I/O 버킷보다 조금 더 긴 CPU 슬립 타임을 설정하도록 한다. 프로세서(110)는 마지막으로 대형의 I/O 버킷의 경우에 종래 인터럽트 방식과 마찬가지로 별도의 폴링 동작을 수행하지 않는다. 프로세서(110)는 슬립 중에 저장 장치(130)에서 동작을 완료하고, 신호(signal)를 전달하는 순간 웨이크업(wake up)하여 I/O 처리를 완료한다.

도 6 내지 도 9는 본 발명의 일 실시예와 종래의 하이브리드 폴링 방식 간의 실험 결과를 나타낸 도면이다.

본 발명의 일 실시예의 효과를 검증하기 위해서 초고성능 저장 장치로서 인텔 옵테인(Optane) SSD 900P를 사용하여 실험을 진행하였다. 해당 저장 장치는 인텔의 최신 메모리 기술, 3D 크로스포인트(XPoint)가 적용되어 종래 저장 장치에 비해 상당히 높은 I/O 처리 성능을 보여준다.

본 발명의 일 실시예에 따른 입출력 요청 완료 방법에 대한 실험 결과는 종래 리눅스 커널이 가장 효과적으로 지원하고 있는 하이브리드 폴링 방식과 비교하였다. 크게 두 가지 경우의 실험을 통해 효용성을 검증하였다.

첫 번째로 같은 크기의 I/O 요청이 발생하는 워크로드에서는 본 발명의 일 실시예에 따른 입출력 요청 완료 방법은 종래 하이브리드 폴링 방식보다 평균적으로 1.19% 높은 I/O 응답 시간을 보였으나, 이는 미미한 수치라고 할 수 있다. 반면에 종래 기법에 비해 본 발명의 일 실시예에 따른 입출력 요청 완료 방법은 최대 43.14%까지 낮은 CPU 사용률을 보여주었다. 이는 I/O 크기가 커질수록 슬립타임을 길게 증가시켜 CPU 자원 소모를 줄였기 때문이다. 이와 같이 CPU 자원 소모를 낮춤으로써 같은 하드웨어 자원 환경에서 더 많은 프로세스와 I/O 요청 처리가 가능할 수 있다.

두 번째로 다른 크기의 I/O 요청이 섞여서 발생하는 워크로드에서는 종래 기법과 본 발명의 일 실시예에 따른 입출력 완료 방법은 비슷한 성능을 보였다. 하지만 큰 크기의 I/O 요청의 비율이 높아질수록 CPU 사용률을 크게 줄어드는 것을 확인할 수 있었다. 앞서 언급한바와 같이, 본 발명의 일 실시예에 따른 입출력 완료 방법은 CPU 사용률을 줄임으로써 데이터베이스 시스템의 경우, 제한된 하드웨어 자원에서 높은 수준의 성능을 보장하면서 더 많은 사용자에게 서비스를 제공할 수 있게 된다.

한편, 복수의 사용자가 존재할 경우 CPU 자원이 더욱 요구된다. 따라서 본 발명의 일 실시예에 따른 컴퓨터 시스템은 CPU 자원을 더 확보하기 위해 슬립 타임을 한 명의 사용자가 존재하는 경우에서의 슬립 타임(예컨대, 평균 I/O 처리 시간의 50%, 또는 70%) 보다 더 긴 시간으로 설정할 수 있다.

상술한 본 발명의 실시예들에 따른 컴퓨터 시스템에서의 입출력 완료 방법은 컴퓨터로 읽을 수 있는 기록매체에 컴퓨터가 읽을 수 있는 코드로서 구현되는 것이 가능하다. 본 발명의 실시예들에 따른 컴퓨터 시스템에서의 입출력 완료 방법은 다양한 컴퓨터 수단을 통하여 수행될 수 있는 프로그램 명령 형태로 구현되어 컴퓨터로 읽을 수 있는 기록매체에 기록될 수 있다.

프로세서에 의해 실행 가능한 적어도 하나의 프로그램을 포함하는 비일시적 컴퓨터 판독가능 저장 매체로서, 상기 적어도 하나의 프로그램은 상기 프로세서에 의해 실행될 때, 상기 프로세서로 하여금: 발생된 입출력 요청의 크기에 대응되는 버킷을 통해 상기 발생된 입출력 요청을 관리하고, 상기 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하고, 상기 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하고, 상기 설정된 버킷별 슬립 타임을 기초로 하여 상기 발생된 입출력 요청을 처리하게 하는 명령어들을 포함하는, 비 일시적 컴퓨터 판독 가능한 저장 매체가 제공될 수 있다.

상술한 본 발명에 따른 방법은 컴퓨터로 읽을 수 있는 기록매체에 컴퓨터가 읽을 수 있는 코드로서 구현되는 것이 가능하다. 컴퓨터가 읽을 수 있는 기록 매체로는 컴퓨터 시스템에 의하여 해독될 수 있는 데이터가 저장된 모든 종류의 기록 매체를 포함한다. 예를 들어, ROM(Read Only Memory), RAM(Random Access Memory), 자기 테이프, 자기 디스크, 플래시 메모리, 광 데이터 저장장치 등이 있을 수 있다. 또한, 컴퓨터로 판독 가능한 기록매체는 컴퓨터 통신망으로 연결된 컴퓨터 시스템에 분산되어, 분산방식으로 읽을 수 있는 코드로서 저장되고 실행될 수 있다.

이상, 도면 및 실시예를 참조하여 설명하였지만, 본 발명의 보호범위가 상기 도면 또는 실시예에 의해 한정되는 것을 의미하지는 않으며 해당 기술 분야의 숙련된 당업자는 하기의 특허 청구의 범위에 기재된 본 발명의 사상 및 영역으로부터 벗어나지 않는 범위 내에서 본 발명을 다양하게 수정 및 변경시킬 수 있음을 이해할 수 있을 것이다.

구체적으로, 설명된 특징들은 디지털 전자 회로, 또는 컴퓨터 하드웨어, 펌웨어, 또는 그들의 조합들 내에서 실행될 수 있다. 특징들은 예컨대, 프로그래밍 가능한 프로세서에 의한 실행을 위해, 기계 판독 가능한 저장 디바이스 내의 저장장치 내에서 구현되는 컴퓨터 프로그램 제품에서 실행될 수 있다. 그리고 특징들은 입력 데이터 상에서 동작하고 출력을 생성함으로써 설명된 실시예들의 함수들을 수행하기 위한 지시어들의 프로그램을 실행하는 프로그래밍 가능한 프로세서에 의해 수행될 수 있다. 설명된 특징들은, 데이터 저장 시스템으로부터 데이터 및 지시어들을 수신하기 위해, 및 데이터 저장 시스템으로 데이터 및 지시어들을 전송하기 위해, 결합된 적어도 하나의 프로그래밍 가능한 프로세서, 적어도 하나의 입력 디바이스, 및 적어도 하나의 출력 디바이스를 포함하는 프로그래밍 가능한 시스템 상에서 실행될 수 있는 하나 이상의 컴퓨터 프로그램들 내에서 실행될 수 있다. 컴퓨터 프로그램은 소정 결과에 대해 특정 동작을 수행하기 위해 컴퓨터 내에서 직접 또는 간접적으로 사용될 수 있는 지시어들의 집합을 포함한다. 컴퓨터 프로그램은 컴파일된 또는 해석된 언어들을 포함하는 프로그래밍 언어 중 어느 형태로 쓰여지고, 모듈, 소자, 서브루틴(subroutine), 또는 다른 컴퓨터 환경에서 사용을 위해 적합한 다른 유닛으로서, 또는 독립 조작 가능한 프로그램으로서 포함하는 어느 형태로도 사용될 수 있다.

지시어들의 프로그램의 실행을 위한 적합한 프로세서들은, 예를 들어, 범용 및 특수 용도 마이크로프로세서들 둘 모두, 및 단독 프로세서 또는 다른 종류의 컴퓨터의 다중 프로세서들 중 하나를 포함한다. 또한 설명된 특징들을 구현하는 컴퓨터 프로그램 지시어들 및 데이터를 구현하기 적합한 저장 디바이스들은 예컨대, EPROM, EEPROM, 및 플래쉬 메모리 디바이스들과 같은 반도체 메모리 디바이스들, 내부 하드 디스크들 및 제거 가능한 디스크들과 같은 자기 디바이스들, 광자기 디스크들 및 CD-ROM 및 DVD-ROM 디스크들을 포함하는 비휘발성 메모리의 모든 형태들을 포함한다. 프로세서 및 메모리는 ASIC들(application-specific integrated circuits) 내에서 통합되거나 또는 ASIC들에 의해 추가될 수 있다.

이상에서 설명한 본 발명은 일련의 기능 블록들을 기초로 설명되고 있지만, 전술한 실시예 및 첨부된 도면에 의해 한정되는 것이 아니고, 본 발명의 기술적 사상을 벗어나지 않는 범위 내에서 여러 가지 치환, 변형 및 변경 가능하다는 것이 본 발명이 속하는 기술분야에서 통상의 지식을 가진 자에게 있어 명백할 것이다.

전술한 실시예들의 조합은 전술한 실시예에 한정되는 것이 아니며, 구현 및/또는 필요에 따라 전술한 실시예들 뿐 아니라 다양한 형태의 조합이 제공될 수 있다.

전술한 실시예들에서, 방법들은 일련의 단계 또는 블록으로서 순서도를 기초로 설명되고 있으나, 본 발명은 단계들의 순서에 한정되는 것은 아니며, 어떤 단계는 상술한 바와 다른 단계와 다른 순서로 또는 동시에 발생할 수 있다. 또한, 당해 기술 분야에서 통상의 지식을 가진 자라면 순서도에 나타난 단계들이 배타적이지 않고, 다른 단계가 포함되거나, 순서도의 하나 또는 그 이상의 단계가 본 발명의 범위에 영향을 미치지 않고 삭제될 수 있음을 이해할 수 있을 것이다.

전술한 실시예는 다양한 양태의 예시들을 포함한다. 다양한 양태들을 나타내기 위한 모든 가능한 조합을 기술할 수는 없지만, 해당 기술 분야의 통상의 지식을 가진 자는 다른 조합이 가능함을 인식할 수 있을 것이다. 따라서, 본 발명은 이하의 특허청구범위 내에 속하는 모든 다른 교체, 수정 및 변경을 포함한다고 할 것이다.

100: 컴퓨터 시스템
110: 프로세서
120: 메모리
130: 저장 장치

Claims (19)

1. 컴퓨터 시스템에서의 입출력 완료 방법에 있어서,
   발생된 입출력 요청의 크기에 대응되는 버킷을 통해 상기 발생된 입출력 요청을 관리하는 단계;
   상기 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하는 단계;
   상기 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하는 단계; 및
   상기 설정된 버킷별 슬립 타임을 기초로 하여 상기 발생된 입출력 요청을 처리하는 단계를 포함하는, 컴퓨터 시스템에서의 입출력 완료 방법.
2. 제1항에 있어서,
   상기 발생된 입출력 요청을 관리하는 단계는,
   상기 발생된 입출력 요청의 크기를 확인하고, 복수의 버킷 중에서 상기 확인된 입출력 요청의 크기에 대응되는 어느 하나의 버킷을 통해 상기 발생된 입출력 요청을 관리하는, 컴퓨터 시스템에서의 입출력 완료 방법.
3. 제2항에 있어서,
   상기 발생된 입출력 요청을 관리하는 단계는,
   블록 계층에서 상기 발생된 입출력 요청의 크기를 확인하는, 컴퓨터 시스템에서의 입출력 완료 방법.
4. 제1항에 있어서,
   상기 발생된 입출력 요청을 관리하는 단계는,
   상기 발생된 입출력 요청에서 읽기 요청에 대한 버킷과 쓰기 요청에 대한 버킷으로 나누어서 관리하는, 컴퓨터 시스템에서의 입출력 완료 방법.
5. 제1항에 있어서,
   상기 입출력 요청의 처리 시간을 계산하는 단계는,
   상기 버킷에서 관리된 이전 입출력 요청의 평균 처리 시간을 계산하는, 컴퓨터 시스템에서의 입출력 완료 방법.
6. 제1항에 있어서,
   상기 버킷별 슬립 타임을 설정하는 단계는,
   상기 계산된 이전 입출력 요청의 처리 시간에 따라 프로세서의 슬립 타임의 비율을 설정하는, 컴퓨터 시스템에서의 입출력 완료 방법.
7. 제1항에 있어서,
   상기 버킷별 슬립 타임을 설정하는 단계는,
   상기 계산된 이전 입출력 요청의 처리 시간이 증가하면, 프로세서의 슬립 타임의 비율을 높게 설정하는, 컴퓨터 시스템에서의 입출력 완료 방법.
8. 제1항에 있어서,
   상기 발생된 입출력 요청을 처리하는 단계는,
   상기 설정된 버킷별 슬립 타임을 기초로 하여 프로세서 슬립 동작을 수행하고, 상기 설정된 버킷별 슬립 타임이 종료되면 폴링 동작을 수행하여 입출력 요청의 완료 여부를 확인하는, 컴퓨터 시스템에서의 입출력 완료 방법.
9. 제1항에 있어서,
   상기 발생된 입출력 요청을 처리하는 단계는,
   상기 설정된 버킷별 슬립 타임이 존재하지 않으면, 인터럽트 방식으로 입출력 요청의 완료 여부를 확인하는, 컴퓨터 시스템에서의 입출력 완료 방법.
10. 컴퓨터 시스템에서의 입출력 요청을 처리하는 저장 장치;
    적어도 하나의 프로그램을 저장하는 메모리; 및
    상기 저장 장치 및 상기 메모리와 연결된 프로세서를 포함하고,
    상기 프로세서는, 상기 적어도 하나의 프로그램을 실행함으로써,
    발생된 입출력 요청의 크기에 대응되는 버킷을 통해 상기 발생된 입출력 요청을 관리하고,
    상기 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하고,
    상기 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하고,
    상기 설정된 버킷별 슬립 타임을 기초로 하여 상기 발생된 입출력 요청을 처리하는, 입출력 완료를 위한 컴퓨터 시스템.
11. 제10항에 있어서,
    상기 프로세서는,
    상기 발생된 입출력 요청의 크기를 확인하고, 복수의 버킷 중에서 상기 확인된 입출력 요청의 크기에 대응되는 어느 하나의 버킷을 통해 상기 발생된 입출력 요청을 관리하는, 입출력 완료를 위한 컴퓨터 시스템.
12. 제11항에 있어서,
    상기 프로세서는,
    블록 계층에서 상기 발생된 입출력 요청의 크기를 확인하는, 입출력 완료를 위한 컴퓨터 시스템.
13. 제10항에 있어서,
    상기 프로세서는,
    상기 발생된 입출력 요청에서 읽기 요청에 대한 버킷과 쓰기 요청에 대한 버킷으로 나누어서 관리하는, 입출력 완료를 위한 컴퓨터 시스템.
14. 제10항에 있어서,
    상기 프로세서는,
    상기 버킷에서 관리된 이전 입출력 요청의 평균 처리 시간을 계산하는, 입출력 완료를 위한 컴퓨터 시스템.
15. 제10항에 있어서,
    상기 프로세서는,
    상기 계산된 이전 입출력 요청의 처리 시간에 따라 프로세서의 슬립 타임의 비율을 설정하는, 입출력 완료를 위한 컴퓨터 시스템.
16. 제10항에 있어서,
    상기 프로세서는,
    상기 계산된 이전 입출력 요청의 처리 시간이 증가하면, 프로세서의 슬립 타임의 비율을 높게 설정하는, 입출력 완료를 위한 컴퓨터 시스템.
17. 제10항에 있어서,
    상기 프로세서는,
    상기 설정된 버킷별 슬립 타임을 기초로 하여 프로세서 슬립 동작을 수행하고, 상기 설정된 버킷별 슬립 타임이 종료되면 폴링 동작을 수행하여 입출력 요청의 완료 여부를 확인하는, 입출력 완료를 위한 컴퓨터 시스템.
18. 제10항에 있어서,
    상기 프로세서는,
    상기 설정된 버킷별 슬립 타임이 존재하지 않으면, 인터럽트 방식으로 입출력 요청의 완료 여부를 확인하는, 입출력 완료를 위한 컴퓨터 시스템.
19. 프로세서에 의해 실행 가능한 적어도 하나의 프로그램을 포함하는 비일시적 컴퓨터 판독가능 저장 매체로서, 상기 적어도 하나의 프로그램은 상기 프로세서에 의해 실행될 때, 상기 프로세서로 하여금:
    발생된 입출력 요청의 크기에 대응되는 버킷을 통해 상기 발생된 입출력 요청을 관리하고,
    상기 버킷을 통해 관리된 이전 입출력 요청의 처리 시간을 계산하고,
    상기 계산된 이전 입출력 요청의 처리 시간에 따라 버킷별 슬립 타임을 설정하고,
    상기 설정된 버킷별 슬립 타임을 기초로 하여 상기 발생된 입출력 요청을 처리하게 하는 명령어들을 포함하는, 비 일시적 컴퓨터 판독 가능한 저장 매체.
    

Images