KR20170063340A - 통계적 분석을 통한 강화된 다중 스트리밍 - Google Patents

Abstract

솔리드 스테이트 드라이브를 이용하는 시스템 및 방법이 설명된다. 수신 회로는 제1 스트림으로부터 쓰기 요청들 및 무효화 요청들을 수신한다. 쓰기 요청들은 솔리드 스테이트의 저장소에 데이터가 기입될 것을 요청한다. 무효화 요청들은 저장소에 기입된 데이터를 무효화한다. 통계 계산 로직은 쓰기 요청들 및 무효화 요청들에 기반하여 스트림에 대한 통계들을 계산한다. 성능 로직은 계산된 통계들을 이용하여 솔리드 스테이트 드라이브의 성능을 개선한다.

Description

통계적 분석을 통한 강화된 다중 스트리밍{ENHANCED MULTI-STREAMING THROUGH STATISTICAL ANALYSIS}

본 발명은 솔리드 스테이트 드라이브에 관한 것으로, 더 상세하게는 솔리드 스테이트 드라이브의 다중 스트리밍에 관한 것이다.

"다중 스트리밍"은 다중 데이터 스트림들을 이용하여 데이터를 저장하는 솔리드 스테이트 드라이브(SSD)의 개발의 최신 경향이다. 이 기술 분야의 전통적인 응용들에서, 각 스트림은 하나의 블록에 지정되고, 각 스트림은 하나 또는 그보다 많은 추정상 유사한 특성들(일반적으로, 데이터의 예상 수명)에 기반하여 할당되는 데이터이다. 유사한 특성을 갖는 데이터를 하나의 스트림(최종적으로는 하나의 스토리지 블록)에 함께 배치하도록 시도함으로써, 그룹화된 데이터가 예측 가능하게 처리되고, 종국적으로 SSD의 가비지 컬렉션을 단순하게 하고 그리고 연관된 쓰기 증폭 인자(WAF, Write Amplification Factor)를 감소시키는 것이 선호된다. 더 상세하게는, 하나의 블록에 알려진 예상 수명을 갖는 스트림의 데이터가 저장되면, 시스템은 해당 블록의 데이터가 언제(또는 어떤 비율로) 만료되는지 더 잘 예측할 수 있고, 따라서 가비지 컬렉션을 위한 희생 블록들의 위치 지정 및 유효 데이터를 전송하는 작업이 용이해진다.

그러나 이러한 기본 접근에는 문제점이 있다. 우선, 많은 경우에, 스트림 내의 데이터의 수명은 근사화될 뿐이다. 이는, 많은 경우에, 근사치와 다르게 행동하는 데이터는 다중 스트리밍 시스템의 타이밍 추정을 위반하며, 가비지 컬렉션 또는 쓰기 증폭 인자 성능이 저해된다. 두 번째로, 데이터 스트림들의 특성들은 시간에 따라 변화한다. 따라서, 다중 스트림 제어에 대해 수행된 최초 타이밍 추정이 위반될 수 있으며, 이는 나쁜 가비지 컬렉션 또는 쓰기 증폭 인자 성능을 유발할 수 있다. 끝으로, 다중 스트림 시스템의 제어의 외부 요인(예를 들어, 전체 디스크)으로 인해, 가비지 컬렉션이 다중 스트리밍된 블록에서 모든 데이터가 만료되기 전에 수행되어야 할 때가 있다. 이 경우, 전통적인 다중 스트림 시스템의 최선의 노력에도 불구하고, 희생 블록의 유효 데이터가 다른 블록에 재기입(예를 들어, 프로그램)되어야만 한다.

따라서, SSD의 성능 향상에 대한 요구가 여전히 존재한다.

본 발명의 목적은 향상된 성능을 갖는 솔리드 스테이트 드라이브를 제공하는 데에 있다.

본 발명의 실시 예에 따른 솔리드 스테이트 드라이브는 데이터를 위한 스토리지, 수신 회로, 통계 계산 로직, 그리고 성능 로직을 포함한다. 수신 회로는 스토리지 내의 데이터에 영향을 주는 복수의 제1 쓰기 요청들 및 복수의 제2 무효화 요청들을 제1 스트림으로부터 수신한다. 통계 계산 로직은 복수의 제1 쓰기 요청들 및 복수의 제2 무효화 요청들로부터 제1 스트림에 대한 통계들을 계산한다. 성능 로직은 계산된 통계들을 이용하여 솔리드 스테이트 드라이브의 블록에 기입된 모든 데이터가 동일한 시간 근처에 무효화될 공산을 증가시킨다.

본 발명의 다른 실시 예에 따른 솔리드 스테이트 드라이브는 시간 로직, 데이터 수명 로직, 통계 계산 로직, 그리고 성능 로직을 포함한다. 시간 로직은 복수의 쓰기 요청들에 대한 복수의 쓰기 시간들 및 복수의 무효화 요청들에 대한 복수의 무효화 시간들을 판별하고, 개별 쓰기 요청들에 대한 개별 쓰기 시간들을 대응하는 개별 무효화 요청들에 대한 개별 무효화 시간들과 짝지운다. 데이터 수명 로직은 복수의 쓰기 시간들로부터의 대응하는 쓰기 시간들 및 복수의 무효화 시간들로부터의 무효화 시간들로부터 데이터 수명들을 계산한다. 통계 계산 로직은 계산된 데이터 수명들로부터 제1 스트림에 대한 통계들을 계산한다. 성능 로직은 계산된 통계들을 이용하여 솔리드 스테이트 드라이브의 블록에 기입된 모든 데이터가 동일한 시간 근처에 무효화될 공산을 증가시킨다.

본 발명의 실시 예에 따른 방법은 솔리드 스테이트 드라이브에서 각각 제1 스트림과 연관된 복수의 제1 쓰기 요청들을 수신하는 단계, 각각 복수의 제1 쓰기 요청들과 연관된 복수의 제2 쓰기 시간들을 판별하는 단계, 솔리드 스테이트 드라이브에서 각각 복수의 제1 쓰기 요청들 중 하나에 의해 기입된 데이터를 삭제하는 복수의 제3 무효화 요청들을 수신하는 단계, 각각 복수의 제3 무효화 요청들 중 하나와 연관된 복수의 제4 무효화 시간들을 판별하는 단계, 복수의 제2 쓰기 시간들 및 복수의 제4 무효화 시간들에 응답하여 제1 스트림에 대한 통계들을 계산하는 단계, 그리고 계산된 통계들을 이용하여 솔리드 스테이트 드라이브의 블록에 기입된 모든 데이터가 동일한 시간 근처에서 무효화될 공산을 증가시키는 단계를 포함한다.

본 발명에 따르면, 통계적 분석을 통한 강화된 다중 스트리밍을 지원함에 따라 향상된 성능을 갖는 솔리드 스테이트 드라이브가 제공된다.

도 1은 연관된 생존 시간을 갖는 스트림과 연관된 데이터를 수신하는 블록을 보여준다.
도 2a 내지 도 2d는 본 발명의 실시 예들에 따라 상이한 생존 시간들을 갖는 다중 스트림들과 연관된 데이터를 수신하는 도 1의 블록의 제1 예를 보여준다.
도 3a 내지 도 3d는 상이한 생존 시간들을 갖는 다중 스트림들과 연관된 데이터를 수신하는 도 1의 블록의 제2 예를 보여준다.
도 4는 본 발명의 실시 예들에 따른 생존 시간을 갖는 제2차 스트림과 연관된 데이터를 수신하는 도 1의 블록을 보여준다.
도 5는 본 발명의 실시 예들에 따른 상이한 스트림들로부터의 데이터를 도 1의 블록에 기입하는 솔리드 스테이트 드라이브를 보여준다.
도 6은 도 5의 선택 로직의 상세를 보여준다.
도 7은 도 6의 평균 쓰기 사이즈 계산기의 상세를 보여준다.
도 8은 도 6의 평균 쓰기 도착률 계산기의 상세를 보여준다.
도 9는 도 6의 스트림 선택 로직의 상세를 보여준다.
도 10은 도 5의 생존 시간 계산기의 상세를 보여준다.
도 11은 도 5의 솔리드 스테이트 드라이브를 포함하는 기계의 상세를 보여준다.
도 12는 본 발명의 실시 예들에 따른 상이한 스트림들로부터의 데이터를 도 1의 블록에 기입하는 도 5의 솔리드 스테이트 드라이브의 절차를 보여주는 순서도이다.
도 13은 본 발명의 실시 예들에 따른 제2차 스트림을 이용하여 상이한 스트림들로부터의 데이터를 도 1의 블록에 기입하는 도 5의 솔리드 스테이트 드라이브의 절차의 순서도를 보여준다.
도 14는 공통 평균을 갖고 상이한 표준 편차들을 갖는 두 개의 정규 분포 곡선들의 그래프를 보여준다.
도 15는 도 14에 도시된 것과 같은 분포 모델에 따르지 않는 데이터의 히스토그램을 보여준다.
도 16은 본 발명의 실시 예들에 따라 쓰기 및 무효 요청을 도 5의 솔리드 스테이트 드라이브로 전송하는 스트림을 보여준다.
도 17은 도 16의 솔리드 스테이트 드라이브의 상세를 보여준다.
도 18은 도 17의 통계 계산 로직의 상세를 보여준다.
도 19는 도 16의 쓰기 요청들에 대한 쓰기 시간들을 판별하는 도 18의 타이밍 로직을 보여준다.
도 20은 짝지워진 쓰기 및 무효화 요청들로부터 데이터 수명을 판별하는 도 18의 데이터 수명 로직을 보여준다.
도 21은 도 20의 데이터 수명으로부터 기능들 또는 히스토그램들을 생성하는 도 18의 통계 로직을 보여준다.
도 22는 본 발명의 다른 실시 예에 따른 짝지워진 쓰기 및 무효화 시간들의 가중치들을 판별하는 도 18의 가중 로직을 보여준다.
도 23은 본 발명의 실시 예들에 따라 도 21의 계산된 통계들을 이용하여 스트림의 새로운 쓰기 요청에서 데이터를 저장할 블록을 선택하는 도 17의 성능 로직을 보여준다.
도 24는 본 발명의 실시 예들에 따른 도 17의 성능 로직의 상세를 보여준다.
도 25는 유효 데이터를 저장하는 도 17의 솔리드 스테이트 드라이브의 소거 블록을 보여준다.
도 26은 도 25의 유효 데이터에 대한 잔여 수명을 측정하는 도 24의 측정된 잔여 수명 로직을 보여준다.
도 27a 및 도 27b는 본 발명의 실시 예들에 따라 스트림에 대한 통계를 계산하고 그리고 계산된 통계를 이용하여 도 17의 솔리드 스테이트 드라이브의 성능을 향상시키는 도 17의 솔리드 스테이트 드라이브의 절차의 순서도를 보여준다.
도 28은 본 발명의 실시 예들에 따라 스트림에 대한 통계를 계산하는 도 18의 통계 계산 로직의 절차의 순서도를 보여준다.
도 29는 본 발명의 실시 예들에 따라 스트림에 대해 계산된 통계를 이용하여 스트림의 새로운 데이터를 저장할 목표를 선택하는 도 17의 성능 로직의 절차의 순서도를 보여준다.
도 30은 본 발명의 실시 예들에 따라 계산된 통계를 이용하여 가비지 컬렉션 동안에 도 25의 소거 블록으로부터 도 25의 유효 데이터가 프로그램될 목표를 선택하는 도 17의 성능 로직의 절차의 순서도를 보여준다.
도 31은 본 발명의 실시 예들에 따라 블록에 기입될 데이터의 스트림을 선택하는 도 17의 성능 로직의 절차의 순서도를 보여준다.
도 32는 본 발명의 실시 예들에 따라 응용에 의해 보고된 스트림 생존 시간이 정확한지를 응용에 보고하는 도 17의 성능 로직의 절차의 순서도를 보여준다.

본 발명의 실시 예들이 첨부된 도면들을 참조하여 설명된다. 그러나 본 발명은 이러한 구체적인 상세들 없이도 이 분야에 통상적인 기술을 가진 자들에 의해 실시될 수 있음이 이해될 것이다. 다시 말하면, 잘 알려진 방법들, 절차들, 구성 요소들, 회로들, 그리고 네트워크들은 실시 예들을 불필요하게 모호하게 하지 않도록 설명되지 않는다.

제1, 제2 등의 용어들이 다양한 구성 요소들을 설명하기 위하여 사용되지만, 구성 요소들은 이 용어들에 의해 한정되지 않음이 이해될 것이다. 이러한 용어들은 구성 요소들을 서로 구분하기 위해서만 사용된다. 예를 들어, 본 발명의 기술적 사상으로부터 괴리되지 않으면서, 제1 모듈은 제2 모듈로 명명될 수 있으며, 마찬가지로 제1 모듈은 제2 모듈로 명명될 수 있다.

본 발명의 기술적 사상의 설명에서 사용되는 용어들은 구체적인 실시 예들을 설명하기 위한 것이며, 본 발명의 기술적 사상을 제한하는 것을 의도하지 않는다. 여기에서 사용되는 "그리고/또는"의 용어는 하나 또는 그보다 많은 연관된 아이템들 중 어느 것 또는 모든 가용한 조합을 참조함이 이해될 것이다. "포함한다" 그리고/또는 "포함하는"의 용어들은 언급된 특성들, 정수들, 단계들, 동작들, 그리고/또는 구성 요소들의 존재를 설명하며, 하나 또는 그보다 많은 특성들, 정수들, 단계들, 동작들, 구성 요소들, 그리고/또는 이들의 조합들의 존재 또는 추가를 배제하지 않는다. 도면들의 구성 요소들 및 특성들은 스케일에 맞게 도시되지는 않는다.

상술된 바와 같이, 솔리드 스테이트 드라이브(SSD)는 블록들로 조직화되는 페이지들에 데이터를 기입한다. 데이터가 갱신될 때에, 이전 데이터를 저장하는 페이지는 RAM (Random Access Memory)으로 복사되고, 수정된 후, SSD의 자유 페이지에 기입된다. 원본 페이지는 무효로 표시되고 새로운 페이지는 유효로 표시된다.

시간이 흐름에 따라, 무효 페이지들의 수가 증가한다. 결국, 무효 페이지들이 가비지 컬렉션을 수행함에 따라 복원되지 않으면, SSD는 자유 페이지들을 갖지 않게 된다. 가비지 컬렉션은 목표 블록(또는 목표 슈퍼 블록)을 선택하고, 해당 블록의 모든 유효 페이지들을 새로운 블록으로 복사하고, 이후에 원본인 목표 블록을 삭제하는 것을 포함한다. 유효 데이터의 복사는 시간 및 에너지를 필요로한다. 또한, 플래시 메모리는 제한된 수의 쓰기들을 지탱하므로, 가비지 컬렉션은 SSD의 수명에 부정적으로 영향을 준다.

플래시 메모리의 가비지 컬렉션은 스토리지 장치의 성능, 응답성 및 수명에 심각한 영향을 주므로, 가비지 컬렉션의 효율성을 최적화하는 것을 돕기 위한 다양한 방법들이 존재한다. 이러한 방법들 중 하나는 다중 스트림이라 불리며, 컴퓨팅 시스템이 데이터 쓰기 활동을 분류하는 것을 허용하는 기술이다.

다중 스트리밍은 SSD가 데이터 쓰기 동작들을 스트림들로 통합하게 하는 방법을 제공한다. 데이터 쓰기 동작은, 스트림과 연관된 모든 데이터가 유사한 생존 시간(TTL, Time-To-Live)을 갖는다는 예측에 기반하여, 복수의 스트림들 중 하나와 연관된다. 이는 스토리지 장치가 데이터가 좁고 예측 가능한 시간 프레임 내에서 전체적으로 무효화 된다는 가정을 갖고, 데이터를 플래시 미디어에 함께 배치하는 것을 가능케 한다. 이러한 배치가 성공할 때, 가비지 컬렉션이 수행된 블록으로부터 유효 데이터를 다른 곳에 저장할 필요가 없으므로, 이러한 배치 전략은 가비지 컬렉션의 집약도를 크게 낮춘다.

다중 스트리밍 시스템의 기본 가정은, 스트림 내의 모든 데이터가 근사하게 동일한 방법으로 행동한다는 것, 예를 들어 스트림 내의 데이터가 근사하게 동일한 수명을 갖는다는 것이다. 일부 데이터 타입에서, 이는 매우 정확한 가정이다. 그러나 다른 데이터 스트림들에서, 이러한 가정은 매우 정확하지 않다. 단일 TTL을 사용하는 스트림을 모델링하는 대신에, 더 나은 모델은 명목(nominal) TTL과 함께 TTL의 분포들을 사용할 수 있다.

이러한 분포들은 정규 분포, 다봉 분포(multi-modal distribution) 등과 같은 통계적 패턴을 거의 따를 수 있다. 예시적으로, 통상적인 스프레드시트를 갱신하는 사무실 노동자로부터의 데이터를 저장하는 서버와 연관된 스트림이 가정된다. 한 주 동안의 업무의 통상 패턴을 반영하면, 대부분의 갱신은 수 시간 동안(또는 기껏해야 하루 동안) 발생한다. 그러나 업무일들 사이의 주간 휴일을 반영하면, 상당히 많은 수의 갱신들이 2일을 조금 넘는 주기로 발생한다. 끝으로, 휴가와 같은 이유로 더 긴 주기로 발생하는 나머지 갱신들이 존재할 수 있다. 도 15는 이러한 데이터를 나타내는 예시적인 히스토그램을 보여준다. 통상적인 스트림은 해당 스트림에 속한 데이터가 무효화되는 기한의 우도(예를 들어, 90%)를 나타내는 단일 수명 형태를 가질 수 있다. 이후에, 해당 스트림은 모든 데이터가 해당 특성을 정확히 갖는 것으로 시스템에 의해 취급(특히, 스트림들을 블록들에 할당하는 경우)될 수 있다. 분포 패턴의 모든 정보는 시스템, 더 상세하게는 SSD에 대해 소실될 수 있다.

혹은, 다중 스트리밍 시스템은 스트림의 데이터 수명 분포의 추적을 유지할 수 있다. 이는 다양한 방법들로 수행될 수 있다. 우선, 이러한 추적은 온전히 호스트 측에서 수행될 수 있으며, 호스트는 필요한 때에 SSD에 분포 모델을 제공할 수 있다. 혹은, SSD는 호스트가 스트림을 왜 그리고 어떻게 생성하고 채우는지에 대해 알지 못하는 경우에도, SSD는 각 스트림 쓰기 요청에 대한 정보를 저장할 수 있다. 스트림 식별자(ID)를 가리키는 메타 데이터와 각 스트림 페이지를 저장함에 따라, 그리고 해당 페이지가 저장 또는 무효화되는 시간을 저장함에 따라, SSD는 스트림의 분포 모델 및 명목(nominal) 데이터 수명을 계산할 수 있다.

