KR100622113B1 - 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템 및그 방법 - Google Patents

Abstract

개시되는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템은 데이터베이스 시스템과 플래쉬 메모리를 인터페이스 하기 위한 것으로, 플래쉬 메모리와 메모리 인터페이스를 포함한다. 메모리 인터페이스는 논리적 메모리 인터페이스와 물리적 메모리 인터페이스의 계층적 구성을 갖는다. 논리적 메모리 인터페이스는 데이터베이스 시스템으로부터 데이터 쓰기, 삭제, 읽기의 명령과 트랜잭션에 관련된 트랜잭션 시작(begin), 종료(commit), 롤백(rollback)과 체크포인트(check-point, implicit-savepoint) 시작, 종료, 롤백의 명령을 받고, 데이터 입/출력명령에 의해 데이터 관리를 위한 정보를 덧붙여 물리적 메모리 인터페이스로 송신하는 한편 그것들의 관리를 위한 동작을 수행하며, 물리적 메모리 인터페이스로부터 수신된 데이터에서 논리적 메모리 인터페이스에서 덧붙여졌던 부분을 제외하고 데이터베이스 시스템으로 송신한다. 한편, 물리적 메모리 인터페이스는 플래쉬 메모리의 논리적 어드레스를 물리적 어드레스로 변환하여 논리적 메모리 인터페이스의 데이터를 플래쉬 메모리에 직접 송/수신한다.

데이터베이스, 플래쉬메모리, 휴대폰, 저장시스템, 인터페이스

Description

데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템 및 그 방법 {FLASH MEMORY STORING SYSTEM FOR DATABASE SYSTEM AND METHOD THEREFOR}

도 1은 본 발명에 따른 플래쉬 메모리 저장 시스템의 구성을 나타낸 블록도이고,

도 2는 본 발명에서 플래쉬 메모리의 섹터 구성을 나타낸 도면이고,

도 3은 도 2에 도시된 하나의 섹터를 논리적 단위인 버킷으로 나눈 상세도이고,

도 4는 도 3에 도시된 하나의 버킷이 가지는 버킷-헤더의 구성도이고,

도 5는 본 발명에서 플래쉬 메모리를 논리적 테이블로 맵핑한 버킷_유용성_테이블을 나타낸 도면이고,

도 6은 본 발명에서 버킷의 상태변환을 보여주는 상태변환도이고,

도 7은 본 발명에서 섹터의 상태를 나타내는 섹터_상태_테이블의 도면이고,

도 8은 본 발명에서 버킷번호를 페이지 번호에 맵핑한 버킷_페이지_테이블의 구성도이고,

도 9는 도 4에 도시된 버킷-헤더의 상태_플래그의 구성도이고,

도 10은 트랜잭션_액션_리스트의 일예를 나타낸 도면이고,

도 11은 본 발명에서 트랜잭션_액션_리스트의 노드 하나가 만들어지는 프로세스의 흐름도이고,

도 12는 본 발명에서 트랜잭션 종료의 제1단계 프로세스를 나타낸 흐름도이고,

도 13은 본 발명에서 트랜잭션 종료의 제2단계 프로세스를 나타낸 흐름도이고,

도 14는 본 발명에서 트랜잭션 롤백 프로세스의 흐름도이고,

도 15는 본 발명에서 트랜잭션 체크포인트 롤백 프로세스의 흐름도이고,

도 16은 본 발명에서 가비지 콜렉션 프로세스의 흐름도이고,

도 17은 본 발명에서 섹터에서 가비지 콜렉션이 진행되는 과정을 순차적으로 나타낸 도면이고,

도 18은 본 발명에서 재시작 회복 프로세스의 흐름도이다.

** 도면의 주요부분에 대한 부호의 설명 **

10 : 메모리 인터페이스 12 : 논리적 메모리 인터페이스

14 : 물리적 메모리 인터페이스 20 : 데이터베이스 시스템

30 : 플래쉬 메모리 32 : 섹터

34 : 버킷 36 : 버킷 헤더

36' : 상태_플래그 36" : 페이지_번호

38 : 버킷 바디

본 발명은 데이터베이스 시스템에서 플래쉬 메모리를 저장장치로 사용하기 위한 시스템 및 방법에 관한 것으로, 보다 상세하게는 데이터베이스 시스템에서 저장 장치로 플래쉬 메모리를 사용할 수 있도록 플래쉬 메모리와 데이터베이스 시스템 간을 인터페이스 하는 플래쉬 메모리 저장 시스템 및 그 방법에 관한 것이다.

플래쉬 메모리는 파울러-노드헴 터널링(fowler-nordheim tunneling) 또는 핫 일렉트론 인젝션(hot electron injection)을 이용하는 반도체 소자로, 쇼크(shock)에 민감하지 않고 전원이 공급되지 않아도 저장된 정보가 사라지지 않는 비휘발성 기억장치이다.

플래쉬 메모리는 NOR형과 NAND형의 두 가지로 구분된다. NOR형은 데이터를 저장하는 각 셀이 병렬구조로 되어 있어 단위면적당 집적도는 떨어지나 임의의 셀을 액세스(random access)할 수 있다. 즉, 병렬구조로 데이터라인과 어드레스라인이 존재하여 바이트 프로그래밍이 가능하므로 코드 저장용으로 많이 사용된다. 이와는 달리 NAND형은 각 셀이 직렬구조이기 때문에 집적도는 높으나 읽기 동작에 앞서 해당 블럭(block)을 선택해야 하며 동작저항이 커서 읽기 속도가 상대적으로 떨어지고 임의 접근이 불가능하여 데이터 저장용으로 많이 사용된다.

이러한 플래쉬 메모리는 기존 데이터가 존재하는 위치에 데이터를 쓰려면(write, program) 기존의 데이터를 소거하고(erase) 쓰기 동작을 해야 한다. 이 때, 소거 동작은 기존 데이터가 존재하는 해당 부분만을 지울 수는 없고 플래쉬 메모리에 하드웨어적으로 정해진 섹터(sector), 블록(block) 혹은 페이지(page) 단위로 지울 수 있는데, 그 단위는 플래쉬 메모리 제조사에서 정하고 있다. 일반적으로 플래쉬 메모리에의 쓰기 동작은 해당영역의 비트(bit)를 0으로 변환하는 작업이고, 소거 동작은 소거의 최소단위가 섹터라면 그 섹터의 모든 비트(bit)를 1로 변환하는 작업이다.

테이터를 처리하는 측면에서 본다면 파일은 관련된 레코드들의 집합이고, 파일시스템은 파일에 이름을 붙이고 저장이나 검색을 위해 논리적으로 그것들을 어디에 위치시켜야 하는지 등을 나타내는 방법이라 할 수 있다. 파일은 계층구조 내의 디렉토리 또는 서브디렉토리 내에 놓여지고, 파일 이름의 길이제한, 글자형태의 제한 등등의 파일의 이름을 붙이는 규칙이 적용되며, 디렉토리 구조를 통하여 파일까지 가는 경로를 설정하는 형식을 포함한다. 또한, 플래쉬 메모리에 사용되고 있는 파일시스템은 파일을 관리하고, 파일을 플래쉬 메모리에 저장하고 플래쉬 메모리로부터 읽어들이는 기능을 구비한다.

플래쉬 메모리를 저장장치로 사용하고 있는 피디에이(PDA), 이동통신단말기 등의 휴대용 통신기기는 호스트 시스템과 플래쉬 메모리간의 인터페이스로 자료구조를 활용한 파일시스템을 이용하여 구현하고 있다. 그러나 파일시스템은 처리하는 정보의 양이 많고 복잡해짐에 따라 자료구조에 대한 표준의 약화, 프로그램과 데이터의 유연성 결여, 프로그램의 생산성 감소 등의 단점을 안고 있다. 위에서 언급한 휴대용 통신기기는 계속적으로 진보하여 기능이 더욱 고도화되어 데이터가 복잡, 다양화 되고 있는데, 이러한 환경에서 계속적으로 파일시스템을 사용하는 것은 앞에서 언급한 문제를 야기시킬 수 있다.

이러한 휴대용 통신기기에 데이터베이스 시스템을 도입한다면 파일시스템의 단점으로 제기되는 문제를 해결할 수 있을 것이다. 하지만, 데이터베이스 시스템을 도입하는 경우 고려해야 할 점들이 있다. 파일시스템과 데이터베이스 시스템은 그 유용성을 따지기 전에 데이터를 파일로 관리한다는 목적이 동일하다. 플래쉬 메모리를 저장장치로 사용하는 기기에서 파일 관리와 데이터의 읽기(read), 쓰기(write)를 위하여 플래쉬 메모리의 하드웨어적 특성을 고려한 플래쉬 파일시스템을 이용하였지만, 데이터베이스 시스템을 파일관리의 목적으로 도입하면 한정된 임베디드 자원에서 파일관리라는 동일한 목적을 위해 두 개의 시스템, 즉 플래쉬 파일시스템과 데이터베이스 시스템이 함께 동작하게 되어 자원의 낭비가 초래된다.

이에 본 발명은 이러한 휴대용 통신기기에 데이터베이스 시스템을 도입하되, 파일관리의 기능은 데이터베이스가 책임지고 데이터의 입/출력 기능은 파일시스템 대신에 플래쉬 메모리의 특징과 데이터베이스의 특징을 고려하여 설계된 플래쉬 인터페이스를 갖는 플래쉬 메모리 저장 시스템이 담당한다.

따라서, 본 발명의 목적은 상기와 같은 종래의 문제점들을 해소하고, 파일 관리 기능을 배제한 데이터 입/출력 기능과 한번 쓰기동작이 된 플래쉬 메모리 영역의 재사용을 위한 가비지 콜렉션(garbage collection)기능을 가지며 데이터베이 스 시스템에서 트랜잭션 장애나 시스템 장애가 발생하여도 데이터베이스의 영속성(durability)과 원자성(atomicity)을 보장할 수 있는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템을 제공하는 데 있다.

본 발명의 다른 목적은 데이터베이스 시스템과 플래쉬 메모리의 인터페이스를 계층적 구조로 설계하여, 데이터베이스 시스템의 변경이나 플래쉬 메모리의 변경에도 플래쉬 메모리 저장시스템의 전체 재설계가 아니라 계층별 필요부분 변경만으로 시스템에 적용할 수 있도록 한 데이터베이스를 위한 플래쉬 메모리 저장 시스템을 제공하는 데 있다.

본 발명의 또다른 목적은 상기 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템에 의해 구현되는 플래쉬 메모리 저장방법을 제공하는 데 있다.

