KR100493732B1 - 비휘발성 메모리내의 코드/데이터 경계를 조정가능하게하는 장치 및 방법 - Google Patents

Abstract

비휘발성 메모리내의 경계를 이동하는 방법이 기재되어 있다. 이 방법은 비휘발성 메모리내의 경계 위치를 식별하는 단계를 포함한다. 경계 위치는 제1 타입의 제1 블록과 제2 타입의 제2 블록 사이의 위치를 포함한다. 이 방법은 또한 제1 타입의 최종 블록으로부터 제1 타입의 제2 블록으로 객체를 할당하는 단계를 포함한다. 또한, 이 방법은 제1 타입의 최종 블록을 소거하는 단계를 포함한다.

Description

비휘발성 메모리내의 코드/데이터 경계를 조정가능하게 하는 장치 및 방법{METHOD AND APPARATUS TO PERMIT ADJUSTABLE CODE/DATA BOUNDARY IN A NONVOLATILE MEMORY}

본 발명은 컴퓨터 메모리 저장 시스템 분야에 관한 것이다. 특히, 본 발명은 동일한 비휘발성 메모리 내에서 코드/데이터 경계(boundary)를 조정가능하게 저장하기 위한 장치 및 방법에 관한 것이다.

셀룰러 전화기 및 호출기와 같은 통신 장치에는 데이터와 코드를 모두 저장할 수 있는 능력이 필요하다. 또한, 통상적으로 통신 장치는 약간의 작업 메모리를 필요로 한다.

이들 통신 장치는 일반적으로 비휘발성 메모리에 코드 및 적어도 약간의 데이터를 저장할 필요가 있다. 예를 들면, 일련 번호, 인증 코드, 자주 거는 번호 등이 비휘발성 메모리에 저장되어야 할 데이터의 예들이다. 코드 및 데이터가 상이한 빈도로 갱신된다면, 통신 장치는 데이터 및 코드의 저장을 위해 상이한 타입의 비휘발성 메모리를 사용해야 할 것이다. 따라서, 통상적으로 종래 기술에 따른 통신 장치는 코드 저장을 위한 일 형태의 비휘발성 메모리, 데이터 저장을 위한 다른 비휘발성 메모리, 및 작업 메모리를 위한 SRAM(static random access memory)과 같은 RAM을 포함한다.

비휘발성 메모리의 하나의 형태로 플래시 EEPROM(flash electrically erasable programmable read only memory)이 있다. 플래시 EEPROM(이하, "플래시 메모리")은 통상적으로 단일 트랜지스터 메모리 셀 블록으로 배열된다. 플래시 메모리는 재기록가능(rewritable) 하지만, 메모리 셀이 먼저 소거되지 않으면 재프로그램될 수 없다. 또한, 그 셀들은 블록단위로만 소거가능하다. 따라서, 하나의 셀을 소거하기 위해서, 셀의 전체 블록이 소거되어야 한다. 플래시 메모리의 갱신은 동일한 블록 또는 다른 블록에 대한 갱신 정보 뿐만 아니라, 블록 외의 유효 정보의 카피, 블록의 소거 및 유효 정보 기록을 제어하는 일부 형태의 매체 관리자(media manager)를 필요로 한다. 소거(erasing), 기록(writing) 등의 처리는 비교적 시간이 소모되는 과정이다.

비휘발성 메모리의 다른 형태로 2-트랜지스터 메모리 셀을 가진 EEPROM(electrically erasable programmable read only memory)이 있다. EEPROM은 플래시 메모리와 유사한 소거가능 블록으로 배열될 수 있지만, 2-트랜지스터 EEPROM은 비교적 갱신하기 쉽고, 갱신을 위해 플래시 메모리에서 필요로 하는 복잡한 매체 관리를 필요로 하지 않는다. 그러나, 2-트랜지스터 EEPROM에 값을 기록하는 것은 소거된 단일 트랜지스터 플래시 메모리 셀의 프로그래밍보다 상당히 많은 시간을 필요로 한다.

종래 기술에 따른 통신 장치 메모리 구조의 하나는 코드 저장을 위한 플래시 메모리, 데이터 저장을 위한 EEPROM, 및 작업 메모리로서의 RAM을 포함한다.

다양한 비휘발성 메모리의 사용은 설계 및 제조 비용 뿐만 아니라 형성 팩터 사이즈(form factor size)를 증가시키는 경향이 있다. 호출기 및 셀룰러 전화기와 같은 개인 통신 장치는 그들의 크기에 따라 특징, 비용 및 전력 소모율이 달라진다.

또한, 새로운 특징들이 계속 부가됨에 따라, 코드 대 데이터 비율이 변경될 필요가 있다. 코드 및 데이터 모두에 대한 저장 요구의 증가가 예상되지 않는다면, 두 타입의 비휘발성 메모리에 대해 여분의 저장소를 제공하는 것은 장치의 비용을 증가시키고 낭비적이다. 코드 및 데이터를 상이한 타입의 비휘발성 메모리에 저장함으로써, 코드에 사용된 비휘발성 메모리내의 잉여 저장 용량은 데이터 저장을 위해 사용될 수 없다. 유사하게, 데이터에 사용된 비휘발성 메모리내의 잉여 저장 용량은 코드 저장을 위해 사용될 수 없다. 따라서, 이러한 설계는 코드에 할당된 비휘발성 메모리 대 데이터에 할당된 비휘발성 메모리의 비율의 변경을 쉽게 수용할 수 없었다.

본 발명은 첨부된 도면에서 제한이 아닌 예시적인 방법으로 도시되어 있고, 여기서, 동일한 참조부호는 유사한 구성요소를 나타낸다.

도1은 동일한 모놀리식 비휘발성 메모리 장치에서의 코드 및 데이터의 저장을 도시한 도면.

도2는 비휘발성 메모리 블록에서의 객체의 저장을 도시한 도면.

도3은 객체 헤더 구조를 도시한 도면.

도4는 복수 인스턴스 저장 구조를 도시한 도면.

도5는 시퀀스 테이블 엔트리 및 상태값을 도시한 도면.

도6은 연관된 데이터 프래그먼트의 위치 및 순서를 식별하기 위한 시퀀스 테이블의 이용을 도시한 도면.

도7은 연관된 시퀀스 테이블 프래그먼트의 위치 및 순서를 식별하기 위한 그룹 데이블의 이용을 도시한 도면.

도8a는 데이터 룩업 테이블을 생성하는 방법을 도시한 도면.

도8b는 데이터/코드 경계를 식별하기 위한 최종 논리 데이터 블록의 이용을 도시한 도면.

도8c는 코드 부분을 확장하기 위한 과정의 일실시예를 도시한 도면.

도8d는 데이터 부분을 확장하기 위한 과정을 도시한 도면.

도9는 인스턴스의 최소수(m), 할당 입도(g), 최대 단일 인스턴스 사이즈(S*g) 및 최대 시퀀스 테이블 사이즈를 포함하는, 다수의 임계값에 대한 데이터 사이즈(z)에 따라 저장 구조를 선택하는 방법을 도시한 도면.

도10은 단일 인스턴스 객체를 기록하는 방법을 도시한 도면.

도11-12는 복수 인스턴스 객체를 기록하는 방법을 도시한 도면.

도13-15는 객체를 다수의 데이터 프래그먼트로 저장하는 방법을 도시한 도면.

도16은 최종 시퀀스 테이블 프래그먼트에 충분한 여분이 있을 경우에 프래그먼트화된 객체에 추가하기 위한 방법을 도시한 도면.

도17-19는 프래그먼트화된 객체의 선택된 프래그먼트를 대체하기 위한 방법을 도시한 도면.

도20은 비휘발성 메모리내의 공간을 교정하기 위한 방법을 도시한 도면.

발명의 요약

비휘발성 메모리내의 경계를 이동하는 방법이 기재되어 있다. 이 방법은 비휘발성 메모리내의 경계 위치를 식별하는 단계를 포함한다. 경계 위치는 제1 타입의 제1 블록 및 제2 타입의 제2 블록 사이의 위치를 의미한다. 이 방법은 또한 객체를 제1 타입의 최종 블록으로부터 제1 타입의 제2 블록으로 할당하는 단계를 포함한다. 또한, 이 방법은 제1 타입의 최종 블록을 소거하는 단계를 포함한다.

본 발명의 다른 특징 및 장점들은 첨부된 도면 및 이하에 따르는 발명의 상세한 설명으로부터 명확해질 것이다.

도1은 모놀리식 비휘발성 메모리 장치(110)에서의 코드 및 데이터의 저장을 도시하고 있다. 일실시예에서, 비휘발성 메모리는 다수의 개별적으로 소거가능한 블록들을 포함한다. 데이터 및 코드 부분에 할당된 공간의 크기는 동일한 블록을 공유하지 않는 데이터 및 코드 부분과 같은 길이로 하나 또는 그 이상의 블록을 스패닝(spanning)할 수 있다.

비휘발성 메모리 장치(110)는 부트 코드(112) 부분, 데이터 저장(114) 부분, 예비(spare) 블록(116), 및 코드 저장(118) 부분을 포함한다. 예비 부분(116)은 비휘발성 메모리 장치의 실제 물리 블록이다. 후술되는 바와 같이, 논리 블록 번호는 예비 블록이 데이터 부분(114)내에서 물리 블록이 될 수 있도록 사용된다.

예비 블록(116)은 무효 컨텐츠에 사용된 공간을 비워두도록 나머지 블록을 소거하기 전에, 또다른 블록의 유효 컨텐츠를 복귀하기 위한 교정(reclamation) 과정 동안에 사용된다. 플래시 메모리의 특성, 및 블록을 소거하는데 요구되는 비교적 긴 시간으로 인해, 교체될 데이터는 비휘발성 메모리내의 새로운 위치에 기록된다. 이전 버전의 데이터는 무효화되고, 그후, 무효 데이터와 연관된 공간은, 블록내의 유효 데이터를 예비 블록으로 카피한 후에 그 블록을 소거함으로써 교정될 수 있다. 소거 후에, 소거된 블록이 새로운 예비 블록이 된다.

도1은 또한 비휘발성 메모리(110)에 연결된 RAM(130) 및 플래시 매체 관리자(140)를 도시하고 있다. 일실시예에 있어서, 플래시 매체 관리자(140)는 데이터/코드 경계(120)의 이동을 제어하고, 이로써, 코드 저장부(118)가 확대되거나 또는 대안적으로 데이터 저장부(114)가 확장되도록 한다. 다른 실시예에서는. 비휘발성 메모리 장치(110)에 연결된 프로세서(미도시)가 데이터/코드 경계(120)의 이동을 제어하여, 이에 따라, 코드 저장부(118)가 확장되거나, 또는 대안적으로 데이터 저장부(114)가 확장되도록 한다. 또 다른 실시예에서는, 비휘발성 메모리 장치(110)에 연결된 제어기(미도시)가 데이터/코드 경계(120)의 이동을 제어하여, 이에 따라, 코드 저장부(118)가 확장되거나, 또는 대안적으로 데이터 저장부(114)가 확장되도록 한다.