또한, 고정된 스트림 TTL은 스트림의 데이터 수명 주기 패턴이 시간의 흐름에 따라 변화하거나 또는 장주기 사이클을 보이는 사실을 반영하지 않는다. 고정된 스트림 TTL에만 의존하는 것은 이러한 변화를 고려하지 않는다. 데이터 수명 주기 패턴의 변화의 가능성을 반영하기 위하여, 시스템은 데이터 수명의 "이동 윈도"를 이용하여 스트림의 분포를 생성할 수 있다. 따라서, 오래된 데이터(또는 오래된 데이터 수명 주기 패턴)은 모델을 왜곡하지 않는다.

이러한 스트림별 통계 모델들은 SSD에서 유용하게 사용될 수 있다. 분포의 윤곽들(contour)은 스트림 대 블록(또는 제1차 대 제2차 스트림) 할당 메커니즘이 이동할 스트림들을 선택할 때에 가장 지능적인 선택이 수행되도록 지원할 수 있다.

예를 들어, 도 14에 도시된 바와 같이, 명목 30분의 수명 및 유사한 공급률(fill rate)을 갖는 두 개의 스트림들이 가정된다. 하나의 스트림은 좁은 분포를 갖고, 다른 스트림은 넓은 분포를 가질 수 있다. 주어진 신뢰 수준에서, 두 스트림들은 비교할만한 이상점들(outliers)을 가질 수 있다. 넓은 분포를 갖는 스트림의 이상점들은 좁은 분포를 갖는 스트림의 이상점들보다 중심(또는 평균)으로부터 더 멀(또는 많을) 수 있다. 넓은 분포를 갖는 스트림의 데이터가 좁은 분포를 갖는 스트림의 데이터보다 먼저 수명 기반 블록에 기입되면, 데이터 무효화는 스트림들로부터의 데이터가 다른 방식으로 해당 블록에 기입되는 경우보다 더 해당 블록에 유효 데이터가 존재하지 않거나 더 적게 존재하게 할 수 있다. 예를 들어, 블록이 37분의 잔여 수명을 갖는 때에, 넓은 분포를 갖는 스트림의 데이터가 해당 블록에 기입될 수 있다. 블록이 32분의 잔여 수명을 갖는 때에, 좁은 분포를 갖는 스트림의 데이터가 해당 블록에 기입될 수 있다.

스트림의 분포의 다른 이용은, 유효 데이터를 갖는 블록이 가비지 컬렉션에 사용되도록 강제된 경우에 발생할 수 있다. 가비지 컬렉터는 잔여 유효 데이터를 참조하고, 메타 데이터를 이용하여 유효 데이터가 속한 스트림 및 경과한 시간을 식별하고, 그리고 해당 스트림의 분포를 이용하여 유효 데이터가 잔여 할 시간을 예측할 수 있다. 이후에, 해당 데이터가 가장 유사한 특성을 갖는 스트림에 배치될 수 있다.

예를 들어, 도 15에 도시된 바와 같이, 매일, 주말 후에, 또는 방학 후에 갱신되는 상술된 스프레드시트의 예, 그리고 40시간 전에 기입된 유효 데이터를 포함하는 소거 블록이 존재하는 경우가 가정된다. 해당 스트림의 분포 모델로부터, SSD는 유효 데이터가 추가적인 24시간 이내에 무효화될 가능성이 있지만, 해당 데이터가 그 후에도 며칠 동안 유효하게 잔여 할 리스크가 있음을 판별할 수 있다. 가비지 컬렉터는 우선 데이터를 24시간의 무효 가능 시간을 갖지만 장시간의 보류를 허용하는 분포를 갖는 현존하는 다른 스트림으로 재분류(또는 재스트림)하는 것을 시도할 수 있다. 이것이 실패하면, 가비지 컬렉터는 데이터를 24시간의 수명 및 더 좁은 산포를 갖는 스트림으로 재분류하는 것 등을 시도할 수 있다.

도 1은 통상적인 시스템에서 연관된 TTL을 갖는 스트림과 연관된 데이터를 수신하는 블록을 보여준다. 도 1에서, 스토리지 장치는 하나의 특정한 스트림에 대해 복수의 쓰기 요청들을 수행할 수 있다. 실제로, 스토리지 장치는, 가용한 미사용 스토리지 블록을 스트림에 할당하고 전용지정(dedicate)하는 것에 의해, 그리고 데이터 값들을 해당 블록 내의 가용한 첫 번째 영역(예를 들어, 페이지(들))에 기입할 수 있다. 블록 내의 가용한 영역은 가장 낮은 위치의 어드레스에서 시작하여 높은 위치의 어드레스로 진행할 수 있다. 블록이 가득 차면, 다른 블록이 스트림에 할당되고 전용지정된다. 블록이 가비지 컬렉션에 의해 완전히 리클레임(reclaim)되면, 해당 블록은 다른 또는 동일한 스트림에 차후 할당되기 위해 가용한 블록 풀로 반환된다.

도 1에서, 가장 먼저 기입된 데이터 값들 중 일부는 삭제 또는 갱신되었고, 이들의 저장 위치들이 무효화되어 있다. 예를 들어, 블록(103)은 스트림에 전용지정되어 있다. 스트림 쓰기들(106, 109, 112)은 페이지들(115, 118, 121)에 기입된다. 최종적으로, 페이지들(115, 118, 121)은 모두 무효화된다. 한편, 가장 최근의 스트림 쓰기들(124, 127)은 페이지들(130, 133)에 기입되었으며, 다른 페이지들(136, 139, 142, 145)은 자유 페이지들로 남겨져 있다. 페이지들(115, 118, 121) 중 하나의 데이터 값이 갱신되었으면, 새로운 갱신된 값이 블록 내의 더 높은 어드레스, 예를 들어 페이지들(148, 151, 130, 133)에 존재할 수 있다. 또는, 새로운 값은 해당 스트림에 할당되고 전용지정된 다른 블록에 존재할 수 있다.

도 1에서, 유효 페이지들(148, 151, 130, 133)은 잔여 TTL 값들(154, 157, 160, 163)과 함께 도시된다. 이러한 값들은 SSD에 실제 저장되지는 않으며, 페이지 내의 데이터가 만료(expire)(또는 삭제 또는 무효화)될 때까지의 시간을 가리킨다. 이 값은 스트림 내의 데이터의 TTL 및 데이터가 SSD에 존재해 온 시간의 차이로 계산될 수 있다. 예를 들어, TTL 값들(154, 157, 160, 163)은 페이지(148)의 데이터가 1분 내에 만료될 것으로 예측되고, 페이지(151)의 데이터가 2분 내에 만료될 것으로 예측되고, 페이지(130)의 데이터가 59분 내에 만료될 것으로 예측되고, 그리고 페이지(133)의 데이터가 60분 내에 만료될 것으로 예측됨을 가리킨다. 이러한 상황은, 예를 들어, 스트림이 60분의 TTL을 갖고 그리고 블록(103)의 하나의 페이지를 차지하는 데이터가 스트림에 매 분마다 도착(예를 들어, 스트림 쓰기가 발생)한 경우에 발생할 수 있다.

블록(103)이 페이지(133)로 끝나면, TTL 값(163)을 갖는 페이지(133)는 만료되는 가장 마지막 페이지이며, 만료되는 데에 60분을 필요로 한다. 따라서, SSD가 블록(103)에서 가비지 컬렉션을 수행하고자 할 때, SSD는 페이지(133)의 데이터가 만료될 때(데이터가 기입된 후 60분 후)까지 대기하거나, 또는 유효 데이터를 블록(103)으로부터 다른 블록으로 복사하고 블록(103)을 소거할 수 있다.

통상적인 다중 스트리밍 스토리지에서, 도 1에 도시된 바와 같이, 단일 블록은 단일 스트림과 연관된다. 블록(103)에 기입되는 데이터는 예측 가증한 TTL을 가질 수 있다. 그러나, 블록(103)을 채우는 데에 필요한 시간으로 인해, 블록(103)의 페이지들은 물결(wave)처럼 무효화된다. 즉, 블록(103)의 페이지들은 시간에 따라 순차적으로 만료될 수 있다. 이는 SSD를 어려운 상황으로 내몰 수 있다. SSD는 모든 데이터가 만료될 때까지 기다려야 하며, 자유 공간으로 전환될 수 있는 공간을 활용할 수 없는 시간 페널티를 겪을 수 있다. 또는, SSD는 일부 유효 페이지들을 다른 블록으로 복사하는 가비지 컬렉션을 블록(103)에서 수행하여야 하며, 알려진 가비지 컬렉션 페널티들을 겪을 수 있다.

도 1은 또한 SSD가 다중 스트리밍 스토리지 없이 어떻게 블록들을 채우는지를 나타낸다. SSD가 다중 스트리밍 스토리지로 동작하지 않을 때, 각 페이지는 근본적으로 랜덤 TTL을 갖고, 블록(103) 내의 데이터가 언제 만료될지를 예측할 수 없다. 순차적인 TTL 값들(154, 157, 160, 163)을 랜덤 값들로 교체하면, 그리고 블록(103) 내의 무효 및 유효 페이지들을 섞으면, 도 1은 통상적인 비 다중 스트리밍 스토리지를 보여준다.

통상적인 다중 스트리밍 시스템들이 특정한 스트림들을 스토리지 블록들에 할당하지만, 스토리지 블록들은 특정한 스트림들에 할당될 필요가 없다. 대신, 블록의 데이터가 정의된 단일 시간에 만료하는 것을 목표로, 전체적인 수명이 블록에 할당되며, 변화하는 TTL의 스트림들의 데이터가 블록에 기입될 수 있다. 스토리지 장치 지능 및 역사(예를 들어, 스트림 역사) 데이터를 이용하여, SSD는 현재 스트림으로부터의 데이터를 해당 블록에 기입하는 것을 지속하는 것이 효율적인지 또는 다른 스트림으로부터의 데이터를 해당 블록의 잔여 페이지들에 기입하는 것이 효율적인지 판별할 수 있다. 물론, 동일한 논리가 블록들의 나중에 할당되는 스트림에 적용될 수 있다. 구체적으로, 스토리지 장치는 제2 스트림보다 제3 스트림으로부터의 데이터를 해당 블록에 기입하는 것이 더 효율적인지 판별할 수 있다. 물론, 해당 블록으로부터 변경되어 이탈된 스트림들의 데이터는 다른 블록들에 기입될 수 있다.

또 다른 해결책은 제2차 스트림들을 사용하는 것이다. 상술된 스트림들은 제1차 스트림들로 여겨질 수 있다. 즉, 각 스트림은 유사한 TTL 특성들을 갖는 데이터를 포함할 수 있다. 그러나 제1차 스트림들로부터의 데이터를 블록들에 기입하는 대신, 제1차 스트림들로부터의 데이터가 제2차 스트림들에 기입될 수 있다. 제2차 스트림은 자신의 TTL을 가지며, 제2차 스트림으로 전송된 데이터는 블록들에 기입될 수 있다. 상이한 제1차 스트림들은 제2차 스트림의 수명에서 얼마나 많은 시간이 남았는지에 따라 데이터를 제2차 스트림으로 제공할 수 있다. 본 발명의 실시 예들에서, 제2차 스트림 및 SSD의 블록들 사이의 관계는 유지되며 블록 내의 데이터의 보다 일관된 만료가 달성된다.

도 2a 내지 도 2d는 본 발명의 실시 예들에 따라 상이한 TTL을 갖는 다중 스트림들과 연관된 데이터를 수신하는 도 1의 블록의 예를 보여준다. 도 2a 내지 도 2d는 또한 다중 스트림들로부터의 데이터를 단일 블록에 기입하는 것의 장점을 보여준다. 도 2a 내지 도 2d에서, SSD의 블록들은 1MB의 사이즈이고, SSD는 두 개의 스트림들을 수신하는 것으로 가정된다. 스트림(205)은 60분의 예측 TTL을 갖고, 한 번에 평균 24KB의 데이터를 기입하고, 그리고 평균 매 분마다 하나의 파일을 기입한다. 스트림(210)은 45분의 예측 TTL을 갖고, 한 번에 평균 256KB의 데이터를 기입하고, 그리고 평균 매 5분마다 하나의 파일 기입한다.

도 2a는 블록(103)에 기입된 데이터 모두가 단일 스트림에 연관된 상황을 다시 보여준다. 스트림(205)에 대해 24KB의 데이터의 평균 파일 사이즈가 주어지면, 그리고 평균 매 분마다 하나의 파일의 쓰기 도착률이 주어지면, 블록(103)의 1MB 용량을 채우는데 대략 45분이 소요된다. 따라서, 블록(103)이 채워진 후에, 블록(103)에 기입된 첫 데이터는 15분의 잔여 TTL 값(215)을 갖고, 블록(103)에 기입된 마지막 데이터는 60분의 잔여 TTL 값(220)을 갖는다. 블록(103)은 마지막 데이터가 기입될 때까지의 45분 및 해당 데이터의 TTL인 1시간을 합한 총 한 시간 45분 동안 유효 데이터를 가질 수 있다.

마지막 데이터가 목표 블록에 추가된 후 한 시간 이전에 목표 블록에 가비지 컬렉션이 강제되면, 블록에 유효 데이터가 여전히 존재하며 이들은 가비지 컬렉션 동안 다른 블록으로 전송되어야 한다. 또한, SSD가 해당 블록에 대해 가비지 컬렉션을 더 일찍 수행할수록, SSD에서 다른 블록으로 재배치되어야 하는 잔여 유효 데이터가 증가한다.

도 2b에서, 스트림(205)이 단지 22분 동안에 데이터를 블록(103)에 기입된 때(블록(103)이 절반 채워진 때)가 고려된다. 22분에, 처음으로 기입된 데이터는 38분의 잔여 TTL 값(215)을 갖고, 마지막 기입된 데이터는 60분의 잔여 TTL 값(225)을 갖는다.

22분 이후에, 블록(103)은 도 2c에 도시된 바와 같이 스트림(210)으로 전환된다. 27분에, 스트림(210)은 데이터를 블록(103)에 기입하여 45분의 TTL 값(230)을 갖는 데이터를 추가한다. TTL 값들(215, 225)은 스트림(210)이 첫 번째 데이터를 기입하는 것을 기다리는 동안 5분 감소한다.

최종적으로, 32분에, 스트림(210)은 두 번째 파일을 블록(103)에 기입한다. 스트림(210)에 대해 주어진 평균 쓰기 사이즈 및 쓰기 도착률에 따라, 두 번째 파일은 블록(103)을 완료(또는 완전히 채움)할 수 있다. 이때에, 스트림(205)으로부터의 기입된 데이터는 28분의 TTL 값(215)으로부터 50분의 TTL 값(225)으로 변화하는 잔여 TTL 값들을 가지며, 스트림(210)으로부터의 기입된 데이터는 40분 및 45분의 TTL 값들(230, 235)을 각각 갖는다. 블록(103)이 32분에 완전히 채워지므로, 그리고 가장 긴 잔여 TTL (TTL 값 225)이 50분 내에 만료할 것이 예측되므로, 블록(103)은 도 2a에서 발생하는 것보다 23분 이른 1시간 22분에 블록(103)을 가비지 컬렉션으로 인도할 수 있다. 또한, 더 많은 데이터가 동일한 시간 부근에 만료하도록 유도되므로, 블록(103)은 모든 데이터가 만료하기 전에는 가비지 컬렉션에 대해 나쁜 후보일 수 있다.

더 많은 스트림들로, 공급률, TTL, 그리고 데이터 사이즈에 대한 더 많은 수의 옵션들로, 페이지들이 모두 한 번에 무효화 되도록 스트림들을 변경하며 블록들을 채우는 능력이 강화된다. 예를 들어, 각각 임의의 TTL, 평균 쓰기 사이즈 및 평균 쓰기 도착률을 갖는 임의의 수의 스트림들이 제공될 수 있다.

도 3a 내지 도 3d는 도 1의 블록(103)이 상이한 TTL을 갖는 다중 스트림들과 연관된 데이터를 어떻게 수신하는지의 제2 예를 보여준다. 도 3a 내지 도 3d에서, 스트림들 사이의 주된 차이점은 TTL이 되도록, 동일한 데이터 공급률 및 평균 쓰기 사이즈를 갖는 네 개의 스트림들이 고려된다. 도 3a 내지 도 3d에서, 네 개의 스트림들은 각각 60분, 45분, 30분 및 15분의 TTL 값들을 갖는 것으로 설명된다.

도 3a에서, 스트림(305)은 60분의 TTL 값(240)을 갖는 블록(103)에 기입한다. 스트림(305)은 60분의 TTL 값(310)을 가지며, 15분 동안에 최대 60분의 잔여 TTL 값(315)을 갖는 데이터가 블록(103)의 4분의 1에 기입된다. 이때, SSD는 도 3b에 도시된 바와 같이 스트림(305)으로부터 스트림(320)으로 전환한다. 스트림(320)은 45분의 TTL 값(325)을 갖는다. 또 다시 15분 동안에 블록(103)의 또 다른 4분의 1에 스트림(302)으로부터 데이터가 기입된다. 이때, 블록(103)은 45분 내에 만료할 것으로 예측되는 데이터(315, 330)로 절반 채워져 있다.

도 3c에 도시된 바와 같이, SSD는 스트림(335)으로 전환한다. 스트림(335)은 30분의 TTL 값(340)을 갖는다. 15분 동안에 스트림(335)은 블록(103)의 또 다른 4분의 1에 데이터를 기입하며, 블록의 4분의 3이 30분의 TTL 값들(315, 330, 345)을 갖는 데이터로 채워진다. 이때, SSD는 도 3d에 도시된 바와 같이 스트림(350)으로 전환한다. 스트림(350)은 15분의 TTL 값(355)을 갖는다. 15분 후에, 스트림(350)이 데이터를 기입하여 블록(103)을 완전히 채우며, 블록(103)의 데이터(315, 330, 345, 360)는 15분 내에 만료할 것으로 예측된다. 따라서, 도 3a의 스트림(305)으로부터 첫 데이터가 기입되고 1시간 15분 후에, 블록(103)의 모든 데이터가 만료될 것으로 예측되며, 전체 블록이 가비지 컬렉션될 수 있다.

통상적인 시스템과 비교하면, 도 2b 내지 도 2d의 예들 및 도 3a 내지 도 3d의 예들은 향상된 가비지 컬렉션 성능을 제공한다. 다중 스트리밍 스토리지를 이용함으로써, 블록은 감소하는 TTL 값들을 갖는 데이터로 순차적으로 채워진다. 블록의 데이터는 전체적으로 더 빠르게 만료하며, 더 많은 데이터가 동일한 시간 부근에서 만료한다. 결과적으로, 가비지 컬렉션이 수행될 때에 블록들은 모든 데이터가 만료되도록 하며, 블록에서 가비지 컬렉션을 수행하기 전에 유효 데이터를 다른 블록으로 복사할 필요성을 제거한다. 또한, 더 많은 데이터가 동일한 시간 부근에 만료하므로, 블록 내의 모든 데이터가 만료하기 전에 해당 블록은 가비지 컬렉션의 대상으로 선택되지 않을 수 있다.