상기와 같은 목적을 달성하기 위한 본 발명의 일 측면에 따르면, 데이터베이스 시스템과 플래쉬 메모리를 인터페이스 하기 위한 시스템으로서, 상기 플래쉬 메모리는 상기 데이터베이스의 페이지와 크기가 동일한 버킷들로 분할되어 논리적으로 맵핑(mapping)되는 섹터들로 이루어지고, 각각의 버킷은 해당 버킷의 식별정보를 갖는 버킷헤더와 데이터를 기록하는 버킷바디로 구성되고, 상기 버킷헤더는 해당 버킷의 동작상태를 나타내는 상태_플래그와 해당 버킷에 기록된 데이터의 페이지 번호가 등록된 페이지_번호를 구비하는 것을 특징으로 하며, 상기 플래쉬 메모리의 섹터 수만큼의 행과 각 섹터의 버킷 수만큼의 열을 가지고 상기 버킷의 상태 를 나타내는 버킷_유용성_테이블과, 상기 버킷의 번호를 상기 페이지_번호에 맵핑한 버킷_페이지_테이블, 및 데이터베이스 시스템의 트랜잭션 과정을 관리하는 트랜잭션_액션_리스트를 마련하고, 상기 데이터베이스 시스템으로부터 쓰기, 읽기, 삭제의 명령과 트랜잭션의 시작, 종료, 롤백의 명령을 받아 상기 플래쉬 메모리에 입/출력하기 위한 일련의 과정을 처리하는 논리적 메모리 인터페이스; 및 상기 논리적 메모리 인터페이스에서 처리되어 출력된 버킷의 논리적 어드레스를 상기 플래쉬 메모리의 물리적 어드레스로 변환하여, 상기 논리적 메모리 인터페이스의 처리데이터를 상기 플래쉬 메모리에 직접 입/출력하는 물리적 메모리 인터페이스를 포함하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템을 제공한다.

상기 실시예에 따르면, 상기 논리적 메모리 인터페이스는 각 섹터에 기록가능한 버킷이 존재하는지를 나타내는 섹터_상태_테이블을 구비하는 것이 바람직하다.

상기 실시예에 따르면, 상기 버킷_유용성_테이블, 상기 버킷_페이지_테이블, 상기 섹터_상태_테이블 및 상기 트랜잭션_액션_리스트는 시스템 초기화시 상기 버킷헤더의 상태_플래그 및 페이지_번호를 참조하여 구성되어 시스템 메모리에 로드(load)된다.

상기와 같은 목적을 달성하기 위한 본 발명의 다른 측면에 따르면, 데이터베이스 시스템과 플래쉬 메모리를 인터페이스 하기 위한 방법으로서, 상기 플래쉬 메모리는 그 섹터들을 상기 데이터베이스의 페이지와 크기가 동일한 버킷들로 분할시켜 논리적으로 맵핑(mapping)하고, 각각의 버킷은 해당 버킷의 식별정보를 갖는 버 킷헤더와 데이터를 기록하는 버킷바디로 구성하며, 상기 버킷헤더는 해당 버킷의 동작상태를 나타내는 상태_플래그와 해당 버킷에 기록된 데이터의 페이지_번호를 등록하고, 상기 플래쉬 메모리의 섹터 수만큼의 행과 각 섹터의 버킷 수만큼의 열을 가지고 상기 버킷의 상태를 나타내는 버킷_유용성_테이블과, 상기 버킷의 번호를 상기 페이지_번호에 맵핑한 버킷_페이지_테이블, 및 데이터베이스 시스템의 트랜잭션 과정을 관리하는 트랜잭션_액션_리스트를 마련하고, 상기 버킷_유용성_테이블, 상기 버킷_페이지_테이블 및 상기 트랜잭션_액션_리스트를 시스템 초기화시 상기 버킷헤더의 상태_플래그 및 페이지_번호를 참조하여 구성시켜 시스템 메모리에 로드(load)시키고, 상기 데이터베이스 시스템으로부터 쓰기, 읽기, 삭제의 명령과 트랜잭션의 시작, 종료, 롤백의 명령을 받으면 상기 버킷_유용성_테이블, 상기 버킷_페이지_테이블 및 상기 트랜잭션_액션_리스트를 참조하여 해당 명령을 처리하여 상기 플래쉬 메모리에 입/출력하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법을 제공한다.

이하에서는 본 발명의 바람직한 실시예를 첨부한 도면들을 참조하여 상세하게 설명하기로 한다.

도 1은 본 발명에 따른 플래쉬 메모리 저장 시스템의 구성을 나타낸 블록도이다. 도 2는 본 발명에서 플래쉬 메모리의 섹터 구성을 나타낸 도면이고, 도 3은 도 2에 도시된 하나의 섹터를 논리적 단위인 버킷으로 나눈 상세도이고, 도 4는 도 3에 도시된 하나의 버킷이 가지는 버킷-헤더의 구성도이다. 도 5는 본 발명에서 플래쉬 메모리를 논리적 테이블로 맵핑한 버킷_유용성_테이블을 나타낸 도면이다. 도 6은 본 발명에서 버킷의 상태변환을 보여주는 상태변환도이고, 도 7은 본 발명에서 섹터의 상태를 나타내는 섹터_상태_테이블의 도면이고, 도 8은 본 발명에서 버킷번호를 페이지 번호에 맵핑한 버킷_페이지_테이블의 구성도이다. 또한, 도 9는 도 4에 도시된 버킷-헤더의 상태_플래그의 구성도이다.

도 1에 도시된 바와 같이, 본 발명의 플래쉬 메모리 저장 시스템(1)은 데이터베이스 시스템(20)과 플래쉬 메모리(30)사이에 그들을 인터페이스하기 위한 메모리 인터페이스(10)를 구비한다. 이 메모리 인터페이스(10)는 논리적 메모리 인터페이스(12)와 물리적 메모리 인터페이스(14)로 구성되어 계층적 구조를 갖는다. 논리적 메모리 인터페이스(12)는 데이터베이스 시스템(20)으로부터 쓰기, 읽기, 삭제의 명령과 트랜잭션(transaction)의 시작(begin), 종료(commit), 롤백(rollback)과 체크포인트 시작, 종료, 롤백의 명령을 받아 수행하며, 플래쉬 메모리(30)의 특징과 데이터베이스 시스템(20)의 특징에 맞게 입/출력하기 위한 일련의 과정을 처리한다. 한편, 물리적 메모리 인터페이스(14)는 논리적 메모리 인터페이스(12)에서 논리적 어드레스로 처리된 버킷을 플래쉬 메모리(30)의 물리적 어드레스로 변환하여, 플래쉬 메모리(30)와 직접 입/출력한다. 본 발명에서는 논리적 메모리 인터페이스(12)에 의해 대부분의 작업이 처리되며, 물리적 메모리 인터페이스(14)는 논리적 메모리 인터페이스(12)에 의해 처리된 결과에 따라 플래쉬 메모리(30)와 직접 인터페이스 한다. 따라서, 이하에서는 논리적 메모리 인터페이스(12)의 구성 및 동작에 대해 초점을 맞춰 중점적으로 설명한다. 또한, 플래쉬 메모리(30)는 NOR형이나 NAND형이 모두 사용될 수 있으며, 여기에서는 NOR형을 예로 들어 설명한다.