도2는 도1의 데이터 저장(114) 부분에 할당되는 개별적인 블록 중의 하나 안에 데이터가 어떻게 저장되고 식별되는지를 나타내고 있다. 할당될 수 있는 공간의 최소량은 단위 입도(unit granularity) 또는 단순 입도(simply granularity)로 언급된다. 저장될 데이터는 하나 또는 그 이상의 입도 단위를 스패닝하는 개별적인 영역으로 할당된다. 이들 각 영역이 하나의 객체로 언급된다. 예를 들면, 블록(210)은 객체 1, 2, 및 3을 포함한다. 블록내의 각 객체는 객체 헤더(object header)에 의해 식별된다. 따라서, 예를 들면, 헤더1(212)은 객체1(222)을 식별하고, 헤더2(214)는 객체2(224)를 식별하고, 헤더3(216)은 객체3(226)을 식별한다.

헤더는 블록의 제1 끝단으로부터 블록의 제2 끝단까지 연속적으로 진행되는 선택 블록에 기록된다. 각 헤더에 연관된 객체는 블록의 제2 끝단으로부터 블록의 제1 끝단측으로 연속적으로 진행되는 블록에 기록된다. 따라서, 추가 객체 및 헤더가 블록(210)에 저장됨에 따라, 헤더 및 객체는 서로를 향해 "증가(grow)"된다.

각 블록(210)은 또한 블록 정보 구조(240)를 갖는다. 블록 정보 구조(240)는 논리 블록 번호(logical block number)(244)를 저장하고, 블록(210)에 대한 교정 상태(reclamation status)(242)를 탐지한다. 논리 블록 번호(244)의 사용은 실제적인 물리 블록의 접근없이 정보를 논리 접근적으로 저장되도록 한다.

교정 동안에, 교정이 예정된 유효 컨텐츠는, 교정 예정된 블록이 소거되기 전에, 다른 블록으로 카피되어야 한다. 일실시예에서, 블록 정보 구조는, 교정 동안에 카피중인 물리 블록을 나타내기 위한 물리 카피(physical copy)(246)를 포함한다. 이것은, 예를 들어, 정전에 의해 카피가 중단되는 경우. 복귀 절차를 위해 유용하다. 또한, 물리 카피(246) 필드는, 예를 들어, 정전으로 인해 소거 동작이 중단된 경우에, 소거되는 과정에 있는 블록들의 식별을 돕는다.

블록 정보 구조(240)는 또한 무결성(integrity) 필드(248)를 포함한다. 무결성 필드는 블록 정보 구조(210) 자체의 무결성을 보장하는데 사용된다. 일실시예에 있어서, 블록에 데이터를 기록한 후에, 그 블록이 유효 데이터를 포함하고 있다는 것을 나타내기 위해, "f0f0" 값이 무결성 필드(248)에 기록된다.

블록 정보 구조는 또한 현재 블록이 데이터를 포함하고 있는 최종 물리 블록이라는 것을 나타내기 위한 최종 데이터 블록 필드(250)를 포함한다. 최종 데이터 블록 필드(250)는 비휘발성 메모리의 데이터 저장 부분에서 데이터를 포함하고 있는 최종 블록을 식별한다.

도3은 헤더 데이터 구조(300)의 일실시예를 도시하고 있다. 헤더 데이터 구조는 식별자(302), 상태(304), 타입(306), 사이즈(308) 및 오프셋(310) 필드를 포함한다. 식별자(302) 필드는 연관된 객체를 식별한다. 예를 들면, 식별자는 데이터에 대한 이름 또는 번호(예, 파라미터 "X" 또는 "5631")가 될 수 있다.

상태(304) 필드는 헤더 및 객체의 상태를 탐지하는데 사용된다. 헤더 및 객체의 상태는, 아래에 논의되는 바와 같이, 전력 손실 복구를 수행할 때 뿐만 아니라 RAM 룩업 테이블을 만들 때에 사용된다. 데이블(320)은 상태 필드에 대한 상태 지정의 일실시예를 나타내고 있다.

사이즈(308)는 복수 할당 단위로 객체의 사이즈를 나타낸다. 따라서, 최소 할당 단위(즉, 입도)가 4Kb인 경우에, 8 사이즈는 객체가 사이즈로 32Kb라는 것을 나타낸다.

오프셋(310)은 블록 내에서 객체의 위치를 식별하는데 사용된다. 일실시예에서, 오프셋(310)은, 입도 단위로 블록의 바닥으로부터 측정되는 객체의 오프셋을 나타내는 포인터이다.

타입(306)은 객체의 타입 및 구조를 나타내는데 사용된다. 일실시예에서, 타입(306)의 제1 부분은 소정의 객체 구조를 식별하는데 사용된다. 타입의 제2 부분은 소정의 객체 구조의 컨텐츠(즉, 그 구조 내에 저장된 데이터의 타입)를 식별한다. 소정의 객체 구조는 객체 사이즈 범위 뿐만 아니라 객체의 예상 휘발성에서의 변화를 수용하도록 설계된다.

데이터의 타입은 일반적으로 애플리케이션에 대해 특정된다. 일실시예에서, 비휘발성 메모리 장치는 셀룰러 전화기 또는 호출기와 같은 무선 통신 장치를 지원한다. 통신 애플리케이션을 위한 데이터 타입의 일례는 데이터 파라미터(예, 통신의 길이, 시작점 및 출발점을 탐지하기 위한), 데이터 스트림, 전화번호, 팩스번호 등, 또는 그 밖의 유저-정의가능(user-definable) 타입을 포함한다.

테이블 번호(312)는 프래그먼트화된 데이터를, 프래그먼트화된 데이터의 위치를 탐지하는데 사용된 테이블과 연관시키는데 사용된다. 테이블 번호(312)의 이용은, 후술되는 바와 같이, 프래그먼트화된 객체에 변경이 이루어질 때에, 발생되어야 할 갱신 량을 최소화하는데 사용된다.

일실시예에서, 소정의 객체 구조는, 복수 인스턴스 객체, 단일 인스턴스 객체, 데이터 프래그먼트, 시퀀스 테이블, 시퀀스 테이블 프래그먼트 및 그룹 테이블을 포함한다.

단일 인스턴스 객체가 블록 내에 전체적으로 피트(fit)될 수 있다. 단일 인스턴스 객체는 다수의 할당 입도로 할당된다. 단일 인스턴스 객체는 블록을 스패닝하도록 인정되지 않는다. 단일 인스턴스 객체로서 저장된 데이터를 검색하기 위해서는, 단지 단일 인스턴스 객체의 위치를 결정하기 위한 헤더를 검사한 후, 단일 인스턴스 객체 자체를 검색할 필요가 있다.

객체를 저장하는데 본래 할당된 동일한 공간을 이용하여 여러 번 갱신될 수 있는 비교적 작은 사이즈의 데이터를 저장하기 위해 복수 인스턴스 단위가 설계된다. 이것은 특히 변수와 같이 자주 갱신되는 데이터에 유용하다.

도4는 복수 인스턴스 객체(400)의 구조를 도시하고 있다. 동일한 할당 공간 내에 복수 인스턴스를 제공하는 것은 작은 데이터 파라미터를 관리하는데 오버헤드를 줄이고, 갱신 성능을 향상시킨다.

복수 인스턴스 객체(400)는 복수 인스턴스 객체내의 각 인스턴스의 사이즈 및 인스턴스의 수를 나타내는 인스턴스 정보(410)를 포함한다. 인스턴스 정보(410)에 이어 다수의 상태 필드(422, 432, 442, 452)가 있다. 각 상태 필드는 객체의 하나의 인스턴스와 연관된다. 따라서, 예를 들면, 상태(422)는 인스턴스(420)에 적용된다. 상태(432)는 인스턴스(430)에, 상태(442)는 인스턴스(440)에, 그리고 상태(452)는 인스턴스(450)에 적용된다. 다양한 상태 조건에 대한 상태 지정의 일실시예가 테이블(460)에 제시되어 있다.

또 다른 객체 구조는 데이터 프래그먼트이다. 일부 객체는 다수 블록의 가용한 공간 내에 저장되기 위해 프래그먼트화되어야 한다. 이것은, 예를 들면, 객체가 블록보다 큰 경우에 필요할 수 있다. 대안적으로, 객체가 주어진 블록내의 나머지 공간보다 큰 경우에 프래그먼트화가 필요할 수 있다. 따라서, 데이터 스패닝 물리 블록 경계(data spanning physical block boundaries)는 복수 데이터 프래그먼트로 프래그먼트화될 것이다. 이들 각 프래그먼트는 데이터 프래그먼트 객체로 언급된다. 데이터 프래그먼트 객체는 본래 데이터의 프래그먼트를 포함하지만, 그 밖의 오버헤드 정보는 포함하지 않는다. 다수의 데이터 프래그먼트로부터 본래 데이터를 재조립(reassemble)하기 위해 데이터 프래그먼트의 순서화된 리스트를 포함하는 시퀀스 테이블이 사용된다.

도5는 시퀀스 테이블 프래그먼트의 각 엔트리에 대한 구조 및 각 엔트리에 대한 상태값을 도시하고 있다. 엔트리는 로직 블록 번호(512), 엔트리 상태(514), 인스턴스(516), 데이터 프래그먼트 사이즈(518), 적용가능한 경우, 데이터 프래그먼트의 이전 버전 사이즈(520), 및 물리 인덱스(522)에 대한 필드를 포함한다. 엔트리 상태에 사용된 상태값은 테이블(560)에 도시되어 있다. 인스턴스는 객체가 동일한 블록에 저장된 하나 이상의 데이터 프래그먼트를 갖는 경우에 특정 데이터 프래그먼트를 식별하기 위해 사용된다.

도6은 시퀀스 테이블(616) 및 시퀀스 테이블과 연관된 모든 데이터 프래그먼트를 조립하는(assembling) 과정을 도시하고 있다. 이에 따라, 예를 들면, 파라미터 X는 물리 블록(610, 620)에 위치되는 다수의 데이터 프래그먼트(614, 626, 628)로 프래그먼트화된다. 대응하는 헤더(612, 622, 624)는 시퀀스 테이블(616)을 식별하기 위해 설정된 각 테이블 번호(312) 필드를 갖는다.

시퀀스 테이블(616)은 완전한 파라미터 X를 재조립하기 위해 사용되는 데이터 프래그먼트 인스턴스 및 논리 블록을 리스팅(listing)한다. 동일한 블록내의 복수 파라미터 X 데이터 프래그먼트는 그 블록내의 발생(occurrence) 또는 인스턴스 뿐만 아니라 그와 연관된 특정 시퀀스 테이블에 의해 구별된다. 시퀀스 테이블에서의 엔트리의 순서는, 완전한 파라미터(X)를 형성하기 위해 데이터 프래그먼트가 수집되어야하는 순서를 나타낸다.

예를 들면, 파라미터 X 객체를 재조립하기 위해서, 파라미터 X 시퀀스 테이블 헤더에 대한 검색이 수행된다(단계1). 일실시예에서, 파라미터 X 시퀀스 테이블 헤더의 위치는, 파라미터의 검색 속도를 향상시키기 위해, 데이터 룩업 테이블에 저장된다. 이 경우에, 데이터 룩업 테이블은 파라미터 X 시퀀스 테이블 헤더가 논리 블록0(610)에 위치된다는 것을 나타낸다.