도 2b 내지 도 2d를 도 3a 내지 도 3d와 비교하여 나타나는 바와 같이, 선택할 더 많은 스트림들이 존재하면, 블록의 모든 데이터가 만료하는 시간은 감소된다. 예를 들어, 도 2b 내지 도 2d에서, 블록의 모든 데이터가 1시간 32분에 만료할 것으로 예상된다. 도 3a 내지 도 3d에서, 블록의 모든 데이터가 1시간 15분에 만료할 것으로 예상된다. 블록의 데이터는 더 동일한 시간 부근에 만료함에 따라, 블록이 유효 데이터를 포함하는 동안 해당 블록이 가비지 컬렉션을 위해 선택되지 않을 수 있다.

도 2a 내지 도 2d에서, 블록(103)에 데이터를 기입하는 데에 두 개의 스트림들이 설명되고 사용되었다. 도 3a 내지 도 3d에서, 데이터를 블록(103)에 기입하는 데에 네 개의 스트림들이 설명되고 사용되었다. 그러나 이러한 예들은 블록(103)에 데이터를 기입하는 데에 사용되는 모든 스트림들을 보여주지만, 본 발명의 다른 예들은 가용한 스트림들의 일부만을 사용할 수 있다. 예를 들어, 도 2a 내지 도 3d에서, SSD에 20개의 스트림들이 기입될 수 있으며, 이러한 스트림들 중 일부만이 블록(103)에 기입될 수 있다. 다양한 스트림들은 상이한 TTL 값들, 쓰기 사이즈들, 그리고 쓰기 도착률들을 가질 수 있으며, 한정되지 않는다.

블록이 얼마나 빨리 최적의 가비지 컬렉션을 위해 준비되는지에 대해 하한이 존재한다. 블록(103)에 기입되는 각 페이지는 자신이 유래한 스트림에 따라 자신의 TTL을 갖는다. 최악의 경우, 블록은 블록을 채우는 시간 및 블록에 기입되는 데이터의 최대 TTL의 합 동안 유효 데이터를 가질 수 있다. 더 정확하게는, 블록(103)은 수학식 1에 의해 계산되는 시간 까지 유효 데이터를 포함할 수 있다.

먼저 기입되는 페이지는 더 긴 TTL을 가질 수 있으며, 해당 페이지의 만료 시간은 더 짧은 TTL을 갖는 나중에 기입되는 페이지의 만료 시간보다 이후일 수 있다. 그러나 종종, 블록의 모든 데이터의 만료 시간은 블록에 마지막으로 기입된 데이터의 만료 시간일 것이다. 따라서, 블록을 채우는 데에 한 시간이 소요된다면, 그리고 마지막 기입된 데이터가 15분의 TTL을 갖는다면, 블록의 데이터는 1시간 15분 근처에서 만료할 것으로 예상된다.

본 발명의 다른 실시 예들에서, 모든 제1차 스트림들은 앞서 설명(또는 도시)된 바와 같이 분석된다. 그러나 블록에 직접 기입하는 대신, 제1차 스트림들은 해당 스트림들의 잔여 시간에 기반하여 시간 제한된 제2차 스트림들에 데이터를 기입할 수 있다. 도 4는 제2차 스트림의 예를 보여준다.

간결한 예로서, 도 3a 내지 도 3d에 도시된 제1차 스트림들, 즉 1시간의 TTL 값(310)을 갖는 스트림(305), 45분의 TTL 값(325)을 갖는 스트림(320), 30분의 TTL 값(340)을 갖는 스트림(335), 그리고 15분의 TTL 값(355)을 갖는 스트림(350)이 고려된다. 또한, 1시간의 TTL 값(410)을 갖는 하나의 제2차 스트림(405)이 고려된다.

제2차 스트림(405)이 생성될 때, 제2차 스트림(405)에 우선 스트림(305)으로부터의 데이터에 할당된다. 제2차 스트림(405)이 노화하여 수명이 45분에 도달하면, 제2차 스트림(405)은 스트림(305)으로부터 데이터를 수신하는 것을 중지하고 스트림(320)으로부터 데이터를 수신하는 것을 시작한다. 마찬가지로, 제2차 스트림(405)의 수명이 30분에 도달하면, 제2차 스트림(405)은 스트림(335)으로부터 데이터를 수신한다. 나중에 수명이 15분 남았을 때, 제2차 스트림(405)은 스트림(350)으로부터 데이터를 수신한다.

이러한 방식에서, 제2차 스트림(405)에 할당된 블록(103)은 모든 데이터가 15분 내에 무효화(이는 제1차 스트림의 세부도(granularity)임에 주의)되게 하며, 전체 블록의 수명은 1시간 15분이다. 이 예에서, 동작들은 도 3a 내지 도 3d에 도시된 실시 예와 유사하지만, 동일할 필요는 없다. 데이터 공급률이 데이터의 수명 또는 블록의 잔여 사이즈와 비교하여 높은 경우, 제2차 스트림의 예는 더 높은 유연성을 제공할 수 있다. 제2차 스트림이 만료하기 전에 제2차 스트림이 블록을 채우면, 제2차 스트림은 새로운 블록으로 이동(잔여 TTL과 함께)되고, 이전 블록은 거의 동시에 만료(제1차 스트림의 세부도 내에서)하는 데이터 모두를 여전히 가질 수 있다. 다시 말하면, 제2차 스트림 메커니즘에서, 시스템은 수명의 끝에 근접한 블록을 채우기 위해 낮은 수명 또는 빠른 공급률을 갖는 스트림들을 찾아야 하는 부담을 갖지 않는다. 만료하는 제2차 스트림에 의해 채워지지 않은 블록은 해당 블록에 이미 저장된 데이터의 잔여 TTL과 유사한 수명을 갖는 새로운 스트림에 의해 채워질 수 있다.

어느 해법으로든, 더 많은 제1차 스트림들로, 더 적은 시간 세부도가 확보될 수 있다. 즉, 페이지들은 더 가까운 시간들 내에서 무효화되는 성향을 가질 수 있다.

앞서 언급된 제1 실시 예와 같이, 다수의 제2차 스트림들이 동시에 동작할 수 있다. 상이한 제2차 스트림들은 제1차 스트림들의 특성들에 따라 상이한 수명들로 생성될 수 있다.

어느 해법에서든, SSD가 상이한 스트림(블록에 데이터를 기입하는 상이한 제1차 스트림 혹은 제2차 스트림에 할당된 상이한 제1차 스트림)으로의 전환을 결정할 때 SSD는 새로운 스트림을 선택하기 위하여 필요한 임의의 알고리즘을 사용할 수 있다. 새로운 제1차 스트림을 선택하기 위한 하나의 알고리즘은 블록 또는 제2차 스트림의 잔여 TTL보다 크고 가장 작은 TTL (또는, 블록 또는 제2차 스트림의 잔여 TTL보다 큰 TTL을 갖는 스트림이 없는 경우 가장 큰 TTL)을 갖는 제1차 스트림을 선택하는 것이다. 따라서, 도 3a를 참조하면, 블록(103)이 60분의 TTL 값(240)을 가지므로, 60분의 TTL 값(310)을 갖는 스트림(305)이 최선의 선택이다. 도 3b에서 TTL 값(240)이 45분으로 감소하면, 45분의 TTL 값(325)을 갖는 스트림(320)이 알고리즘에 따라 최선의 선택이 된다. 도 3c에서 TTL 값(240)이 30분으로 감소하면, 30분의 TTL 값(340)을 갖는 스트림(335)이 알고리즘에 따라 최선의 선택이 된다. 동일한 선택 전략이 도 4의 제2차 스트림(405)과 연관될 제1차 스트림을 선택할 때에 적용될 수 있다.

다른 예로서, SSD는 블록의 잔여 TTL과 가장 가까운 TTL을 갖는 제1차 스트림을 선택할 수 있다. 따라서, 도 3a를 참조하면, 60분의 TTL 값(310)을 갖는 스트림(305)이 블록(103)의 60분의 TTL 값(240)과 가장 가까우며, 해당 스트림은 7분 30초까지 사용하는 것이 유지될 수 있다. 이 시간 후에, 45분의 TTL 값(325)을 갖는 스트림(320)이 블록(103)의 52분 30초의 잔여 TTL 값(240)에 가장 가까우며, 22분 30초까지 사용하는 것이 유지된다. 22분 30초 이후에, 30분의 TTL 값(340)을 갖는 스트림(335)이 블록(103)의 37분 30초의 잔여 TTL 값(240)과 가장 가깝다.

도 5는 본 발명의 실시 예들에 따라 도 1의 블록에 상이한 스트림들로부터의 데이터를 기입하는 SSD를 보여준다. 도 5에서, SSD (505)가 도시된다. SSD (505)는 정보(동작들 또는 데이터)를 송신 및 수신하는 데에 사용되는 회로(510)를 포함할 수 있다. SSD (505)는 또한 SSD 컨트롤러(515) 및 플래시 메모리(520)를 포함할 수 있다. SSD 컨트롤러(515)는 SSD (505)의 동작을 제어할 수 있다. 플래시 메모리(520)는 데이터를 저장할 수 있다. 즉, 플래시 메모리(520)는 도 1의 블록(103)에 데이터를 저장할 수 있다.

SSD 컨트롤러(515)는 다른 구성 요소들 중에서도 특히 선택 로직(525), 쓰기 로직(530) 및 TTL 계산기(535)를 포함할 수 있다. 선택 로직(525)은 도 1의 블록(103)에 데이터를 기입하는 데에 또는 도 4의 제2차 스트림(405)에 할당하는 데에(도 4의 제2차 스트림이 사용되는 경우) 사용될 스트림을 선택할 수 있다. 쓰기 로직(530)은 데이터를 플래시 메모리(520)에 기입, 예를 들어 도 4의 제2차 스트림(405)의 커맨드에 따라 기입할 수 있다. 더 상세하게는, 쓰기 로직(530)은 도 1의 블록(103)의 페이지와 같은 플래시 메모리(520)의 페이지에 데이터를 기입할 수 있다. TTL 계산기(535)는 스트림의 TTL (예를 들어, 도 2a 내지 도 2d의 TTL 값들(245, 250), 도 3a 내지 도 3d의 TTL 값들(310, 325, 340, 355) 또는 도 4의 TTL 값(410)과 같은) 또는 블록의 TTL (예를 들어, 도 2a 내지 도 3d의 블록 TTL 값들(240))을 계산할 수 있다.

제2차 스트림들을 사용하는 본 발명의 실시 예에서, SSD 컨트롤러(515)는 제2차 스트림 생성기(540)를 포함할 수 있다. 제2차 스트림 생성기(540)는 도 4의 블록(103)과 연관된 도 4의 제2차 스트림(405)을 생성할 수 있다.

도 6은 도 5의 선택 로직(525)의 상세를 보여준다. 도 6에서, 선택 로직(525)은 비교기(605), 평균 쓰기 계산기(610), 평균 쓰기 도착률 계산기(615), 스트림 선택 로직(620), 그리고 스토리지(625)를 포함한다. 스토리지(625)는 블록 TTL (240) 또는 제2차 스트림 TTL (410)을 저장할 수 있다. 블록 TTL (240) 또는 제2차 스트림 TTL (410)은 선택 로직(525)의 외부에 저장될 수 있다. 비교기(605)는 도 2a 내지 도 2d의 스트림들(205, 210)에 대한 TTL 값들(245, 250) 및 도 3a 내지 도 3d의 스트림들(305, 320, 335, 350)에 대한 TTL 값들(310, 325, 340, 355)을 본 발명의 실시 예들에 따라 블록 TTL (240) 또는 제2차 스트림 TTL (410)과 비교할 수 있다. 이러한 비교에 기반하여, 본 발명의 실시 예들에 따라, 스트림 선택 로직(620)은 도 1의 블록(103)에 데이터를 기입할 스트림 또는 도 4의 제2차 스트림(405)에 할당될 스트림을 선택할 수 있다.

선택 로직(525)은 필요한 시간에 동작할 수 있다. 예를 들어, 선택 로직(525)은 5분과 같은 주기 기반으로 사용될 수 있다. 또는, 선택 로직(525)은 도 5의 SSD (505)에 새로운 쓰기 요청이 전달될 때마다 사용될 수 있다. 또는, 선택 로직(525)은 블록 TTL (240) 또는 제2차 스트림 TTL (410)이 도 1의 블록(103) 또는 도 4의 제2차 스트림(405)에 현재 데이터를 기입중인 스트림의 TTL 값, 예를 들어 도 2a 내지 도 2d의 TTL 값들(245 또는 250) 또는 도 3a 내지 도 3d의 TTL 값들(310, 325, 340, 355)보다 낮아질 때마다 수행될 수 있다. 선택 로직(525)은 스트림을 선택할 때에 각 스트림의 평균 쓰기 사이즈 및 평균 쓰기 도착률과 같은 다른 정보를 고려할 수 있다. 예를 들어, 도 2a 내지 도 3d의 60분의 TTL 값(240)을 갖는 블록(103)이 60페이지를 갖는 것으로 가정된다. 60분의 TTL 값을 갖는 하나의 페이지를 매 분마다 기입하는 스트림은 블록(103)이 120분(마지막 페이지가 기입될 때까지의 60분 및 해당 페이지가 만료할 때까지의 60분) 동안 유효 데이터를 저장할 수 있다. 그러나, 15분의 TTL 값을 갖는 하나의 페이지를 5분마다 기입하는 다른 스트림이 유일하게 가용하고 그리고 선택 로직(525)이 45분에 해당 스트림으로 전환하면, 블록(103)을 채우는 데에 120분이 소요되고 블록(103)의 마지막 데이터가 만료되기까지 15분이 추가로 소요된다. 따라서, 평균 쓰기 사이즈 및 평균 쓰기 도착률은 스트림을 변경하는 최적의 시간에 영향을 준다. 선택 로직(525)을 사용하는 다른 스케줄이 사용될 수 있으며, 한정되지 않는다.

도 7은 도 6의 평균 쓰기 사이즈 계산기(610)의 상세를 보여준다. 도 7에서, 평균 쓰기 사이즈 계산기(610)는 주어진 스트림에 대한 쓰기 동작들(106, 109, 112, 124, 127)에 대한 정보를 수신하고, 해당 쓰기들에 대한 평균 쓰기 사이즈(705)를 계산할 수 있다. 즉, 기입된 데이터의 양의 합이 수행된 쓰기 동작들의 횟수로 나누어진다. 상술된 바와 같이, 평균 쓰기 사이즈 계산기(610)는 스트림, 스트림의 최근 n개의 쓰기 동작들, 마지막 n개의 쓰기 동작들 중 가장 빠른 k개의 쓰기 동작들, 마지막 t 분 동안에 발생하는 스트림의 쓰기 동작들, 또는 스트림의 쓰기 동작들을 선택하는 다른 필요한 시도에 따라 선택된 쓰기 동작들의 가용한 모든 정보를 사용할 수 있다.

도 8은 도 6의 평균 쓰기 도착률 계산기(615)의 상세를 보여준다. 도 8에서, 평균 쓰기 도착률 계산기(615)는 주어진 스트림에 대한 쓰기 동작들(106, 109, 112, 124, 127)에 대한 정보를 수신하고, 해당 쓰기 동작들의 평균 쓰기 도착률(805)을 계산할 수 있다. 즉, 첫 번째 및 마지막 쓰기 동작들 사이의 시간의 양이 해당 구간 동안 수행된 쓰기 동작들의 수로 나누어질 수 있다. 상술된 바와 같이, 평균 쓰기 도착률 계산기(615)는 스트림, 스트림의 최근 n개의 쓰기 동작들, 마지막 n개의 쓰기 동작들 중 가장 빠른 k개의 쓰기 동작들, 마지막 t 분 동안에 발생하는 스트림의 쓰기 동작들, 또는 스트림의 쓰기 동작들을 선택하는 다른 필요한 시도에 따라 선택된 쓰기 동작들의 가용한 모든 정보를 사용할 수 있다.

도 9는 도 6의 스트림 선택 로직(620)의 상세를 보여준다. 도 9에서, 스트림 선택 로직(620)은 도 2a 내지 도 3d의 블록 TTL (240), 도 2a 내지 도 2d의 스트림들(205, 210)로부터의 TTL 값들(245, 250), 도 3a 내지 도 3d의 스트림들(305, 320, 335, 350)의 TTL 값들(310, 325, 340, 355), 각 스트림의 평균 쓰기 사이즈(705), 그리고 각 스트림의 평균 쓰기 도착률(805)과 같은 다양한 정보를 수신할 수 있다. 스트림 선택 로직(620)은 이러한 정보를 이용하여 스트림(905)을 선택하고 도 2b 내지 도 3d의 블록(103)에 기입할 수 있다. 스트림 선택 로직(620)은 필요한 전략을 이용하여 스트림(905)을 선택하고, 이를 도 2b 내지 도 3d의 블록(103) 또는 도 4의 제2차 스트림(405)에 기입할 수 있다. 예를 들어, 스트림 선택 로직(620)은 도 2a 내지 도 3d의 블록의 잔여 TTL (240)보다 작은 가장 큰 TTL을 갖는 스트림을 선택할 수 있다. 또는, 스트림 선택 로직(620)은, 도 2a 내지 도 2d를 참조하여 설명된 바와 같이, 스트림들을 전환하는 시간을 계산하여 데이터 만료를 최적화할 수 있다. 스트림 선택 로직(620)은 다른 선택 전략들 또한 사용할 수 있다. 상술된 바와 같이, 스트림 선택 로직(620)은 제공되는 모든 정보 또는 이들 중 일부를 이용하여 스트림(905)을 선택할 수 있다. 예시적으로, 스트림 선택 로직(620)이 도 9에 도시된 정보 모드를 사용하지 않는 경우, 스트림 선택 로직(620)은 도 9에 도시된 정보 모두를 제공받을 필요는 없다.

도 10은 도 5의 TTL 계산기(535)의 상세를 보여준다. 도 10에서, TTL 계산기(535)는 주어진 스트림에 대한 쓰기 동작들(106, 109, 112, 124, 127)의 정보를 수신하고, 해당 스트림의 TTL 값(310, 325, 340 또는 355)을 계산할 수 있다. 즉, 데이터가 기입되는 시간 및 데이터가 갱신 또는 삭제되는 시간 사이의 시간 구간이 측정되고, 측정된 시간 구간들이 합해지고, 합해진 시간이 영향을 받은 페이지들의 수로 나누어질 수 있다. 상술된 바와 같이, TTL 계산기(535)는 스트림, 스트림의 최근 n개의 쓰기 동작들, 마지막 n개의 쓰기 동작들 중 가장 빠른 k개의 쓰기 동작들, 마지막 t 분 동안에 발생하는 스트림의 쓰기 동작들, 또는 스트림의 쓰기 동작들을 선택하는 다른 필요한 시도에 따라 선택된 쓰기 동작들의 가용한 모든 정보를 사용할 수 있다.