플래쉬 메모리(30)를 저장장치로 사용하는 데이터베이스 시스템(20)은 효율적인 입/출력을 위하여 하나의 큰 덩어리의 데이터베이스 파일구조를 작은 파일 단위(예컨대, 4KB)로 나누어 인터페이스 하는데, 이를 페이지(page)라 하며, 페이지의 첫 4바이트(bytes)는 더미(dummy)값으로 처리된다. 플래쉬 메모리(30)는 도 2에 나타낸 바와 같이 물리적 단위인 섹터(32)로 나뉘어져 있고, 이러한 섹터(32)가 여러 개 모여 하나의 플래쉬 메모리(30)를 구성한다. 예컨대 플래쉬 메모리(30)의 크기가 1MB이고, 섹터(32) 하나의 크기가 64KB이면, 플래쉬 메모리(30)는 16개의 섹터(32)를 가진다. 이러한 플래쉬 메모리(30)의 효율적 관리를 위하여 본 발명에서는 도 3에 도시한 바와 같이 각 섹터(32)를 논리적으로 데이터베이스 시스템의 페이지 사이즈와 동일한 크기인 4KB의 고정된 버킷(bucket)(34)으로 분할한다. 그리고, 각 버킷(34)은 버킷의 식별정보를 표시하는 버킷-헤더(bucket-header(4 bytes))(36)와 데이터가 기록되는 버킷-바디(bucket body(4Kbytes - 4 bytes))(38)로 구성한다. 섹터(32) 하나의 크기는 64KB이므로 섹터(32) 하나에 16개의 버킷(34)이 존재할 수 있다. 각 버킷(34)은 데이터베이스 시스템(20)의 각 페이지의 내용을 보관하는 플래쉬 메모리(30)의 해당 공간을 의미하고, 하나의 페이지는 하나의 버킷(34)으로 맵핑(mapping)된다. 데이터베이스 시스템(20)의 페이지의 첫 4 바이트(bytes)의 의미 없는 값에 해당하는 버킷-헤더(36)는 논리적 메모리 인터페이스(12)에 의해 도 4에 도시한 것처럼 상태_플래그(status_flag)(36')와 페이지_번호(page_number)(36")의 의미있는 값으로 구성된다. 상태_플래그(36')는 트랜잭션에 따라 변화하는 버킷(34)의 상태를 나타내며, 페이지_번호(36")는 그 버킷(34)이 어느 페이지의 내용을 저장하고 있는지를 나타낸다.

논리적 메모리 인터페이스(12)는 버킷(34)들의 사용상태를 관리하기 위하여 도 5와 같은 버킷_유용성_테이블(Tb1)을 구비한다. 이 테이블(Tb1)은 섹터(32) 수만큼의 행과 각 섹터(32)의 버킷(34) 수만큼의 열로 이루어진다. 버킷_유용성_테이블(Tb1)의 <m,n> 엔트리(entry)의 값은 섹터 m의 버킷 n의 사용상태를 나타낸다. 이 버킷 엔트리의 값으로는 '초기상태', '할당완료', '반환완료 ' 등 도 6에 도시한 상태들 중 한가지가 된다. 예를 들어, 도 6에 도시된 바와 같이, 어떤 버킷(34)을 포함하는 섹터(32)가 가비지 콜렉터(garbage collector)의 섹터 소거(erase) 작업에 의해 소거된 경우 그 버킷 엔트리의 값은 '초기상태'(St1)로 설정되고, 그 버킷(34)이 데이터베이스 시스템(20)의 특정 페이지에 할당(allocate)된 경우 그 버킷 엔트리의 값은 '할당완료'(St2)로 설정되며, 그 버킷(34)이 특정 페이지로부터 반환(deallocate)된 경우 그 버킷 엔트리의 값은 '반환완료'(St3)로 설정된다. 도 6에서, 이 '초기상태'(St1), '할당완료'(St2), 및 '반환완료'(St3) 이외의 다른 값들은 트랜잭션의 수행 중 과도기적인 상태의 값들을 나타내며, 이러한 트랜잭션에 따른 버킷(34)의 상태 변환들에 대해서는 도 6을 참조하여 뒤에서 좀더 상세하게 설명하기로 한다. 특히, 버킷_유용성_테이블(Tb1)은 시스템 부팅 (booting)시에 플래쉬 메모리(30)의 모든 버킷(34)들의 버킷-헤더(36)의 상태_플래그(36')와 페이지_번호(36")를 읽어서 초기화되며 시스템의 종료시 시스템 메모리에서 삭제된다. 이 시스템 메모리로는 주로 랜덤 액세스 메모리(RAM; 이하, '램'이라 함)가 사용된다.

본 발명에서 플래쉬 메모리(30)의 각 섹터(32)들은 그 섹터(32)의 첫 번째 버킷부터 마지막 버킷까지 차례로 할당되는데, 버킷_유용성_테이블(Tb1)을 이용함으로써 특정 섹터(32)의 특정 버킷(34)의 현재 사용여부를 신속하고 간단하게 식별할 수 있으므로 데이터베이스 시스템(20)의 새로운 페이지 또는 기존 페이지의 변경된 내용을 기록할 공간을 확보할 때에 효율적으로 동작할 수 있다.

논리적 메모리 인터페이스(12)는 마지막으로 할당된 버킷(34)의 버킷_번호(bucket number)를 램 상의 변수(예컨대, 마지막_버킷_번호(LBN))에 기억한다. 따라서, 새로운 버킷(34)의 할당은 변수 LBN이 갖고 있는 버킷_번호를 기준으로 순차적으로 버킷_유용성_테이블(Tb1)의 버킷 엔트리값이 '초기상태'인 곳을 찾으며 마지막 엔트리 까지도 '초기상태'의 값을 가지는 것이 없으면 첫 번째 버킷 엔트리부터 다시 검사한다. 만일 모든 버킷 엔트리가 '초기상태'가 아니면 플래쉬 메모리(30)에 더 이상 기록할 빈 공간이 없는 상태로, 데이터베이스 풀(full)을 의미한다.

섹터(32)의 개수를 H, 하나의 섹터(32)내의 버킷(34)들의 개수를 W라 할 경 우, 버킷_번호 B(0 ≤ B < H×W)와 이들의 관계는 아래식과 같다.

(1) 버킷_번호 B가 주어진 경우, 그 버킷의 섹터 인덱스(0~15의 값) s와 버킷 인덱스 o(0~15의 값)는 다음과 같이 구해진다.

s = B / W;

o = B % W;

(2) 섹터 인덱스 s와 버킷 인덱스 o가 주어진 경우, 그 버킷의 버킷번호 B는 다음과 같이 구해진다.

B = s * W + o;

논리적 메모리 인터페이스(12)는 섹터(32)의 상태를 표시하기 위해 도 7과 같은 섹터_상태_테이블(Tb2)을 마련하고 있다. 섹터_상태_테이블(Tb2)은 시스템 초기화시 시스템 메모리(램)에 구성되고, 시스템 종료시 램에서 삭제된다. 이 섹터_상태_테이블(Tb2)에서 볼 때 하나의 섹터에서 하나이상의 '초기상태'의 버킷이 존재하면 이용가능(Available) 상태라 하며, 섹터내에 '초기상태'의 버킷이 하나도 없을 때 그 섹터의 상태를 풀(Full) 상태라 한다. 섹터_상태_테이블(Tb2)의 변경은 다음의 경우에 발생한다.

(1) 그 섹터 내의 마지막 버킷이 할당되면, 그 섹터의 상태를 풀(Full) 상태로 바꾼다.

(2) 그 섹터를 가비지 콜렉터가 소거하면, 그 섹터의 상태를 풀(full) 상태에서 이용가능(Available) 상태로 바꾼다.

이 섹터_상태_테이블(Tb2)은 현재 '초기상태'의 섹터가 몇 개 존재하는지를 파악하여 후에 설명되는 가비지 콜렉션의 동작에 영향을 미친다.

플래쉬 메모리(30)는 물리적 특성상 특정 페이지를 변경(update)할 경우 그 페이지를 그 페이지의 해당 버킷(34)에 곧바로 인플레이스-업데이트(inplace-update)할 수 없으므로 새로운 버킷을 하나 확보하고 그 버킷에 수정된 페이지의 내용을 기록하고 기존 버킷을 지금 또는 나중에 소거해야 한다. 따라서, 한번 기록(write)한 페이지 P(그 내용을 A, 버킷을 B라 가정한다)를 변경하여 내용 A'로 수정하기 위해서는 '초기상태'인 버킷(버킷 B')에 변경된 페이지 P(내용은 A')를 기록하고, 이전 버킷 B는 '반환완료'로 처리하여 그때 또는 나중에 섹터 소거동작으로 '초기상태'로 만들게 된다.

데이터베이스 시스템(20)과 논리적 메모리 인터페이스(12)에서 각 페이지에 대한 참조는 그 페이지의 페이지_번호를 이용하여 수행되므로 그 페이지가 변경된 경우, 그 페이지의 페이지_번호를 지닌 다른 모든 버킷(34)들을 변경하는 것은 너무나 많은 부담을 가진다. 따라서, 본 발명에서는 이들 버킷(34)들을 일일이 참조하지 않고 하나의 페이지에 하나의 버킷(34)의 참조가 정확히 수행되게 하기 위하여 도 8과 같이 버킷번호를 페이지_번호에 맵핑(mapping)한 테이블인 버킷_페이지_테이블(Tb3)을 마련하고 있다. 버킷_페이지_테이블(Tb3)은 총 섹터수(H)×하나의 섹터내 총 버킷수(W)의 엔트리(entry)들을 가지며, 각 엔트리는 위에서 언급한 것 과 같이 섹터 인덱스(s)와 버킷 인덱스(o)의 조합으로 이루어진 버킷_번호(B = s × W + o)를 가진다. 이 버킷_페이지_테이블(Tb3)은 시스템 메모리(RAM)에서만 관리되며, 시스템 부팅시에 1MB의 플래쉬 메모리(30)에서 각 섹터(32)의 버킷-헤더(36)의 상태_플래그(36')와 페이지_번호(36")를 이용하여 구성된다. 즉, 버킷-헤더(36)의 상태_플래그(36')의 값이 '할당완료'인 경우에 한하여 그 페이지_번호(36")에 해당하는 버킷_페이지_테이블(Tb3)의 엔트리를 그 버킷(34)의 버킷_번호(B)로 설정한다. 따라서, 특정 버킷(34)이 특정 페이지_번호(36")에 할당될 경우 그 페이지_번호(36")에 해당하는 엔트리의 값을 그 버킷_번호(B)로 설정하고, 특정 페이지가 데이터베이스에서 삭제되어 해당 버킷(34)이 삭제될 경우 해당 엔트리값을 -1로 설정하며, 시스템의 종료시에는 버킷_페이지_테이블(Tb3)이 시스템 메모리(RAM)에서 삭제되게 된다.

버킷-헤더(36)는 전술한 바와 같이 버킷(34)의 상태를 나타내는 상태_플래그(Status_flag; 36')와 그 버킷(34)이 관련된 페이지의 페이지_번호(36")를 가진다. 버킷(34)의 상태_플래그(36')는 재시작 회복(restart recovery) 및 시스템의 정상적인 리부팅(rebooting)을 하는데 이용된다. 상태_플래그(36')는 또한 도 9에서 도시한 바와 같이 16비트(bit)로서 의미 있는 비트필드(bit field)를 가지며, 각 필드의 의미는 다음과 같다. 즉, 15번에서 6번까지의 비트필드는 의미 없는 값이며 향후 확장을 위한 것이다. 5번 비트필드는 트랜잭션의 완료(commit) 과정의 일부로 의미 있는 데이터가 되었음을 의미한다. 4번 비트필드는 버킷(34)이 변경(수 정) 혹은 삭제의 대상이 되었음을 의미한다. 3번 비트필드는 트랜잭션의 완료과정의 일부로 버킷(34)이 반환의 대상이 되었음을 의미한다. 2번 비트필드는 반환이 완료된 버킷(34)으로 가비지 콜렉션의 대상이 될 수 있음을 의미한다. 1번 비트필드는 '초기상태'의 버킷(34)이 트랜잭션의 대상으로 할당되었음을 의미한다. 0번 비트필드는 트랜잭션이 끝난 버킷(34)임을 의미한다.

이러한 버킷(34)의 상태_플래그(36')는 도 6에 도시한 바와 같이 트랜잭션의 진행에 따라 변화하며, 도 6의 상태변환도에서 각 상태의 의미는 다음과 같다.

1) 초기상태(St1)는 5bit~0bit가 '111111'의 값을 가지며, 어떠한 데이터도 기록되지 않아 새로운 버킷을 할당할 수 있는 상태이다.

2) 할당_트랜잭션_중(St4)은 5bit~0bit가 '111101'의 값을 갖는 상태로서, 초기상태(St1)의 특정 버킷이 할당된 후 그 버킷이 완료되지도 롤백되지도 않았음을 나타낸다. 그 버킷은 해당 페이지의 내용을 가지고 있을 수도 있고 가지지 않을 수도 있다. 이는 버킷 할당시에 버킷(34)의 상태_플래그(36')를 변경한 후 버킷 내용을 변경하기 때문이다. 새로운 버킷(34)의 할당은 다음의 경우에 수행된다. 첫째, 새로운 페이지를 할당받은 경우, 둘째, 종료한 트랜잭션이 기록한 버킷의 내용을 변경하는 경우, 셋째, 현재 트랜잭션이 기록한 페이지의 내용을 변경하는 경우이다.

3) 할당_트랜잭션_완료(St5)는 5bit~0bit가 '011101'의 값을 갖는 상태로서, 할당_트랜잭션_중(St4) 상태의 버킷이 트랜잭션의 완료 과정의 일부로 유용한 데이터를 가지고 있음을 나타낸다.

4) 할당완료(St2)는 5bit~0bit가 '011100'의 값을 갖는 상태로서, 할당_트랜잭션_완료(St5) 상태의 버킷(34)이 트랜잭션의 완료과정의 최종 단계로서 완전한 버킷(34)이 되어 트랜잭션을 종료하면 하나의 데이터파일이 됨을 의미한다.

5) 반환_트랜잭션_끝(St6)은 5bit~0bit가 '001100'의 값을 갖는 상태로서, 종료한 다른 트랜잭션에 의해 생성되어 페이지의 내용을 담고 있는 할당완료(St2)의 버킷(34)을 현재 트랜잭션이 그 페이지의 내용을 수정할 경우, 기존 버킷(34)의 상태는 반환_트랜잭션_끝(St6) 상태로 변경된다. 이 경우, 할당완료(St2)상태의 버킷(예컨대, Bm)에 담긴 페이지(예컨대, Pi)의 내용(예컨대, BB)을 수정할 경우, 그 과정은 버킷 Bm의 상태를 반환_트랜잭션_끝(St6)으로 변경하고 새로운 버킷(예컨대, Bw)을 할당받고 버킷 Bw의 상태를 할당_트랜잭션_중(St4)으로 설정하며 변경된 페이지 Pi의 내용 BB'를 버킷 Bw의 버킷-바디(38)에 기록한다.

6) 반환_트랜잭션_완료(St7)는 5bit~0bit가 '000100'의 값을 갖는 상태로서, 반환_트랜잭션_중(St8) 또는 반환_트랜잭션_끝(St6) 상태의 버킷이 트랜잭션 완료과정의 일부로 버킷이 반환될 것임을 나타내는 상태이다.

7) 반환완료(St3)는 5bit~0bit가 '000000'의 값을 갖는 상태로서, 반환_트랜잭션_완료(St7) 상태의 버킷이 트랜잭션 완료의 마지막 단계로 반환되어 섹터소거 작업에 참여할 수 있음을 나타낸다.

8) 반환_트랜잭션_중(St8)은 5bit~0bit가 '101101'의 값을 갖는 상태로서, 현재 트랜잭션에 의해 페이지의 내용을 담기 위해 할당된 버킷, 즉 할당_트랜잭션_중(St4)의 버킷(34)이 그 트랜잭션에 의해 페이지의 내용이 변경됨으로써 변경된 내용을 새로운 버킷에 담고자 할 경우 기존 버킷의 상태를 할당_트랜잭션_중(St4)에서 반환_트랜잭션_중(St8)으로 변경한다. 이 경우 변경된 페이지 내용은 초기상태(St1)의 버킷을 할당받아 그 상태를 할당_트랜잭션_중(St4)으로 하고 버킷-바디(38)에 그 페이지 내용을 기록하게 된다.