파라미터 X 시퀀스 테이블 헤더의 위치를 정하기 위해, 논리 블록0이 스캔된다. 파라미터 X 시퀀스 테이블 헤더는 파라미터 X 시퀀스 테이블(616)의 위치를 식별한다(단계2). 시퀀스 테이블(616)의 각 엔트리는 파라미터 X를 재구성하는데 필요한 시퀀스 테이블에 연관된 데이터 프래그먼트의 인스턴스 및 논리 블록을 식별한다.

시퀀스 테이블(616)은, 제1 데이터 프래그먼트가 논리 블록0에 위치된 시퀀스 테이블(616)에 연관된 파라미터 X 데이터 프래그먼트의 제1 인스턴스인 것을 나타낸다. 따라서, 파라미터 X 데이터 프래그먼트를 논리 블록0(610)에서 616의 테이블 번호로 식별하는 제1 헤더를 검색함으로써, 제1 데이터 프래그먼트의 위치가 결정된다(단계3). 이 경우에, 파라미터 X 데이터 프래그먼트를 논리 블록0(610)에서 616의 테이블 번호로 식별하는 제1 헤더는 헤더(612)이다. 그후, 헤더(612)는 파라미터 X 데이터 프래그먼트의 위치결정에 사용된다(단계4).

시퀀스 테이블(616)을 참조하면, 다음의 파라미터 X 데이터 프래그먼트는 논리 블록1에서의 제2 파라미터 X 데이터 프래그먼트로 결정된다. 따라서, 논리 블록1은 파라미터 X 데이터 프래그먼트 헤더의 제2 발생의 위치결정을 위해 검색될 수 있다(단계5). 헤더(624)는 단계6에 도시된 바와 같이 파라미터 X 데이터 프래그먼트(626)의 위치를 식별한다.

최종 파라미터 X 데이터 프래그먼트는 논리 블록1(620)에서의 제1 파라미터 X 데이터 프래그먼트로 결정된다. 따라서, 논리 블록1은 파라미터 X 데이터 프래그먼트 헤더의 제1 발생의 위치결정을 위해 검색된다. 이 예에서, 파라미터 X 데이터 프래그먼트 헤더의 제1 발생은 단계(7)에 나타난 헤더(622)이다. 파라미터 X 데이터 프래그먼트 헤더(622)는 단계(8)에 도시된 바와 같이 제3 및 최종 파라미터 X 데이터 프래그먼트(628)의 위치를 식별한다.

파라미터가 많은 수의 데이터 프래그먼트를 갖는 경우, 시퀀스 테이블은 물리 블록 경계를 스패닝할 필요가 있다. 대안적으로, 데이터 프래그먼트의 수는 소정의 임계값을 초과하는 시퀀스 테이블 사이즈를 필요로 할 수 있다. 복수 논리 또는 물리 블록에 대한 접근을 유지하도록 시도하거나, 또는 시퀀스 테이블을 소정의 임계값 이상으로 증가를 허용하는 대신에, 다른 시퀀스 테이블이 생성된다. 일실시예에서, 이 소정의 임계값은 단일 인스턴스 객체에 허용된 최대 사이즈이다. 시퀀스 테이블의 사이즈가 증가함에 따라, 블록을 갱신할 때에 시퀀스 테이블을 카피하는데 필요한 시간의 양이 그 만큼 증가된다.

시퀀스 테이블이 데이터 프래그먼트를 탐지하는데 사용되는 것과 거의 동일한 방식으로, 그룹 테이블이 개별적인 시퀀스 테이블을 탐지하는데 사용된다. 그룹 테이블 및 복수 시퀀스 테이블의 사용은 또한 시퀀스 테이블의 카피를 관리하는데 필요한 시간을 감소시킬 수 있다. 그룹 테이블은 큰 시퀀스 테이블을 다수의 보다 작은 시퀀스 테이블 프래그먼트로 효과적으로 프래그먼트화한다. 복수 시퀀스 테이블이 그룹 테이블과 함께 사용될 때, 개별적인 시퀀스 테이블은 시퀀스 테이블 프래그먼트로 식별된다.

도7은 시퀀스 테이블 프래그먼트와 함께 그룹 테이블(716)의 사용을 도시하고 있다. 그룹 테이블(716)은 시퀀스 테이블 구조와 유사하지만, 식별된 프래그먼트는 그들 자신이 그 객체에 연관된 데이터 프래그먼트의 순서 및 위치를 식별하는 시퀀스 테이블 프래그먼트이다. 따라서, 그룹 테이블(716)의 각 엔트리는 데이터 프래그먼트의 그룹을 간접적으로 식별한다.

파라미터 X를 검색하기 위해, 파라미터의 그룹 테이블 헤더가 먼저 위치결정된다. 이 경우에, 파라미터 X 그룹 테이블 헤더는 논리 블록0(710)에서 발견된다. 그룹 테이블 헤더(712)는 그룹 테이블(716)을 식별한다. 그룹 테이블(716)의 각 엔트리는 시퀀스 테이블 프래그먼트의 인스턴스 및 위치를 식별한다.

그룹 테이블(716)은 제1 시퀀스 테이블 프래그먼트가 논리 블록0에 위치된 파라미터 X 시퀀스 테이블 프래그먼트의 제1 인스턴스라는 것을 나타낸다. 이것은 논리 블록0(710)에서 파라미터 X 시퀀스 테이블 프래그먼트를 식별하는 제1 헤더를 검색함으로써 위치결정된다. 이 경우에, 논리 블록0에서 파라미터 X 시퀀스 테이블을 식별하는 제1 헤더는 헤더(718)이다. 그리고 나서, 헤더(718)는 파라미터 X 시퀀스 프래그먼트(714)의 위치결정에 사용될 수 있다.

시퀀스 테이블 프래그먼트(714)는 제1 데이터 프래그먼트가 논리 블록1(720)에 위치된 시퀀스 테이블 프래그먼트(714)에 연관된 파라미터 X 데이터 프래그먼트의 제1 인스턴스라는 것을 나타낸다. 따라서, 논리 블록(720)은 시퀀스 테이블(714)을 나타내도록 설정된 데이블 번호를 갖는 파라미터 X 데이터 프래그먼트 헤더(724)의 제1 인스턴스의 위치결정을 위해 검색된다. 위치된 헤더는 파라미터 X 데이터 프래그먼트(730)의 위치를 식별한다. 시퀀스 테이블(714)에 연관된 제2 및 제3 데이터 프래그먼트는 도시되지 않았다.

그룹 테이블(716)에 나타난 제2 및 제3 시퀀스 테이블 프래그먼트는, 그룹 테이블에 의해 나타난 순서로 헤더(726, 722)를 찾아서 제2(726) 및 제3(732) 시퀀스 테이블 프래그먼트 각각의 위치결정하는데 그 헤더를 이용함으로써, 유사하게 위치결정될 수 있다. 주어진 시퀀스 테이블내의 엔트리는 동일한 시퀀스 테이블을 식별하는 헤더를 가진 데이터 프래그먼트 인스턴스와 관련된다. 따라서, 예를 들면, 상이한 시퀀스 테이블에 연관된 많은 데이터 프래그먼트가 동일한 블록에 위치결정될 수 있다. 그러나, 객체를 재조립하기 위해 시퀀스 테이블을 트래버싱(traversing)할 때, 동일한 시퀀스 테이블 프래그먼트를 공유하는 것 이외의 인스턴스는 무시된다.

일실시예에서, 비휘발성 메모리 장치의 액세스 성능을 향상시키기 위해 데이터 룩업 테이블이 사용된다. 컴퓨터 시스템에서 구현될 때, 룩업 테이블은 비휘발성 메모리 내에 저장된 데이터의 액세스를 용이하게 할 수 있다. 데이터 룩업 테이블은 컴퓨터 시스템의 초기와 동안에 RAM에 내장되고, 기록 및 소거 동작 동안에 적절하게 갱신된다. 데이터 룩업 테이블은 특정 블록에 대한 포인터, 및 특정 식별자를 갖는 데이터에 대해 선택된 헤더에 연관된 오프셋을 제공한다.

일실시예에서, 데이터 룩업 테이블은 데이터에 대한 인덱스로서 식별자를 사용한다. 대안적 실시예에서, 데이터 룩업 테이블은 데이터에 대한 인덱스로서 타입 및 식별자를 모두 사용한다. 후자의 실시예는 식별자와 타입의 조합이 유일(unique)하다면, 비-유일성(non-unique) 식별자의 사용을 허용한다. 또한, 후자의 실시예는 데이터의 식별자보다는 데이터의 타입에 기반한 빠른 검색이 가능하다.

데이터 룩업 테이블 생성 과정의 일실시예가 도8a에 도시되어 있다. 단계(810)에서 초기화가 시작된다. 단계(820)에서, 유효 단일 인스턴스 헤더, 시퀀스 테이블 헤더, 복수 인스턴스 헤더 및 그룹 테이블 헤더에 대해 물리 블록이 스캔된다. 데이터 프래그먼트는 무시된다. 유사하게, 시퀀스 테이블 프래그먼트는 무시된다.

단일 인스턴스 헤더, 시퀀스 테이블 헤더, 복수 인스턴스 헤더 또는 그룹 테이블 헤더가 발견된 경우(단계(830)), 그 헤더에 연관된 데이터에 대한 타입 및 논리 블록 번호(예, 논리 블록0, 파라미터 X)가 룩업 데이블에 저장된다(단계(840)). 일실시예에서, 식별자는 룩업 테이블에 명시적으로 저장된 값이라기 보다는 룩업 테이블내의 위치에 대응하는 번호이다. 결과적으로, 식별자는 룩업 테이블내의 엔트리 위치를 계산하는데 사용된다. 그리고 나서, 그 식별자에 대한 논리 블록 번호 및 타입은 계산된 위치로 룩업 테이블에 저장된다. 다른 실시예에서, 타입은 데이터 룩업 테이블에 저장되지 않는다. 대안적으로, 데이터 룩업 테이블은 그 헤더에 연관된 데이터에 대한 타입, 논리 블록 번호 및 식별자를 명시적으로 저장할 수 있다. 이러한 헤더가 더이상 위치되지 않을 때까지 스캐닝 과정이 계속되고, 이 과정은 단계(890)에서 종료된다.

데이터 룩업 테이블은 그룹 테이블 객체, 시퀀스 테이블 객체, 복수 인스턴스 객체 및 단일 인스턴스 객체에 대한 헤더를 식별한다. 파라미터 X를 검색하기 위해, 비휘발성 메모리내의 모든 블록의 헤더를 스캐닝하기 보다는, 먼저 데이터 룩업 테이블이 참조될 수 있다. 개별적인 데이터 프래그먼트 및 시퀀스 테이블 프래그먼트는 룩업 테이블에 목록되지 않는다.

블록내 가용 공간의 빠른 판단을 용이하게 하기 위해, 논리 블록 테이블이 RAM에 저장된다. 논리 블록 테이블은 논리-물리 블록 변환 맵을 제공하며, 초기화동안에 생성된다. 초기화 동안에, 가용 공간의 크기 및 무효 공간(즉, 무효 객체 및 헤더에 의해 사용된 공간)의 크기를 결정하기 위해 각 물리 블록이 스캔된다. 이 정보는 비휘발성 메모리 장치내의 각 블록에 대해 수집되고, RAM의 논리 블록 상태 테이블에 저장된다. 그리고 나서, 논리 블록 테이블은 비휘발성 메모리 장치에 대한 후속 동작을 위해 갱신될 수 있다.