도 11은 도 5의 SSD를 포함하는 기계의 상세를 보여준다. 도 11을 참조하면, 통상적으로, 기계 또는 기계들(1105)은 하나 또는 그보다 많은 프로세서들(1110)을 포함한다. 프로세서들(1110)은 메모리 컨트롤러(1115) 및 클럭(1120)을 포함한다. 클럭(1120)은 기계 또는 기계들(1105)의 구성 요소들의 동작들을 조율하는 데에 사용된다. 프로세서들(1110)은 메모리(1125)와 결합될 수 있으며, 메모리들(1125)은 랜덤 액세스 메모리(RAM), 읽기 전용 메모리(ROM), 또는 다른 상태 보존 매체를 포함할 수 있다. 프로세서들(1110)은 스토리지 장치(505) 및 네트워크 커넥터(1130)에 연결될 수 있으며, 네트워크 커넥터(1130)는 이더넷 커넥터일 수 있다. 프로세서들(1110)은 버스(1135)에 연결될 수 있으며, 버스(1135)는 사용자 인터페이스(1140) 및 입출력 엔진(1145)을 사용하여 관리되는 입출력 인터페이스 포트들과 연결될 수 있다.

도 12는 본 발명의 실시 예들에 따라 도 1의 블록(103)에 상이한 스트림들로부터의 데이터를 기입하는 도 5의 SSD의 절차의 순서도이다. 도 12의 블록(1205)에서, 도 5의 SSD (505)는 도 1의 블록(103)을 식별할 수 있다. 블록(1210)에서, 도 5의 SSD (505)는 도 2a 내지 도 3d의 블록 TTL (240)을 도 1의 블록(103)과 연관할 수 있다. 블록(1215)에서, 도 5의 SSD (505)는 도 2a 내지 도 2d의 스트림들(205, 210) 및 도 3a 내지 도 3d의 스트림들(305, 320, 335, 350)을 수신할 수 있다. 블록(1220)에서, 도 5의 SSD (505)는 도 1의 블록(103)에 기입할 스트림(905)을 선택할 수 있다. 블록(1225)에서, 도 5의 SSD (505)는 선택된 스트림(905)으로부터의 데이터를 도 1의 블록(103)에 기입할 수 있다. 점선(1230)으로 도시된 바와 같이, 제어는 옵션으로 블록(1220)으로 회귀하며, 이후에 도 5의 SSD (505)가 다른 블록을 선택하고 도 1의 블록(103)에 기입하는 것을 가능하게 할 수 있다.

도 13은 본 발명의 실시 예들에 따라 제2차 스트림을 이용하여 도 1의 블록에 상이한 스트림들로부터의 데이터를 기입하는 도 5의 SSD의 절차의 순서도를 보여준다. 도 13의 블록(1205)에서, 도 5의 SSD (505)는 도 1의 블록(103)을 식별한다. 블록(1305)에서, 도 5의 SSD (505)는 도 4의 제2차 스트림(405)을 생성한다. 블록(1310)에서, 도 5의 SSD (505)는 도 4의 TTL (410)을 도 4의 제2차 스트림(405)에 할당할 수 있다. 블록(1315)에서, 도 5의 SSD (505)는 도 2a 내지 도 2d의 스트림들(205, 210) 또는 도 3a 내지 도 3d의 스트림들(305, 320, 335, 350)을 수신할 수 있다. 블록(1315)에서, 도 5의 SSD (505)는 도 4의 제2차 스트림(405)에 기입할 스트림(905)을 선택할 수 있다. 블록(1320)에서, 도 5의 SSD (505)는 선택된 스트림(905)으로부터의 데이터를 도 4의 제2차 스트림(405)에 기입할 수 있다. 블록(1325)에서, 도 5의 SSD (505)는 도 4의 제2차 스트림(405)으로부터의 데이터를 도 1의 블록(103)에 기입할 수 있다. 점선(1330)으로 도시된 바와 같이, 제어는 옵션으로 블록(1215)으로 회귀하며, 이후에 도 5의 SSD (505)가 도 4의 제2차 스트림(405)에 기입할 다른 스트림을 선택하는 것을 가능하게 할 수 있다.

상술된 설명은 강화된 다중 스트리밍이 블록의 데이터 무효화의 시간에 접근함으로써 전체적인 SSD 성능을 어떻게 향상시키는지를 보여준다. 블록의 데이터가 무효화되는 시간에 주의 깊게 접근함으로써, 소거 블록이 자유롭게 되기 전에 더 적은 유효 데이터(이상적으로는 유효 데이터가 존재하지 않음)가 다른 블록으로 프로그램되어야 하므로, 가비지 컬렉션 효율이 향상된다. 그러나 상술된 설명은 스트림에 대해 제공되는 메타 데이터(예를 들어, 스트림 TTL)가 정확하게 스트림의 데이터의 수명을 나타낸다고 가정한다. 데이터가 스트림 메타 데이터에 완전히 따르지 않거나 또는 스트림 메타 데이터를 제공하는 호스트가 정확하지 않은 스트림 메타 데이터를 제공함으로 인해 이러한 정보가 부정확하다면, SSD의 전체적인 성능은 데이터가 SSD 블록들이 랜덤하게 기입될 때보다 좋지 않을 수 있다.

스트림 TTL에 의존함에 따른 문제 중 하나는 스트림 TTL이 통상적으로 단일 수라는 점이다. 스트림 TTL이 30분, 36시간 또는 다른 단일 수이면, 해당 수는 보통 스트림 데이터의 수명의 평균 또는 중간 값이며, 또는, 정규 분포에서, 평균에서 특정한 표준 편차 내의 특정 점의 수일 수 있다. 격리(isolation)에서 이 수를 사용하는 것은 스트림 메타 데이터의 많은 부분을 버린다. 데이터의 특정한 부분이 무효화되기 전에 얼마나 오래 지속할지를 SSD 또는 호스트가 100% 정확하게 아는 방법은 없지만, 보다 복잡한 모델을 이용하여 스트림을 모델링하는 것은 더 정확한 측정을 제공할 수 있다.

도 14 및 도 15는 평균 또는 중간 값과 같은 단일 수를 스트림 메타 데이터로 사용함에 따라 얼마나 많은 데이터가 소실되는지 그리고 이러한 정보를 무시함에 따른 잠재적인 결과를 보여준다. 도 14는 공통 평균을 갖지만 표준 편차가 다른 두 개의 예시적인 정규 분포 곡선들을 보여준다. 도 14에서, 갱신 횟수 대 갱신들 사이의 시간의 양, 그리고 비교 곡선들(1410, 1415)을 표시하는 그래프(1405)가 도시된다. 그러나, 곡선(1410)은 매우 좁은 분포를 갖고, 따라서 작은 표준 편차를 갖는다. 반면, 곡선(1415)은 매우 넓은 분포를 갖고, 따라서 큰 표준 편차를 갖는다.

곡선들(1410, 1415) 모두는 평균 값(1420)을 공유하며, 또한 공통 중간 값을 공유할 수 있다. 또한, 주어진 신뢰 수준에서, 곡선들(1410, 1415)은 데이터 포인트들을 동일 개수 갖는 것으로 추정된다. 신뢰 수준은 그래프(1405)에서 평균(1420)으로부터의 거리로 여겨지며, 데이터 포인트들의 주어진 비율이 평균(1420)으로부터 해당 거리보다 멀게 존재하지 않을 수 있다. 예를 들어, 경계들(1425)은 곡선(1410)의 데이터 포인트들의 90%를 포함하는 제한을 나타내며, 90% 신뢰 수준으로 표현된다. 또한, 곡선(1415)에 대해 90% 신뢰 수준으로 경계들이 정해질 수도 있다. 그러나, 곡선(1415)이 더 넓으므로, 곡선(1415)의 90% 신뢰 수준의 경계들은 곡선(1410)의 90% 신뢰 수준의 경계들(1425)보다 평균(1420)으로부터 더 멀 수 있다. 즉, 곡선(1410)의 이상점들(outliers), 즉 90% 신뢰 수준의 밖에 있는 데이터 포인트들은 곡선(1415)의 이상점들보다 평균(1420)에 더 가까울 수 있다. 이러한 차이의 중요성은 도 23 내지 도 26을 참조하여 후술된다.

도 14의 곡선들(1410, 1415)이 정규 분포들(예를 들어, 가우시안 벨 곡선)로 도시되지만, 곡선들(1410, 1415)은 다른 타임의 분포들, 예를 들어, 다봉 분포로 대체될 수 있다. 후술되는 통계적 분석은 다른 분포 형태들에도 동일하게 적용될 수 있다.

일부 상황들에서, 데이터는 단일 분포 함수에 잘 부합하지 않는다. 도 15는 도 14에 도시된 것과 같은 분포 모델에 부합하지 않는 데이터의 예시적인 히스토그램을 보여준다. 도 15에서, 도 14의 그래프(1405)와 같이, 그래프(1505)는 갱신 횟수 대 갱신들 사이의 시간을 보여준다. 곡선(1510)은 데이터 갱신 횟수들, 예를 들어 상술된 사무실 작업자의 스프레드시트를 나타낸다. 대부분의 갱신들은 18 내지 24시간 간격으로 발생한다. 주말로 인해, 데이터는 60시간 정도 변경되지 않을 수 있다. 작업자들의 휴가로 인해, 갱신은 160 시간 정도에 수행될 수 있다.

그래프(1505)의 곡선(1510)은 정규 분포 또는 다른 단순 분포를 따르지 않는다. 대신, 18 내지 36시간 정도에 갱신들이 집중되며, 더 작은 비슷한 집중이 60시간 및 160시간 정도에 발생한다. 지역적 최대 값들을 중심으로 한 근처에서, 곡선(1510)은 정규 분포로 보이게 나타난다. 그러나 전체적인 관점에서, 곡선(1510)의 분포는 정규하지 않다.

갱신들 사이의 평균 시간 또는 90%와 같은 신뢰 구간을 이용하여, 곡선(1510)의 스트림 TTL은 대략 60시간일 수 있다. 그러나 이 수는 데이터가 어떻게 분포되는지를 완전하게 보여주기 어렵다. 곡선(1510)을 검토하여 보여지는 바와 같이, 데이터는 36시간 근처에서 가장 높은 확률로 갱신될 수 있다. 데이터가 36시간 이내에 갱신되지 않으면, 해당 데이터는 다음으로 60시간 근처에서 가장 높은 확률로 갱신될 수 있다. 데이터가 60시간 근처에서 갱신되지 않으면, 해당 데이터는 160시간이 될 때가지 변경되지 않을 확률이 크다.

도 16은 본 발명의 실시 예들에 따라 도 5의 SSD에 쓰기 및 무효화 요청들을 전달하는 스트림을 보여준다. 도 16에서, 응용(1605)은 SSD (505)로 다양한 쓰기 및 무효화 요청들을 이슈하는 것으로 도시된다. 응용(1605)은 읽기 요청 또한 이슈할 수 있으나, 읽기 요청들은 SSD (505)에 저장된 데이터를 변화시키지 않으므로, 읽기 요청들은 설명에서 제외된다. 예를 들어, 도 16은 쓰기 요청들(1610, 1615, 1620, 1625) 및 무효화 요청들(1630, 1635, 1640)을 이슈하는 응용(1605)을 보여준다. 이러한 쓰기 요청들 및 무효화 요청들은 도 3a 내지 도 3d의 스트림들(305, 320, 335, 350)과 같은 스트림의 일부일 수 있다. 도 16에서 네 개의 쓰기 요청들 및 세 개의 무효화 요청들이 도시되지만, 이러한 개수들은 예시적인 것이다. 본 발명의 실시 예들은 임의의 수의 쓰기 및 무효화 요청들을 스트림의 일부로 이슈하는 응용(1605)을 지원할 수 있다.

응용(1605)은 현존하는 어드레스에서 현존하는 데이터를 새로운 데이터로 치환할 것을 요청하는 덮어쓰기(또는 갱신) 요청들을 전송할 수 있다. SSD들에서, 덮어쓰기는 허용되지 않는다. 현존하는 데이터는 무효화(또는 삭제)되어야 하고, 새로운 데이터는 스토리지 장치의 새로운 어드레스에 기입된다. 다른 타입의 스토리지 장치들을 사용하는 다중 스트리밍에서, 덮어쓰기들은 가능할 수 있다. 본 발명의 일부 실시 예들에서, 데이터가 즉시 치환되므로, 덮어쓰기들은 데이터의 수명을 종료하는 것으로 취급되지 않을 수 있다. 본 발명의 다른 실시 예들에서, 덮어쓰기들은 원본 데이터를 삭제하고 그 자리에 새로운 데이터를 기입하는 것으로 취급되며, 따라서 원본 데이터의 수명이 종료되고 새로운 데이터의 수명이 시작되는 것으로 취급될 수 있다. 그러나, 덮어쓰기가 원본 데이터의 수명을 종료하는 것으로 취급되지 않으면, 덮어쓰기는 읽기 요청들과 같이 무시될 수 있다. 덮어쓰기들이 원본 데이터의 수명을 종료하고 새로운 데이터의 수명을 시작하는 것으로 취급되면, 덮어쓰기들은 삭제 및 쓰기 요청들의 조합으로 여겨질 수 있다. 따라서, 예를 들어, 무효화 요청(1630) 및 쓰기 요청(1625)을 전송하는 대신, 응용(1605)은 하나의 덮어쓰기 요청을 전송하고, SSD (505)는 해당 요청을 무효화 요청(1630) 및 쓰기 요청(1625)으로 해석할 수 있다. 이 예에서, 무효화 시간(1645) 및 쓰기 시간(1650)은 동일한 값 또는 무효화 시간(1645)이 쓰기 시간(1650)보다 미세하게 선행하는 매우 가까운 값일 수 있다.

도 16은 요청들을 이슈하는 응용에 의해 스트림들이 판별됨을 보여준다. 이는 스트림에 포함되는 데이터를 결정하는 한 가지 방법이지만, 본 발명의 실시 예들은 스트림 지정을 위한 다른 임의의 필요한 소스를 포함할 수 있다. 예를 들어, 스트림은 특정한 호스트 기계 또는 호스트 기계들의 세트로부터 이슈되는 모든 요청들을 포함할 수 있다. 또는, 스트림은 그룹 내의 특정한 사용자가 사용 중인 기계에 관계없이, 특정한 사용자와 연관된 요청들을 포함할 수 있다. 통상적으로, SSD (505)는 요청들을 이슈하는 파일 시스템 너머의 요청들의 소스에 대한 정보를 모르므로, 스트림들은 SSD (505)의 외부에서 정의된다. 그러나 여기서 설명된 것처럼, 충분한 정보가 주어지면 스트림들은 SSD (505)에 의해 정의될 수 있으며, SSD (505)는 요청들을 구체적인 스트림과 연관할 수 있다.

간결한 설명을 위하여, 도 16은 쓰기 요청들 및 무효화 요청들은 번호로 짝지워진 것으로 도시된다. 예를 들어, 무효화 요청(1630)은 쓰기 요청(1610)에 의해 기입된 데이터를 삭제할 수 있다. 무효화 요청(1635)은 쓰기 요청(1615)에 의해 기입된 데이터를 삭제할 수 있다. 무효화 요청(1640)은 쓰기 요청(1620)에 의해 기입된 데이터를 삭제할 수 있다. 응용(1605)이 아직 대응하는 무효화 요청을 이슈하지 않았으므로, 쓰기 요청(1625)에 의해 기입된 데이터는 SSD (505)에 유지될 수 있다. 도 16은 번호로 식별되는 쓰기 요청들 및 무효화 요청들을 보여주지만, 실제로 SSD (505)는 액세스 되는 데이터, 예를 들어 요청의 논리 페이지 어드레스(LPA, Logical Page Address)를 이용하여 무효화 요청들을 쓰기 요청들과 짝지울 수 있다.

도 16은 쓰기 시간들(1655, 1660, 1665, 1650) 및 무효화 시간들(1645, 1670, 1675)을 보여준다. 각 쓰기 시간 및 무효화 시간은 특정한 쓰기 및 무효화 요청에 대응할 수 있다. 따라서, 예를 들어, 쓰기 시간(1655)은 쓰기 요청(1610)이 이슈된 시간일 수 있으며, 쓰기 시간(1660)은 쓰기 요청(1615)이 이슈된 시간일 수 있다. SSD (505)는 요청이 수신되는 때에 내부 클럭(SSD (505)가 클럭을 포함하는 경우)을 액세스하거나 또는 요청들이 이슈되는 호스트 기계에 문의하여 요청의 시간을 판별할 수 있다. 본 발명의 다른 실시 예들에서, 호스트 기계는 쓰기 시간들(1655, 1660, 1665, 1650) 및 무효화 시간들(1645, 1670, 1675)을 자동으로 제공할 수 있다. 본 발명의 다른 실시 예들에서, 요청이 이슈되는 시간을 사용하는 대신에, SSD (505)는 SSD (505)가 요청을 수행하는 시간을 사용할 수 있다. SSD (505)는 내부 클럭 또는 호스트 기계의 클럭을 이용하여 요청의 시간을 판별할 수 있다.

도 17은 도 16의 SSD (505)의 상세를 보여준다. 도 5의 SSD (505)와 달리, 도 17에서 SSD (505)는 SSD 컨트롤러(515) 내에 다른 구성 요소들을 포함할 수 있다. 구체적으로, SSD 컨트롤러(515)는 통계 계산 로직(1705) 및 성능 로직(1710)을 포함할 수 있다. 통계 계산 로직(1705)은 데이터 스트림에 대한 통계들을 계산할 수 있다. 성능 로직(1710)은 통계 계산 로직(1705)에 의해 계산된 통계들을 이용하여 SSD (505)의 성능을 향상시킬 수 있다.

도 18은 도 17의 통계 계산 로직(1705)의 상세를 보여준다. 도 18에서, 통계 계산 로직(1705)은 시간 로직(1805), 데이터 수명 로직(1810), 통계 로직(1815), 가중 로직(1820), 그리고 스토리지(1825)를 포함한다. 시간 로직(1805)은 요청의 시간을 판별할 수 있다. 데이터 수명 로직(1810)은 개별 데이터 원소의 수명을 계산할 수 있다. 통계 로직(1815)은 개별 데이터 원소들에 대한 정보로부터 스트림에 대한 전체적인 통계를 판별할 수 있다. 가중 로직(1820)은 개별 데이터 원소들을 어떻게 가중하는지에 대한 정보를 저장할 수 있다.