논리적 메모리 인터페이스(12)는 트랜잭션의 완료 및 롤백과 체크포인트의 완료 및 롤백을 위하여 트랜잭션의 수행에 관련된 정보들을 그것들의 발생순으로 링크된 리스트(linked list)를 만들어 관리한다. 이를 트랜잭션_액션_리스트(Transaction_action_list)라 하며, 도 10은 트랜잭션_액션_리스트의 일예를 나타낸 것으로, 이를 보면 리스트가 여러개의 노드들(Nd1~Nd6)이 링크되어 구성됨을 알 수 있다. 이 트랜잭션_액션_리스트의 각 노드(node)는 도 10에서 보는 바와 같이 <액션_타입(action_type), 페이지_번호 (page_number), 이전_버킷_번호(before_bucket_number), 이후_버킷_번호(after_bucket_number)>로 구성된다. 이를 구현하는 동작 코드(operation code)는 아래와 같다.

---------------------------------------------------------

typedef struct tagTransactionNode

{

UINT8 ActionType;

UINT16 PageNr;

UINT16 BeforeBNo; /* before bucket number */

UINT16 AfterBNo; /* after bucket number */

struct tagTransactionNode *next;

} TransactionNode;

----------------------------------------------------------

데이터베이스 시스템(20)에서 발생하여 요청되는 '액션_타입'은 트랜잭션 시작(begin)을 의미하는 'TR_BEGIN', 트랜잭션의 종료를 의미하는 'TR_COMMIT', 트랜잭션 롤백을 의미하는 'TR_ROLLBACK', 트랜잭션의 시작과 완료에서와 같이 하나의 상태의 영속성을 위해 상태의 시작과 끝에 하나의 상태의 시작(Implicit_Savepoint_Start, CheckPoint_Begin)과 완료를 의미하는 'TR_CPBEGIN' 및 'TR_CPCOMMIT', 그리고 그것의 롤백을 의미하는 'TR_CPROLLBACK'이 있다. 그 외의 액션_타입으로는 논리적 메모리 인터페이스(12)에서 결정되는 새로운 페이지의 쓰기를 의미하는 'TR_WRITE', 페이지 삭제를 의미하는 'TR_DELETE', 기존 페이지에의 쓰기로 페이지의 변경을 의미하는 'TR_UPDATE'가 있다. 그리고 페이지 읽기가 있으나 이는 트랜잭션_액션_리스트에 포함되지 않고, 읽기 요청이 왔을 때 즉시 버킷_페이지_테이블(Tb3)을 이용하여 요청된 페이지_번호로써 페이지 데이터가 들어있는 버킷(34)의 위치를 찾아 플래쉬 메모리(30)로부터 데이터베이스 시스템(20)으로 읽어 들이는 동작이다. 더 나아가, 읽기 요청에 대한 보다 신속한 응답을 위해 다음의 방법이 제공될 수도 있다. 시스템 메모리(램)에 일정크기의 버퍼 (buffer)와 버퍼상의 어느 위치에 어떤 페이지번호의 내용이 기록되어 있는지를 알 수 있는 테이블을 마련하고 한번 읽기요청된 페이지의 내용을 그 버퍼에 기록하여 두었다가 후에 같은 페이지의 읽기 요청이 왔을 경우 플래쉬 메모리(30)를 직접 읽지 않고 테이블을 이용하여 버퍼에 담긴 페이지 내용을 읽어 들이는 방법이다. 만일, 버퍼에 담아둔 페이지가 플래쉬 메모리(30)에서 변경이 되면 버퍼에서 그 페이지의 내용을 삭제한다. 왜냐하면, 버퍼에 담아둔 페이지의 내용이 실제 플래쉬 메모리(30)에 쓰여진 내용과 다르게 되기 때문이다. 그러면 버퍼에서 삭제된 페이지 갯수만큼 다음번 읽기요청이 있을때 새로운 페이지 내용을 버퍼에 기록해 둘 수 있다. 그러나, 이와 같은 방법은 페이지크기×n의 크기를 가지는 버퍼를 마련해야 하므로 비교적 많은 램 공간이 요구되는 단점이 있다.

트랜잭션_액션_리스트의 '페이지_번호'는 쓰기, 변경, 삭제에 관련된 페이지의 페이지 번호를 나타낸다. '이전_버킷_번호'는 페이지 변경, 삭제와 관련하여 해당 페이지의 변경전 데이터(data; image를 포함)를 가진 버킷의 버킷 번호를 나타낸다. '이후_버킷_번호'는 페이지 쓰기, 변경과 관련하여 해당 페이지의 변경된 또는 새로운 데이터를 가진 버킷의 버킷 번호를 나타낸다.

따라서, 트랜잭션의 진행, 즉 새로운 상태 추가, 트랜잭션 완료, 트랜잭션 롤백을 수행할 때 버킷(34)의 상태와 어떤 버킷(34)이 트랜잭션에 참가하였는지를 확인하기 위하여 본 발명에서는 버킷(34)의 상태_플래그(36')를 읽을 필요없이 버킷_유용성_테이블(Tb1)의 정보를 읽어 확인하고 수정하며, 상태_플래그(36')는 변환만 해준다. 그로 인하여, 플래쉬 메모리(30)에 있는 버킷(34)의 상태_플래그 (36')를 읽는 시간과 비용을 없앨 수 있다.

도 11은 본 발명에서 데이터베이스 시스템으로부터 트랜잭션의 시작 명령에 따라 트랜잭션_액션_리스트의 노드가 만들어지는 프로세스의 흐름도로, 이 순서도를 참조하여 노드가 만들어지면서 플래쉬 메모리에 액세스되는 과정을 상세히 설명한다.

가) 데이터베이스 시스템(20)으로부터 트랜잭션의 시작 명령이 있으면 트랜잭션을 시작한다. 이때 논리적 메모리 인터페이스(12)에서는 아무런 동작이 없다.

나) 데이터베이스 시스템(20)으로부터 논리적 메모리 인터페이스(12)에 쓰기나 삭제를 요청하면, 논리적 메모리 인터페이스(12)는 새로운 노드를 생성하여 이 노드에 요청된 '페이지_번호'를 기록한다(S100).

다) 데이터베이스 시스템(20)에서 처리되는 에스큐엘(SQL)문에 상관없이 데이터베이스 인터페이스를 통하여 전달되는 페이지 변경 및 추가의 동작은 쓰기와 삭제이다. 따라서, 동작 명령이 쓰기인지 삭제인지를 판단하여(S102), 쓰기일 경우 다음과 같은 과정을 수행한다.

동작 명령의 페이지_번호에 해당하는 버킷_페이지_테이블(Tb3)의 엔트리값을 읽어 페이지의 쓰기 동작인지 변경 동작인지를 판단한다.(S104) 예를 들어, 페이지_번호 Pi, 그 페이지의 데이터 Pd를 쓰기 할 경우 버킷_페이지_테이블(Tb3)에서 Pi의 엔트리값이 -1이면 플래쉬 메모리(30)에 동일 페이지_번호가 쓰여진 유효한 버킷이 없는 것으로 새로운 페이지의 쓰기이고, 그 액션_타입은 TR_WRITE이 된다(S106). 반면에, 단계S104에서 엔트리값이 -1이 아니면 페이지 변경(update)에 해당하고, 이 페이지 변경에서 노드의 액션_타입은 TR_UPDATE가 된다(S108).

한편, 단계S102에서 데이터베이스 시스템(20)에서 쓰기 명령이 아니라 삭제 명령이 요청되면 해당 페이지의 삭제로 판단하고 그 액션_타입은 TR_DELETE이 된다(S110).

라) 변경과 삭제는 그 페이지가 저장되어 있는 버킷(34)의 버킷_번호, 즉 버킷_페이지_테이블(Tb3)의 요청된 페이지_번호에 해당하는 엔트리값을 노드의 '이전_버킷_번호'로 등록하고(S112), 그 버킷의 상태_플래그(36')를 버킷_유용성_테이블(Tb1)로부터 읽어 할당완료(S80)인지를 판단한다(S114). 여기서, 할당완료이면 버킷(34)의 상태_플래그(36')와 버킷_유용성_테이블(Tb1)의 값을 반환_트랜잭션_끝(St6)으로 변경하고(S116), 반면에 할당_트랜잭션_중(St4)이면 버킷(34)의 상태_플래그(36')와 버킷_유용성_테이블(Tb1)의 값을 반환_트랜잭션_중(St8)으로 변환한다(S118). 이때 버킷_유용성_테이블(Tb1)의 값 뿐만 아니라 상태_플래그(36')를 변경하는 것은 갑작스런 정전 등의 이유로 정상적인 동작을 하지 못할 경우를 대비하여 데이터베이스를 복구하기 위한 고려이다.