일실시예에 있어서, 모놀리식 비휘발성 메모리 장치의 포맷(formatting) 및 초기 분할(partition) 동안에, 적어도 하나의 예비 블록을 포함한, 많은 블록들이 데이터와 별도로 설정된다. 예비 블록을 제외하고, 데이터 부분내의 각 블록은 블록 정보 구조를 포함할 수 있다. 대안적 실시예에 있어서, 초기 포맷 동안에, 최종 데이터 블록 필드(250)는 최종 논리 블록을 제외한 모든 블록에 대해 "0"으로 설정된다. 최종 논리 블록(즉, 데이터 부분에서 가장 높은 논리 블록 번호를 가진 데이터 블록)의 최종 데이터 블록 필드(250)는 "1"로 설정된다. 이에 따라, 예를 들면, D 블록이 데이터 부분과 별도로 설정된다. D번째 블록의 최종 블록 필드(250)는 "1"로 설정될 것이다. 시스템에서 가용 예비 블록의 수가 M인 경우, 데이터 부분은 D+M 블록으로 구성될 것이다. M=1인 시스템에서, 데이터/코드 경계는 (D+1)번째 블록과 다음 블록 사이가 된다.

초기 분할 과정 후에, 예비 블록은 데이터 부분을 통해 플로팅(floating)할 수 있다. 유사하게, 블록들이 교정 및 수정됨에 따라, 최종 논리 블록이 데이터 부분을 통해 플로팅할 수 있다. 모놀리식 메모리 장치의 초기 분할화(partitioning) 후에, 데이터/코드 부분의 위치결정을 위해 최종 데이터 블록 필드가 사용된다.

도8b는 데이터/코드 경계를 식별하기 위한 최종 논리 데이터 블록 필드의 이용을 도시하고 있다. 데이터 부분내의 블록의 수를 식별하기 위한 요구가 단계(805)에서 수신된다. 통상적으로, 비휘발성 메모리는 다수의 블록을 포함할 것이다. 이어서, 단계(815)에서, 데이터 부분의 제1 물리 블록이 선택된다. 단계(825)는 블록 정보 구조가 선택된 블록에 존재하는지를 판단한다. 예를 들면, 예비 블록은 블록 정보 구조를 갖지 않는다. 일실시예에 있어서, 무결성 필드(248)는 블록이 실제로 블록 정보 구조를 포함하는지를 확인하는데 사용될 수 있다.

블록 정보 구조가 발견되지 않는 경우, 이 과정은 단계(835)로 진행되어, 다음의 가용 물리 블록을 선택한다. 일실시예에서, 다음의 물리 블록은 물리 블록 번호에 대응하는 값을 증가 또는 감소시킴으로써 선택된다. 단계(825-835)는 블록 정보 구조를 가진 블록이 위치결정될 때까지 블록들이 가용하다면 반복된다.

선택된 블록이 블록 정보 구조를 갖는 경우, 단계(845)에서 최종 논리 데이터 필드(250)가 "1"로 설정되었는지를 판단한다. 만일, 그렇지 않다면, 다른 블록이 단계(835)에서 선택되고, "1"로 설정된 최종 데이터 블록 필드(250)를 가진 블록이 위치결정될 때까지, 이 과정은 단계(825, 835, 845)로 진행된다.

단계(855)에서, 최종 데이터 블록 필드(250)가 위치결정되고, 데이터/코드 경계가 식별된다. 특히, 데이터 부분의 물리 블록의 수는, 데이터 부분에서 사용된 예비 블록 수를 선택된 블록의 블록 정보 구조에서 나타난 논리 블록 수에 더함으로써 식별된다. 코드 부분이 데이터 블록내의 최종 물리 블록에 뒤따르고, 이에 따라, 데이터 부분의 최종 물리 블록이 결정되고 나면, 데이터/코드 경계가 식별될 수 있다.

예를 들면, 일실시예에 있어서, 데이터 부분은 1개의 예비 블록과 4개의 다른 물리 블록으로 구성된다. 초기 분할 과정 동안에, 4번째 물리 블록의 최종 데이터 블록 필드(250)가 "1"로 설정될 것이다. 그러나, 데이터 부분에서의 공간의 교정 또는 수정 후에, 논리 블록 번호는 더이상 물리 블록 번호와 일치하지 않는다. 이에 따라, 예를 들면, 논리 블록4가 물리 블록2에 저장될 수 있다. 따라서, "1"로 설정된 최종 데이터 블록 필드(250)를 가진 물리 블록이 물리 블록2가 될 것이다.

도8b의 방법을 적용하면, 데이터 부분의 최종 물리 블록은, 물리 블록2의 논리 블록 수와 예비 블록 수를 더함으로써 결정될 수 있다. 이 경우에, 물리 블록2에 대한 논리 블록 번호는 4가 되고, 예비 블록 수는 1이 된다. 따라서, 최종 물리 데이터 블록은 블록5이다.

데이터/코드 경계의 식별은 코드 부분을 축소함으로써 데이터 부분의 확장을 허용한다. 대안적으로, 데이터/코드 경계의 식별은 데이터 부분을 축소함으로써 코드 부분의 확장을 허용한다. 일실시예에 있어서, 코드는 인접하게 저장된다. 따라서, 인접성(contiguity)을 유지하기 위해, 전체 코드 부분이 연속하도록 코드 부분이 확장된다. 코드 부분의 인접 확장은 데이터/코드 경계에서 데이터 부분내의 가용 물리 블록을 필요로 한다. 따라서, 데이터 부분내의 데이터는, 데이터/코드 경계가 더이상 데이터 저장이 필요하지 않을 때까지 재위치될 필요가 있다.

도8c는 코드 부분을 확장하는 과정의 일실시예를 도시하고 있다. 코드 확장 요구가 수신되면, 단계(807)에서 이 과정이 시작된다. 이어서, 단계(817)에서 최종 논리 데이터 블록이 위치결정 된다. 일실시예에 있어서, "1"로 설정된 최종 데이터 블록 필드(250)를 가진 블록을 판단함으로써, 최종 논리 블록이 위치결정 된다. 단계(817)에서 최종 논리 블록이 위치결정된 후에, 단계(827)가 처리된다.

단계(827)에서, 최종 논리 데이터 블록내의 객체가 데이터 부분내의 다른 블록으로 재 위치결정된다. 다른 객체의 재 위치결정은 시퀀스 테이블을 대체 또는 갱신을 필요로 한다. 일실시예에 있어서, 재위치결정 과정 동안, 정전되는 경우에서 복구 과정을 가능하게 하기 위해, 재위치 결정된 후에 최종 논리 데이터 블록내에서 객체들이 무효로 표시된다. 다른 실시예에 있어서, 최종 논리 블록내의 데이터는 데이터 부분내의 빈 블록으로 이동된다. 또 다른 실시예에 있어서, 최종 논리 블록내의 데이터는 부분적으로 빈 블록으로 이동된다.

객체가 단계(827)에서 재위치 결정된 후에, 단계(837)에서 최종 논리 블록으로 두 번째 교정된다. 교정 과정 동안에, 최종 논리 블록에 대한 두 번째 최종 데이터 블록 필드(250)가 "1"로 설정된다. 예를 들면, 블록4가 가장 높은 번호의 논리 블록인 경우, 이 논리 블록 번호를 가진 블록이 교정되고, 블록의 최종 데이터 블록 필드(250)가 "1"로 설정된다. 그리고 나서, 최종 논리 블록의 블록 무결성 지시자가 단계(847)에서 수정될 수 있다. 일실시예에 있어서, 최종 논리 블록의 블록 무결성 지시자는 최종 논리 블록의 무결성 필드(248)를 "0"값으로 설정함으로써 수정된다. 대안적 실시예에 있어서, 무결성 필드(248)를 "0"으로 설정하기 전에 전력 손실이 발생된 경우, 최종 논리 블록 및 두 번째 최종 논리 블록 모두가 "1"로 설정된 최종 데이터 블록 필드(250)를 가진다. 따라서, 최종 논리 블록은 가장 높은 논리 블록 번호를 가진 블록으로써 식별된다. 식별된 최종 논리 블록은 단계(847)에 따라 수정된다. 이어서, 단계(857)가 진행된다.

단계(857)에서, 최종 논리 블록이 소거되어, 이에 따라, 두 번째 최종 논리 블록(단계(837)에서 식별된)이 최종 논리 블록이 된다. 블록 정보 구조는 소거된 블록에 기록되지 않는다. 이어서, 단계(867-887)에서, 소거 또는 예비 블록이 코드 데이터 경계로 이동되고, 단계(899)의 초기화 동안에, 코드 부분의 확장이 완료된다. 일실시예에서, 초기화 동안에, 신규 데이터/코드 경계는 소거된 블록 또는 예비 블록이 코드 부분의 일부가 되도록 결정될 것이다.

단계(867)를 참조하면, 소거된 데이터 블록 또는 예비 블록이 데이터. 코드 경계에 있지 않은 경우, 데이터 부분의 최종 물리 블록이 재 위치결정될 것이다. 이것은 이미 거기에 저장되어야 할 논리 블록을 재 위치결정하는 중간 단계를 필요로 한다.

단계(867)에서, 소거된 블록 또는 예비 블록이 데이터/코드 경계에 있는지를 판단한다. 예를 들면, 일실시예에 있어서, 그 블록이 예비 블록인지 또는 소거된 블록인지를 판단하기 위해, 데이터/코드 경계(즉, 최종 물리 데이터 블록)에서의 데이터 블록의 무결성 필드(248)가 조사된다. 두 블록 모두가 데이터/코드 경계에 있지 않은 경우, 단계(877)에서, 데이터/코드 경계에서의 블록은 예비 블록으로 카피된다. 그리고 나서, 단계(887)에서, 데이터/코드 경계에서의 블록이 예비 블록으로 교정된다. 따라서, 데이터/코드 경계에서의 블록이 최종 논리 데이터 블록이 아닌 경우, 필요에 따라, 최종 논리 데이터 블록을 그 위치로 이동하기 위한 준비 중에, 예비 블록을 데이터 부분의 최종 물리 블록으로 이동하도록 논리 블록들이 조정된다. 이제 데이터 부분내의 최종 물리 블록이 코드 부분으로 사용가능하고, 데이터/코드 경계가 도8a의 과정을 이용하여 위치결정되면, 코드 부분에 속하는 것으로 식별될 것이다.

일실시예에 있어서, 도8c에 도시된 코드 확장 단계는 전력 복구 동작(미도시)을 더 포함한다. 전력 복구 동작은 정전 타이밍에 기반하여 코드 확장 단계의 복구를 허용한다. 상세히 말하면, 단계(837) 동안의 전력 손실 경우에, 전력 리턴 단계(837)가 완료된 후, 두 번째 최종 블록의 최종 데이터 블록 필드(250)가 "0"으로 설정되고, 단계(807-809)가 재처리된다. 단계(837) 후에 정전이 발생한 경우, 전력 리턴 단계(847-899)가 진행된다. 단계(847 또는 857) 동안에 정전이 발생한 경우, 전력 리턴 후의 두 경우에, 데이터 부분내의 예비 블록이 소거되고, 단계(877-899)가 진행된다.