스토리지(1825)는 스트림 메타 데이터를 저장할 수 있다. 예를 들어, 스트림 메타 데이터는 개별 요청들의 쓰기 및 무효화 시간들, 데이터 원소들의 수명들, 또는 스트림에 대한 전체적인 통계 정보를 포함할 수 있다. 도 17의 SSD (505)에 저장되는 특정 데이터 원소에 대해, 통계 계산 로직(1705)은 두 조각의 데이터, 즉 요청을 이슈한 스트림의 식별자(ID) 및 데이터가 삭제되기 전 얼마나 오래 동안 데이터가 저장되었는지를 사용할 수 있다. 더 기술적으로, 삭제는 무효화 직후에는 발생하지는 않는 가비지 컬렉션을 수행하여 무효 페이지들을 리클레임하는 도 17의 SSD (505)에 의존하므로, 삭제는 도 16의 응용(1605)에 의한 무효화일 수 있다. 스트림의 ID는 통계 로직(1815)이 데이터가 유래한 스트림을 알 수 있게 하고, 통계 로직(1815)이 해당 스트림에 대한 통계를 계산할 수 있게 한다. 데이터가 무효화되기 전 얼마나 오래 동안 저장되었는지는 해당 스트림에 대한 특정 데이터 원소에 적합한 메타 데이터를 통계 로직(1815)에 제공할 수 있다. 이러한 두 값들이 주어지면, 통계 계산 로직(1705)은 분포 함수와 같은 통계 함수를 스트림의 데이터에 맞추려 시도하거나 또는 스트림의 데이터의 히스토그램을 저장할 수 있다. 통계 함수 또는 히스토그램은 해당 스트림에서 미래 데이터의 수명을 더 정확하게 예측하는 데에 사용될 수 있다.

예를 들어, 정규 분포를 포함하는 많은 분포 함수들은 데이터의 평균 및 분산을 아는 것에 의해 완전하게 정의될 수 있다. 이러한 값들은 수학식 3 및 수학식 4를 이용하여 각각 계산될 수 있다.

수학식 3 및 수학식 4에서, X는 스트림에 대한 개별 데이터 수명들 각각으로 치환될 수 있고, n은 데이터 원소들의 수를 나타낸다. n의 사이즈 및 X의 대응하는 값은 도 17의 SSD (505)에 기입되는 데이터의 변화에 의해 변할 수 있으며, 또한 너무 오래된 데이터가 버려지는 것에 의해서도 변할 수 있다. 예를 들어, 후술되는 바와 같이, 통계를 계산하는 데에 사용되는 데이터를 전체 스트림 데이터 수명들 중에서 가장 최근의 일부로 제한하는 이동 윈도가 사용될 수 있다. 가장 최근의 1000번의 데이터 수명들을 고려하는 이동 윈도가 사용되면, n은 1000번의 스트림 쓰기들 및 무효화들이 발생한 후에 1000으로 고정될 수 있다. X의 값은 가장 최근의 1000번의 스트림 쓰기들 및 읽기들과 함께 변할 수 있다. 다른 분포 함수에 대해, 다른 변수들이 계산될 수 있다. 통계 로직(1815)은 임의의 수의 분포 함수들을 생성하고, 실제 데이터와 비교하여 가장 적은 마진을 제공하는 분포 함수를 선택할 수 있다. 충분히 정확한 분포 함수가 찾아지지 않으면, 통계 로직(1815)은 도 15의 히스토그램(1510)을 생성하여 데이터의 예상 수명들을 판별할 수 있다.

도 17 및 도 18에서 도 18의 스토리지(1825)가 SSD 컨트롤러(515) 내에 위치하는 것으로 도시되지만, 본 발명의 다른 실시 예들은 스토리지(1825)를 다른 곳에 포함할 수 있다. 예를 들어, 스토리지(1825)는 도 17의 플래시 메모리(520)의 일부를 차지할 수 있다. 또는, 스토리지(1825)는 도 17의 SSD (505)의 플래시 변환 계층(FTL)에 저장될 수 있다. 또는, 스토리지(1825)는 도 17의 SSD (505) 내부의 동적 RAM에 저장될 수 있다.

도 17의 SSD (505)에 데이터가 얼마나 오래 저장되었는지는 단일 값으로 저장되거나 또는 해당 데이터의 쓰기 및 무효화 시간들의 쌍으로 저장될 수 있다. 쓰기 및 무효화 시간들의 쌍은 데이터가 도 17의 SSD (505)에 얼마나 오래 저장되었는지를 직접 계산하게 할 수 있다. 그러나 스토리지(1825)가 데이터가 얼마나 오래 저장되었는지를 단일 r값으로 저장하는 경우에도 해당 데이터의 쓰기 시간을 더 저장하는 것에 장점이 있다. 예를 들어, 도 17의 SSD (505)에 데이터가 기입된 시간을 아는 것은 통계 로직(1815)이 해당 데이터가 얼마나 오래된 것인지를 알게 한다. 통계 로직(1815)은 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)에서 이들의 영향을 얼마나 가중할지를 판별하는 데에 데이터의 나이를 사용할 수 있다.

데이터의 나이가 왜 스트림의 통계들을 계산하는 데에 적절한지의 예로서, 데이터의 모든 조각들에 대한 정보를 도 17의 SSD (505)에 기입하는 것은 막대한 저장 공간을 필요로 한다는 점이 상기되어야 한다. 가장 최근의 트랜잭션들만을 포함하는 이동 윈도를 사용함으로써 또는 이전 데이터의 요약을 저장하는 이동 윈도를 사용함으로써, 본 발명의 실시 예들은 통계 데이터에 대한 저장 수요를 감소시킬 수 있다. 이동 윈도의 사이즈는 필요한 임의의 사이즈일 수 있다. 예를 들어, 이동 윈도는 가장 최근의 1000번의 데이터 쓰기들만을 포함할 수 있다. 통계 정보를 저장하는 데에만 기가바이트의 데이터를 필요로 하는 대신, 스토리지(1825)는 스트림당 수 킬로바이트만을 필요로 할 수 있으며, 저장 수요가 크게 감소할 수 있다. 이동 윈도의 사이즈는 필요한 임의의 사이즈일 수 있으나, 여기에서는 1000번의 데이터 쓰기들만이 예시적으로 사용된다. 이동 윈도가 사용되면, 통계 로직(1815)에서 사용되는 쓰기 시간들 및 무효화 시간들의 개수는 스트림의 쓰기 요청들 및 무효화 요청들의 개수보다 작다.

데이터가 도 17의 SSD (505)에 얼마나 오래 저장되었는지 뿐만 아니라 데이터의 쓰기 시간을 저장함에 따라, 통계 로직(1815)은 데이터 요청들의 나이를 모델들에 반영할 수 있다. 이러한 방법으로, 통계 로직(1815)은 이동 윈도 내의 가장 최근의 데이터 쓰기들을 식별하고, 스토리지(1825)로부터 다른 오래된 쓰기들을 삭제할 수 있다. 이동 윈도를 사용함으로써, 오래된 데이터의 영향은 무시될 수 있다. 데이터의 수명 주기 패턴이 변화되면, 오래된 데이터는 계산된 통계들에 부정적인 영향을 줄 수 있다. 예를 들어, 도 17의 SSD (505)에 원래는 48시간 동안 데이터가 저장되었었지만 현재는 24시간 동안 데이터가 저장되는 상황이 고려된다. 모든 역사 데이터가 고려되면, 무효화까지의 평균 시간은 현재 발생하는 것보다 높게 나타난다. 따라서, 현재 스트림으로부터의 데이터에 대해 실제 발생하는 것보다 길게 유효 데이터를 저장하는 것이 예상되는 도 17의 SSD (505)의 블록에 데이터가 기입될 수 있다.

오래된 데이터가 현재 데이터보다 짧은 시간 동안 저장되는 반대의 시나리오가 고려된다. 이 시나리오에서, 무효화까지의 평균 시간은 현재 발생하는 것보다 짧을 수 있다. 따라서, 실제 발생하는 것보다 이르게 무효화되는 것이 예상되는 SSD (505)의 블록에 데이터가 저장될 수 있다. 이러한 블록에서 가비지 컬렉션이 수행되면, 해당 블록을 자유화되기 전에 다른 블록에 프로그램되어야 하는 유효 데이터가 존재할 수 있다. 이러한 프로그램은 가비지 컬렉션의 속도를 저하시켜 데이터 액세스 요청의 속도를 저하시키고, 그리고 도 17의 SSD (505)에 대한 쓰기 증폭 인자를 증가시킨다. 이들은 모두 바람직하지 않다.

도 19는 도 16의 쓰기 요청들에 대한 쓰기 시간들을 판별하는 도 18의 시간 로직(1805)을 보여준다. 도 19에서, 시간 로직(1805)은 다양한 요청들(1610~1640)을 수신하고, 해당 요청들의 시간들(1655~1675)을 판별할 수 있다. 도 16을 참조하여 설명된 바와 같이, 본 발명의 상이한 실시 예들에서, 요청의 시간은 요청이 이슈된 시간 또는 요청이 수행된 시간일 수 있다. 시간 로직(1805)은 요청으로부터의 정보(요청에 포함되어 있다면)를 액세스하거나, 도 17의 SSD (505) 내의 클럭을 체크하거나, 또는 요청의 시간을 호스트 기계에 요청함으로써 요청의 시간을 판별할 수 있다.

도 20은 쓰기 및 무효화 요청들의 쌍으로부터 데이터 수명을 판별하는 도 18의 데이터 수명 로직(1810)을 보여준다. 도 20에서, 데이터 수명 로직(1810)은 쓰기 및 무효화 시간들의 쌍을 수신할 수 있다. 예를 들어, 데이터 수명 로직(1810)은 쓰기 시간(1655) 및 무효화 시간(1645)을 포함하는 쌍, 쓰기 시간(1660) 및 무효화 시간(1670)을 포함하는 쌍, 그리고 쓰기 시간(1665) 및 무효화 시간(1675)을 포함하는 쌍을 수신할 수 있다. 도 16을 참조하여 설명된 바와 같이, 쓰기 시간들 및 무효화 시간들은 대응하는 쓰기 및 무효화 요청들과 함께 제공되는 정보에 기반하여 또는 요청들의 LBA에 기반하는 것과 같은 다른 방법으로 짝지워질 수 있다.

응용이 데이터가 기입될 구체적인 위치를 특정하는 것을 SSD가 허용하는 것이 가능함에도, 쓰기 요청이 이슈되는 때에 데이터가 기입될 어드레스는 알려지지 않으므로, 쓰기 요청은 통상적으로 SSD의 어드레스를 특정하지 않는다. 그러나 데이터가 기입될 어드레스를 SSD가 식별하면, SSD는 해당 어드레스를 쓰기 요청과 연관하여 쓰기 및 무효화 요청들을 짝지울 수 있다.

쓰기 및 무효화 요청들이 짝지워지면, 연관된 쓰기 및 무효화 시간들 또한 짝지워지는 것으로 여겨질 수 있다. 데이터가 언제 기입되고 언제 삭제되었는지를 알게 됨에 따라, 데이터 수명 로직(1810)은 무효화 시간으로부터 쓰기 시간을 감함으로써 데이터가 SSD에 얼마나 오래 존재하였는지 계산할 수 있다. 따라서, 데이터 수명 로직(1810)은 무효화 시간(1645) 및 쓰기 시간(1655) 사이의 차이를 데이터 수명(2005)으로, 무효화 시간(1670) 및 쓰기 시간(1660) 사이의 차이를 데이터 수명(2010)으로, 그리고 무효화 시간(1675) 및 쓰기 시간(1665) 사이의 차이를 데이터 수명(2015)으로 계산할 수 있다.

도 21은 도 20의 데이터 수명들로부터 함수들 또는 히스토그램들을 생성하는 도 18의 통계 로직(1815)을 보여준다. 도 21에서, 통계 로직(1815)은 데이터 수명들(2005, 2010, 2015)을 수신하고, 도 14의 곡선들(1410, 1415)과 같은 통계 함수들 또는 도 15의 히스토그램(1510)과 같은 히스토그램을 생성할 수 있다. 통계 로직(1815)은 데이터 수명들에 도 14의 곡선들(1410, 1415)과 같은 분포 함수들과 같은 통계 함수를 맞추려 시도할 수 있다. 통계 함수가 데이터 수명들에 완전히 들어맞지 않지만 해당 통계 함수가 허용 가능한 오차(tolerance) 내에서 데이터 수명들에 부합하면, 해당 통계 함수가 사용될 수 있다. 허용 가능한 오차는 사전에 결정될 수 있으며, 현재 사용 중인 오차가 지나치게 느슨하거나 엄격하면 동적으로 조절될 수 있다. 오차는 필요한 방법으로 측정될 수 있다. 예를 들어, 오차는 최악 조건 해석(통계 삼수의 예측 값들로부터 가장 다른 데이터 포인트를 찾음), 루프-합 스퀘어(root-sum squared) 분석(통계 함수의 예측 값들로부터 각 데이터 포인트가 얼마나 벗어나는지를 고려), 제2차(second order) 오차(예측된 분포로부터 데이터 값들의 분포가 얼마나 멀게 변화하는지 고려), 또는 다른 필요한 오차 측정을 통해 측정될 수 있다.

데이터 값들의 허용 가능한 예측 변소를 제공하는 통계 함수가 존재하지 않으면, 통계 로직(1815)은 히스토그램을 생성할 수 있다. 히스토그램은 데이터에 곡선을 맞추려 하지 않으므로, 히스토그램은 항상 가능하다. 그러나 가용한 데이터에 들어맞는 통계 함수를 찾을 수 있으면, 통계 함수는 보통 히스토그램보다 더 간결하게 설명되며, 평균 또는 중간 데이터 값, 통계 편차, 또는 구체적인 신뢰 수준에 대한 값들의 범위와 같은 키 메트릭들의 더 쉬운 해법을 제공한다.

도 22는 본 발명의 실시 예들에 따라 쓰기 및 무효화 시간들의 쌍에 대한 가중치들을 판별하는 도 18의 가중 로직(1820)을 보여준다. 도 18을 참조하여 설명된 바와 같이, 스트림에 대한 모든 역사적 통계 데이터를 저장하는 것은 많은 저장 공간을 차지하며, 이동 윈도를 이용하는 것은 유지되어야 하는 데이터의 양을 감소시킨다. 그러나 본 발명의 일부 실시 예들에서, 예를 들어, 통계 데이터가 도 17의 SSD (505)가 아닌 하드 디스크 드라이브와 같은 저비용 스토리지에 저장되는 경우, 저장 공간은 고려되지 않는다. 그러나 모든 역사적 통계 데이터가 유지되면, 오래된 데이터는 계산된 통계들에 불균형한 영향을 가질 수 있다. 이러한 문제를 개선하기 위하여, 가중치들(2205, 2210, 2215)이 사용될 수 있다.

쓰기 및 무효화 시간들의 각 쌍에 대해, 가중 로직(1820)은 가중치를 할당한다. 도 22에서, 가중치(2205)는 쓰기 시간(1655) 및 무효화 시간(1645)에 할당될 수 있다. 가중치(2210)는 쓰기 시간(1660) 및 무효화 시간(1670)에 할당될 수 있다. 가중치(2215)는 쓰기 시간(1665) 및 무효화 시간(1675)에 할당될 수 있다. 가중치들(2205, 2210, 2215)은 도 18의 통계 로직(1815)에 의해 통계들의 계산에 반영될 수 있다. 이러한 방법으로, 새로운 데이터는 오래된 데이터보다 더 가중되고, 오래된 데이터가 통계들에 너무 큰 영향을 주는 것을 방지하면서 오래된 데이터를 사용하는 것이 허용될 수 있다(혹은 반대로도).

가중치들(2205, 2210, 2215)은 필요한 방법으로 결정될 수 있다. 예를 들어, 쓰기 및 무효화 시간들의 가장 새로운 쌍은 1로 할당될 수 있으며, 쓰기 및 무효화 시간들의 다음으로 가장 새로운 쌍은 2로 할당될 수 있다. 스트림에 대한 통계들을 계산할 때, 가중치의 역이 데이터에 적용될 수 있다. 또는, 데이터 포인트들은 나이에 따라 그룹들(bins)로 분할될 수 있으며, 가장 최근의 데이터 포인트들에 가장 큰 가중치를 부여하며 각 그룹에 가중치가 할당될 수 있다. 이러한 방법은 각 그룹 내의 모든 데이터 포인트들에 동등한 가중치를 부여하여, 어느 하나의 데이터 포인트가 결과를 지배하는 것을 회피한다. 다른 가중 전략들 또한 사용될 수 있다.

스트림에 대한 통계들의 계산이 이해되었으므로, 이러한 통계들의 가능한 사용들이 소개된다. 다른 가능성들 중에서도, 계산된 통계들(1410, 1415, 1510)은 새로운 데이터가 기입될 블록을 선택하는 데에 사용될 수 있으며, 다중 스트림들을 하나로 합치고(또는, 다중 스트림들을 단일 블록에 기입), 소거 블록으로부터의 유효 데이터를 프로그램하고, 그리고 거짓을 말하는 응용들을 보고할 수 있다.

도 23은 본 발명의 실시 예들에 따라 도 21의 계산된 통계들을 이용하여 스트림에 대한 새로운 쓰기 요청의 데이터를 저장할 블록을 선택하는 도 17의 성능 로직(1710)을 보여준다. 도 23에서 성능 로직(1710)은 데이터(2305)를 수신할 수 있다. 데이터(2305)는 도 16의 응용(1605)으로부터 수신되는 새로운 데이터(점선 박스의 새로운 쓰기 요청(2310)으로 도시됨)일 수 있다. 또는 데이터(2305)는 소거 블록으로부터 새로운 블록으로 프로그램되어야 하는 데이터일 수 있다. 이유 불문하고, 성능 로직(1710)은 계산된 통계들(1410, 1415, 1510)을 이용하여 데이터(2305)가 기입될 블록(103)을 선택할 수 있다.

예를 들어, 데이터(2305)가 수명이 정규 분포인 스트림으로부터 온 것으로 가정된다. 또한, 이 스트림의 정규 분포는 50분의 평균 및 데이터 수명들의 90%가 60분 이하인 표준 편차를 갖는 것으로 가정된다. 이러한 통계들은 90%의 신뢰 수준으로 60분의 예상 수명을 갖는 스트림으로 다르게 표현될 수 있다. 블록(103)은 60분의 잔여 블록 TTL (240)을 갖는다. 데이터(2305)가 90%의 신뢰 수준으로 60분 내에 만료할 것이 예상되므로, 블록(103)은 데이터(2305)에 잘 부합한다. 따라서, 성능 로직(17100은 블록(103)을 선택하여 데이터(2305)를 기입할 수 있다.

도 23은 블록(130)과 같은 블록이 데이터(2305)와 같은 개별 데이터를 저장하도록 어떻게 선택되는지를 설명한다. 도 23은 데이터(2305)가 기입될 블록을 선택하는 데에 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)이 어떻게 사용되는지를 보여준다. 도 14 및 도 14의 계산된 통계들(1410, 1415, 1510)을 사용하는 것은 스트림 TTL을 사용하는 것의 대안을 제공한다. 스트림 TTL은 스트림에 대해 계산될 수 있는 단지 하나의 가능성일 뿐이다.