마) 단계 S116 또는 S118을 수행한 후 '액션_타입'이 삭제(TR_DELETE)인지를 판단하여(S120), 삭제이면 논리적 메모리 인터페이스(12)로 요청되어진 하나의 명령은 종료(완료)된다. 한편, 단계S120에서 '액션_타입'이 삭제가 아니거나, 즉 변경이거나 단계S106의 쓰기인 경우는 초기상태의 버킷(34)을 할당받아 버킷_유용 성_테이블(Tb1)의 엔트리값과 상태_플래그(36')를 할당_트랜잭션_중으로 변환하고, 그 버킷(34)의 버킷_번호를 트랜잭션_액션_리스트의 노드의 '이후_버킷_번호'에 기록하고, 페이지 데이터를 버킷-바디(38)에 기록한다.(S122)

이제 트랜잭션이 진행되면서 노드가 만들어지고 각 버킷들의 상태가 변화하는 과정을 도 6, 도 10 및 도 11을 병행 참조하면서 설명한다. 도 10과 같은 트랜잭션_액션_리스트가 만들어진 결과를 보면 페이지 번호 Pa, Pb의 데이터는 종료한 다른 트랜잭션에서 생성된 것이어서 상태_플래그(36') 및 버킷_유용성_테이블(Tb1)의 값은 '할당완료'(St2)이며, 페이지 번호 Pc, Pd의 페이지 데이터는 현재 트랜잭션에서 생성 및 변환된 것이다.

트랜잭션_액션_리스트의 노드 Nd1은 트랜잭션 시작 다음에 발생한 것으로 데이터베이스 시스템(20)으로부터 페이지 번호 Pc에 대한 액션이 논리적 메모리 인터페이스(12)로 요청되어지고, 그에 따라 그 페이지 번호가 새로이 생성한 노드의 '페이지_번호'에 기록된다(S100). 이 액션의 타입은 쓰기이므로 단계S102에서 단계S104로 넘어가고, 단계S104에서 버킷_페이지_테이블(Tb3)의 페이지 번호에 대한 엔트리값이 -1이여서 노드의 '액션_타입'은 TR_WRITE가 된다(S106). 그 결과, 버킷_유용성_테이블(Tb1)에 의해 새로운 버킷(34)을 할당받고 그 버킷_번호 2를 '이후_버킷_번호'에 기록하고, 버킷_유용성_테이블(Tb1)과 상태_플래그(36')를 할당_트랜잭션_중(St4)으로 변경 기록한다. 그리고 나서, 페이지 데이터를 그 버킷(34)에 기록한다.(S122)

노드 Nd2는 노드 Nd1이 만들어지는 과정과 동일하게 만들어져, 첫번째 노드 Nd1 뒤에 추가되고 그 페이지의 데이터를 할당받은 버킷(34)에 기록한다.

노드 Nd3은 페이지번호 Pc를 가진 페이지의 변경으로써, 요청된 액션의 페이지 번호 Pc를 노드 하나를 생성하여 그 '페이지_번호'에 기록하고(S100), 요청되어진 액션(명령)이 쓰기이고 버킷_페이지_테이블(Tb3)의 엔트리값이 2이므로 '액션_타입'은 TR_UPDATE로 판단한다(S102,S104,S108). 그럼, 액션_타입이 페이지 변경이므로 버킷_페이지_테이블(Tb3)의 Pb의 엔트리값인 버킷 번호 2를 '이전_버킷_번호'에 기록하고(S112), 그 버킷(34)의 버킷_유용성_테이블(Tb1)의 값이 할당_트랜잭션_중(St4)이므로 상태_플래그(36')와 버킷_유용성_테이블(Tb1)의 값을 반환_트랜잭션_중(St8)으로 변환 기록한다(S118). 변경된 페이지의 테이터를 기록하기 위하여 버킷 하나(예컨대, 버킷_번호 4)를 할당받아 버킷 번호를 '이후_버킷_번호'에 기록하고, 그 상태_플래그(36')와 버킷_유용성_테이블(Tb1)의 엔트리값을 할당_트랜잭션_중(St4)으로 변환 기록한다. 또한, 버킷_페이지_테이블(Tb3)의 페이지번호 Pb에 해당하는 엔트리값을 새로 할당받은 버킷번호 4로 변경하고, 이렇게 만들어진 노드 Nd3을 노드 Nd2 뒤에 추가하고 변경된 페이지 데이터를 4번 버킷(34)에 기록한다.(S122)

노드 Nd4는 하나의 상태의 영속성(durability)을 보장받기 위해 데이터베이스 시스템(20)에서 체크포인트(Check Point) 시작의 명령을 주었을 때 하나의 노드를 생성하고 그 노드의 '액션_타입'을 TR_CPBEGIN으로 하여 노드 Nd3 뒤에 추가한다. 이 액션은 실제 플래쉬 메모리(30)로의 행동은 없으며, 단지 체크포인트의 시 점만 논리적 메모리 인터페이스(12)에서 갖고 있으면서 만일 데이터베이스 시스템(20)에서 체크포인트 롤백의 명령이 있을 때 노드 Nd4를 기준으로 하여 그 이후에 수행된 동작을 체크포인트 시작 이전으로 되돌릴 수 있도록 한다.

노드 Nd5는 체크포인트 시작 이후에 발생한 것으로 노드 하나를 생성하여 액션의 페이지 번호 Pa를 그 '페이지_번호'에 기록하고(S100), 그 액션의 형태가 쓰기이며 버킷_페이지_테이블(Tb3)의 엔트리값이 0이므로 '액션_타입'은 TR_UPDATE로 판단된다(S102,S104,S108). 그에 따라 '이전_버킷_번호'에 버킷번호 0을 기록하고(S112), 그 버킷의 버킷_유용성_테이블(Tb1)이 할당완료(St2)이므로 상태_플래그(36')와 버킷_유용성_테이블(Tb1)의 값을 반환_트랜잭션_끝(St6)으로 변환한다(S116). 그리고, 변경된 페이지의 테이터를 기록하기 위하여 버킷 하나(예컨대, 버킷_번호 5)를 할당받아 버킷번호를 '이후_버킷_번호'에 기록하고, 그 상태_플래그(36')와 버킷_유용성_테이블(Tb1)의 엔트리값을 할당_트랜잭션_중(St4)으로 변환 기록한다. 또한, 버킷_페이지_테이블(Tb3)의 Pa의 엔트리값을 새로 할당받은 버킷번호 5로 변경하고, 이렇게 만들어진 노드 Nd5를 이전 노드 Nd4 뒤에 추가하고 변경된 페이지 데이터를 5번 버킷(34)에 기록한다.(S122)

실제동작에 있어 노드 Nd4이후에 데이터베이스 시스템(20)이 정한 임의의 시점에 체크포인트 종료나 롤백의 명령이 논리적 메모리 인터페이스(12)로 전달된다. 그러나, 체크포인트 종료나 롤백은 트랜잭션_액션_리스트에 반영되지 않고, 특히 체크포인트 종료는 아무런 동작도 일으키지 않으며, 체크포인트 롤백의 동작은 체크포인트 이전의 상태로 되돌려주는 것으로 이에 대해서는 뒤에서 좀더 상세히 설 명한다.

노드 Nd6는 페이지 번호 Pb의 페이지 데이터 삭제명령을 수행하는 것으로, 노드 하나를 생성하여 '페이지_번호'에 페이지 번호 Pb를 기록하고(S100), 액션의 형태가 삭제이므로 '액션_타입'에 TR_DELETE를 기록한다(S102,S110). 그리고, 버킷_페이지_테이블(Tb3)의 페이지번호 Pb의 엔트리값이 1이므로 '이전_버킷_번호'에 버킷번호 1을 기록하고(S112), 버킷_유용성_테이블(Tb1)의 값이 할당완료(St2)이므로 도 6의 상태변화에 따라 상태_플래그(36')와 버킷_유용성_테이블(Tb1)의 값을 반환_트랜잭션_끝(St6)으로 변경한다(S114,S116). 마지막으로, 이렇게 변경된 노드 Nd6를 이전 노드 Nd5 뒤에 추가한다.

트랜잭션의 진행중 데이터베이스 시스템(20)으로부터 트랜잭션 종료와 롤백, 체크포인트 종료와 롤백은 다음에 설명하는 순서에 따라 처리된다.

도 12는 본 발명에서 트랜잭션 종료의 제1단계 프로세스를 나타낸 흐름도이고, 도 13은 본 발명에서 트랜잭션 종료의 제2단계 프로세스를 나타낸 흐름도로, 이제부터 이 두 도면들을 참조하여 트랜잭션 종료 동작에 대해 상세히 설명한다.

트랜잭션 종료(commit)는 다음과 같이 두 단계로 진행된다. 제1단계로는, 도 12에 도시한 바와 같이 트랜잭션_액션_리스트의 첫 번째 노드부터 마지막 노드까지 '액션_타입'에 따라 TR_UPDATE와 TR_DELETE의 '이전_버킷_번호'에 위치한 버킷의 상태_플래그와 버킷_유용성_테이블의 엔트리값을 반환_트랜잭션_완료(St7)로 변환한다(S200,S202). 한편, '액션_타입'에 따라 TR_WRITE와 TR_UPDATE의 '이후_ 버킷_번호'에 위치한 버킷번호의 버킷_유용성_테이블의 엔트리값이 할당_트랜잭션_중(St4)이면 할당_트랜잭션_완료(St5)로 변환하고(S206,S208), 그렇지 않으면 반환_트랜잭션_완료(St7)로 변환한다(S210).

제2단계는 도 13에 도시한 바와 같이 트랜잭션_액션_리스트의 첫 번째 노드부터 마지막 노드까지 '액션_타입'에 따라 분류하여, 액션_타입 TR_UPDATE와 TR_DELETE는 '이전_버킷_번호'에 위치한 버킷(34)의 상태_플래그와 버킷_유용성_테이블의 엔트리값을 반환완료(St3)로 변환한다(S230,S232). 한편, 단계S230에서 '액션_타입'이 TR_UPDATE에서 단계S232의 반환완료이거나 TR_WRITE인 경우, '이후_버킷_번호'에 위치한 버킷(34)의 버킷_유용성_테이블의 엔트리값이 할당_트랜잭션_완료(St5)인가를 판단하여(S236), 할당_트랜잭션_완료이면 할당완료(St2)로 버킷_유용성_테이블과 상태_플래그를 변환하고(S238), 아니면 반환완료(St3)로 버킷_유용성_테이블과 상태_플래그를 변환한다(S240).

실제 예를 들어 설명하면, 도 10의 트랜잭션_액션_리스트에서 마지막 노드 다음에 트랜잭션 종료가 명령되면 노드 Nd1의 2번 버킷은 노드 Nd3에 의해 반환_트랜잭션_중(St8)이 되었으므로, 도 12의 단계S200 및 S202 과정을 거쳐 반환_트랜잭션_완료(St7)가 된다(S200,S202). 다음 노드 Nd2의 3번 버킷은 단계S200 및 S206 과정을 차례로 거쳐 할당_트랜잭션_완료(St5)가 된다(S200,S206,S208). 그 다음 노드 Nd3의 2번 버킷은 이미 반환_트랜잭션_완료(St7)이므로 상태가 그대로 유지되며, 4번 버킷은 도 12의 단계S206,S208을 거쳐 할당_트랜잭션_완료(St5)가 된다. 또한, 노드 Nd5의 0번 버킷은 도 12의 단계S202에 따라 반환_트랜잭션_완료(St7)가 되고, 5번 버킷은 도 12의 단계S206,S208에 따라 할당_트랜잭션_완료(St5)가 된다. 노드 Nd6의 1번 버킷은 도 12의 단계S202에 따라 반환_트랜잭션_완료(St7)가 된다.

트랜잭션 종료의 두번째 단계로 도 10의 트랜잭션의 첫번째 노드 Nd1의 2번 버킷은 도 13의 단계S230,S236,S240을 거쳐 반환완료(St3)로, 다음 노드 Nd2의 3번 버킷은 도 13의 단계S236,S238을 거쳐 할당완료(St2)로 된다. 또한, 다음 노드 Nd3의 2번 버킷은 노드 Nd1에서 이미 반환완료(St3)가 되었고, 4번 버킷은 도 13의 단계S236,S238에 따라 할당완료(St2)가 된다. 다음 노드 Nd5의 0번 버킷은 도 13의 단계S232에 따라 반환완료(St3)가 되고, 5번 버킷은 도 13의 단계S236,S238에 따라 할당완료(St2)가 된다. 다음 노드 Nd6의 1번 버킷은 도 13의 단계S232에 따라 반환완료(St3)가 된다. 따라서 도 10의 트랜잭션_액션_리스트의 트랜잭션 종료 결과, 각 버킷번호의 버킷 상태는 0번 버킷은 반환완료(St3), 1번 버킷은 반환완료(St3), 2번 버킷은 반환완료(St3), 3번 버킷은 할당완료(St2), 4번 버킷은 할당완료(St2), 5번 버킷은 할당완료(St2)가 된다.

도 14는 본 발명에서 트랜잭션 롤백 프로세스의 흐름도로, 여기서 트랜잭션 롤백(rollback)은 현재의 트랜잭션이 일어나기 이전상태로 되돌려 주는 동작이다. 이에 대해 좀더 상세하게 설명하면 다음과 같다.

트랜잭션_액션_리스트의 첫 번째 노드부터 끝 노드까지 '액션_타입'에 따라 분류하여(S300), TR_WRITE와 TR_UPDATE의 경우 '이후_버킷_번호'에 위치한 버킷의 상태_플래그와 버킷_유용성_테이블의 그 엔트리값을 반환완료로 만들어(S302), 가비지 콜렉션(Garbage collection)의 대상이 되도록 하여 섹터소거의 대상이 되게 한다. 그리고, TR_UPDATE와 TR_DELETE의 이전_버킷_번호에 위치한 버킷들 중 반환_트랜잭션_끝인 것을 초기상태의 버킷으로 버킷 복사하고 복사한 버킷의 상태_플래그를 '할당완료'로 한다(S304,S306,S308) 그리고 나서, 이전_버킷_번호에 위치한 버킷의 상태_플래그와 버킷_유용성_테이블의 엔트리값을 '반환완료'로 변환한다(S310) 반면에, 단계S306에서 반환_트랜잭션_끝이 아닌 것은 복사를 하지 않고, 곧바로 단계S310으로 넘어가 이전_버킷_번호에 위치한 버킷의 상태를 '반환완료'로 변환한다(S310).

구체적인 예를 들어 설명하면, 도 10의 트랜잭션_액션_리스트에서 데이터베이스 시스템(20)으로부터 트랜잭션 롤백의 명령을 받으면 도 14에 따라 첫번째 노드 Nd1의 2번 버킷은 '반환완료'가 된다(S302). 다음 노드 Nd2의 3번 버킷도 '반환완료'가 된다(S302). 그 다음 노드 Nd3의 4번 버킷도 '반환완료'가 되고(S302), 2번 버킷은 '반환_트랜잭션_중'이므로 버킷복사 없이 '반환완료'로 만들면 되는데, 이미 첫번째 노드 Nd1에서 변경되었다. 다음 노드 Nd5의 5번 버킷은 '반환완료'가 되고(S302), 0번 버킷은 '반환_트랜잭션_끝'이므로 그 버킷을 초기상태의 새로운 버킷을 하나 할당받아 복사하고 복사한 버킷의 상태를 '할당완료'로 한 다음(S306,S308), 복사 대상이 되었던 0번 버킷의 상태를 '반환완료'로 만든다(S310). 다음 노드 Nd6의 1번 버킷도 앞 노드 Nd5의 이전_버킷_번호에 위치한 0번 버킷과 동일하게 새로 할당받은 버킷에 복사하고 상태를 '할당완료'로 하며(S308), 1번 버 킷은 '반환완료'로 만든다(S310).

한편, 체크포인트의 시작(노드 Nd4)과 종료는 트랜잭션_액션_리스트의 버킷들에게 영향을 미치지 않으므로 아무런 동작이 없다.

도 15는 본 발명에서 트랜잭션 체크포인트 롤백 프로세스의 흐름도로, 체크포인트 롤백은 체크포인트가 시작된 후에 수행된 트랜잭션을 되돌린다. 그리고, 데이터베이스 시스템(20)의 명령에 의한 체크포인트 시작과 종료 및 롤백 사이의 '액션_타입'은 TR_UPDATE뿐이다. 트랜잭션_액션_리스트에서 노드의 액션_타입이 TR_CPBEGIN인 다음의 노드부터 차례로 이후_버킷_번호에 위치한 버킷의 상태_플래그를 '반환완료'로 처리한다(S330). 이전_버킷_번호에 위치한 버킷은 새로운 버킷을 하나 할당받아 버킷을 복사하고(S332), 이전_버킷_번호에 위치한 버킷의 상태를 판단하여(S334), 복사 대상이었던 이전_버킷_번호에 위치한 버킷이 '반환_트랜잭션_끝'이면 상태를 '할당완료'로 변경하고(S336), 반면 '반환_트랜잭션_중'이면 상태를 '할당_트랜잭션_중'으로 변경한다(S338). 위 단계S338에서 '할당_트랜잭션_중'으로 변경된 버킷은 현재 트랜잭션의 다른 상태에서 수행되었던 것이므로 전체 트랜잭션_액션_리스트의 처음부터 검색하여 '이전_버킷_번호'에 위치한 버킷번호와 동일한 것을 단계 S332에서 새로 할당받아 '할당_트랜잭션_중'으로 처리했던 그 버킷의 버킷 번호로 변경한다(S340). 마지막으로 이전_버킷_번호에 위치한 버킷을 '반환완료'로 만들고, 그 노드는 트랜잭션_액션_리스트에서 삭제한다(S342).

예를 들어, 도 10의 트랜잭션에서 노드 Nd4의 TR_CPBEGIN 명령 이후 노드 Nd5이후에 TR_CPROLLBACK의 명령이 왔다면 도 15의 단계S330에 의해 5번 버킷은 '반환완료'가 되고, 0번 버킷의 상태는 '반환_트랜잭션_끝'으로 종료한 다른 트랜잭션의 결과를 현 트랜잭션에서 변경하였으므로 새 버킷을 할당받아 버킷을 복사하고(S332), 복사한 버킷의 상태는 '할당완료'로 만들며(S334,S336), '이전_버킷_번호'에 있는 버킷은 '반환완료'로 만들고, 그 노드는 트랜잭션_액션_리스트에서 삭제하게 된다.(S338,S340,S342)

도 16은 본 발명에서 가비지 콜렉션 프로세스의 흐름도이고, 도 17은 본 발명에서 섹터에서 가비지 콜렉션이 진행되는 과정을 순차적으로 나타낸 도면으로, 이 도면들을 참조하여 버킷들의 소거 작업에 대해 구체적으로 설명하고자 한다.

데이터베이스 시스템에서 트랜잭션이 없는 상태, 즉 플래쉬 메모리에 더 이상의 입/출력이 없는 상태를 무부하(idle) 상태라 하며, 플래쉬 메모리(30)의 특성상 한번 쓰기작업을 한 영역은 소거작업을 거쳐야 다시 쓰기를 할 수 있으며, 이 소거작업은 섹터 단위로만 할 수 있다. 따라서, 무부하 상태일 때 트랜잭션 중 반환완료된 버킷들을 모아 소거(erase) 작업을 통해 그 버킷을 다시 초기상태로 만들며, 이러한 작업을 가비지 콜렉션(garbage colletion)이라 한다.

한 섹터에서 일정 수 이상의 반환완료된 버킷이 존재하면 무부하 상태에서 가비지 콜렉션이 시작된다. 구체적으로, 도 16에서 보는 바와 같이 그 섹터의 나머지 버킷들 중 할당완료된 버킷이 존재하는지를 판단하여(S400), 존재하면 그 버킷들을 읽어 그 데이터를 버퍼(buffer)에 저장한다(S402). 버퍼에 저장된 버킷의 데이터를 다른 섹터의 초기상태 버킷으로 복사하기 위하여 마지막으로 할당된 버킷번호를 체크한다(S404). 버킷 복사를 위하여 새로 할당될 버킷의 위치가 가비지 콜렉션 대상의 섹터에 포함되는지를 판단하여, 포함되면 그 섹터의 다음번 섹터를 기준으로 하여 순차적으로 초기상태의 버킷이 존재하는 위치를 찾는다(S406,S408). 반면, 새로 할당될 버킷의 위치가 가비지 콜렉션의 대상이 되는 섹터에 포함되지 않으면 단계S404에서 체크한 마지막으로 할당된 버킷의 다음번 초기상태 버킷을 복사될 버킷의 위치로 할당한다(S410). 이제 단계 S408 또는 S410에서 할당받은 초기상태의 버킷에, 단계S402에서 버퍼에 저장해둔 버킷의 데이터를 복사하고 복사된 버킷의 상태_플래그 및 버킷_유용성_테이블의 해당 엔트리값을 할당완료로 변환한다(S412). 또한, 버퍼에 저장해둔 버킷의 복사가 전부 이루어졌는지를 판단하여(S414), 전부 복사가 되지 않았다면 단계S404로 되돌아가 남은 버킷의 복사를 위하여 복사된 버킷으로부터 다음번에 위치하며 가비지 콜렉션의 대상이 아닌 섹터의 초기상태의 버킷을 할당받아 복사를 계속 진행한다(S404,S410,S412). 한편, 단계S414의 판단결과 전부 복사가 이루어져 버퍼에 더 이상 복사할 버킷이 존재하지 않으면 가비지 콜렉션 대상이 된 섹터를 소거한다(S416).

위와 같은 과정으로 진행되는 소거작업에 대해 도 17을 참조하여 좀더 부연설명하면, 도 17의 (ⅰ)와 같이 섹터 0에 일정 개수, 예컨대 12개의 반환완료된 버킷이 있고, 시스템이 무부하 상태로 진입하면 섹터 0은 가비지 콜렉션의 대상이 된다. 도 17의 (ⅰ)에서 보면 섹터 0에는 버킷들 중 할당완료된 버킷, 예컨대 버킷_ 번호 4,5,7,8의 버킷들이 존재하므로 그 버킷들의 데이터를 버퍼에 저장한다(S400,S402). 도 17의 (ⅰ)에서 마지막으로 할당된 버킷은 섹터 1의 버킷 0이므로 새로이 할당될 버킷의 위치가 가비지 콜렉션 대상의 섹터에 포함되지 않으므로, 도 17의 (ⅱ)에 도시한 바와 같이 마지막 할당된 버킷의 다음 위치부터 차례로 초기상태의 버킷, 즉 섹터 1의 버킷_번호 1,2,3,4번 버킷들을 할당하여 버퍼에 담겨진 버킷 데이터를 복사하고(S404,S406,S410,S412), 버퍼에 있는 모든 버킷들의 복사가 끝나면 도 17의 (ⅲ)과 같이 섹터 0을 소거하여 초기상태의 버킷들로만 구성된 섹터 0을 만든다(S414,S416).

이상 설명한 소거과정들을 거쳐 버킷들이 다른 장소로 옮겨졌으므로, 최종적으로 그러한 변동사항을 버킷들의 사용상태를 관리하는 버킷_유용성_테이블과 버킷_페이지_테이블을 수정하여 반영한다.

이렇게 순차적으로 초기상태의 버킷을 찾아 할당을 하는 것은 플래쉬 메모리의 쓰기횟수가 제한되어 있기 때문에 특정영역을 계속해서 쓰기보다 여러 영역을 고르게 쓰기 위함이다. 그러나, 섹터내에 반환완료된 버킷들이 일정 개수가 되지 않거나 시스템이 장시간 무부하 상태가 되지 않아 가비지 콜렉션 동작을 수행할 수 없어 반환완료된 버킷들이 다수가 있음에도 불구하고 초기상태의 버킷들로 만들 수 없는 경우가 있다. 본 발명에서는 이러한 문제를 방지하기 위하여 섹터_상태_테이블을 체크하여 '초기상태'의 섹터가 하나만 남았을 때는 무부하 상태가 아닐지라도 가장 많은 수의 반환완료된 버킷을 보유한 섹터를 찾아 가비지 콜렉션 동작을 수행하여 '초기상태'의 버킷을 확보한다.

특히, 트랜잭션 중 정전(power loss), 오류로 인한 리셋(reset)으로 램(RAM)에 있던 버킷_유용성_테이블, 버킷_페이지_테이블, 트랜잭션_액션_리스트 등의 정보가 사라진 경우 트랜잭션 중이었다면 데이터베이스 시스템(20)이 어떤 동작이었는지 논리적 메모리 인터페이스(12)에서는 알 수 없기 때문에 시스템이 오동작할 수 있다. 이에, 본 발명은 버킷-헤더(36)의 상태_플래그(36')로써 각 버킷(34)의 복구여부를 판단하여 시스템이 정상 작동할 수 있게 하며, 본 발명에서는 이를 재시작 회복이라 칭한다. 도 18은 본 발명에서 재시작 회복 프로세스의 흐름도를 나타낸 것으로, 이 도면을 참조하여 재시작 회복 작동에 대해 설명하기로 한다.

시스템을 다시 부팅(booting)시키거나 리셋(reset)되었을 때 논리적 메모리 인터페이스(12)는 전체 플래쉬 메모리(30)의 버킷-헤더(36)의 상태_플래그(36')를 읽어들여, '초기상태', '할당완료', '반환완료' 이외의 상태에 있는 버킷들이 있는가를 판단한다.(S500,S502) 이러한 상태의 버킷들이 있다면, 초기상태, 할당완료, 반환완료가 아닌 버킷들을 다음의 집합으로 분류한다.

* 집합A(종료_이전) = 집합A1(할당_트랜잭션_중) U 집합A2(반환_트랜잭션_중) U 집합A3(반환_트랜잭션_끝)

* 집합B(종료_이후) = 집합B1(할당_트랜잭션_종료) U 집합B2(반환_트랜잭션_종료)

버킷(34)의 상태_플래그(36')에 따라 위와 같이 분류하는 것은 바로 직전에 트랜잭션이 수행되었다면, 그 트랜잭션이 종료 중이었는지 아닌지를 판별하기 위함이다. 종료 중이었음을 알 수 있는 버킷(34)의 상태_플래그(36')는 도 6에 도시한 바와 같이 '반환_트랜잭션_완료'나 '할당_트랜잭션_완료'이다. 따라서, 도 18에서 보는 바와 같이 단계S502에서 판단한 결과 읽어들인 상태_플래그들이 할당완료, 반환완료, 초기상태의 버킷만으로 구성되어 있으면 이는 복구할 버킷이 없는 것이다. 그러나, 단계S502에서 할당완료, 반환완료, 초기상태가 아닌 버킷이 존재하면 이는 복구할 버킷이 있는 것으로, 그러면 그 복구할 버킷이 어디에 해당하는지를 판단하기 위해 복구할 버킷의 상태가 위에 정의한 집합 A 또는 B에 속하는지를 판단한다.(S504) 위에 정의한 집합 B에 속하는 것이 있으면 데이터베이스 시스템(20)은 종료를 진행중이며, '할당_트랜잭션_중' 및 '할당_트랜잭션_종료'인 버킷들을 '할당완료'로 처리하고 나머지 상태의 버킷들은 '반환완료'로 처리한다.(S506) 반면, 집합 B에 속하는 것이 없고 집합 A에 속하는 것이 있으면 트랜잭션 중이나 종료의 명령이 실행되지 않은 상태이므로, '할당_트랜잭션_중' 및 '반환_트랜잭션_중'은 '반환완료'로 처리하고, '반환_트랜잭션_끝'은 종료한 다른 트랜잭션의 결과를 변경한 것이므로 초기상태 버킷을 할당받아 버킷을 복사하고 그 상태를 '할당완료'로 만들고, 복사 대상이 되었던 '반환_트랜잭션_끝'의 버킷은 '반환완료'로 만든다.(S508)

예를 들어, 도 10의 트랜잭션 과정중 예기치 못한 오류로 시스템이 리셋되었다면, 정상적인 데이터베이스 시스템(20) 작동을 위해 트랜잭션이 일어나지 않은 상황으로 버킷들의 상태를 되돌려 놓아야 한다. 리셋이후 버킷들의 상태는 버킷번호 0번(St6), 1번(St6), 2번(St8), 3번(St4), 4번(St4), 5번(St4)이 된다. 이를 도 18에 나타낸 과정에 따라 복구를 하면 집합 B(종료이후)에 속한 버킷이 없으므 로 집합 A(종료_이전)의 버킷들 중 '반환_트랜잭션_끝(St6)'인 0번과 1번 버킷들을 다른 초기상태의 버킷들로 복사하고 그 상태를 '할당완료'로 만들고, 0번과 1번 버킷들의 상태를 '반환완료'로 변경한다. 그리고, 나머지 2번, 3번, 4번 및 5번 버킷은 트랜잭션에 새로이 수행된 것이므로 그 상태를 모두 '반환완료'로 만든다. 그리고 나서, 버킷_유용성_테이블과 버킷_페이지_테이블도 결과에 맞게 변환하여 준다. 그 결과, 버킷은 트랜잭션 수행 이전 상태인 0번과 1번의 버킷이 '할당완료'인 상태가 된다.

한편, 본 발명에서 물리적 메모리 인터페이스(14)는 플래쉬 메모리(30)와 직접 입/출력하는 기능을 담당하며, 논리적 메모리 인터페이스(12)에서 논리적 어드레스로 처리된 버킷을 플래쉬 메모리(30)의 물리적 어드레스로 변환하며 플래쉬 메모리 액서스(access) 콘트롤(control) 절차에 따라 플래쉬 메모리(30)와 인터페이스 한다. 이상 바람직한 실시예에서는 NOR형을 예로 들어 설명하였으나 NAND형도 동일하게 적용된다. 다만, NAND형은 하드웨어적인 구성이 NOR형과 달리 섹터대신 다수의 블록(Block)이 모여 하나의 메모리가 되고, 블록은 다수의 페이지로 구성되어 있으며, 페이지의 일반적인 크기는 512바이트(Bytes)이지만 그 크기는 제조회사에 따라 약간 다를 수 있다. 따라서, 본 발명을 NAND형에 적용하기 위해서는 블록을 섹터로, 페이지를 버킷으로 맵핑하기만 하면 된다. 예를 들어, 본 발명의 바람직한 실시예에서 데이터베이스 시스템의 페이지와 버킷이 4KB이므로 이와 동일한 시스템에서는 NAND형 메모리의 페이지 4개를 하나의 버킷으로 맵핑하면 동일하게 적용된다. 이러한 NOR형 및 NAND형 플래쉬 메모리(30)를 직접 인터페이스하는 동작은 이미 보편적으로 알려져 있기 때문에 그에 대한 상세한 설명은 생략하기로 한다. 조금 부연하자면, 플래쉬 메모리 액서스 콘트롤의 형태 및 명령의 방법은 각 플래쉬 메모리 제조회사가 제시하며 물리적 메모리 인터페이스(14)에서는 그 제시된 방법에 의해 플래쉬 메모리(30)를 콘트롤하게 된다.

이상 설명한 바와 같이, 본 발명에 따른 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템은 기존의 플래쉬 파일시스템처럼 복잡한 연산의 과정을 거치지 않고 플래쉬 메모리를 테이터베이스 시스템의 입/출력 단위인 페이지와 동일한 구조(크기)로 분할하여 이를 버킷이라 칭하고, 데이터베이스 시스템의 페이지에 대응되는 버킷을 관리함으로써 플래쉬 메모리의 특성을 고려하면서 데이터베이스 시스템의 트랜잭션 기능을 수용하여 입/출력에서 신속하고 정확한 동작이 가능하다. 나아가, 본 발명은 데이터베이스 시스템을 사용하는 휴대용 통신기기에서 파일관리라는 동일한 목적을 위해 두 개의 시스템을 사용하는 기존 방식에 비해, 구조적으로 단순하고 데이터의 처리가 빠른 잇점이 있다.

더욱이, 본 발명은 기존의 파일시스템을 사용하는 방식에서와 같이 시스템의 비정상적인 종료에 대한 복구를 위해 플래쉬 메모리에 데이터베이스 저장영역 이외에 부가적으로 데이터베이스 복구영역을 따로 두어 복구될 페이지를 트랜잭션 중에 매번 기록하는 수고를 덜었으며, 이와 같이 복구를 위한 전용공간을 할당할 필요가 없이 버킷-헤더의 상태_플래그를 관리해 줌으로써 완벽한 복구가 가능하며, 복구영역의 쓰기 비용을 줄이는 효과가 있다.

여기에서 개시되는 실시예는 여러가지 실시가능한 예 중에서 당업자의 이해를 돕기 위하여 가장 바람직한 예를 선정하여 제시한 것일 뿐, 본 발명의 기술적 사상이 반드시 이 실시예에 의해서만 한정되거나 제한되는 것은 아니고, 본 발명의 기술적 사상을 벗어나지 않는 범위 내에서 다양한 변화와 변경이 가능함은 물론, 균등한 다른 실시예가 가능하다.

Claims (21)

1. 데이터베이스 시스템과 플래쉬 메모리를 인터페이스 하기 위한 시스템으로서,

   상기 플래쉬 메모리는 상기 데이터베이스 시스템의 페이지와 크기가 동일한 버킷들로 분할되어 논리적으로 맵핑(mapping)되는 섹터들로 이루어지고, 각각의 버킷은 해당 버킷의 식별정보를 갖는 버킷헤더와 데이터를 기록하는 버킷바디로 구성되고, 상기 버킷헤더는 해당 버킷의 동작상태를 나타내는 상태_플래그와 해당 버킷에 기록된 데이터의 페이지_번호가 등록되는 것을 특징으로 하며,

   상기 플래쉬 메모리의 섹터 수만큼의 행과 각 섹터의 버킷 수만큼의 열을 가지고 상기 버킷의 상태를 나타내는 버킷_유용성_테이블과, 상기 버킷의 번호를 상기 페이지_번호에 맵핑한 버킷_페이지_테이블, 및 데이터베이스 시스템의 트랜잭션 과정을 관리하는 트랜잭션_액션_리스트를 마련하고, 상기 데이터베이스 시스템으로부터 쓰기, 읽기, 삭제의 명령과 트랜잭션의 시작, 종료, 롤백과 체크포인트의 시작, 종료, 롤백의 명령을 받아 상기 플래쉬 메모리에 입/출력하기 위한 일련의 과정을 처리하는 논리적 메모리 인터페이스; 및

   상기 논리적 메모리 인터페이스에서 처리되어 출력된 버킷의 논리적 어드레스를 상기 플래쉬 메모리의 물리적 어드레스로 변환하여, 상기 논리적 메모리 인터페이스의 처리데이터를 상기 플래쉬 메모리에 직접 입/출력하는 물리적 메모리 인터페이스를 포함하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템.
2. 제 1항에 있어서, 상기 논리적 메모리 인터페이스는 각 섹터에 기록가능한 버킷이 존재하는지를 나타내는 섹터_상태_테이블을 구비하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템.
3. 제 2항에 있어서, 상기 버킷_유용성_테이블, 상기 버킷_페이지_테이블, 상기 섹터_상태_테이블 및 상기 트랜잭션_액션_리스트는 시스템 초기화시 상기 버킷헤더의 상태_플래그 및 페이지_번호를 참조하여 구성되어 시스템 메모리에 로드(load)되는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템.
4. 제 3항에 있어서, 상기 트랜잭션_액션_리스트는 상기 데이터베이스 시스템으로부터 전달되는 진행중인 액션_타입, 페이지_번호, 이전_버킷_번호, 이후_버킷_번호를 포함하는 노드들로서 링크되어 구성되어, 트랜잭션의 수행에 관련된 정보를 표시하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템.
5. 제 3항 또는 제 4항에 있어서, 상기 버킷의 상태_플래그와 상기 버킷_유용성_테이블은 트랜잭션에 따라 버킷의 변화된 상태가 기록되며, 트랜잭션의 수행으로 상기 버킷의 상태가 변화되면 그에 따라 수정되는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템.
6. 제 5항에 있어서, 상기 상태_플래그와 상기 버킷_유용성_테이블에 기록되는 버킷상태는 초기상태, 할당완료, 반환완료, 할당_트랜잭션_중, 할당_트랜잭션_완료, 반환_트랜잭션_중, 반환_트랜잭션_끝, 반환_트랜잭션_완료로 구분되는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템.
7. 제 3항에 있어서, 상기 버킷_유용성_테이블의 첫 번째 엔트리부터 차례로 버킷의 상태를 확인하여, 그 상태가 초기상태인 버킷에 새로운 버킷을 할당하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장 시스템.
8. 데이터베이스 시스템과 플래쉬 메모리를 인터페이스 하기 위한 방법으로서,

   상기 플래쉬 메모리는 그 섹터들을 상기 데이터베이스 시스템의 페이지와 크기가 동일한 버킷들로 분할시켜 논리적으로 맵핑(mapping)하고, 각각의 버킷은 해당 버킷의 식별정보를 갖는 버킷헤더와 데이터를 기록하는 버킷바디로 구성하며, 상기 버킷헤더는 해당 버킷의 동작상태를 나타내는 상태_플래그와 해당 버킷에 기록된 데이터의 페이지_번호를 등록하고,

   상기 플래쉬 메모리의 섹터 수만큼의 행과 각 섹터의 버킷 수만큼의 열을 가지고 상기 버킷의 상태를 나타내는 버킷_유용성_테이블과, 상기 버킷의 번호를 상기 페이지_번호에 맵핑한 버킷_페이지_테이블, 및 데이터베이스 시스템의 트랜잭션 과정을 관리하는 트랜잭션_액션_리스트를 마련하고,

   상기 버킷_유용성_테이블, 상기 버킷_페이지_테이블 및 상기 트랜잭션_액션_리스트를 시스템 초기화시 상기 버킷헤더의 상태_플래그 및 페이지_번호를 참조하여 구성시켜 시스템 메모리에 로드(load)시키고, 상기 데이터베이스 시스템으로부터 쓰기, 읽기, 삭제의 명령과 트랜잭션의 시작, 종료, 롤백의 명령과 체크포인트의 시작, 종료, 롤백의 명령을 받으면 상기 버킷_유용성_테이블, 상기 버킷_페이지_테이블 및 상기 트랜잭션_액션_리스트를 참조하여 해당 명령을 처리하여 상기 플래쉬 메모리에 입/출력하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
9. 제 8항에 있어서, 상기 데이터베이스 시스템으로부터 상기 트랜잭션의 시작 명령이 있으면,

   a-1) 데이터베이스 시스템으로부터 요청된 페이지_번호를 트랜잭션_액션_리스트의 노드를 생성하여 기록하는 단계;

   a-2) 상기 데이터베이스 시스템으로부터 내려온 명령이 쓰기 명령인지를 판단하는 단계;

   a-3) 쓰기 명령이면 버킷_페이지_테이블에서 상기 요청된 페이지_번호의 엔트리값을 찾아 해당 버킷에 기존에 기록된 내용이 있는지를 확인하는 단계;

   a-4) 상기 버킷에 기록된 내용이 존재하면 변경동작으로 판정하고, 상기 버킷_페이지_테이블의 해당 페이지 엔트리값을 트랜잭션_액션_리스트의 이전_버킷_번호에 기록하는 단계;

   a-5) 상기 버킷의 상태가 할당완료인지를 버킷_유용성_테이블로부터 확인하는 단계; 및

   a-6) 상기 버킷이 할당완료 상태이면 상기 버킷_유용성_테이블과 상태_플래그를 반환_트랜잭션_끝으로 변경하고, 초기상태의 버킷을 할당받아 상기 페이지의 데이터를 기록하는 단계를 수행하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