도8d는 데이터 부분의 확장 과정을 도시하고 있다, 일실시예에 있어서, 유저는 코드 부분내의 최종 물리 블록이 코드 저장에 사용되지 않았다는 것을 확인할 필요가 있다. 대안적 실시예에 있어서, 도8d에서의 단계의 처리 동안에 정전이 발생한 경우에는 전력 손실 복구 단계가 필요하지 않는다. 대신에, 데이터 부분 확장 동안에 발생된 정전을 복구하기 위해, 단계(806-846)가 간단히 재 진행된다.

데이터 부분 확장 요구가 수신되면, 단계(806)에서, 과정이 시작된다. 이어서, 단계(816)에서 데이터/코드 경계에 인접한 코드 블록을 선택한다. 단계(816)에서 선택된 코드 블록은 단계(826)에서 소거된다.

단계(836)에서, 블록 구조 정보가 소거된 블록에 기록된다. 일실시예에서, 기록된 블록 구조 정보는 가장 높은 번호의 논리 블록에 1을 더한 것과 같은 논리 블록 수를 포함한다. 이에 따라, 소거된 블록이 최종 논리 블록이 된다. 4개의 데이터 블록의 이전의 예에 이어, 소거된 블록은 5개의 논리 블록 수를 포함한다. 따라서, 논리 블록 수가 4인 데이터 블록이 이전 논리 블록이 된다. 다른 실시예에 있어서, 기록된 블록 구조 정보는 최종 데이터 블록 필드(250)를 "1"로 설정하는 것을 포함한다. 최종 데이터 블록 필드를 "1"로 설정하는 것은, 소거된 블록이 데이터/코드 경계가 결정될 때에, 초기화 동안에 최종 데이터 블록으로 식별될 것이라는 것을 보장한다. 또 다른 실시예에 있어서, 기록된 블록 구조 정보는 블록 무결성 필드에 값을 기록하는 것을 포함하여, 이에 따라, 소거된 블록이 이제 데이터 부분의 유효 블록이라는 것을 나타내게 된다.

단계(846)에서, 이전의 최종 논리 블록의 최종 데이터 블록 필드(250)가 "0"으로 설정된다. 최종 데이터 블록 필드(250)를 "0"으로 설정하는 것은, 이전의 최종 논리 블록이 데이터/코드 경계가 결정될 때에, 초기화 동안에 최종 데이터 블록으로 식별될 것이라는 것을 보장한다. 따라서, 일실시예에 있어서, 단계(846)는 모놀리식 메모리 장치의 초기화가 뒤따른다.

일실시예에서, 기록될 데이터에 대한 저장 구조는 자동적으로 선택된다. 비휘발성 메모리 내에 할당될 수 있는 공간의 최소량이 단위 입도로 언급된다. 가장 많이 가용 공간을 가진 블록이 신규 객체를 기록할 후보로 선택된다. 저장될 데이터에 대한 저장 구조의 선택은 후보 블록내의 가용 공간 및 임계수에 대한 데이터의 사이즈에 기반한다.

수반되는 오버헤드를 갖는 복수 인스턴스의 소정의 최대 수(m)가 1 입도 단위(g)내에 피트될 수 있는 경우, 복수 인스턴스 구조가 선택된다. m*z + 오버헤드(g)인 경우, 복수 인스턴스 데이터 구조가 선택될 수 있다. 이러한 경우라면, 복수 인스턴스 데이터 구조가 선택될 것이다.

도4에 도시된 실시예에서, 오버헤드는 1바이트 인스턴스 사이즈, 1바이트 인스턴스 수, 및 각 인스턴스에 대한 1/2 바이트를 포함한다. g=128 바이트 및 m=3인 경우에, 복수 인스턴스 단위 구조는 z가 42 바이트와 같거나 또는 작다면, 복수 인스턴스 단위 구조가 선택될 수 있다. 따라서, 예를 들면, 40 바이트 사이즈 데이터는 복수 인스턴스 구조로 저장될 수 있다.

복수 인스턴스 구조에서 인스턴스의 수는 m으로 제한되지 않는다. 복수 인스턴스 구조가 선택되면, 인스턴스 사이즈(402)는 z 이고, 인스턴스 수(404)(k)는 "int(x)"가 x의 정수 성분을 리턴하도록 "int"가 정수 함수를 나타내는 경우에, 작거나 같은 값으로 계산된다.

이 경우에, 상태 필드로 인해, 오버헤드는 인스턴스 수(k)의 함수이다. 결과적으로, k는 f가 인스턴스 수에 독립적인 오버헤드의 고정 부분을 나타내고, v가 각 인스턴스에 추가되는 오버헤드 양을 나타내는 경우로 계산된다. 복수 인스턴스 오버헤드의 고정 부분은 2 바이트이고, 단위 인스턴스 오버헤드(per instance overhead)는 5 바이트이다. 이에 따라, 이 예에서, 7 바이트 파라미터는 복수 인스턴스 구조에서 16 인스턴스까지 가질 수 있다.

복수 인스턴스 구조에 부적합한 경우, 최대 단일 인스턴스 사이즈가 초과되지 않는 한, 데이터는 단일 인스턴스 객체로 저장될 수 있다. 일실시예에서, 최대 단일 인스턴스 사이즈는 많은 최대 할당 단위로 표현된다. 따라서, 단위 입도(g)가 128 바이트인 경우, 4단위/프래그먼트의 최대 단일 인스턴스 사이즈는, 데이터 사이즈가 512 바이트를 초과하는 경우에 데이터가 프래그먼트화되어야 하는 것을 나타낸다. 또한, 데이터 사이즈가 후보 블록내의 가용 공간의 크기(z)보다 작은 경우, 데이터가 프래그먼트화되어야 한다. 데이터 사이즈가 512 바이트보다 작은 경우, 데이터는 충분한 공간이 가용하다면 단일 인스턴스 단위로 저장될 수 있다. 수학적으로 표현하면, 단일 인스턴스 객체 구조는 zmin(s*g,z)(여기서, ab라면 min(a,b)=a, 그렇지 않으면 b) 길이로 선택된다.

데이터 사이즈가 최대 단일 인스턴스 사이즈보다 큰 경우, 데이터는 프래그먼트화되어야 한다. 가능하면, 데이터 프래그먼트는 최대 단일 인스턴스 사이즈만한 크기가 될 것이다. 데이터는 데이터 프래그먼트 및 시퀀스 테이블을 이용하여, 최대 시퀀스 테이블 사이즈를 초과하지 않는 결과로서 생성된 테이블의 사이즈와 같은 길이로 저장된다. 그렇지 않은 경우, 데이터는 데이터 프래그먼트, 시퀀스 테이블 프래그먼트 및 그룹 테이블을 이용하여 저장된다.

일실시예에서, 사용되는 데이터 구조에 대한 판단은 자동화된다. 도9는 비휘발성 메모리에 데이터를 먼저 저장하기 위해 사용되는 객체 구조를 결정하는 과정이 도시되어 있다. 단계(910)에서 데이터 기록 요구가 수신된다. 통상적으로, 비휘발성 메모리는 다수의 블록을 포함할 수 있다. 저장 시스템의 사용 동안에, 블록들은 다른 크기의 가용 공간을 가질 수 있다. 신규 데이터 객체를 저장할 때에, 단계(912)에서 최대 가용 공간 크기를 갖는 블록이 선택된다.

단계(920)에서와 같이 판단되는 경우, 단계(922)에서 복수 인스턴스가 저장 구조로 선택된다. 그렇지 않으면, 과정은 단계(930)로 진행된다.

단계(930)에서와 같이 z가 최대 단일 인스턴스 사이즈보다 작거나 같다고 판단되면, 단계(932)에서 단일 인스턴스 구조가 선택된다. 단일 인스턴스 구조는, z가 s*g 최대 단일 인스턴스 사이즈가 되도록 입도 단위(g)의 최소 정수가 할당된다. z가 최대 단일 인스턴스 사이즈를 초과하는 경우, 데이터가 프래그먼트화되어야 한다. 단계(934)에서 데이터를 저장하는데 필요한 프래그먼트의 수가 결정된다.

필요한 프래그먼트 수가, 단계(940)에서 판단된 것과 같이, 시퀀스 테이블에 대한 최대 사이즈를 초과하는 경우, 단계(942)에 나타난 바와 같이, 데이터가 프래그먼트화되어, 시퀀스 테이블 프래그먼트 및 그룹 테이블을 이용하여 저장된다. 그렇지 않으면, 단계(944)에 나타난 바와 같이, 시퀀스 테이블을 이용하여 데이터가 저장된다. 대안적 실시예에서는, 개별적인 시퀀스 테이블이 없고, 이에 따라, z가 최대 단일 인스턴스 사이즈를 초과할 때마다 그룹 테이블 및 시퀀스 테이블 프래그먼트가 사용된다. 다시 말해서, 점선(946)으로 나타낸 바와 같이, 이 과정은 그룹 테이블, 시퀀스 테이블 프래그먼트 및 데이터 프래그먼트를 이용하여 데이터를 저장하는 단계(942)로 진행된다.

단일 인스턴스 객체를 기록하는 과정이 도10에 도시되어 있는데, 이 과정은 단계(1010)로 시작한다. 단계(1020)에서, 최대 가용 공간 크기를 갖는 블록이 위치결정 된다. 단계(1030)에서, 객체에 대한 헤더가 "allocating(할당중)" 상태로 기록된다. 헤더가 성공적으로 기록된 후에, 단계(1032)에서 그 단계는 "header written(헤더 기록됨)"으로 변경된다.

단계(1040)에서, 객체를 기록하는 과정이 초기화된다. 객체의 일부만이 기록되고 있는 경우, 그 부분은 객체의 이전-존재 버전으로 대응 부분을 교체하는 것으로 취급된다. 교체되지 않는 부분은 이전-존재한, 유효 버전과 동일할 것이다. 따라서, 객체의 신규 버전을 기록하는 것은 교체되지 않는 이전-존재한, 객체의 유효 버전 부분들의 카피를 필요로 한다. 객체의 신규 버전의 헤더 상태는, 이 객체가 기록되었다는 것을 나타내기 위해, 단계91042)에서 "allocated(할당됨)"로 변경된다.

그리고 나서, 이전-존재한, 객체의 "유효(valid)" 버전은 단계(1050)에서 무효화된다. 단계(1060)에서, 기록될 객체에 대한 상태가 "valid(유효)"로 변경된다. 최종적으로, 데이터 룩업 테이블이 단계(1070)에서 갱신된다.

복수 인스턴스 객체를 기록하는 과정은 단계(1110)로 시작하는, 도11-12에 도시된 것과 같다. 단계(1112)에서 동일한 식별자를 갖는 기-존재 복수-인스턴스 객체가 있는지를 판단한다. 만일, 존재하면, 이 과정은 기-존재 복수-인스턴스 객체내의 가용 엔트리를 활용할 수 있다.