도 1, 도 4 내지 도 6, 그리고 도 13을 참조하여 설명된 바와 같이, 제2차 스트림들은 특정 블록에 어떤 데이터를 기입할지를 관리하는 것을 단순화하는 메커니즘을 제공한다. 계산된 통계들을 사용하는 도 14 내지 도 23을 참조하여 설명된 그리고 도 24 내지 도 32를 참조하여 후술될 본 발명의 실시 예들은 데이터(2305)를 기입할 제2차 스트림을 선택하는 데에 사용될 수 있다. 바꿔 말하면, 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)은 특정 블록과 연관된 제2차 스트림을 선택하는 데에 사용될 수 있다. 제2차 스트림에 기입되는 데이터는, 데이터가 유래한 제1차 스트림에 무관하게, 연관된 블록에 기입될 수 있다. 제2차 스트림을 사용하는 본 발명의 실시 예들에서, 성능 로직(1710)은 블록 TTL (240)과 달리 제2차 스트림의 TTL에 기반하여 제2차 스트임에 기입될 데이터를 선택할 수 있다.

블록(103)의 잔여 TTL이 데이터(2305)의 예상 수명보다 크지만 유사하므로, 성능 로직(1710)은 블록(103)을 선택할 수 있다. 예를 들어, 잔여 TTL이 60분인 블록 및 잔여 TTL이 90분인 블록 사이에서, 데이터(2305)가 블록 내의 다른 데이터와 함께 만료하려면, 60분의 잔여 TTL을 갖는 블록이 더 나은 선택이다. 반면, 90분의 잔여 TTL을 갖는 블록 및 45분의 잔여 TTL을 갖는 블록 사이에서, 블록에서 가비지 컬렉션이 수행될 때에 데이터(2305)가 유효 데이터가 아니려면, 90분의 잔여 TTL을 갖는 블록이 더 나은 선택이다.

성능 로직(1710)은 데이터(2305)가 유래한 스트림에 할당되는 블록을 선택할 필요가 없음이 주지되어야 한다. 즉, 데이터(2305)가 유래한 스트림에 블록(103)을 할당하는 대신에, 성능 로직(1710)은 최선의 선택이 되도록 데이터(2305)를 저장할 블록을 선택할 수 있다. 따라서, 데이터가 블록의 잔여 TTL에 부합하는 예상 수명을 가지면, 성능 로직(1710)은 다중 스트림들로부터의 데이터를 단일 블록에 기입할 수 있다. 따라서, 다중 스트림들이 유사한 예상 수명들을 가지면, 해당 스트림들로부터의 데이터는 동일한 블록에 기입되고, 이는 기존의 시스템들에서는 발생하지 않는 결과이다.

도 24는 본 발명의 실시 예들에 따른 도 17의 성능 로직(1710)의 상세를 보여준다. 도 24에서, 성능 로직(1710)은 예상 잔여 수명 로직(2410), 비교기(2415), 스토리지 선택기(2420), 그리고 보고 로직(2425)을 포함한다. 예상 잔여 수명 로직(2410)은 특정 데이터 원소에 대한 예상 잔여 수명을 판별할 수 있다. 예상 잔여 수명 로직(2410)에 "잔여"의 용어가 포함되어 있지만, 일반적인 의미에서, 쓰기 요청이 최초에 수신된 때에 데이터 원소가 도 17의 SSD (505)에 얼마나 오래 존재할 것인지가 예측되는 초기 예측은 또한 데이터 원소의 예상 잔여 수명일 수 있다. 따라서, "잔여"는 일부 시간 구간 동안 도 17의 SSD (505)에 거주하였던 데이터에 대한 예상 잔여 수명 그리고 새로운 데이터 원소가 도 17의 SSD (505)에 초기에 수신된 때에 데이터 원소가 도 17의 SSD (505)에 얼마나 오래 거주할 것인지를 예측하는 원본 측정 모두를 포함할 수 있다. 바꿔 말하면, 데이터가 도 17의 SSD (505)에 의해 처음 수신된 때에, 데이터의 예상 잔여 수명은 데이터가 도 17의 SSD (505)에 저장되고 시간이 경과하지 않은 때에 부여된, 예상 수명일 수 있다.

이러한 개념을 돕기 위한 예시가 설명된다. 도 15의 히스토그램(1510)을 생성하는 스트림이 고려된다. 90%의 신뢰 수준으로, 해당 스트림의 데이터는 36시간의 예상 수명을 갖는다. 따라서, 데이터가 도 17의 SSD (505)에 12시간 동안 이미 저장되었으면, 해당 데이터는 24시간(36시간 빼기 12시간)의 예상 잔여 수명을 갖는다. 그러나 데이터가 도 17의 SSD (505)에 새로 수신되면, 해당 데이터는 36시간(데이터가 저장된 후 시간 경과가 없으므로 36시간 빼기 0시간)의 예상 잔여 수명을 갖는다. 따라서, "잔여"의 용어의 사용은 논의 중인 데이터가 임의의 시간 동안 도 17의 SSD에 저장되어 있지 않았을 가능성을 포함하는 것으로 의도된다.

비교기(2415)는 두 개(또는 그보다 많은)의 값들을 비교하여 더 큰 또는 더 작은 값을 판별하는 데에 사용될 수 있다. 비교기(2415)는 다중 용도들을 갖는다. 본 발명의 일부 실시 예들에서, 비교기(2415)는 예상 잔여 수명 로직(2410)에 의해 계산된 데이터 원소의 예상 잔여 수명을 블록 TTL (240)과 같은 블록 TTL과 비교하고, 데이터 원소의 예상 잔여 수명에 잘 부합하는 블록을 찾으려 시도하는 데에 사용될 수 있다. 본 발명의 다른 실시 예들에서, 비교기(2415)는 예상 잔여 수명 로직(2410)에 의해 계산되는 예상 잔여 수명을 도 4의 제2차 스트림 TTL (415)과 같은 제2차 스트림 TTL과 비교하고, 데이터 원소의 예상 잔여 수명에 잘 부합하는 제2차 스트림을 찾으려 시도하는 데에 사용될 수 있다. 본 발명의 다른 실시 예들에서, 비교기(2415)는 도 16의 응용(1605)으로부터 수신되는 스트림 TTL (310)과 같은 스트림 TTL을 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)과 비교하고, 도 16의 응용이 거짓을 말하는지 판별하고 그리고 의도적이든 또는 사고이든 부정확한 스트림 메타 데이터를 보고하는 데에 사용될 수 있다.

스토리지 선택기(2420)는 데이터가 기입될 스토리지를 선택할 수 있다. 스토리지는 블록(예를 들어, 논의중인 데이터가 도 3a 내지 도 3d에 도시된 제1차 스트림으로부터 유래하였으면) 또는 제2차 스트림(예를 들어, 논의중인 데이터가 도 4에 도시된 제2차 스트림에 데이터를 공급하는 스트림으로부터 유래하였으면)일 수 있다. 데이터는 최종적으로 도 17의 플래시 메모리(520)의 블록에 기입되어야 함이 주지되어야 한다. 따라서, 스토리지 선택기(2420)가 제2차 스트림을 선택하는 데에 사용되어도, 제2차 스트림은 데이터가 최종적으로 기입될 도 17의 플래시 메모리(520)의 블록과 연관되므로, 이 동작은 간접적인 블록 선택이다.

스토리지 선택기(2420)가 어떻게 동작하는지(블록 또는 제2차 스트림을 선택하는지)에 관계없이, 논의중인 데이터는 새로운 쓰기 요청의 스트림으로부터 수신되는 새로운 데이터 또는 가비지 컬렉션이 수행되어야 하고 따라서 프로그램을 필요로 하는 블록에 이전에 저장되었던 데이터일 수 있다.

보고 로직(2425)은 스트림 TTL과 같은 스트림 메타 데이터가 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)과 일치하지 않음을 도 16의 응용(1605)과 같은 응용 또는 스트림을 주관하는 호스트에 알리는 데에 사용될 수 있다. 도 16의 응용(1605)으로부터 수신된 스트림 메타 데이터가 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)과 다르면(예를 들어 심각하게 다르면), 보고 로직(2425)은 해당 불일치를 보고할 수 있다. 스트림 메타 데이터가 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)과 심각하게 다르기 위한 차이는 사용자에 의해 정의될 수 있다. 보고 로직(2425)에 의해 도 16의 응용(1605)에 전송되는 정보는 가변될 수 있다. 보고 로직(2425)은 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)의 일부(도 16의 응용(1605)이 전송하는 통계들의 실제 값과 같은)만을 전송할 수 있으며, 또는 보고 로직(2425)은 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510) 모두를 전송할 수 있다.

도 25는 유효 데이터를 저장하는 도 17의 SSD (505)의 소거 블록을 보여준다. 도 25에서, 블록(2505)이 도시된다. 블록(2505)은 8개의 페이지들의 데이터들을 포함하는 것으로 도시되나, 본 발명의 실시 예들은 임의의 수의 페이지들을 포함하는 블록들을 지원할 수 있다. 블록(2505)에서, 페이지(2510)는 유효 데이터를 저장한다. 블록(2505)의 나머지 모든 페이지들은 무효 데이터이다. 따라서, 블록(2505)은 가비지 컬렉션을 위한 좋은 후보로 여겨질 수 있다.

페이지(2510)가 유효 데이터를 저장하므로, 페이지(2510)는 블록(2505)이 자유롭게 되기 전에 다른 블록으로 재배치되어야 한다. 그러나 페이지(2510)가 일정 시간 동안 도 17의 SSD (505)에 위치되어 왔으므로, 잔여 수명은 원래 스트림의 TTL 또는 해당 스트림에 대해 계산된 다른 통계들보다 작을 수 있다. 따라서, 페이지(2510)의 예상 잔여 수명은 도 24의 예상 잔여 수명 로직(2410)에 의해 계산되므로, 도 24의 스토리지 선택기(2420)는 페이지(2510)를 최적으로 프로그램하기 위해 페이지(2510)의 예상 잔여 수명을 알 필요가 있다.

도 26은 도 25의 유효 데이터의 잔여 수명을 예측하는 도 24의 예상 데이터 잔여 수명 로직(2410)을 보여준다. 도 26에서, 예상 잔여 수명 로직(2410)은 유효 데이터가 애초에 할당된 스트림에 대해 계산된 통계들(1410, 1415, 1510) 또는 통계 함수 또는 히스토그램을 취할 수 있다. 예상 잔여 수명 로직(2410)은 도 25의 페이지(2510)가 도 25의 블록(2505)에 언제 기입되었는지를 나타내는 쓰기 시간(1655) 또한 획득할 수 있다. 이 값들을 이용하여, 예상 잔여 수명 로직(2410)은 도 25의 페이지(2510)의 예상 잔여 수명(2605)을 계산할 수 있다.

그러나 도 25에 도시된 소거 블록의 가비지 컬렉션의 일부로서 프로그램되는 유효 데이터에 대해서든 또는 도 23을 참조하여 설명된 새로운 데이터에 대해서든, 예상 잔여 수명(2605)은 예상 스트림 TTL로부터 데이터가 저장되어온 시간을 단순히 감하는 것보다는 더 복잡할 수 있다. 예를 들어, 도 15의 히스토그램(1510)을 생성하는 스트림이 다시 고려된다. 앞서 언급된 바와 같이, 히스토그램(1510)에 대한 90%의 신뢰 수준은 스트림의 데이터의 예상 수명이 36시간임을 가리킨다. 그러나 도 25의 페이지(2510)가 이미 40시간 저장되어 왔고 그리고 도 24의 예상 잔여 수명 로직(2410)이 단순히 감산을 수행하면, 도 17의 성능 로직(1710)이 알게 되는 것은 도 25의 페이지(2510)가 이미 무효화되었을 것으로 예상된다는 것 뿐이다.

대신, 예상 잔여 수명 로직(2410)은 도 15의 히스토그램(1510)의 전체를 고려할 수 있다. 도 25의 페이지(2510)가 이미 40시간 동안 저장되어 왔으므로, 페이지(2510)는 스트림의 예상 수명을 초과했으며, 예상 수명에만 의존하는 것은 의미 있는 정보를 제공하지 않는다. 그러나, 히스토그램(1510)으로부터, 데이터가 36시간 이상 지속되었으면, 60시간까지 지속할 것(이보다 더 오래 지속할 수 있더라도)으로 판별될 수 있다. 따라서, 예상 잔여 수명 로직(2410)은 도 25의 페이지(2510)가 애초의 예상 수명보다 오래 저장되어 왔더라도, 도 25의 페이지(2510)의 예상 잔여 수명이 이제 20 시간(새로운 최적의 예상 수명인 60시간보다 이미 저장되어온 40시간 적은)인 것으로 판별할 수 있다. 주어진 이러한 예상에 따라, 도 24의 스토리지 선택기(2420)는 대략 20시간의 TTL을 갖는 블록을 검색하고, 도 25의 페이지(2510)를 검색된 블록에 프로그램할 수 있다.

도 24의 스토리지 선택기(2420)가 도 25의 페이지(2510)가 유래한 스트림과 연관된 블록을 선택할 수 있지만, 본 발명의 실시 예들은 사용되는 다른 스트림들과 연관된 블록들을 허용할 수 있다. 도 17의 SSD (505)는 어느 스트림 데이터가 특정한 데이터를 생성하는지 실제로 관여하지 않는다. 스트림들의 목적은 통상적인 수명을 갖는 데이터를 함께 저장함으로써 스토리지 효율을 향상시키는 것이다. 스트림들이 의도된 대로 동작하면, 블록들의 데이터는 대략 동시에 무효화되며, 유효 데이터의 프로그램을 먼저 수행할 필요 없이 블록들이 가비지 컬렉션의 대상이 될 수 있다.

도 25를 참조하여 설명된 상황에서, 도 25의 블록(2505)이 가비지 컬렉션의 대상이 된 때에 도 25의 페이지(2510)가 여전히 유효 데이터를 포함하므로, 상황은 예상대로 흘러가지 않는다. 그러나 도 25의 페이지(2510)가 비슷한 잔여 수명을 갖는 다른 데이터를 갖는 블록에 저장되면, 새로운 블록의 데이터는 거의 동시에 무효화되며, 새로운 블록이 어떤 데이터의 프로그램 없이 가비지 컬렉션의 대상이 될 수 있다.

도 25의 페이지(2510)가 새로운 블록에 프로그램되면, 새로운 의문이 발생한다. 도 25의 페이지(2510)는 원래 스트림 소속을 유지하는가 또는 도 25의 페이지(2510)는 도 25의 페이지(2510)가 프로그램된 블록과 연관된 스트림의 일부로 취급되는가 본 발명의 실시 예들은 두 가능성들을 모두 지원한다. 원래 스트림 소속을 유지함으로써, 도 25의 페이지(2510)의 후속 프로그램은 더 정확할 수 있다. 그러나 스트림들은 페이지보다는 블록들에 소속되므로, 도 25의 페이지(2510)를 새로운 스트림의 일부로 고려하는 것은 데이터 관리를 간단하게 한다. 물론, 도 16의 응용(1605)이 도 25의 페이지(2510)를 무효화하기 전에, 도 25의 페이지(2510)가 프로그램된 블록이 가비지 컬렉션의 대상이 되지 않는다면, 이러한 선택은 거의 영향을 미치지 않는다.

도 27a 및 도 27b는 본 발명의 실시 예에 따라 도 17의 SSD (505)가 스트림에 대한 통계를 계산하고 통계를 이용하여 도 17의 SSD (505)의 성능을 향상시키는 예시적인 절차의 순서도를 보여준다. 도 27a의 블록(2705)에서, 수신 회로는 스트림에 대한 쓰기 요청들(1610, 1615, 1620, 1625)을 수신할 수 있다. 블록(2710)에서, 도 5의 쓰기 로직(530)은 쓰기 요청들(1610, 1615, 1620, 1625)을 수행할 수 있다. 블록(2715)에서, 도 18의 시간 로직(1805)은 도 3의 쓰기 요청들(1610, 1615, 1620, 1625)의 도 16의 쓰기 시간들(1655, 1660, 1665, 1650)을 판별할 수 있다. 블록(2720)에서, 수신 회로는 스트림에 대한 무효화 요청들(1630, 1635, 1640)을 수신할 수 있다. 블록(2725)에서, 도 5의 쓰기 로직(530)은 무효화 요청들(1630, 1635, 1640)을 수행할 수 있다. 블록(2750)에서, 도 18의 시간 로직(1805)은 도 3의 무효화 요청들(1630, 1635, 1640)의 무효화 시간들(1645, 1670, 1675)을 판별할 수 있다.

도 27b의 블록(2730)에서, 도 18의 가중 로직(1820)은 도 16의 다양한 쓰기 시간들(1655, 1660, 1665, 1650) 및 무효화 시간들(1645, 1670, 1675)에 대한 가중치들을 판별할 수 있다. 블록(2735)에서, 도 18의 스토리지(1825)는 도 16의 쓰기 시간들(1655, 1660, 1665, 1650) 및 무효화 시간들(1645, 1670, 1675)을 저장할 수 있다. 블록(2740)에서, 통계 로직(1815)은 도 14 및 도 15의 통계들(1410, 1415, 1510)을 계산할 수 있다. 블록(2745)에서, 도 17의 성능 로직(1710)은 도 14 및 도 14의 계산된 통계들(1410, 1415, 1510)을 이용하여 도 17의 SSD (505)의 성능을 향상시킬 수 있다. 도 17의 성능 로직(1710)은 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)을 이용하여, 데이터가 기입될 블록 또는 제2차 스트림을 선택하거나, 공유 블록에 기입하기 위한 공통 혹은 유사한 통계들을 갖는 다중 스트림들을 조합하거나, 가비지 컬렉션 시에 프로그램되는 데이터를 재스트림(restream), 예를 들어 다른 스트림에 할당하거나, 또는 응용이 제공한 스트림 TTL이 정확하지 않음을 응용에게 알릴 수 있다.

도 28은 본 발명의 실시 예에 따라 도 18의 통계 계산 로직(1705)이 스트림에 대한 통계들을 계산하는 절차의 순서도를 보여준다. 도 28의 블록(2805)에서, 도 18의 통계 계산 로직(1705)은 대응하는 쓰기 요청들 및 무효화 요청들에 대한 도 16의 쓰기 시간들(1655, 1660, 1665, 1650) 및 무효화 시간들(1645, 1670, 1675)을 짝지을 수 있다. 블록(2810)에서, 도 18의 데이터 수명 로직(1810)은 데이터의 수명을 쓰기 시간 및 무효화 시간 사이의 차이로 계산할 수 있다. 블록(2815)에서, 도 18의 통계 계산 로직(1815)은 데이터 수명에 들어맞는 도 14의 통계 함수들(예를 들어 분포 함수들)을 생성할 수 있다. 아니면, 블록(2820)에서, 도 18의 통계 계산 로직(1815)은 도 15의 히스토그램(1510)을 생성할 수 있다.