10. 제 9항에 있어서, 상기 a-2)단계에서 쓰기 명령이 아니면 삭제 명령으로 판정하고, 상기 버킷_페이지_테이블의 해당 페이지 엔트리값을 트랜잭션_액션_리스트의 이전_버킷_번호에 기록하고, 상기 버킷의 상태가 할당완료인지를 버킷_유용성_테이블로부터 확인한 후 삭제 명령을 완료하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
11. 제 9항에 있어서, 상기 a-3)단계에서 상기 버킷에 기록된 내용이 존재하지 않으면 쓰기동작으로 판정하고, 상기 a-6)단계를 곧바로 수행하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
12. 제 9항에 있어서, 상기 a-5)단계에서 할당완료가 아닌 경우, 상기 버킷_유용성_테이블과 상태_플래그를 반환_트랜잭션_중으로 변경하고, 초기상태의 버킷을 할당받아 상기 페이지의 데이터를 기록하는 단계를 더 포함하는 데이터베이스 시스템 을 위한 플래쉬 메모리 저장방법.
13. 제 12항에 있어서, 상기 초기상태의 버킷을 할당받아 상기 페이지의 데이터를 기록하는 것은 초기상태의 버킷을 할당받아 노드의 '이후_버킷_번호'에 기록하고, 상태_플래그와 버킷_유용성_테이블을 할당_트랜잭션_중으로 변환하고, 할당받은 버킷에 상기 페이지의 데이터를 기록하는 것에 의해 수행되는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
14. 제 8항에 있어서, 상기 데이터베이스 시스템으로부터 상기 트랜잭션의 종료 명령이 있으면,

    b-1) 상기 트랜잭션_액션_리스트의 첫 번째 노드부터 마지막 노드까지 '액션_타입'에 따라 TR_UPDATE와 TR_DELETE의 '이전_버킷_번호'에 위치한 버킷의 상태_플래그와 버킷_유용성_테이블의 엔트리값을 반환_트랜잭션_완료로 변환하고, '액션_타입'에 따라 TR_WRITE와 TR_UPDATE의 '이후_버킷_번호'에 위치한 버킷번호의 버킷_유용성_테이블의 엔트리값이 할당_트랜잭션_중이면 할당_트랜잭션_완료로 변환하고 그렇지 않으면 반환_트랜잭션_완료로 변환하는 제1단계; 및

    b-2) 상기 트랜잭션_액션_리스트의 첫 번째 노드부터 마지막 노드까지 '액션_타입'에 따라 분류하고, 액션_타입 TR_UPDATE와 TR_DELETE는 '이전_버킷_번호'에 위치한 버킷의 상태_플래그와 버킷_유용성_테이블의 엔트리값을 반환완료로 변환하고, '액션_타입'이 TR_UPDATE에서 반환완료이거나 TR_WRITE인 경우, '이후_버킷_번 호'에 위치한 버킷의 버킷_유용성_테이블의 엔트리값이 할당_트랜잭션_완료이면 할당완료로 버킷_유용성_테이블과 상태_플래그를 변환하고 그렇지 않으면 반환완료로 버킷_유용성_테이블과 상태_플래그를 변환하는 제2단계를 수행하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