동일한 이름을 가진, 기-존재 복수 인스턴스 객체가 존재하는 경우, 이 과정은 단계(1112)로 진행된다. 단계(1114)는 1)z가 각 인스턴스에 대해 가용한 공간의 최대 크기인지, 2)적어도 하나의 엔트리가 기록될 객체에 남아있는지를 판단한다. 두 조건이 모두 만족하면, 이 기록 동작은 가용한 복수 인스턴스 객체 엔트리를 이용할 수 있다. 그렇지 않으면, 단계(1120-1132)에서, 새로운 복수 인스턴스 객체가 기록되어야 한다.

단계(1120)에서, 복수 인스턴스 객체를 저장할 충분한 공간을 가진 블록을 검색함으로써, 새로운 복수 인스턴스 객체의 처리가 시작된다. 대안적 실시예에서는, 최대 크기의 자유 공간을 가진 블록이 선택된다.

단계(1122)에서, 복수 인스턴스 객체 헤더는 "allocating" 상태로 기록된다. 이 상태는, 헤더가 성공적으로 기록되었다는 것을 나타내기 위해, 단계(1124)에서 변경된다. 단계(1130)에서 복수 인스턴스 데이터 구조의 기록이 시작된다.

단계(1140)에서, 복수 인스턴스 구조내의 제1 가용 엔트리가 복수 인스턴스 객체의 저장을 위해 선택된다. 도12를 참조하면, 단계(1210)에서, 선택된 엔트리의 상태가 "allocating"으로 변경된다. 단계(1220)에서 선택된 엔트리에 대한 객체의 기록이 시작된다. 그리고 나서, 단계(1222)에서, 선택된 엔트리의 상태가 "valid"로 변경된다.

이제 객체의 인스턴스가 저장된다. 단계(1230)에서 가용 엔트리가 현재의 복수 인스턴스 객체 구조에서의 제1 엔트리인지를 판단한다. 만일, 그렇지 않다면, 이 과정은 복수 인스턴스 객체내의 이전 엔트리를 무효화하기 위해 단계(1232)로 진행된다. 그리고 나서, 복수 인스턴스 객체의 갱신 과정은 단계(1290)에서 완료된다.

선택된 엔트리가 복수 인스턴스 객체에서 제1 엔트리인 경우, 동일한 식별자를 갖는 기-존재 객체를 무효화하고, 새로운 복수 인스턴스 객체를 유효화하기 위해, 부가적인 단계(1240-1270)가 수행된다. 단계(1240)에서, 복수 인스턴스 객체 상태가 "allocated"로 변경된다. 단계(1250)에서, 동일한 식별자를 갖는 기-존재 객체가 무효화된다(상태 = "invalid"). 그리고 나서, 단계(1260)에서, 새로운 복수 인스턴스 객체의 상태가 "valid"로 변경된다. 단계(1270)에서, 새로운 복수 인스턴스 객체의 생성은 룩업 테이블의 갱신을 필요로 한다. 그후, 단계(1290)에서, 복수 인스턴스 객체 저장 고정이 완료된다.

도13-15는 기록될 데이터의 사이즈 z가 모든 프래그먼트에 할당가능한 최대 사이즈 s*g를 초과할 때에, 다수의 데이터 프래그먼트로 객체를 기록하는 과정을 도시하고 있다. 일실시예에서, s는 복수의 입도로 표현된 최대 단일 인스턴스 객체 사이즈이다. 이 과정은 단계(1310)에서 시작한다.

단계(1320)에서, 충분한 자유 공간을 가진 블록이 그룹 테이블을 기록하도록 선택된다. 일실시예에서, 객체가 최대 사이즈 s*g를 초과하도록 허용되지 않고, 이에 따라 s*g 사이즈의 객체를 저장할 수 있는 블록이 그룹 테이블을 저장하기 위한 블록으로 선택될 수 있다. 일실시예에서, 최대 크기의 가용 자유 공간을 가진 블록이 선택된다.

단계(1322)에서, 그룹 테이블 헤더가 "allocating" 상태로 기록된다. 그룹 데이블 헤더를 기록한 후에, 단계(1324)에서 상태가 "header written(헤더 기록됨)"으로 변경된다.

단계(1330)에서, 현재 블록에 시퀀스 테이블 프래그먼트를 생성할 충분한 공간이 있는지를 판단한다. 현재 블록은, 이것이 객체에 대한 제1 시퀀스 테이블 프래그먼트인 경우에 그룹 테이블이 생성되었던 동일한 블록이다. 그렇지 않으면, 현재 블록은 최종 데이터 프래그먼트가 기록되었던 블록이다.

현재 블록내에 충분하지 않은 공간이 있는 경우, 단계(1332)에서, 최대 가용 공간을 가진 블록이 다음의 시퀀스 테이블 프래그먼트를 기록할 시퀀스 테이블 블록으로 선택된다. 그렇지 않으면, 단계(1334)에서, 현재의 블록이 다음의 시퀀스 테이블 프래그먼트를 기록할 시퀀스 테이블 블록으로 선택된다.

시퀀스 테이블 블록이 선택되고 나면, 단계(1340)에서, 시퀀스 테이블 프래그먼트 헤더가 "allocating" 상태로 기록된다. 헤더가 성공적으로 기록된 후에, 단계(1342)에서, 상태는 "header written"으로 변경된다.

도14는 각 데이터 프래그먼트를 기록하는 과정을 도시하고 있다. 일실시예에서, 객체가 완전히 저장될 때까지 가능한 한 큰 프래그먼트를 선택함으로써 데이터가 저장된다. z ≤g, g < z ≤ s*g, 또는 z > s*g 의 3가지 가능성이 있다.

단계(1410)에서 나머지 데이터로부터 k 사이즈의 프래그먼트를 선택하는데, 여기서, k는 1)최대 프래그먼트 사이즈 s*g 또는 2) 저장될 나머지 데이터의 크기 z 보다 작다.

단계(1420)는 최종 데이터 프래그먼트가 기록되었던 블록내에 충분한 공간이 있는지를 판단한다. 저장될 나머지 데이터의 크기가 최대 프래그먼트 사이즈(예, 1 입도 단위 g)보다 작은 경우, 데이터 프래그먼트는 여전히 z ≤g 이더라도 저장을 위한 1 입도 단위를 필요로 할 것이다. g < z ≤s*g 인 경우, 저장에 가용한 적어도 j 입도 단위가 존재해야 하며, 여기서, j는 z ≤j*g ≤s*g 가 되도록 하는 정수이다. z > s*g 인 경우, 사이즈 s*g의 데이터 프래그먼트를 저장하는데 이용가능한 충분한 공간이 존재해야 한다.

만일, 그렇다면, 단계(1422)에서 최종 데이터 프래그먼트가 기록되었던 블록이 다음의 데이터 프래그먼트를 기록하도록 선택된다. (이것이 주어진 객체에 대한 제1 데이터 프래그먼트인 경우, 시퀀스 테이블 프래그먼트가 위치결정될 블록은 "최종 데이터 프래그먼트가 기록되었던" 블록으로 간주된다.) 그렇지 않으면, 단계(1424)에서, 다음의 데이터 프래그먼트를 기록하기에 충분한 공간을 가진 다른 블록이 선택된다.

단계(1430)에서, 데이터 프래그먼트 헤더는 "allocating" 상태로 기록된다. 단계(1432)에서, 상태는 "header written" 상태로 변경된다. 단계(1440)에서 데이터 프래그먼트의 기록을 시작한다. 데이터 프래그먼트가 기록된 후에, 단계(1442)에서, 데이터 프래그먼트의 상태는 "allocated"로 변경된다. 그리고 나서, 데이터 프래그먼트에 대한 시퀀스 테이블 엔트리는 "valid" 상태로 기록된다. 그후, 이 과정은 도15로 진행된다.

도15를 참조하면, 단계(1510)에서 저장될 데이터가 남아있는지를 판단한다. 만일, 그렇다면, 이 과정은 단계(1520)로 진행되어, 다른 엔트리가 현재의 시퀀스 테이블 프래그먼트에 추가될 수 있는지는 판단하게 된다. 현재 시퀀스 테이블 프래그먼트가 가득차지 않았다면, 프로세싱은 도14의 단계(1410)로 진행되어, 데이터의 저장 및 프래그먼트화를 계속할 수 있다. 현재 시퀀스 테이블 프래그먼트에 여유 공간이 존재하지 않는다면, 단계(1570)에서, 현재의 시퀀스 테이블 프래그먼트 헤더 상태는 "allocated"로 변경된다. 그리고 나서, 새로운 시퀀스 테이블 프래그먼트를 생성하기 위해, 도13의 단계(1330)로 리턴된 후에, 이 과정은 데이터의 프래그먼트화 및 저장을 진행한다.

단계(1510)에서 저장될 데이터가 남아있지 않은 경우, 단계(1530)에서, 현재의 시퀀스 테이블 프래그먼트 헤더 상태는 "allocated"로 변경된다. 이 점에서, 모든 객체의 데이터 프래그먼트가 저장되고, 그룹 테이블 및 시퀀스 테이블 프래그먼트로 위치결정될 수 있다. 단계(1532)에서 객체의 그룹 테이블에 연관된 모든 데이터 프래그먼트의 상태를 "valid"로 변경한다.

그리고 나서, 단계(1540)에서, 객체의 기-존재 "유효" 버전이 무효화된다. 단계(1542)에서, 객체의 현재 버전에 연관된 모든 시퀀스 테이블 프래그먼트는 "valid"로 변경된 상태를 갖는다. 그리고 나서, 단계(1550)에서, 객체의 현재 버전에 대한 그룹 테이블의 상태는 "valid"로 변경된다. 그후, 단계(1560)에서, 룩업 테이블(예, 데이터 룩업 테이블)이 갱신된다. 그리고 나서, 단계(1590)에서, 객체를 다수의 데이터 프래그먼트로 기록하는 과정이 완료된다.

도10의 단계(1050), 도12의 단계(1250) 및 도15의 단계(1540)에 제시된 객체의 유효한 이전 버전을 무효화하는 과정은 객체 구조에 따라 다르다. 유효한 이전 버전으로 하기 위해, 객체의 헤더는 "valid" 상태 및 기록될 데이터와 동일한 식별자를 가져야 한다. 객체의 2 버전이 상이한 객체 구조를 갖는 경우, 이전 버전은 완전히 무효화되어야 한다.

복수 인스턴스 객체 또는 단일 인스턴스 객체를 무효화하는 것은 단지 그 객체에 대한 상태를 "invalid"로 변경하는 것을 필요로 한다. 그러나, 프래그먼트화된 객체를 무효화하는 것은 각 데이터 프래그먼트, 각 시퀀스 테이블 프래그먼트 엔트리, 각 시퀀스 테이블 프래그먼트 및 그룹 테이블을 무효화해야 한다.

단일 인스턴스 객체 및 복수 인스턴스 객체의 생성 및 갱신은 일반적으로 객체의 이전 버전의 교체를 필요로 한다. 따라서, 예를 들면, 단일 인스턴스 객체에 대한 수정은 단일 인스턴스 객체의 이전 버전을 무효화하고, 새로운 객체의 기록을 초래할 수 있다. 복수 인스턴스 객체에 대한 수정은, 객체의 신규 버전을 기록하기 위해, 이전 엔트리 또는 이전의 복수 인스턴스 객체 구조 중의 어느 하나에 대한 무효화를 초래할 수 있다. 따라서, 단일 인스턴스 객체의 수정 또는 복수 인스턴스 객체의 선택된 인스턴스의 수정은 통상적으로 적합한 객체의 인스턴스 또는 이전 버전의 분해를 초래한다.