도 29는 본 발명의 실시 예에 따라 도 17의 성능 로직(1710)이 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)을 이용하여 스트림에 대한 새로운 데이터를 저장할 목표를 선택하는 예시적인 절차의 순서도를 보여준다. 도 29의 블록(2905)에서, 도 17의 수신 회로(510)는 도 23의 새로운 데이터(2305) 및 스트림 ID를 포함하는 도 23의 새로운 쓰기 요청(2310)을 수신할 수 있다. 블록(2910)에서, 도 24의 스토리지 선택기(2420)는 도 23의 새 데이터(2305)를 저장할 목표를 선택할 수 있다. 목표는 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)에 따른 스트림 수명에 들어맞는 수명을 갖는 블록 또는 스트림 수명에 들어맞는 수명을 갖는 제2차 스트림일 수 있다. 아니면, 블록(2915)에 도시된 바와 같이, 스트림이 공통의 또는 유사한 스트림 메타 데이터(예를 들어, 예측 수명)를 가지면, 도 24의 스토리지 선택기(2420)는 두 개 이상의 스트림들 사이에 공유되는 목표를 찾아낼 수 있다. 목표는 블록 또는 제2차 스트림일 수 있다. 블록(2920)에서, 도 24의 스토리지 선택기(2420)는 도 23의 데이터(2305)를 저장할 목표를 선택할 수 있다. 블록(2925)에서, 도 5의 쓰기 로직(530)은 도 23의 새 데이터(2305)를 선택된 목표에 기입할 수 있다.

도 30은 본 발명의 실시 예에 따라 도 17의 성능 로직(1710)이 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)을 이용하여 가비지 컬렉션 시에 도 25의 소거 블록(2505)으로부터의 유효 데이터(2510)를 프로그램할 목표를 선택하는 예시적인 절차의 순서도를 보여준다. 도 30의 블록(3005)에서, 가비지 컬렉션 로직은 도 25의 블록(2505)을 가비지 컬렉션을 위해 선택할 수 있다. 블록(3010)에서, 가비지 컬렉션 로직은 도 25의 소거 블록(2505)에 유효 데이터(2510)가 존재하는지 판별할 수 있다. 블록(3015)에서, 도 24의 예상 잔여 수명 로직(2410)은 도 25의 유효 데이터(2510)가 도 17의 SSD (505)에 얼마나 오래 저장되어 있었는지 판별할 수 있다. 블록(3020)에서, 도 24의 예상 잔여 수명 로직(2410)은 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)을 이용하여 도 25의 유효 데이터(2510)에 대한 도 26의 예상 잔여 수명(2605)을 계산할 수 있다. 블록(3025)에서, 도 24의 스토리지 선택기(2420)는 도 26의 예상 잔여 수명(2605)보다 조금(또는 가장 조금) 큰 블록 TTL을 갖는 블록 또는 제2차 스트림을 선택할 수 있다. 블록(3030)에서, 도 24의 스토리지 선택기(2420)가 블록을 선택하고 있으면, 도 24의 스토리지 선택기(2420)는 무엇이 가장 잘 작동하는지에 따라, 알려진 TTL을 갖는 현존 블록을 선택하거나 또는 새로운 블록을 선택하고 해당 블록에 도 26의 예상 잔여 수명(2605)보다 조금 큰 TTL을 할당할 수 있다. 예를 들어, 자유 페이지들을 갖는 사용중인 블록들이 존재하지 않거나 또는 자유 페이지들을 갖는 사용중인 모든 블록들이 도 26의 예상 잔여 수명(2605)보다 작거나 또는 도 26의 예상 잔여 수명(2605)보다 매우 큰 TTL을 가지면, 도 24의 스토리지 선택기(2420)는 현재 사용중이지 않은 블록을 선택하고 해당 블록에 도 26의 예상 잔여 수명(2605)을 만족하는 블록 TTL을 할당할 수 있다. 아니면, 도 24의 스토리지 선택기(2420)가 제2차 스트림을 선택중이면, 도 24의 스토리지 선택기(2420)는 제2차 스트림의 잔여 TTL에 기반하여 제2차 스트림을 선택할 수 있다. 도 24의 스토리지 선택기(2420)가 블록 또는 제2차 스트림을 선택중인지에 관계없이, 블록(3030)에서, 도 5의 쓰기 로직(530)은 도 25의 유효 데이터(2510)를 선택된 블록 또는 제2차 스트림에 프로그램할 수 있다.

도 31은 본 발명의 실시 예에 따라 도 17의 성능 로직(1710)이 블록에 기입될 데이터의 스트림을 선택하는 예시적인 절차의 순서도를 보여준다. 도 31의 블록(3105)에서, 도 17의 수신 회로(510)는 도 3a의 스트림(305)에 대한 데이터를 수신할 수 있다. 블록(3110)에서, 도 17의 수신 회로(510)는 도 3b의 스트림(320)에 대한 데이터를 수신할 수 있다. 블록(3115)에서, 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)에 기반하여, 도 24의 스토리지 선택기(2420)는 도 3a의 스트림(305) 및 도 3b의 스트림(320) 사이에서 블록에 기입할 스트림을 선택할 수 있다.

도 32는 본 발명의 실시 예에 따라 도 17의 성능 로직(1710)이 도 16의 응용(1605)에 의해 보고된 스트림 TTL이 정확한지를 도 16의 응용(1605) 또는 더 일반적으로는 호스트에 보고하는 예시적인 절차의 순서도를 보여준다. 도 32의 블록(3205)에서, 도 17의 성능 로직(1710)은 도 16의 응용(1605) 또는 스트림 요청들에 책임이 있는 다른 소스들로부터 스트림 TTL (또는 다른 스트림 메타 데이터)을 수신한다. 블록(3210)에서, 도 24의 비교기(2415)는 수신된 TTL을 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)과 비교할 수 있다. 블록(3215)에서, 도 17의 성능 로직(1710)은 도 16의 응용으로부터 수신된 스트림 TTL이 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510)의 수용 가능한 문턱 내에 있는지 판별할 수 있다. 그렇지 않으면, 블록(3220)에서, 보고 로직(2425)은 제공된 스트림 TTL이 도 14 및 도 14의 계산된 통계들(1410, 1415, 1510)과 일치하지 않음을 도 16의 응용(1605)에 보고할 수 있다. 도 24의 보고 로직(2425)은 도 14 및 도 15의 계산된 통계들(1410, 1415, 1510) 또는 이들의 부분 집합을 도 16의 응용(1605)에 제공하여 도 16의 응용(1605)을 수정할 수 있다.

도 1 내지 도 32는 본 발명의 일부 실시 예들을 보여준다. 그러나 본 발명의 실시 예들은 필요한 조합으로 조합될 수 있다. 예를 들어, 도 16의 호스트 기계 또는 응용(1605)으로부터 제어되는 도 3a 내지 도 3d의 스트림 TTL (310, 325, 340, 355)에 의존하는 대신, 도 17의 통계 계산 로직(1705)은 도 14 및 도 15의 통계들(1410, 1415, 1510)을 계산할 수 있다. 도 5의 선택 로직(525)은 블록(103)에 기입할 블록을 선택할 때에 도 3a 내지 도 3d의 스트림 TTL (310, 325, 340, 355) 대신에 도 14 및 도 15의 통계들(1410, 1415, 1510)을 사용할 수 있다.

도 12 및 도 13, 그리고 도 27a 내지 도 332에서, 본 발명의 일부 실시 예들이 도시되었다. 그러나 이 분야에 숙련된 자들은 블록들의 순서를 변경함으로써, 블록들을 생략함으로써, 또는 도시되지 않은 링크들을 포함함으로써 본 발명의 다른 실시 예들이 가능함을 이해할 것이다. 순서도들의 이러한 모든 변경들은 명시되지 않더라도 본 발명의 실시 예들인 것으로 여겨진다.

이하의 설명은 본 발명의 기술적 사상이 구현된 적절한 기계 또는 기계들의 간결하고 일반적인 설명을 제공하고자 한다. 기계 또는 기계들은 키보드, 마우스 등과 같은 통상적인 입력 장치들로부터의 입력뿐 아니라 또 다른 기계로부터 수신되는 지시들, 가상현실 환경과의 상호 작용, 생체 피드백 또는 다른 입력 신호에 의해 적어도 일부 제어될 수 있다. 여기에서, "기계"는 단일 기계, 가상 기계, 또는 통신할 수 있게 결합된 기계들의 시스템, 가상 기계들 또는 함께 동작하는 장치들을 넓게 포함할 수 있다. 예시적인 기계는 개인용 컴퓨터, 워크스테이션, 서버, 포터블 컴퓨터, 핸드헬드 장치, 전화기, 태블릿 등과 같은 컴퓨팅 장치들뿐 아니라 개인 또는 공용 수송(예를 들어, 자동차, 기차, 택시 등)과 같은 수송 장치들을 포함할 수 있다.

기계 또는 기계들은 프로그램 가능한 또는 프로그램 가능하지 않는 로직 장치들 또는 어레이들, ASIC (Application Specific Integrated Circuits), 임베디드 컴퓨터, 스마트 카드 등과 같은 임베디드 제어기들을 포함할 수 있다. 기계 또는 기계들은 네트워크 인터페이스, 모뎀 또는 다른 통신 연결과 같은 하나 또는 그보다 많은 원격 기계들로의 하나 또는 그보다 많은 연결들을 활용할 수 있다. 기계들은 인트라넷, 인터넷, LAN (local area network), WAN (wide area network) 등과 같은 물리적 또는 논리적 네트워크를 통해 서로 연결될 수 있다. 이 분야에 숙련된 자들은 네트워크 연결이 무선 주파수(RF), 위성, 마이크로파, IEEE 802.11, 블루투스®, 광, 적외선, 케이블, 레이저 등을 포함하는 다양한 유선 또는 무선 단거리 또는 장거리 캐리어들 및 프로토콜들을 활용함이 이해될 것이다.

본 발명의 실시 예들은 기계에 의해 액세스 된 때에 기계가 작업을 수행하거나 또는 추상적인 데이터 타입들 또는 저 레벨 하드웨어 콘텍스트를 정의하도록 하는 함수들, 절차들, 데이터 구조들, 응용 프로그램 등을 포함하는 연관된 데이터를 참조하여 설명될 수 있다. 연관된 데이터는 RAM, ROM 등과 같은 휘발성 또는 불휘발성 메모리 또는 하드 드라이브, 플로피 디스크, 광학 스토리지, 테이프, 플래시 메모리, 메모리 스틱, 디지털 비디오 디스크, 생체 스토리지 등을 포함하는 다른 저장 장치들 및 연관된 저장 매체에 저장될 수 있다. 연관된 데이터는 물리적 또는 논리적 네트워크를 포함하는 전송 환경을 걸쳐 패킷, 직렬 데이터, 병렬 데이터, 전송 신호 등의 형태로 전달될 수 있으며, 압축된 또는 암호화된 형태로 사용될 수 있다. 연관된 데이터는 분산 환경에서 사용될 수 있으며, 기계 액세스에 대해 지역적으로 또는 원격으로 저장될 수 있다.

본 발명의 실시 예들은 하나 또는 그보다 많은 프로세서들에 의해 실행될 수 있는 명령들을 포함하는 실재하는 비임시적인 기계로 독출될 수 있는 매체를 포함할 수 있다. 명령들은 상술된 본 발명의 원소들을 수행하게 하는 명령들을 포함할 수 있다.

본 발명의 기술적 사상이 실시 예들을 참조하여 설명되었지만, 설명된 실시 예들은 배치 및 상세 측면에서 본 발명의 기술적 사상으로부터 멀어지지 않으면서 필요에 따라 수정 또는 조합될 수 있다. 앞선 설명들이 구체적인 실시 예들에 집중하였지만, 다른 구성 또한 고려될 수 있다. 구체적으로, "본 발명의 실시 예에 따른" 또는 이와 유사한 표현이 사용되었지만, 이러한 표현들은 가능한 일반적인 실시 예를 참조하며, 본 발명의 기술적 사상을 구체적인 실시 예의 구성으로 한정하지 않는다. 여기에 사용되는 바와 같이, 이러한 용어들은 동일한 또는 다른 실시 예들로 조합 가능한 상이한 실시 예들을 참조할 수 있다.

앞서 설명된 실시 예들은 본 발명의 기술적 사상을 제한하지 않는다. 적은 수의 실시 예들만이 설명되었지만, 이 분야에 숙련된 자들은 이러한 실시 예들이 본 발명의 신규한 기술적 사상 및 장점으로부터 멀어지지 않으면서 다양하게 수정될 수 있음이 이해될 것이다. 따라서, 이러한 모든 수정들은 청구 범위에 기재된 바와 같이 본 발명의 기술적 사상에 포함된다.

본 발명의 실시예들은 아래의 문구들에 의해 확장될 수 있으며, 한정되지 않는다.

제1 문구로서, 본 발명의 실시 예는 솔리드 스테이트 드라이브(SSD)를 포함한다. SSD는 데이터를 위한 스토리지, 제1 스트림으로부터 스토리지 내의 데이터에 영향을 주는 복수의 제1 쓰기 요청들 및 복수의 제2 무효화 요청들을 수신하는 수신 회로, 상기 복수의 제1 쓰기 요청들 및 상기 복수의 제2 무효화 요청들로부터 상기 제1 스트림에 대한 통계를 계산하는 통계 계산 로직, 그리고 계산된 통계를 이용하여 SSD의 하나의 블록(103)에 기입되는 모든 데이터가 동일한 시간 근처에 무효화될 공산(likelihood)을 증가시키는 성능 로직을 포함한다.

제2 문구로서, 본 발명의 실시 예는 제1 문구에 따른 SSD를 포함한다. 통계 계산 로직은 시간 로직 및 데이터 수명 로직을 포함한다. 시간 로직은 복수의 제1 쓰기 요청들에 대한 복수의 쓰기 시간들 및 복수의 무효화 요청들에 대한 복수의 무효화 시간들을 판별하고, 개별 쓰기 요청들에 대한 개별 쓰기 시간들을 대응하는 개별 무효화 요청들에 대한 개별 무효화 시간들과 짝지운다. 데이터 수명 로직은 복수의 쓰기 시간들로부터의 대응하는 쓰기 시간들 및 복수의 무효화 시간들로부터의 무효화 시간들로부터 데이터 수명들을 계산한다.

제3 문구로서, 본 발명의 실시 예는 제2 문구의 SSD를 포함한다. 통계 계산 로직은 계산된 데이터 수명들에 들어맞는 통계 함수를 생성하는 통계 로직을 더 포함한다.

제4 문구로서, 본 발명의 실시 예는 제3 문구의 SSD를 포함한다. 통계 로직은 계산된 데이터 수명들에 들어맞는 분포 함수를 계산한다.

제5 문구로서, 본 발명의 실시 예는 제2 문구의 SSD를 포함한다. 통계 계산 로직은 계산된 데이터 수명들로부터 히스토그램을 생성한다.

제6 문구로서, 본 발명의 실시 예는 제2 문구의 SSD를 포함한다. SSD는 계산된 데이터 수명들을 위한 스토리지를 더 포함한다.

제7 문구로서, 본 발명의 실시 예는 제2 문구의 SSD를 포함한다. 복수의 쓰기 시간들 및 복수의 무효화 시간들은 가장 최근의 쓰기 시간들 및 무효화 시간들을 포함한다.

제8 문구로서, 본 발명의 실시 예는 제2 문구의 SSD를 포함한다. 통계 계산 로직은 계산된 데이터 수명들에 대한 가중치들을 판별하는 가중 로직을 더 포함한다.

제9 문구로서, 본 발명의 실시 예는 제1 문구의 SSD를 포함한다. 수신 회로는 새로운 데이터를 포함하는 새로운 쓰기 요청을 수신한다. 성능 로직은 계산된 통계에 응답하여 새로운 데이터를 저장할 목표를 선택하는 스토리지 선택기를 포함한다. 목표는 SSD의 블록 및 제2차 스트림 중 하나이다.

제10 문구로서, 본 발명의 실시 예는 제10 문구의 SSD를 포함한다. 목표는 신뢰 수준에 대해 예측된 스트림 TTL (Time-To-Live)보다 가장 조금 큰 TTL을 포함한다.

제11 문구로서, 본 발명의 실시 예는 제9 문구의 SSD를 포함한다. 스토리지 선택기는 제2 신뢰 수준에 대해 제2 스트림 TTL을 포함하는 제2 스트림(305, 320, 335, 350)으로부터의 데이터 및 새로운 데이터 모두를 저장할 블록을 선택한다. 제2 스트림 TTL은 예측된 스트림 TTL에 가깝다.

제12 문구로서, 본 발명의 실시 예는 제1 문구의 SSD를 포함한다. 성능 로직은 예상 잔여 수명 로직 및 스토리지 선택기를 포함한다. 예상 잔여 수명 로직은 계산된 통계들을 이용하여 유효 데이터에 대한 예상 잔여 수명을 예측한다. 소거 블록(2505) 내의 유효 데이터는 가비지 컬렉션의 대상이 된다. 스토리지 선택기는 유효 데이터를 프로그램할 목표를 선택한다. 목표는 제2 블록 및 제2차 스트림 중 하나이다. 목표는 유효 데이터에 대한 예상 잔여 수명보다 가장 조금 큰 TTL을 갖는다.

제13 문구로서, 본 발명의 실시 예는 제12 문구의 SSD를 포함한다. 제2 블록은 제2 스트림에 할당된다.

제14 문구로서, 본 발명의 실시 예는 제1 문구의 SSD를 포함한다. 성능 로직은 계산된 통계들 및 제2 스트림에 대한 제2 계산된 통계들에 응답하여, 제1 스트림 및 제2 스트림 중 하나를 선택하여 데이터를 블록에 기입한다.

제15 문구로서, 본 발명의 실시 예는 제1 문구의 SSD를 포함한다. 성능 로직은 비교기 및 보고 로직을 포함한다. 비교기는 계산된 통계들을 응용에 의해 제공되는 스트림 TTL과 비교한다. 보고 로직은 스트림 TTL이 계산된 통계들과 크게 다를 때에 계산된 통계들의 부분 집합을 응용에 보고한다.

제16 문구로서, 본 발명의 실시 예는 SSD를 위한 로직을 포함한다. 로직은 시간 로직, 데이터 수명 로직, 통계 계산 로직 및 성능 로직을 포함한다. 시간 로직은 복수의 쓰기 요청들에 대한 복수의 쓰기 시간들 및 복수의 무효와 요청들에 대한 복수의 무효화 시간들을 판별하고, 개별 쓰기 요청들에 대한 개별 싸기 시간들을 대응하는 개별 무효화 요청들에 대한 개별 무효화 시간들과 짝지운다. 데이터 수명 로직은 복수의 쓰기 시간들로부터의 대응하는 쓰기 시간들 및 복수의 무효화 시간들로부터의 무효화 시간들로부터 데이터 수명들을 계산한다. 통계 계산 로직은 계산된 데이터 수명들로부터 제1 스트림에 대한 통계들을 계산한다. 성능 로직은 계산된 통계들을 이용하여 SSD의 블록(103)에 기입되는 모든 데이터가 동일한 시간 근처에 무효화될 공산을 증가시킨다.

제17 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. 통계 계산 로직은 계산된 데이터 수명들에 들어맞는 통계 함수를 생성하는 통계 로직을 더 포함한다.

제18 문구로서, 본 발명의 실시 예는 제17 문구의 로직을 포함한다. 통계 로직은 계산된 데이터 수명들에 들어맞는 분포 함수를 계산한다.