15. 제 8항에 있어서, 상기 데이터베이스 시스템으로부터 상기 트랜잭션의 롤백 명령이 있으면,

    c-1) 상기 트랜잭션_액션_리스트의 첫 번째 노드부터 끝 노드까지 '액션_타입'에 따라 분류하여, TR_WRITE와 TR_UPDATE의 경우 섹터소거의 대상이 되도록 '이후_버킷_번호'에 위치한 버킷의 상태_플래그와 버킷_유용성_테이블의 그 엔트리값을 반환완료로 변경하는 단계;

    c-2) TR_UPDATE와 TR_DELETE의 이전_버킷_번호에 위치한 버킷들 중 반환_트랜잭션_끝인 것을 초기상태의 버킷으로 버킷 복사하고 복사한 버킷의 상태_플래그를 '할당완료'로 변경하는 단계; 및

    c-3) 이전_버킷_번호에 위치한 버킷의 상태_플래그와 버킷_유용성_테이블의 엔트리값을 '반환완료'로 변경하는 단계를 수행하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
16. 제 15항에 있어서, 상기 c-1)단계 후 반환_트랜잭션_끝이 아닌 것은 복사를 하지 않고, 곧바로 상기 c-3)단계로 넘어가 이전_버킷_번호에 위치한 버킷의 상태 를 '반환완료'로 변환하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
17. 제 8항에 있어서, 상기 데이터베이스 시스템에서 트랜잭션이 없는 상태일 때, 한 섹터에서 일정 수 이상의 반환완료된 버킷이 존재하면 트랜잭션 중 반환완료된 버킷들을 모아 소거 작업을 통해 그 버킷을 다시 초기상태로 만드는 가비지 콜렉션(garbage colletion) 작업이 수행되는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
18. 제 17항에 있어서, 상기 가비지 콜렉션 작업은

    d-1) 섹터의 상기 반환완료된 버킷들 이외의 나머지 버킷들 중 할당완료된 버킷이 존재하는지를 판단하여, 존재하면 그 버킷들을 읽어 그 데이터를 버퍼(buffer)에 저장하는 단계;

    d-2) 상기 버퍼에 저장된 버킷의 데이터를 다른 섹터의 초기상태 버킷으로 복사하기 위하여 마지막으로 할당된 버킷번호를 체크하는 단계;

    d-3) 버킷 복사를 위하여 새로 할당될 버킷의 위치가 가비지 콜렉션 대상의 섹터에 포함되는지를 판단하여, 포함되면 그 섹터의 다음번 섹터를 기준으로 하여 순차적으로 초기상태의 버킷이 존재하는 위치를 탐색하고, 새로 할당될 버킷의 위치가 가비지 콜렉션의 대상이 되는 섹터에 포함되지 않으면 체크한 마지막으로 할당된 버킷의 다음번 초기상태 버킷을 복사될 버킷의 위치로 할당하는 단계;

    d-4) 할당받은 초기상태의 버킷에, 버퍼에 저장해둔 버킷의 데이터를 복사하고 복사된 버킷의 상태_플래그 및 버킷_유용성_테이블을 할당완료로 변환하는 단계; 및

    d-5) 전부 복사가 이루어져 버퍼에 더 이상 복사할 버킷이 존재하지 않으면 가비지 콜렉션 대상이 된 섹터를 소거하는 단계를 포함하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