프래그먼트화된 객체에 대한 수정은 특정 데이터 프래그먼트 또는 단지 소수의 데이터 프래그먼트에만 영향을 줄 수 있다. 그러나, 변경은 영향을 받은 시퀀스 테이블 프래그먼트 및 그룹 테이블에 연결될 수 있다. 그러나, 플래시 메모리의 특성으로 인해, 시퀀스 테이블 프래그먼트 및 그룹 테이블이 적절히 수정되지 못할 수 있다.

이러한 목표를 달성하기 위한 하나의 방법은 매 시간마다 객체를 재기록하는 것이다. 그러나, 이러한 기술은 적은 양의 데이터가 갱신될 필요가 있는 경우에 비효율적이 될 수 있다. 플래시 메모리의 특성은 소거 및 카피에 소비되는 시간을 없애기 위해 가능한 한 적게 갱신을 하려는 경향이 있다. 일실시예에서는, 단지 영향을 받은 시퀀스 테이블 프래그먼트, 그룹 테이블 및 데이터 프래그먼트가 교체된다.

객체에 대한 통상적인 수정은 객체의 끝단에 추가하거나, 또는 객체의 일부를 교체하는 것을 포함한다. 도16은 최종 시퀀스 테이블 프래그먼트가 더 많은 데이터 프래그먼트를 수용할 수 있는 충분한 엔트리 공간을 갖는 경우, 객체의 끝단에 추가하는 과정을 도시하고 있다.

단계(1610)에서, 객체의 최종 데이터 프래그먼트가 위치결정 된다. 단계(1612)에서, 사이즈 k의 프래그먼트가 추가될 나머지 데이터로부터 선택된다. 단계(1620)에서, 프래그먼트를 수용할 충분한 저장 공간을 가진 블록이 위치결정 된다. 단계(1612 및 1620)는 도14의 단계(1410 및 1424)와 동일한 조건으로 수행된다.

단계(1622)에서, 추가될 시퀀스 테이블에 연관된 선택 블록에서의 유효 프래그먼트의 수가 카운트된다. 그리고 나서, 단계(1630)에서 시퀀스 테이블 엔트리는 "allocating" 상태로 기록된다. 그후, 단계(1632)에서, 시퀀스 테이블 엔트리 상태는 "entry written"으로 변경된다.

단계(1634)에서, 데이터 프래그먼트 헤더는 데이터 프래그먼트 상태가 "allocating"이라는 것을 나타내도록 기록된다. 이 상태는 단계(1636)에서 "header written"으로 변경된다. 단계(1640)에서 데이터 프래그먼트 자체의 기록을 시작한다.

데이터 프래그먼트가 기록된 후에, 단계(1642)에서, 데이터 프래그먼트 상태가 "allocated"로 변경된다. 그리고 나서, 단계(1644)에서, 데이터 프래그먼트 상태가 "valid"로 변경된다.

단계(1650)에서 추가될 남은 데이터가 존재하는지를 판단한다. 만일, 그렇다면, 추가될 남은 데이터가 없을 때까지 단계(1612-1642)가 반복된다. 데이터가 저장된 후에, 단계(1670)에서, 새로운 시퀀스 테이블 엔트리의 상태가 "valid"로 변경된다. 현재의 시퀀스 테이블에 충분한 공간이 존재하면, 단계(1690)에서, 추가 과정이 종료된다.

도17-18은 프래그먼트화된 객체의 일부를 일대일 프래그먼트로 교체하는 과정을 도시하고 있다(즉, 하나의 프래그먼트가 단지 하나의 다른 프래그먼트로 교체된다). 일반적으로, 교체된 데이터 프래그먼트는 무효화될 것이다. 이와 연관된 시퀀스 테이블 프래그먼트는 데이터 프래그먼트의 교체 위치로 재 기록되어야 한다. 유사하게, 그룹 테이블은 시퀀스 테이블 프래그먼트의 신규 위치를 반영하도록 재 기록되어야 한다.

단계(1710)에서, 교체될 데이터 프래그먼트 및 이에 대응하는 시퀀스 테이블 프래그먼트가 위치결정 된다. 단계(1712)에서, 새로운 그룹 테이블을 저장하는데 충분한 공간을 가진 블록이 위치결정 된다. 단계(1714)에서, 새로운 그룹 테이블 헤더는 "allocating" 상태로 기록된다. 단계(1716)에서, 새로운 그룹 테이블의 상태가 "header written"으로 변경된다.

단계(1720)에서, 시퀀스 테이블 프래그먼트에 대한 인스턴스 정보없이, 영향받지 않은 그룹 테이블을 이전의 그룹 테이블로부터 새로운 그룹 테이블로 카피한다. 영향받지 않은 그룹 테이블 엔트리는 변경되지 않는 시퀀스 테이블 프래그먼트의 위치를 식별한다. 동일한 객체에 대한 하나 이상의 시퀀스 테이블 프래그먼트가 동일한 블록에 위치결정되면, 교체 과정 동안에 시퀀스 테이블 프래그먼트 중 하나의 제거는 동일한 블록에 위치결정된 객체의 모든 후속 시퀀스 테이블 프래그먼트에 대한 인스턴스 정보(즉, "카운트")를 반드시 변경한다. 따라서, 단계(1722)에서 변경되지 않은 시퀀스 테이블 프래그먼트를 식별하는 다른 변경되지 않은 그룹 테이블 엔트리에 대한 인스턴스 정보를 갱신한다.

단계(1730 내지 1844)는 교체될 각 시퀀스 테이블에 적용된다. 단계91730)는 선택된 이전의 시퀀스 테이블 프래그먼트에 대해 새로운 시퀀스 테이블 프래그먼트를 기록할 충분한 공간을 가진 블록을 위치결정한다. 단계(1732)에서, 새로운 시퀀스 테이블 프래그먼트 헤더가 "allocating" 상태로 기록된다. 단계(1734)에서, 새로운 시퀀스 테이블 프래그먼트 상태가 "header written"으로 변경된다. 단계(1736)에서, 변경되지 않은 데이터 프래그먼트를 식별하는 이전 시퀀스 테이블의 엔트리가 새로운 시퀀스 테이블에 카피된다. 그리고 나서, 단계(1738)에서, 이들 엔트리는 갱신된 인스턴스 정보를 갖는다. 개별적인 시퀀스 테이블에 대한 인스턴스 정보의 갱신은, 변경되지 않은 데이터 프래그먼트에 대한 인스턴스 정보를 계산할 때에 교체되는 데이터 프래그먼트를 카운트하지 않는다.

이 과정은 도18의 단계(1810)에서 교체 데이터 프래그먼트 중 하나를 선택함으로써 계속된다. 단계(1812)에서, 교체 데이터 프래그먼트 중 하나를 기록하는데 충분한 공간을 가진 블록이 선택된다. 단계(1814)에서, 데이터 프래그먼트 헤더는 "allocating" 상태로 기록된다. 단계(1814)에서, 데이터 프래그먼트를 새로운 시퀀스 테이블 프래그먼트와 연관시키는 테이블 번호(312)가 또한 헤더의 일부로 기록된다. 단계(1816)에서, 데이터 프래그먼트 상태가 "header written"으로 변경된다.

단계(1820)에서 교체 데이터 프래그먼트의 기록이 시작된다. 그리고 나서, 단계(1824)에서 이 데이터 프래그먼트를 식별하는 시퀀스 테이블 엔트리에 인스턴스 정보를 기록하기 전에, 단계(1822)에서, 이 프래그먼트에 대한 인스턴스 수가 계산된다.

단계(1830)에서 저장될 추가 데이터 프래그먼트가 존재하는지를 판단한다. 만일, 존재하고 선택된 시퀀스 테이블 프래그먼트가 가득차지 않았다면(1840), 이 과정은 단계(1810)로 리턴하여 선택된 시퀀스 테이블 프래그먼트에 연관된 데이터 프래그먼트의 교체를 진행한다. 시퀀스 테이블 프래그먼트가 가득 찬 경우(1840), 해로운 시퀀스 테이블 프래그먼트 상태가 "allocated"로 변경되고(1842), 새로운 시퀀스 테이블 프래그먼트를 생성하기 위해, 단계(1740)로 리턴하기 전에, 단계(1844)에서, 새로운 그룹 테이블이 이 시퀀스 테이블 프래그먼트에 대한 정보로 갱신된다.

만일, 저장될 데이터 프래그먼트가 더 이상 존재하지 않는다며, 도19의 단계(1910)에서, 새로운 시퀀스 테이블 프래그먼트 상태가 "allocated"로 변경되고, 단계(1920)에서, 새로운 그룹 테이블이 이 시퀀스 테이블 프래그먼트에 대한 정보로 갱신된다. 그리고 나서, 단계(1930)에서, 모든 교체된 데이터 프래그먼트, 시퀀스 테이블 프래그먼트, 및 이전 그룹 테이블의 상태가 "invalid"로 변경된다. 단계(1990)에서 이 과정이 완료되기 전에, 단계(1940)에서, 새로운 데이터 프래그먼트, 시퀀스 테이블 프래그먼트 및 그룹 테이블의 상태가 "valid"로 변경된다.

전술된 데이터를 수정 및 기록하는 실시예는 기록 또는 수정 동작 동안에 전력 손실의 경우에 이전 상태로 복구가 가능하도록 하기 위해 많은 상태값을 이용한다. 시퀀스 테이블의 각 엔트리, 시퀀스 테이블 자체, 시퀀스 테이블에서 식별된 모든 데이터 프래그먼트 및 그룹 테이블의 상태는 기록 및 수정 과정 동안에 특정 시점에서 변경된다. 복수 상태값은 이 과정 중의 하나가 어떤 시점에서 방해되었는지의 여부와 그 시점을 판단할 수 있게 한다. 기록 또는 수정 과정이 완료되지 않으면, 비휘발성 메모리는 주지된 상태로 재 저장될 수 있다. 전력 손실 복구가 필요하지 않은 경우, 중간 단계가 수행될 필요가 없다.

결국, 비휘발성 메모리는 무효 데이터 양에 대응하는 소정의 임계값에 다다를 것이다. 일실시예어서, 이 임계값은 주어진 블록내의 무효 데이터 량에 기반한다. 대안적으로, 이 임계값은 비휘발성 메모리내의 전체 무효 데이터 량에 기반할 수 있다.

무효 데이터에 의해 사용된 공간은 "교정(reclamation)"으로 언급된 과정을 통해 복구되어 저장에 이용가능하게 될 수 있다. 도20은 교정 과정을 도시하고 있다. 일실시예에서, 가용 공간 량이 소정의 임계값 이하로 떨어지면, 교정 동작이 트리거된다(단계2020). 그렇지 않으면, 단계(2022)에 나타난 바와 같이 교정이 트리거되지 않는다.

일실시예에서, 교정 과정은 무효 데이터를 포함하는 블록의 집합으로부터 가장 많은 무효 데이터 량을 가진 블록을 선택함으로써, 복구를 위한 블록의 우선 순위를 결정한다(단계2030). 단계(2032)에서, 선택된 블록내의 모든 유효 객체는 선택된 블록으로부터 예비 블록(116)으로 카피된다.