제19 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. 통계 계산 로직은 계산된 데이터 수명들로부터 히스토그램을 생성한다.

제20 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. SSD는 계산된 데이터 수명들을 위한 스토리지를 더 포함한다.

제21 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. 복수의 쓰기 시간들 및 복수의 무효화 시간들은 가장 최근의 쓰기 시간들 및 무효화 시간들을 포함한다.

제22 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. 통계 계산 로직은 계산된 데이터 수명들에 대한 가중치들을 판별하는 가중 로직을 더 포함한다.

제23 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. 성능 로직은 계산된 통계에 응답하여 새로운 데이터를 저장할 목표를 선택한다. 목표는 블록 및 제2차 스트림 중 하나이다.

제24 문구로서, 본 발명의 실시 예는 제23 문구의 로직을 포함한다. 목표는 신뢰 수준에 대해 예측된 스트림 TTL (Time-To-Live)보다 가장 조금 큰 블록 TTL을 포함한다.

제25 문구로서, 본 발명의 실시 예는 제24 문구의 로직을 포함한다. 성능 로직은 제2 신뢰 수준에 대해 제2 스트림 TTL을 포함하는 제2 스트림(305, 320, 335, 350)으로부터의 데이터 및 새로운 데이터를 저장할 블록을 선택한다. 제2 스트림 TTL은 예측 스트림 TTL과 근접하다.

제26 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. 성능 로직은 예상 잔여 수명 로직 및 스토리지 선택기를 포함한다. 예상 잔여 수명 로직은 계산된 통계들을 이용하여 유효 데이터의 예상 잔여 수명을 계산한다. 소거 블록(2505) 내의 유효 데이터는 가비지 컬렉션의 대상이 된다. 스토리지 선택기는 유효 데이터를 프로그램할 목표를 선택한다. 목표는 블록 및 제2차 스트림 중 하나이다. 목표는 유효 데이터의 예상 잔여 수명보다 가장 조금 큰 블록 TTL을 갖는다.

제27 문구로서, 본 발명의 실시 예는 제26 문구의 로직을 포함한다. 제2 블록은 제2 스트림에 할당된다.

제28 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. 성능 로직은 계산된 통계들 및 제2 스트림에 대해 계산된 제2 통계들에 응답하여, 제1 스트림 및 제2 스트림 중 하나를 선택하여 블록에 데이터를 기입한다.

제29 문구로서, 본 발명의 실시 예는 제16 문구의 로직을 포함한다. 성능 로직은 비교기 및 보고 로직을 포함한다. 비교기는 계산된 통계들을 응용에 의해 제공되는 스트림 TTL과 비교한다. 보고 로직은 스트림 TTL이 계산된 통계들과 크게 다르면 응용에 계산된 통계들의 부분 집합을 보고한다.

제30 문구로서, 본 발명의 실시 예는 방법을 포함한다. 방법은 각각 제1 스트림과 연관된 복수의 제1 쓰기 요청들을 SSD에서 수신하는 단계, 각각 복수의 제1 쓰기 요청들 중 하나와 연관되는 복수의 제2 쓰기 시간들을 판별하는 단계, 각각 복수의 제1 쓰기 요청들에 의해 기입된 데이터를 삭제하는 복수의 제3 무효화 요청들을 SSD에서 수신하는 단계, 각각 복수의 제3 무효화 요청들 중 하나와 연관되는 복수의 제4 무효화 시간들을 판별하는 단계, 복수의 제2 쓰기 시간들 및 복수의 제4 무효화 시간들에 응답하여 제1 스트림에 대한 통계들을 계산하는 단계, 그리고 계산된 통계들을 이용하여 SSD의 블록(103)에 기입되는 모든 데이터가 동일한 시간 근처에 무효화될 공산이 증가시키는 단계를 포함한다.

제31 문구로서, 본 발명의 실시 예는 제30 문구의 방법을 포함한다. 복수의 제2 쓰기 시간들을 판별하는 단계는, 복수의 제1 쓰기 요청들 각각을 수행하는 단계, 그리고 복수의 제2 쓰기 시간들을 복수의 제1 쓰기 요청들이 수행된 시간들로 판별하는 단계를 포함한다. 복수의 제4 무효화 시간들을 판별하는 단계는, 복수의 제3 무효화 요청들 각각을 수행하는 단계, 그리고 복수의 제4 무효화 시간들을 복수의 제3 무효화 요청들이 수행된 시간들로 판별하는 단계를 포함한다.

제32 문구로서, 본 발명의 실시 예는 제30 문구의 방법을 포함한다. 제1 스트림에 대한 통계들을 계산하는 단계는, 복수의 제2 쓰기 시간들 및 복수의 제4 무효화 시간들을 저장하는 단계를 포함한다.

제33 문구로서, 본 발명의 실시 예는 제30 문구의 방법을 포함한다. 제1 스트림에 대한 통계들을 계산하는 단계는, 각각 상기 복수의 제1 쓰기 요청들 중 특정한 쓰기 요청과 연관되며 복수의 제2 쓰기 시간들로부터의 하나의 쓰기 시간 및 복수의 제4 무효화 시간들로부터의 하나의 무효화 시간을 포함하는 복수의 제5 시간 쌍들을 판별하는 단계, 각각 복수의 제5 시간 쌍들 중 하나에서 하나의 쓰기 시간 및 하나의 무효화 시간 사이의 차이를 포함하는 복수의 제6 데이터 수명들을 계산하는 단계, 그리고 복수의 제6 데이터 수명들에 응답하여 제1 스트림에 대한 통계들을 계산하는 단계를 포함한다.

제34 문구로서, 본 발명의 실시 예는 제33 문구의 방법을 포함한다. 복수의 제5 시간 쌍들을 판별하는 단계는, 복수의 제1 쓰기 요청들보다 수가 적은 복수의 제5 시간 쌍들을 판별하는 단계를 포함한다.

제35 문구로서, 본 발명의 실시 예는 제34 문구의 방법을 포함한다. 복수의 제5 시간 쌍들을 판별하는 단계는, 복수의 제1 쓰기 요청들의 가장 최근의 부분 집합인 복수의 제5 시간 쌍들을 판별하는 단계를 포함한다.

제36 문구로서, 본 발명의 실시 예는 제34 문구의 방법을 포함한다. 복수의 제4 무효화 시간들을 판별하는 단계는, 복수의 제2 쓰기 시간들과 개수가 동일한 복수의 제4 무효화 시간들을 판별하는 단계를 포함한다.

제37 문구로서, 본 발명의 실시 예는 제33 문구의 방법을 포함한다. 복수의 제2 쓰기 시간들을 판별하는 단계는, 각각 복수의 제2 쓰기 시간들 중 하나의 쓰기 시간과 연관되는 복수의 제6 가중치들을 판별하는 단계를 포함한다. 제1 스트림에 대한 통계들을 계산하는 단계는 복수의 제6 데이터 수명들 및 복수의 제6 가중치들에 기반한다.

제38 문구로서, 본 발명의 실시 예는 제33 문구의 방법을 포함한다. 제1 스트림에 대한 통계들을 계산하는 단계는 복수의 제6 데이터 수명들에 들어맞는 통계 함수를 생성하는 단계를 포함한다.

제39 문구로서, 본 발명의 실시 예는 제38 문구의 방법을 포함한다. 통계 함수를 생성하는 단계는 복수의 제6 데이터 수명들에 들어맞는 분포 함수를 생성하는 단계를 포함한다.

제40 문구로서, 본 발명의 실시 예는 제33 문구의 방법을 포함한다. 제1 스트림에 대한 통계들을 계산하는 단계는 복수의 제6 데이터 수명들에 대한 히스토그램을 생성하는 단계를 포함한다.

제41 문구로서, 본 발명의 실시 예는 제30 문구의 방법을 포함한다. 계산된 통계들을 이용하여 SSD의 성능을 개선하는 단계는, 새로운 데이터를 포함하는 새로운 쓰기 요청을 수신하는 단계, 그리고 계산된 통계를 이용하여 새로운 데이터를 저장할 목표를 선택하는 단계를 포함한다. 목표는 SSD의 블록 및 제2차 스트림 중 하나이다.

제42 문구로서, 본 발명의 실시 예는 제41 문구의 방법을 포함한다. 상기 계산된 통계들을 이용하여 상기 새로운 데이터를 기입할 목표를 선택하는 단계는, 제1 신뢰 수준에 대해 제1 스트림에 대해 예측된 제1 스트림 TTL (Time-To-Live)보다 가장 조금 큰 TTL을 갖는 목표를 선택하는 단계를 포함한다.

제43 문구로서, 본 발명의 실시 예는 제42 문구의 방법을 포함한다. 목표는 제1 스트림 및 제2 스트림으로부터의 데이터를 저장하도록 지정된다. 제2 스트림은 제2 신뢰 수준에 대해 제1 스트림 TTL과 가까운 제2 스트림 TTL을 포함한다.

제44 문구로서, 본 발명의 실시 예는 제30 문구의 방법을 포함한다. 계산된 통계들을 이용하여 SSD의 성능을 개선하는 단계는, 계산된 통계들을 이용하여 가비지 컬렉션의 대상인 소거 블록으로부터의 무효 데이터를 프로그램할 목표 블록을 선택하는 단계를 포함한다.

제45 문구로서, 본 발명의 실시 예는 제44 문구의 방법을 포함한다. 계산된 통계들을 이용하여 가비지 컬렉션의 대상인 소거 블록으로부터의 무효 데이터를 프로그램할 목표 블록을 선택하는 단계는, 소거 블록 내의 유효 데이터를 식별하는 단계, 계산된 통계들을 이용하여 유효 데이터에 대한 예상 잔여 수명을 판별하는 단계, 유효 데이터에 대한 예상 잔여 수명보다 가장 조금 큰 블록 TTL을 갖는 목표 블록을 선택하는 단계, 그리고 유효 데이터를 목표 블록에 프로그램하는 단계를 포함한다.

제46 문구로서, 본 발명의 실시 예는 제45 문구의 방법을 포함한다. 목표 블록에 제2 스트림이 할당된다.

제47 문구로서, 본 발명의 실시 예는 제30 문구의 방법을 포함한다. 방법은 각각 제2 스트림과 연관되는 복수의 제5 쓰기 요청들을 SSD에서 수신하는 단계, 각각 복수의 제5 쓰기 요청들 중 하나와 연관되는 복수의 제6 쓰기 시간들을 판별하는 단계, 각각 복수의 제5 쓰기 요청들 중 하나에 의해 기입된 제2 데이터를 삭제하는 복수의 제7 무효화 요청들을 SSD에서 수신하는 단계, 각각 복수의 제7 무효화 요청들 중 하나와 연관되는 복수의 제8 무효화 시간들을 판별하는 단계, 복수의 제6 쓰기 시간들 및 복수의 제8 무효화 시간들에 응답하여 제2 스트림에 대한 제2 통계들을 계산하는 단계, 제1 스트림과 연관되는 새로운 제1 쓰기 요청을 SSD에서 수신하는 단계, 그리고 제2 스트림과 연관되는 새로운 제5 쓰기 요청을 SSD에서 수신하는 단계를 포함한다. 계산된 통계들을 이용하여 SSD의 성능을 개선하는 단계는 새로운 제1 쓰기 요청 또는 새로운 제5 쓰기 요청을 계산된 통계들 및 계산된 제2 통계들에 기반하여 SSD의 블록에 기입할지 선택하는 단계를 포함한다.

제48 문구로서, 본 발명의 실시 예는 제30 문구의 방법을 포함한다. 방법은 응용으로부터 스트림 TTL을 수신하는 단계를 포함한다. 계산된 통계들을 이용하여 SSD의 성능을 개선하는 단계는 스트림 TTL을 계산된 통계들과 비교하는 단계, 그리고 스트림 TTL이 계산된 통계들로부터 크게 다르면, 계산된 통계들의 부분 집합을 응용에 보고하는 단계를 포함한다.

결과적으로, 설명된 실시 예들에 대한 넓고 다양한 순열의 관점에서, 상세한 설명 및 첨부된 소재들은 예시적인 것에 불과하며, 본 발명의 기술적 사상의 범위를 한정하지 않는다. 따라서, 첨부된 청구 범위와 같이, 이러한 모든 변경들을 후술되는 청구항들의 기술적 사상의 범위 및 그것에 등가적인 것에 속한다.

505; 솔리드 스테이트 드라이브(SSD)
510; 회로
515; SSD 컨트롤러
520; 플래시 메모리
525; 선택 로직
530; 쓰기 로직
535; TTL 계산기
540; 제2차 스트림 생성기
605; 비교기
610; 평균 쓰기 사이즈 계산기
615; 평균 쓰기 도착률 계산기
620; 스트림 선택 로직
625; 스토리지
1105; 기계
1110; 프로세서
1115; 메모리 컨트롤러
1120; 클럭
1125; 메모리
1130; 네트워크 커넥터
1135; 버스
1140; 사용자 인터페이스
1145; 입출력 엔진
1705; 통계 계산 로직
1710; 성능 로직

Claims (10)

1. 솔리드 스테이트 드라이브에 있어서:
   데이터를 위한 스토리지;
   상기 스토리지 내의 상기 데이터에 영향을 주는 복수의 제1 쓰기 요청들 및 복수의 제2 무효화 요청들을 제1 스트림으로부터 수신하는 수신 회로;
   상기 복수의 제1 쓰기 요청들 및 상기 복수의 제2 무효화 요청들로부터 상기 제1 스트림에 대한 통계들을 계산하는 통계 계산 로직; 그리고
   상기 계산된 통계들을 이용하여 상기 솔리드 스테이트 드라이브의 블록에 기입된 모든 데이터가 동일한 시간 근처에 무효화될 공산을 증가시키는 성능 로직을 포함하는 솔리드 스테이트 드라이브.
2. 제1항에 있어서,
   상기 통계 계산 로직은,
   상기 복수의 제1 쓰기 요청들에 대한 복수의 쓰기 시간들 및 상기 복수의 제2 무효화 요청들에 대한 복수의 무효화 시간들을 판별하고, 개별 쓰기 요청들에 대한 개별 쓰기 시간들을 대응하는 개별 무효화 요청들에 대한 개별 무효화 시간들과 짝지우는 시간 로직; 그리고
   상기 복수의 시간들로부터의 대응하는 쓰기 시간들 및 상기 복수의 무효화시간들로부터의 무효화 시간들로부터 데이터 수명들을 계산하는 데이터 수명 로직을 포함하는 솔리드 스테이트 드라이브.
3. 제2항에 있어서,
   상기 통계 계산 로직은 상기 계산된 데이터 수명들에 들어맞는 통계 함수를 생성하는 통계 로직을 더 포함하는 솔리드 스테이트 드라이브.
4. 제2항에 있어서,
   상기 통계 계산 로직은 상기 계산된 데이터 수명들로부터 히스토그램을 생성하는 솔리드 스테이트 드라이브.
5. 제2항에 있어서,
   상기 복수의 쓰기 시간들 및 상기 복수의 무효화 시간들은 가장 최근의 쓰기 시간들 및 무효화 시간들을 포함하는 솔리드 스테이트 드라이브.
6. 제1항에 있어서,
   상기 수신 회로는 새로운 데이터를 포함하는 새로운 쓰기 요청을 수신하고,
   상기 성능 로직은 상기 계산된 통계에 응답하여 생기 새로운 데이터를 저장할 목표를 선택하는 스토리지 선택기를 포함하고,
   상기 목표는 상기 솔리드 스테이트 드라이브의 블록 및 제2차 스트림 중 하나인 솔리드 스테이트 드라이브.
7. 제1항에 있어서,
   상기 성능 로직은,
   상기 계산된 통계들을 이용하여 가비지 컬렉션의 대상이 된 소거 블록 내의 유효 데이터에 대한 예상 잔여 수명을 계산하는 예상 잔여 수명 로직; 그리고
   상기 유효 데이터를 프로그램할 목표를 선택하는 스토리지 선택기를 포함하고,
   상기 목표는 상기 솔리드 스테이트 드라이브의 블록 및 제2차 스트림 중 하나이고,
   상기 목표는 상기 유효 데이터에 대한 상기 예상 잔여 수명보다 가장 조금 큰 생존 시간(TTL, Time-To-Live)을 갖는 솔리드 스테이트 드라이브.
8. 솔리드 스테이트 드라이브를 위한 로직에 있어서:
   복수의 쓰기 요청들에 대한 복수의 쓰기 시간들 및 복수의 무효화 요청들에 대한 복수의 무효화 시간들을 판별하고, 개별 쓰기 요청들에 대한 개별 쓰기 시간들을 대응하는 개별 무효화 요청들에 대한 개별 무효화 시간들과 짝지우는 시간 로직;
   상기 복수의 쓰기 시간들로부터의 대응하는 쓰기 시간들 및 상기 복수의 무효화 시간들로부터의 무효화 시간들로부터 데이터 수명들을 계산하는 데이터 수명 로직;
   상기 계산된 데이터 수명들로부터 제1 스트림에 대한 통계들을 계산하는 통계 계산 로직; 그리고
   상기 계산된 통계들을 이용하여 상기 솔리드 스테이트 드라이브의 블록에 기입된 모든 데이터가 동일한 시간 근처에 무효화될 공산을 증가시키는 성능 로직을 포함하는 로직.
9. 방법에 있어서:
   솔리드 스테이트 드라이브에서 각각 제1 스트림과 연관된 복수의 제1 쓰기 요청들을 수신하는 단계;
   각각 상기 복수의 제1 쓰기 요청들과 연관된 복수의 제2 쓰기 시간들을 판별하는 단계;
   상기 솔리드 스테이트 드라이브에서 각각 상기 복수의 제1 쓰기 요청들 중 하나에 의해 기입된 데이터를 삭제하는 복수의 제3 무효화 요청들을 수신하는 단계;
   각각 상기 복수의 제3 무효화 요청들 중 하나와 연관된 복수의 제4 무효화 시간들을 판별하는 단계;
   상기 복수의 제2 쓰기 시간들 및 상기 복수의 제4 무효화 시간들에 응답하여 상기 제1 스트림에 대한 통계들을 계산하는 단계; 그리고
   상기 계산된 통계들을 이용하여 상기 솔리드 스테이트 드라이브의 블록에 기입된 모든 데이터가 동일한 시간 근처에서 무효화될 공산을 증가시키는 단계를 포함하는 방법.
10. 제9항에 있어서,
    상기 계산된 통계들을 이용하여 상기 솔리드 스테이트 드라이브의 블록에 기입된 모든 데이터가 동일한 시간 근처에서 무효화될 공산을 증가시키는 단계는,
    새로운 데이터를 포함하는 새로운 쓰기 요청을 수신하는 단계; 그리고
    상기 계산된 통계들을 이용하여 상기 새로운 데이터를 기입할 목표를 선택하는 단계를 포함하고,
    상기 목표는 상기 솔리드 스테이트 드라이브의 블록 및 제2차 스트림 중 하나인 방법.

Images