19. 제 8항에 있어서, 트랜잭션 중에 정전, 오류로 인한 리셋이 발생한 경우, 버킷-헤더의 상태_플래그로써 각 버킷의 복구여부를 판단하여 시스템이 정상 작동할 수 있게 하는 재시작 회복 동작을 수행하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
20. 제 19항에 있어서, 상기 재시작 회복 동작은

    e-1) 시스템을 다시 부팅(booting)시키거나 리셋(reset)되었을 때 논리적 메모리 인터페이스는 플래쉬 메모리의 전체 버킷-헤더의 상태_플래그를 읽어들여, '초기상태', '할당완료', '반환완료' 이외의 상태에 있는 버킷들이 존재하는가를 판단하는 단계;

    e-2) 판단결과 할당완료, 반환완료, 초기상태가 아닌 버킷이 존재하면, 그 복구할 버킷이 어느 상태에 해당하는지를 판단하는 단계; 및

    e-3) 상기 복구할 버킷이 종료_이후 상태에 속하는 것이 있으면, '할당_트랜 잭션_중' 및 '할당_트랜잭션_종료'인 버킷들을 '할당완료'로 처리하고 나머지 상태의 버킷들은 '반환완료'로 처리하는 단계를 구비하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.
21. 제 20항에 있어서,

    상기 e-2)단계에서 복구할 버킷이 종료_이전 상태에 속하는 것이 있으면, '할당_트랜잭션_중' 및 '반환_트랜잭션_중'은 '반환완료'로 처리하고, '반환_트랜잭션_끝'은 초기상태 버킷을 할당받아 버킷을 복사하고 그 상태를 '할당완료'로 만들고, 복사 대상이 되었던 '반환_트랜잭션_끝'의 버킷은 '반환완료'로 변경하는 단계를 구비하는 것을 특징으로 하는 데이터베이스 시스템을 위한 플래쉬 메모리 저장방법.

Images