유효 객체를 카피할 때, 무효 객체에 의해 이미 사용된 공간은 압축되어, 유효 객체의 헤더가 연속되고, 도2에 도시된 바와 같이, 객체 자신이 서로에 대해 연속으로 위치결정 된다. 이에 따라, 무효 객체( 및 그에 대응하는 헤더)에 의해 이전에 사용된 공간의 양이 복구되어, 영역(230)의 사이즈에서의 증가를 초래한다.

단계(2040)에서, 예비 블록(116)에 대한 블록 정보 구조(240)가 선택된 블록의 논리 블록 수로 갱신된다. 그리고 나서, 단계(2042)에서, 선택된 블록이 소거되어, 다른 블록을 교정할 때에 사용될 새로운 예비 블록이 된다.

일실시예에서는, 단계(2010)에 나타낸 바와 같이, 단지 기록 또는 수정 명령에 응답하여 교정 과정이 트리거된다. 단계(2020)에서 트리거되고 나면, 교정 과정은, 단계(2050)에서 판단되는 것과 같이, 요구된 동자을 수행할 충분한 자유 공간이 있을 때까지, 단계(2030-2050)를 반복한다.

앞의 명세서에서, 본 발명은 특정한 실시예를 참조하여 설명되었다. 그러나, 첨부된 청구범위에 기재된 것과 같이, 본 발명의 보다 넓은 사상 및 범위에서 벗어나지 않는 한, 다양한 수정 및 변경이 수행될 수 있다는 것이 명백할 것이다. 따라서, 본 명세서 및 도면은 제한적인 의미라기 보다는 예시적인 의미로 간주되어야 한다.

Claims (33)

1. 비휘발성 메모리 내의 경계(boundary)를 이동하는 방법에 있어서,

   상기 비휘발성 메모리 내의 경계 위치를 식별하는 단계 - 여기서, 상기 비휘발성 메모리는 제1 타입의 다수의 블록과 제2 타입의 다수의 블록을 포함하고, 상기 경계 위치는 제1 타입의 블록과 제2 타입의 블록 사이의 위치를 포함함 -;

   소거 블록(erased block) 또는 예비 블록(spare block)이 경계 위치에 배치되어 있는지를 판단하는 단계; 및

   상기 제1 타입의 블록으로부터 상기 제2 타입의 블록으로 상기 소거 블록 또는 상기 예비 블록을 변경하기 위해 경계 위치를 이동하는 단계

   를 포함하는 방법.
2. 제1항에 있어서,

   제1 타입의 최종 블록으로부터 다른 제1 타입의 블록으로 객체(object)를 할당하는 단계;

   상기 제1 타입의 최종 블록을 소거하는 단계; 및

   상기 비휘발성 메모리를 초기화하는 단계 - 상기 초기화 단계는 제1 타입의 제1 블록을 상기 제2 타입의 블록으로 변경하도록 동작함 -

   를 더 포함하는 방법.
3. 제2항에 있어서,

   상기 제1 타입의 제3 블록을 상기 제1 타입의 최종 블록으로 변경하는 단계

   를 더 포함하는 방법.
4. 제2항에 있어서,

   상기 초기화 단계 전에, 상기 제1 타입의 제1 블록을 상기 제1 타입의 예비 블록으로 교환하는 단계

   를 더 포함하는 방법.
5. 제2항에 있어서,

   상기 최종 블록은 상기 제1 타입의 제1 블록을 포함하는

   방법.
6. 제1항에 있어서,

   상기 제1 타입은 데이터 부분을 포함하는

   방법.
7. 제1항에 있어서,

   상기 제2 타입은 코드 부분을 포함하는

   방법.
8. 비휘발성 메모리 내의 경계를 이동하는 방법에 있어서,

   상기 비휘발성 메모리 내의 경계 위치를 식별하는 단계 - 여기서, 상기 경계 위치는 제1 타입의 제1 블록과 제2 타입의 제2 블록 사이의 위치를 포함함 -;

   상기 제2 타입의 제1 블록을 소거하는 단계;

   상기 제2 타입의 제1 블록에 블록 구조 정보를 기록하는 단계; 및

   상기 제2 타입의 제1 블록을 상기 제1 타입의 블록으로 변경하기 위해 상기 경계 위치를 이동하는 단계

   를 포함하는 방법.
9. 제8항에 있어서,

   상기 블록 구조 정보를 기록하는 단계는 상기 제1 타입의 가장 높은 번호의(highest numbered) 논리 블록에 1을 더한 것과 같은 논리 블록 번호를 기록하는 단계를 포함하는

   방법.
10. 제8항에 있어서,

    데이터 블록 필드를 제1 타입의 최종 블록의 제1 값으로 설정하는 단계

    를 더 포함하는 방법.
11. 제10항에 있어서,

    상기 블록 구조 정보를 기록하는 단계는 데이터 블록 필드를 상기 제2 타입의 제1 블록의 제2 값으로 설정하는 단계를 포함하는

    방법.
12. 제11항에 있어서,

    상기 비휘발성 메모리를 초기화하는 단계

    를 더 포함하고,

    상기 초기화 단계는, 상기 제2 타입의 제1 블록을 상기 제1 타입의 블록으로 변경하기 위해 상기 경계 위치를 이동하는 단계를 포함하는

    방법.
13. 제8항에 있어서,

    상기 제1 타입은 데이터 부분을 포함하는

    방법.
14. 제8항에 있어서,

    상기 제2 타입은 코드 부분을 포함하는

    방법.
15. 데이터 부분과 코드 부분 사이에 이동가능한 경계를 갖도록 구성된 비휘발성 메모리를 구비한 메모리 시스템에 있어서,

    상기 비휘발성 메모리는,

    각 블록이 다수의 객체 및 블록 정보 구조를 갖는 다수의 데이터 블록 - 여기서, 상기 블록 정보 구조는 상기 다수의 데이터 블록의 최종 논리 블록을 나타내도록 동작하는 최종 필드를 포함함 -;

    상기 데이터 블록에 연결된 다수의 예비 블록; 및

    다수의 코드 블록 - 상기 다수의 코드 블록의 제1 블록은 상기 다수의 데이터 블록 중의 하나 또는 상기 다수의 예비 블록 중의 하나에 인접함 - 을 포함하는

    메모리 시스템.
16. 제15항에 있어서,

    상기 블록 정보 구조는 논리 블록 번호를 포함하고, 상기 논리 블록 번호는 상기 다수의 데이터 블록내의 블록의 수를 식별하도록 동작하는

    메모리 시스템.
17. 제16항에 있어서,

    상기 비휘발성 메모리에 연결되어, 상기 이동가능한 경계의 위치를 제어하도록 동작하는 프로세서

    를 더 포함하는 메모리 시스템.
18. 제17항에 있어서,

    상기 프로세서는 또한 상기 비휘발성 메모리의 데이터 부분을 확장하도록 동작하는

    메모리 시스템.
19. 제18항에 있어서,

    상기 프로세서는 상기 비휘발성 메모리의 데이터 부분을 확장하기 위해 상기 다수의 코드 블록의 제1 블록에 블록 정보 구조를 기록하는

    메모리 시스템.
20. 제17항에 있어서,

    상기 프로세서는 상기 비휘발성 메모리의 코드 부분을 확장하도록 동작하는

    메모리 시스템.
21. 제20항에 있어서,

    상기 프로세서는 또한 상기 비휘발성 메모리의 코드 부분을 확장하기 위해, 상기 비휘발성 메모리의 데이터 부분의 최종 논리 블록을 소거하도록 동작하는

    메모리 시스템.
22. 제1항에 있어서,

    상기 제1 타입의 최종 블록으로부터 상기 제1 타입의 다른 블록으로 객체를 할당하는 단계; 및

    소거 블록을 생성하기 위해 상기 제1 타입의 최종 블록을 소거하는 단계

    를 더 포함하는 방법.
23. 제1항에 있어서,

    상기 비휘발성 메모리 내의 경계 위치를 식별하는 단계는 플래시 메모리 경계 내의 위치를 식별하는 단계를 포함하는

    방법.
24. 코드 부분 및 데이터 부분을 갖는 비휘발성 메모리에 저장된 정보를 업데이트하기 위한 방법에 있어서,

    상기 비휘발성 메모리의 상기 코드 부분을 감소시킴으로써 상기 비휘발성 메모리의 상기 데이터 부분을 확장하는 단계

    를 포함하고,

    여기서, 상기 데이터 부분과 상기 코드 부분 사이에 데이터/코드 경계가 존재하고, 상기 코드 부분은 코드를 저장하기 위한 다수의 코드 블록을 포함하고, 상기 데이터 부분은 데이터를 저장하기 위한 다수의 데이터 블록 및 적어도 하나의 예비 블록을 포함하는

    방법.
25. 제24항에 있어서,

    상기 비휘발성 메모리의 상기 데이터 부분을 감소시킴으로써 상기 비휘발성 메모리의 상기 코드 부분을 확장하는 단계

    를 더 포함하는 방법.
26. 제25항에 있어서,

    상기 코드 부분을 확장하는 단계는,

    상기 데이터 부분과 상기 코드 부분 사이의 데이터/코드 경계에서 상기 데이터 부분 내에 위치된 물리적인 블록을 식별하는 단계; 및

    상기 물리적인 블록이 상기 코드 부분 내에 위치되도록 상기 데이터/코드 경계를 이동하는 단계를 포함하는

    방법.
27. 제24항에 있어서,

    상기 데이터 부분을 확장하는 단계는,

    상기 데이터 부분과 상기 코드 부분 사이의 데이터/코드 경계에서 상기 코드 부분 내에 위치된 물리적인 블록을 식별하는 단계; 및

    상기 물리적인 블록이 상기 데이터 부분 내에 위치되도록 상기 데이터/코드 경계를 이동하는 단계를 포함하는

    방법.
28. 제27항에 있어서,

    상기 데이터 부분을 확장하는 단계는 블록 구조 정보를 상기 물리적인 블록에 기록하는 단계를 더 포함하는

    방법.
29. 코드 부분 및 데이터 부분을 갖는 비휘발성 메모리; 및

    상기 비휘발성 메모리의 상기 코드 부분을 감소시킴으로써 상기 비휘발성 메모리의 상기 데이터 부분을 확장하기 위해 상기 비휘발성 메모리에 결합되는 프로세서

    를 포함하고,

    여기서, 상기 데이터 부분과 상기 코드 부분 사이에 데이터/코드 경계가 존재하고, 상기 코드 부분은 코드를 저장하기 위한 다수의 코드 블록을 포함하고, 상기 데이터 부분은 데이터를 저장하기 위한 다수의 데이터 블록 및 적어도 하나의 예비 블록을 포함하는

    시스템.
30. 제29항에 있어서,

    상기 비휘발성 메모리는 상기 데이터 부분 내에 적어도 하나의 예비 블록을 포함하는

    시스템.
31. 제29항에 있어서,

    상기 비휘발성 메모리는 플래시 메모리인

    시스템.
32. 삭제
33. 제29항에 있어서,

    상기 프로세서는 상기 비휘발성 메모리의 상기 데이터 부분을 감소시킴으로써 상기 비휘발성 메모리의 상기 코드 부분을 확장하도록 동작하는

    시스템.