KR20200145673A - 비닝 도중 거친 깊이 컬링 - Google Patents

Abstract

본 발명의 양상들은 픽셀 지오메트리들의 비닝 도중에 거친 깊이 컬링을 위한 비닝 유닛을 포함한다. 비닝 유닛은 프리미티브들을 수신하기 위한 래스터라이저를 포함하고, 그리고 픽셀 커버리지 정보 및 깊이 정보를 생성한다. 비닝 유닛은 프리미티브들의 윈도우 내에서 로컬 컬링을 수행하기 위한 하나 이상의 로컬 컬링 스테이지들을 포함한다. 로컬 컬링 유닛은 생존 커버리지 및 생존 깊이 정보의 집합을 출력한다. 비닝 유닛은 이전에 수신된 커버리지 정보 및 깊이 정보의 전부에 기초하여 더 컬링하기 위해 생존 커버리지 정보 및 생존 깊이 정보의 집합을 사용하는 하나 이상의 글로벌 컬링 스테이지들을 포함한다.

Description

비닝 도중 거친 깊이 컬링{COARSE DEPTH CULLING DURING BINNING}

본 발명은 그래픽 처리 장치(Graphics Processing Units; GPUs)에 관한 것으로, 좀 더 상세하게는 비닝 도중 거친(coarse) 깊이 컬링(Culll) 하는 방법 및 시스템에 관한 것이다.

그래픽스 처리 장치(Graphics Procesing Units; GPUs)는 컴퓨터-생성(computer-generated) 그래픽들의 처리를 가속화하기 위한 특수 장치이다. GPU는 신경 네트워크들, 인공 지능(AI), 고 성능 시스템들, 자율 주행 차들, 모바일 장치들, 게이밍 시스템들 등과 같은 다양한 현대 컴퓨팅 환경들에서도 또한 사용된다.

은면 소거(Hidden Surface Removal; HSR) 방법들은 카메라에 더 근접한 다른 표면들에 의해 카메라로부터 숨겨지거나 가려지는 면들이 처리되는 것을 제거하는 것을 가리킨다. 데스크탑 GPU들은 쿼드들(quads; 즉, 2x2 픽셀 블록들)의 컬링을 가능하게 하는 깊이 버퍼를 유지하는데, 쿼드들의 깊이는 다른 이미-처리된 쿼드들에 의해 가려지는 것을 가리킨다. 이러한 기법의 영향력은 (표)면들이 앞뒤로(front-to-back) 분류되는 정도에 의존한다.

기존의 HSR 방법들은 제거를 위한 숨겨진 면들의 구성 정점들(vertices) 및 프리미티브들(primitives)을 타겟팅하지 않고, 숨겨진 쿼드들을 제거하는 것을 주로 목표로 한다. 모바일 GPU들은 프론트-엔드(front-end) 패스들의 모든 출력 속성들, 전형적으로 정점 셰이딩(vertex shading)을 생성하고, 그리고 속성들을 다시 읽을 수 있다. 고려 가능한 리소스들 및 에너지는 결국 가시적인(visible) 쿼드들로 귀결되지 않는 완전히-가려진(completely-occluded) 프리미티브들 및 그들의 정점들의 큰 부분을 처리하는 데 사용된다. GPU들은 일반적으로 결국에는 이후의 쿼드들에 의해 가려지는 쿼드들을 컬링하는 데 제한된 능력을 갖는다. 한 일반적인 접근법은 픽셀 쉐이딩(pixel shading) 이전에 쿼드들를 버퍼링 업(buffering up)하여 이전 쿼드를 가리는 버퍼에서 이후의 쿼드를 식별하는 것을 포함한다. 그러나, 이러한 접근법은 실용적인 비용-효율적인(cost-effective) 버퍼 크기들에 의해 제한된다.

대부분의 타일-기반 지연 렌더링(tile-based deferred rendering, TBDR) GPU들은 프리미티브(primitive) 당 이미지 당 프론트-엔트 스테이지들을 한 번 실행하고, 중간 버퍼에 결과들을 캐시(cache)하고, 프래그먼트(fragment)/픽셀 스테이지들을 실행하기 위해 타일 당 한 번 중간 버퍼로부터 독출한다. 이러한 TBDR GPU들 중 몇몇은 HST을 위한 접근법과 유사한 것을 사용한다. 타일-기반 GPU들은 지오메트리(geometry)가 영향을 주는 픽셀들의 타일들에 의해 분류되는 비닝 단계를 포함한다. 하나의 타일은 픽셀들의 직사각형 블록이다. 비닝 유닛(때로는 타일러(tiler)로 지칭되기도 함)은 픽셀들의 타일 각각에 투사(발생)되는 드로우들(draws) 및 프리미티브들(pritimitives)의 리스트를 생성한다. 프리미티브들은 보통 삼각형들인, 좌표계의 기하학적인 도형들이다. 타일들은 픽셀들의 그룹이다. 비닝 유닛은 타일에 영향을 주는 프리미티브들만이 처리되도록 하여, 렌더링이 타일 단위로 동작하도록 허용한다. 일반적인 비닝은 공간적인(special) 분류만을 사용하고, 가시성(visibility)을 고려하지 않는다. 다시 말해서, 다른 프리미티브들에 의해 가려지는 하나의 타일 내부의 프리미티브들이 배제(exclude)되지 않는다.

가시성을 포함하지 않는 것은 이미지 내의 특정 픽셀들의 오버 드로우(overdraw), 또는 반복되는 음영(쉐이딩, shading)을 야기한다. 가시성 컬링을 사용하면, 픽셀들의 반복되는 쉐이딩의 양이 감소될 수 있고, 그리고 대응하는 픽셀 쉐이더(pixel shader) 호출들(invocations)도 또한 줄여질 수 있다.

본 발명의 목적은 상술된 기술적 과제를 해결하기 위한 것으로, 본 발명의 목적은 비닝 도중 거친(coarse) 깊이 컬링(Culll) 하는 방법 및 시스템을 제공하는 데 있다.

몇몇 실시 예들은 픽셀 지오메트리들의 비닝 도중에 거친 깊이 컬링을 위한 비닝 유닛을 포함한다. 비닝 유닛은 프리미티브들을 수신하는 래스터라이저를 포함하고, 그리고 픽셀 커버리지 정보 및 깊이 정보를 생성한다. 비닝 유닛은 프리미티브들의 윈도우 내에서 로컬 컬링을 수행하기 위한 하나 이상의 로컬 컬링 스테이지들을 포함한다. 로컬 컬링 유닛은 생존 커버리지 및 생존 깊이 정보의 집합(세트)을 출력한다. 비닝 유닛은 이전에 수신된 커버리지 정보 및 깊이 정보의 전부에 기초하여 더 컬링하기 위해 생존 커버리지 및 생존 깊이 정보의 집합을 사용하는 하나 이상의 글로벌 컬링 스테이지들을 포함한다.

본 발명의 실시 예에 따르면 비닝 중 소모되는 메모리 대역폭이 감소되고, 픽셀 쉐이더 호출들이 감소되고, 상태 관리 오버헤드가 감소되고, 오버드로우 레이트가 감소된 비닝 유닛이 제공될 수 있다. 이에 따라, 이미지 처리에 필요한 비용 및 시간이 감소되고 이미지 처리의 성능이 향상될 수 있다.

본 발명의 원리들의 앞서 설명한 그리고 추가적인 특징들 및 장점들은 첨부되는 도면들을 참조하여 생성된 이어지는 상세한 설명으로부터 보다 잘 명백해질 것이다:
도 1은 몇몇 실시 예들에 따른 비닝 유닛의 예시적인 다이어그램이다.
도 2는 은면 제거(Hidden Surface Removal; HSR) 기술을 나타내는 예시적인 다이어그램이다.
도 3은 몇몇 실시 예들에 따른 {프리미티브, 타일}({prim, tile}) 컬링 및 쿼드 컬링의 예시적인 다이어그램이다.
도 4는 몇몇 실시 예들에 따른 메모리에 저장된 깊이 및 커버리지 구조의 예시적인 다이어그램이다.
도 5는 몇몇 실시 예들에 따른 로컬 컬링 스테이지를 사용하여 깊이 및 커버리지 병합의 구현을 위한 경우들의 예시적인 다이어그램이다.
도 6은 도 5에 도시된 다양한 블록들을 위한 범례(600)를 포함하는 다이어그램이다.
도 7은 몇몇 실시 예들에 따른 깊이 테스트 모듈의 예시적인 다이어그램이다.
도 8은 몇몇 실시 예들에 따른 도 7의 깊이 테스트 모듈의 집합 테스터기의 예시적인 다이어그램이다.
도 9는 몇몇 실시 예들에 따른 깊이 업데이트 로직 섹션의 예시적인 다이어그램이다.
도 10은 몇몇 실시 예들에 따른 도 1의 비닝 유닛을 포함하는 GPU의 예시적인 블록도이다.

이하에서 개시되는 실시 예들이 상세하게 참조될 것이며, 이들의 예시들은 첨부된 도면들에 도시되어 있다. 이어지는 상세한 설명에서, 본 개시의 철저한 이해를 위해 여러 구체적인 세부 사항들이 설명된다. 그러나, 통상의 기술자는 개시된 양상들이 이러한 구체적인 세부 사항들이 없어도 실시될 수 있음을 이해할 것이다. 다른 예시들에서, 잘 알려진 방법들, 절차들, 구성 요소들 및 회로들은 여기에서 개시된 발명을 모호하게 하지 않기 위해 상세하게 설명되지는 않았다.

비록 제 1, 제 2 등과 같은 용어들이 다양한 요소들을 설명하기 위해 여기에서 사용될 수 있으나, 이러한 요소들이 이러한 용어들에 의해 한정되지 아니해야 할 것으로 이해될 것이다. 이러한 용어들은 한 요소를 다른 요소로부터 구별하기 위해서만 사용되었다. 예를 들어, 제 1 프리미티브는 제 2 프리미티브로도 지칭될 수 있고, 유사하게, 제 2 프리미티브는 제 1 프리미티브로 본 발명의 범위를 벗어나지 아니하면서 지칭될 수 있다.

이하의 본 발명의 설명에서 사용되는 용어는 특정한 실시 예를 설명하기 위해 사용되는 것일 뿐 본 발명을 한정하는 것을 의도하지 않는다. 본 발명의 설명 및 첨부된 청구하들에서 사용된 바와 같이, 단수형 표현들은 문맥 상 명백하게 상반되는 것을 나타내지 않는 한, 복수형 표현들 또한 포함하는 것으로 의도되었다. 또한 “및/또는” 이란 용어는 이하에서 연관된 나열된 요소들의 하나 이상의 가능한 모든 조합들을 지칭하고 그리고 포함하는 것으로 이해될 것이다. 또한 본 명세서에서 사용된 “포함한다” 및/또는 “포함하는”이라는 용어는, 언급된 특징들, 정수들, 단계들, 동작들, 요소들, 및/또는 구성 요소들의 존재를 특정하지만, 하나 이상의 다른 특징들, 정수들, 단계들, 동작들, 요소들, 구성 요소들, 및/또는 그것들의 그룹의 존재 또는 추가를 배제하지는 않는 것으로 더 이해될 것이다. 도면들의 구성 요소들 및 특징들은 반드시 축적(scale)대로 그려진 것은 아니다.

몇몇 실시 예들은 드로우들(draws) 및 프리미티브들(primitives)을 가시성(visibility)에 기초한 타일-당 리스트들로부터 컬링(cull)할 수 있는 능력을 포함하는 증강된(augmented) 비닝(binning) 유닛을 포함한다. 이하에서 개시된 비닝 유닛은 픽셀(또는 픽셀들의 그룹) 레벨의 입도(세분도, granularity)에서의 최종 깊이 표현에 대한 거친(coarse) 근사(approximation)를 생성할 수 있다. 비닝 유닛은 또한 비닝 과정에서 소모되는 메모리 대역폭을 최소화할 수 있다. 비닝 유닛은 프리미티브들 및 드로우콜들(drawcalls)을 타일 패스들에서 처리되는 것으로부터 컬링함으로써 일(작업)을 줄일 수 있다. 비닝 유닛은 거친 깊이 표현을 프리로딩함으로써 기존의 “초기-Z(Early-Z)”하드웨어의 컬링 성능을 향상 시킬 수 있으며, 따라서 더 적은 픽셀들 및/또는 프래그먼트들(fragments)이 쉐이딩(shading)되는 결과를 가져온다. “초기-Z”는 픽셀-당 쉐이딩되는 깊이 처리의 한 형태이다.

프리미티브들 각각에 대하여, 여기에서 개시된 비닝 유닛은 필요한 입도(예를 들어, 샘플들 또는 픽셀들)에서 프리미티브를 래스터라이즈(래스터화, rasterize)할 수 있다. 만약 픽셀 당 단 하나의 샘플만이 있다면, 그렇다면 샘플은 픽셀과 균등하다. 픽셀 당 단 하나의 샘플만이 존재하는 것이 필요한 것은 아니지만, “샘플” 및 “픽셀”이란 용어들은 이하에서 일반적으로 상호 교환 가능하도록 사용된다. 비닝 유닛은 미리 정해진 크기의 블록들의, 픽셀들의 블록 각각에 대한 프리미티브 각각에 대하여 깊이 범위를 계산할 수 있다. 비닝 유닛은 이 프리미티브-당 {커버리지, 깊이 범위} 정보를 이미지에 대한 중간 {커버리지, 깊이 범위} 표현을 유지하기 위해 사용할 수 있으며, 최종적인 {커버리지, 깊이 범위} 표현으로 끝이 난다. 비닝 유닛은 {커버리지, 깊이 범위} 표현을 거친, 압축적인 방식으로 유지할 수 있다. 비닝 유닛은 중간 {커버리지, 깊이 범위} 표현을 하나 이상의 타일들로부터의 프리미티브들을 컬링하기 위해 사용할 수 있다.

몇몇 실시 예들에서, 비닝 유닛은 {커버리지, 깊이 범위} 표현을 계층(hierarchy)으로서 유지할 수 있다. 몇몇 실시 예들에서, 계층은 하드웨어 회로에서 유지될 수 있다. 계층에서의 후속적인 단계들은 동일한 커버리지 입도를 사용하거나, 또는 더 거칠어 질(coarsen) 수 있다. 각각의 단계는 하나 이상의 프리미티브들에 대한 {커버리지, 깊이 범위} 표현, 프리미티브들의 윈도우(window), 또는 지금까지 보여진 모든 프리미티브들의 부집합을 유지할 수 있다. 어떤 단계들은 이 {커버리지, 깊이 범위} 표현을 온-칩(on-chip)으로(예를 들어, 하드웨어 회로를 이용함으로써) 오직 유지할 수 있고, 반면에 다른 단계들은 메모리에 의해 지원되는(backed) 온-칩 캐시들(caches)을 가질 수 있다.

예시적인 계층은 프리미티브들의 원도우에 대한 {커버리지, 깊이 범위} 표현을 온-칩으로 유지하되, 커버리지는 안티-앨리어스/앨리어스(anti-aliased/aliased) 렌더링을 위해 샘플/픽셀 입도에서 각각 유지되는 제 1 단계를 포함할 수 있다. 제 2 단계는 지금까지 보여진 모든 프리미티브들에 대한 {커버리지, 깊이 범위} 표현을, 필요한 경우 제외(exclusion)하여, 메모리에 온-칩 캐시와 함께 유지할 수 있다. 커버리지는 안티-앨리어스 또는 앨리어스 렌더링을 위해, 픽셀 또는 픽셀들의 블록에서 각각 유지될 수 있다. 몇몇 실시 예들에서, 픽셀들의 블록은 쿼드(quad), 예를 들어 2x2 픽셀들의 블록일 수 있다.

예시적인 계층의 제 1 단계는 현재 프리미티브들의 윈도우로부터의 깊이에 기초하여 인커밍(incoming) 프리미티브를 컬링할 수 있다. 몇몇 실시 예들에서, 제 1 단계는 인커밍 프리미티브로부터의 깊이에 기초하여 현재 프리미티브들의 윈도우 전체를 컬링할 수 있다. 예시적인 계층의 제 2 단계는 인커밍 프리미티브, 또는 프리미티브들의 윈도우를, 이전의 프리미티브들에 기반하여 컬링할 수 있다. 몇몇 실시 예들에서, 제 2 단계는 모든 이전의 프리미티브들을 인커밍 프리미티브 또는 프리미티브들의 원도우로부터의 깊이에 기초하여 컬링할 수 있다.

이 문서에서 개시된 것은 비닝 패스에서 동작하는 거친 깊이-기반 은면 제거 기술이며, 이것은 어떤 프리미티브들 및 드로우콜들이 특정 타일에 영향을 주는 지 나타내는 압축된 카운트 스트림(count stream) 표현을 생성할 수 있고, 그리고 최종적인 렌더링된 이미지에서 보이지 않는 프리미티브들 및 드로우콜들 대부분을 포함하는 것을 필요로 하지 않을 수 있다. 개시된 기술은 또한 그래픽 어플리케이션 특정 인터페이스들(graphics application specific interfaces; 또는 Application Programming Interfaces; APIs)에 의해 요구되는 기존의 깊이 컬링 하드웨어들에 의한 픽셀 컬링을 증가시키기 위해 프리로드된 깊이 버퍼로서 사용되는 이미지에 대한 근사적인 압축된 깊이 및 커버리지 표현을 생성할 수 있다. 픽셀들의 블록 각각에 대하여, 거친 커버리지 마스크가 하나의 픽셀 또는 하나의 픽셀들의 블록의 입도에서, 깊이 범위들의 사전(dictionary)과 결합되어 생성될 수 있다. 몇몇 실시 예들에서, 각각의 커버된 개체(entity; 즉, 픽셀 또는 픽셀들의 블록)은 사전 내의 특정 깊이 범위 내의 깊이 값들을 가지도록 보장될 수 있다.

개시된 비닝 유닛은 프리미티브들을 비닝 패스에서 컬링할 수 있고, 그 결과 컬러 패스 동안 처리되는 프리미티브들의 수가 감소된다. 이 기술은 컬러 패스들에서 그래픽 처리 장치(Graphic Processing Unit; GPU)의 프론트-엔드(front-end) 파이프라인들에 의한 타일-당 프리미티브들의 처리를 감소시킬 수 있다. 이 기술은 또한 비닝 패스가 정점들(vertices) 및 프리미티브들에 대한 위치 정보만을 생성하는 감소된 쉐이더들과 함께 실행(run)될 때 전체 프론트-엔드 쉐이딩 비용을 감소시킬 수 있다. 비닝 유닛은 만약 드로우 내의 모든 프리미티브들이 깊이 고려로 인해 컬링된 경우, 드로우들을 컬링할 수 있고, 그 결과 상태 관리의 성능 영향 및 오버헤드를 감소시킬 수 있다. 비닝 유닛은 거친 깊이-커버리지 표현을 컬러 패스에서 픽셀들 및 픽셀-쿼드들을 컬링하기 위해 사용할 수 있고, 그 결과 픽셀 쉐이더 호출들(invocations)의 수 및 전체 픽셀 처리 비용들을 줄일 수 있다.

몇몇 실시 예들에서, 비닝 유닛은 {커버리지, 깊이} 표현들의 계층을 사용하고, 이는 캐시 등과 같은 하드웨어 회로에 저장될 수 있다. 몇몇 실시 예들에서, 비닝 회로는 이후의 프리미티브들을 이전의 프리미티브들로부터의 깊이를 이용하여 컬링한다. 몇몇 실시 예들에서, 비닝 유닛은 이전의 프리미티브들의 범위들을 이후의 프리미티브들로부터의 깊이를 사용하여 컬링한다.

여기에서 설명된 몇몇 실시 예들은 타일-기반 지연 렌더링(tile-based deferred rendering, TBDR) GPU를 위한 효과적인 3D 렌더링을 위한 거친 가시성 컬링 구조를 포함한다. 일반적인 TBDR GPU들의 적어도 두 개의 비효율성들: 1) 불필요한 오버드로우(overdraw) 및 2) 비닝 또는 타일링(tiling) 이후에 렌더링하는 도중 불필요한 프리미티브들의 처리가 해결된다. 여기에서 설명된 방법들 및 시스템들은 오버드로우의 양을 최소화하기 위해 거친 가시성 컬링 단계를 사용하는 특정 타일에 영향을 미치는 프리미티브들 및 드로우콜들의 리스트를 결정하는 비너(binner) 또는 타일러(tiler)를 증강(augment)한다.

여기에서 설명되는 방법들 및 시스템들은 각각의 타일에 투사(발생)되는(incident) 드로우들 및 프리미티브들의 리스트를 생성하는 것에 더하여, 또한 그러한 리스트들로부터의 드로우들 및 프리미티브들을 만약 드로우/프리미티브들에 의해 생성된 모든 프래그먼트들이 이전의 드로우들/프리미티브들에 의해 가려지는 경우 컬링하는 증강된 비닝 또는 타일러 유닛(일반적으로 이하에서 “비닝 유닛”으로 지칭됨)을 포함할 수 있다. 또한, 여기에서 설명되는 방법들 및 시스템들은 비닝 도중 이미지의 픽셀 각각에서의 깊이의 거친 표현을 생성하고, 그리고 초기-Z(Early-Z) 하드웨어가 이후의 프래그먼트들에 의해 가려질 프래그먼트들을 제거할 수 있도록 그 표현을 깊이 버퍼로 프리로드(preload)함으로써 오버드로우를 최소화한다.

여기에서 설명되는 방법들 및 시스템들을 사용함으로써, GPU는 낭비되는 일, 즉 정점(vertex) 및 이후의 쉐이더들을 포함하는 프론트-엔드 파이프라인에서의 프리미티브들의 처리에서 낭비되는 일 및 픽셀 쉐이더들을 포함하는 백-엔드(back-end) 파이프라인에서의 픽셀 쿼드들의 처리에서 낭비되는 일의 양을 최소화할 수 있다.

비닝 패스 도중에 변환-후(post-transform) 프리미티브들을 처리함으로써, 여기에서 설명되는 방법들 및 시스템들은 각 프리미티브의 수신과 함께 이미지에서의 가시적인 깊이 범위의 중간 표현을 생성하고, 컬러 패스에서 이미지 렌더링되는 도중 프리로드될 수 있는 최종적인 깊이 표현으로 끝이 난다. 또한, 몇몇 실시 예들은 표현들의 메모리 사용량(memory footprint)을 줄이기 위해 중간 깊이 표현을 거친, 압축된 표현으로 유지할 수 있다. 또한, 몇몇 실시 예들은 여러 면들이 하나의 블록 내에서 활성화(active)된 때라도 좋은 깊이 해상도를 확실하게 하기 위해 깊이 집합을 선택하는 픽셀-당 또는 쿼드-당 선택기(selector)와 함께 여러 집합들로 깊이 표현을 유지할 수 있다. 또한, 몇몇 실시 예들은 비닝 패스 그 자체 동안에 전체 프리미티브들을 컬링하기 위해 중간 깊이 표현을 사용할 수 있다. 또한, 최종적인 깊이 표현은 개개의 픽셀들 및 쿼드들을 컬링하기 위해 컬러 패스 도중에 시작하는 깊이 버퍼로써 프리로드될 수 있다. 여기에서 설명되는 방법들 및 시스템들은 그러한 쿼드들을, 비용-효율적인(cost-effective) 버퍼 크기에 의해 결정되는 제한된 윈도우 내에서 식별하는 것에 한정되지 않는 대체적이나 보완적인 접근을 사용할 수 있다. 대신에, 여기에서 설명되는 방법들 및 시스템들은 사용되는 비닝 동안에 거친 깊이 버퍼를 생성할 수 있다.

여기에서 개시된 몇몇 실시 예들은 비닝 패스에서 동작하는 거친 깊이-기반 은면 제거 방법을 포함한다. 비닝 패스는 어떤 프리미티브들 및 드로우콜들이 특정 타일에 영향을 주는지 나타내는 압축된 카운트 스트림 표현을 생성할 수 있고, 그리고 최종적인 렌더링된 이미지에서 보이지 않는 프리미티브들 및 드로우콜들 대부분을 포함하지 않는다. 비닝 패스는 그래픽 API들에 의해 알려진 기존의 깊이 컬링 하드웨어에 의한 픽셀 컬링을 증가시키기 위해 프리로드된 깊이 버퍼로서 사용되기 위한 이미지에 대한 근사적인 압축된 깊이 및 커버리지 표현을 생성할 수 있다. 몇몇 실시 예들은, 픽셀들의 블록 각각에 대해, 깊이 범위들의 사전과 결합된, 픽셀들 또는 픽셀들의 블록의 입도에서의 거친 커버리지 마스크를 생성할 수 있다. 몇몇 실시 예들에서, 커버된 개체(픽셀 또는 픽셀들의 블록) 각각은 사전 내의 특정 깊이 범위 내의 깊이 값들을 가지도록 보장된다. 몇몇 실시 예들은 비닝 패스에서 프리미티브들을 컬링하기 위해 거친 깊이-커버리지 표현을 사용하고, 그 결과 컬러 패스 도중 처리되는 프리미티브들의 수를 줄인다. 이것은, 차례로, 컬러 패스들의 프론트-엔드 파이프라인들에 의한 프리미티브들 타일-당 처리, 그리고 비닝 패스가 정점들(vertices) 및 프리미티브들에 대한 위치 정보만을 생성하는 감소된 쉐이더들과 함께 실행될 때 전체 프론트-엔드 쉐이딩 비용을 줄일 수 있다.

드로우 내의 모든 프리미티브들이 깊이 고려로 인하여 컬링되면, 몇몇 실시 예들은 드로우들을 컬링하여, 상태 관리의 성능 및 오버헤드 영향을 감소시킨다. 몇몇 실시 예들은 거친 깊이-커버리지 표현을 사용하여 컬러 패스에서 픽셀들 및 픽셀-쿼드들을 컬링하고, 그 결과 픽셀 쉐이더 호출들의 수 및 전체 픽셀 처리 비용을 줄인다.

여기에서 개시된 비닝 유닛의 몇몇 장점들은 앞에서-뒤로(front-to-back)의 어플리케이션 분류 지오메트리(application sorting geometry)에 의지(reliant)하지 않는다는 것, 및 비닝 회로는 지오메트리가 뒤에서-앞으로(back-to-front)를 제출(submit)되는 경우에도 성공적으로 대부분의 가려진 쿼드들을 컬링할 수 있다는 것이다. 또다른 장점은 여기에서 개시된 비닝 유닛은 쿼드들을 홀드(hold)하기 위해 큰 버퍼를 필요로 하지 않는다는 점, 및 컬링을 가능하게 하는 쿼드들의 홀딩의 지연 시간(latency)에 의해 영향을 받지 않는다는 점이다. 또 다른 장점은 근사적인 깊이 버퍼에 기초한 프리미티브들 및 쿼드들의 컬링으로 인한 중요한 깊이 복잡성을 갖는 임의의 이미지의 렌더링 중 감소된 픽셀 쉐이더 호출들이다. 또 다른 장점은 완전히 가려진 쿼드들을 갖는 프리미티브들을 컬링하는 것으로 인한 감소된 프론트-엔드 쉐이딩 작업 및 이와 연관된 정점-쉐이딩(vertex-shading), 설정(setup) 및 래스터화(rasterization)이다. 또 다른 장점은 임의의 가시적인 쿼드들에 영향을 미치지 않는 특정한 드로우들을 컬링하는 것으로 인한 감소된 상태-관리 오버헤드이다. 보조적인 이익들은 텍스쳐들(textures), 정점 속성들, 및 연관된 고정-함수(fixed-function) 처리를 위한 감소된 메모리 대역폭을 포함하는 감소된 쉐이더 호출들을 포함한다. 또한, 렌더링 도중 감소된 오버드로우 레이트가, 낭비되는 픽셀 쉐이딩 작업의 감소를 야기하며 달성된다.

도 1은 몇몇 실시 예들에 따른 비닝 유닛(100)의 예시적인 다이어그램이다. 비닝 유닛(100)은 똑같은 것을 하기 위해 추가적인 패스를 실행하는 복잡성 및 비용을 피하기 위해, 몇몇 근사적이나 보수적인(conservative) HSR을 비닝 패스 도중에 수행할 수 있다. 결과적으로 기술을 수행하는 것의 추가적인 복잡성이 비닝 유닛(100) 그 자체에 국한(localize)된다. 비닝 유닛(100)은 이미지 내의 프리미티브들 및 드로우콜들의 스트림을 얻고, 그리고 압축된 카운트 스트림들―개체(여기서 개체는 하나의 프리미티브 또는 하나의 드로우콜) 당 타일 당 하나를 생성하며, GPU에서 비닝 작업을 수행할 수 있다. 비닝은 단일 타일의 입도에서, 또는 대체적으로 다수의 타일들의 입도에서 수행될 수 있다. 비닝의 결과는 하나의 이미지 내의 모든 비닝 타일들에 대한 압축된 카운트 스트림들의 생성일 수 있다. 비닝 유닛(100)은 두 종류의 HSR을 수행할 수 있다: 1) {Prim, Tile} 컬링 및 2) 쿼드 컬링.

{Prim, Tile} 컬링은 프리미티브들을 특정 타일들의 압축된 카운트 스트림들로부터 제거하는 것을 수반하며, 이는 프론트-엔드 및 백-엔드 처리를 위한 작업을 절감한다. 여기에서 사용된 줄임말 “prim”은 하나 이상의 프리미티브들을 지칭한다. 타일들은 픽셀들의 직사각형 블록들이며, 이들은 GPU에 의해 단일 트랜잭션으로서 렌더링된다. 압축된 카운트 스트림들은 개체(entity)가 하나의 타일의 렌더링된 결과들에 영향을 주는 지를 알려주고, 여기서 개체는 하나의 프리미티브, 드로우콜, 또는 다른 무언가일 수 있다.

쿼드 컬링은 프리로드를 위한 근사적인 Z-버퍼를 생성할 수 있다. 이는 컬러 패스 동안 픽셀 쉐이더 호출들의 쿼드들을 절감한다. 쿼드들은 2x2 직사각형 픽셀 블록들이고, 이들은 텍스쳐들(textures)의 접근(access)을 허용하기 위해 함께 렌더링된다. 개시된 기술은 쿼드들이 이후의 쿼드들에 의해 가려지는 경우를 다루고 따라서, 개시된 기술은 가려짐(occlusion)에 대한 프론트-투-백(front-to-back) 분류에 의존적이지 않다.

고-수준(high-level)에서, 비닝 유닛(100)은 프리미티브들에 걸친 커버리지 및 깊이를 병합(coalesce)할 수 있고, 생성되는 이러한 구조로 {Prim, Tile}들을 컬링하고, 그리고 거친 깊이를 메모리에 저장한다. 비닝 유닛(100)은 거친 범위내 샘플들내에서 보간(interpolating) 깊이와 함께 샘플 입도에서 커버리지 정보를 생성할 수 있는 래스터라이저(105)를 포함할 수 있다. 래스터라이저(래스터화기)(105)는 프리미티브들 및/또는 정점 데이터(102)를 수신하고, 그리고 픽셀들의 블록의 입도에서 커버리지를 계산할 수 있는 제 1-스테이지 거친 래스터라이저(110)를 포함할 수 있다. 이 제 1 스테이지는 픽셀들의 블록의 모서리들(corners)에서 깊이의 범위를 계산할 수 있는 깊이 보간 로직(120)으로 증강될 수 있다. 거친 래스터라이저(110)는 2x2 타일 모서리들 또는 블록들에서 가장자리(edge) 방정식들 및 값들을 포함하는 중간 래스터라이저 정보(122)를, 그 입도에서의 깊이 정보와 함께 출력할 수 있다. 2x2 타일 모서리들 또는 블록들은 타일들의 실행들(runs)을 대신하여 순서 변경될 수 있다. 이는 후술되는 스트림 누산기 엔트리들(Stream Accumulator Entries; 이하 SA 엔트리들; 135)에 대한 로컬성(국부성, locality)을 최대화한다. 래스터라이저(105)는 또한 중간 래스터라이저 정보(122)를 수신할 수 있고, 그리고 픽셀들의 입도에서 커버리지를 계산할 수 있는 제 2 스테이지 미세(fine) 래스터라이저(115)를 포함할 수 있다. 거친 래스터라이저(110)는 블록의 입도에서 래스터화 및 깊이를 계산할 수 있다. 미세 래스터라이저(115)는 거친 래스터라이저(110)에서 오는 거친 래스터화 결과(또는 중간 래스터라이저 정보, 122)가 주어지면 픽셀/샘플 커버리지를 계산할 수 있다. 래스터라이저(105)는 {prim, tile, block} 정보(125)를 깊이 및 픽셀 커버리지와 같이 출력할 수 있다.

비닝 유닛(100)의 하나 이상의 로컬 컬링 스테이지들(130)은 커버리지 및 깊이-기반 컬링을 수행할 수 있다. 로컬 컬링 스테이지(130)는 임의의 지원하는(backing) 상태 없이 미세(fine-grained) 커버리지 입도를 사용하여 프리미티브들 및 드로우콜들의 윈도우 내에서 동작하는 로컬 컬링을 수행할 수 있다. 이 스테이지는 타일 내의 프리미티브들 및 드로우콜들의 윈도우 상에서 동작하고, 그리고 윈도우 내에서 프리미티브들을 컬링하기 위해 오직 이 프리미티브들로부터의 깊이를 사용한다. 이 컬링은 이전 프리미티브들을 컬링하기 위해 이후의 프리미티브들을 사용할 수 있고, 또는 반대의 경우도 마찬가지로 할 수 있다. 즉, 이 스테이지는 순서대로 앞을 보면서(looking ahead) 컬링하거나, 또는 뒤를 보면서(looking behind) 컬링할 수 있다. 로컬 컬링 스테이지(130)는 다수의 SA 엔트리들(135), 하나 이상의 누산기들(140), 및 플러쉬(flush) 제어 로직(145)을 포함할 수 있다. SA 엔트리들(135)는 OR된 커버리지 마스크들을 생성할 수 있고, 그리고 블록 각각의 깊이-범위를 유지할 수 있다.

비닝 유닛(100)은 여기에서 지칭되는 것처럼 “블록”이라 불리는 타일보다 작은 픽셀들의 블록들 상에서 동작할 수 있다. {커버리지, 깊이 범위} 표현은 여기에서 “노드”로 지칭될 수 있다. 노드는 픽셀/쿼드들이 속하는(falls within) 깊이의 범위와 함께 블록에서 픽셀/쿼드 커버리지를 정의할 수 있다. 블록의 치수(dimension) 및 깊이 사전의 크기는 하드웨어 비용을 최소화하기 위해 설계 시에 선택될 수 있다. 다른 실시 예들은 블록 치수들 및 깊이 사전 크기를 동적으로 변화시키도록 선택할 수 있다.

로컬 컬링 스테이지(130)는 프리미티브들의 최근 윈도우에 국부적인 상태 상에서 동작할 수 있고, 그리고 과거 및 현재의 프리미티브들의 컬링이 가능하다. 따라서, 로컬 컬링 스테이지(130)는 과거의 K 프리미티브들로부터의 커버리지 및 깊이 정보를 이용하여 블록내의 과거의 K 프리미티브들의 일부 또는 전부, 또는 현재의 프리미티브들을 컬링할 수 있다. 로컬 컬링 스테이지(130)는 이 윈도우 너머의 임의의 프리미티브들에 대한 어떤 지식도 필요로 하지 않는다. 윈도우의 크기는 온-칩 하드웨어 비용을 정의할 수 있고, 그리고 설계 시에 선택될 수 있다. 다른 실시 예들은 다른 크기들 또는 동적 사이징(sizing)을 선택할 수 있다.

비닝 유닛(100)은 로컬 컬링 스테이지(130)의 출력(155)을 업데이트 할 수 있는 하나 이상의 글로벌 컬링 스테이지들(또는 글로벌 컬링 로직들; 150)을 포함할 수 있다. 예를 들어, 글로벌 컬링 스테이지(150)는 제 1 스테이지 로컬 컬링 스테이지(130)로부터 프리미티브들의 윈도우를 컬링할 수 있고, 그리고 제 1 스테이지(즉, 130)로부터의 인커밍 커버리지/깊이 정보(즉, 출력 (155))를 사용하여 이전에 보인 커버리지 전체를 컬링하기 위해 그 프리미티브들을 사용할 수 있다고, 또는 반대의 경우도 마찬가지이다. 글로벌 컬링 스테이지(150)는 컬링 동작을 개선하기 위해 선택적인 확장들(extensions)을 포함할 수 있다. 예를 들어, 글로벌 컬링 스테이지(150)는 콘텍스트-의존적인(context-dependent) 컬링 동작을 구현하여 3D 공간의 원뿔들(cones) 또는 구들(spheres)과 같은 특정한 지오메트리들을 위한 내부-외부(inside-outside) 테스트들을 수행하기 위해 특별한 컬링 동작을 다룰 수 있는데, 여기서 원뿔의 일부인 삼각형이 만약 삼각형이 커버하는 모든 픽셀들이 삼각형의 하나의 면 상에 있는 경우, 예를 들어 삼각형의 법선(normal)을 따르는 면에 있는 경우 컬링될 수 있다. 만약 이미지가 다른 이미지의 출력으로서 생성된 깊이 버퍼를 프리로드하면, 그러면 글로벌 컬링 스테이지(150)는 컬링 성능을 개선하기 위해 이 후속적인 이미지에 대한 시작 지점으로서 사용될 수 있다. 이에 따라, 작업량-특정적인(workload-specific) 컬링을 위한 하나 이상의 사용자(custom) 확장들이 사용될 수 있고, 이는 가시성 컬링 또는 은면 제거일 필요는 없다. 글로벌 또는 로컬 컬링 스테이지들은 하나 이상의 사용자 확장들을 사용할 수 있다.

글로벌 컬링 로직(150)은 후술되는 깊이 테스트 모듈(705)을 포함할 수 있다. 몇몇 실시 예들에서, 글로벌 컬링 스테이지(150)는 기존 비닝/타일링 로직에포섭되는(subsumed) 선택적인 구성 요소들을 포함한다. 예를 들어, 글로벌 컬링 스테이지(150)는 백킹(backing) 데이터가 온-칩 메모리, 예를 들어 온-칩 버퍼(165) 내에 상주하는것에에 대한 트랜잭션들을 우선화하는(prioritize) 리-오더링 큐(160)를 포함할 수 있다. 몇몇 실시 예들에서, 글로벌 컬링 스테이지(150)는 GPU 렌더링의 후속적인 스테이지들에 의해 소모될 커버된 드로우콜들 및 프리미티브들의 스트림을 생성할 수 있는 비닝 로직(182)을 포함한다. 이러한 스트림을 위한 메모리는 할당(allocator) 유닛(170)에 의해 제공될 수 있고, 그리고 데이터는 스트림으로 병합 로직 섹션(175)에 의해 쓰여질 수 있다. 병합 로직 섹션(175)은 온-칩으로 구현될 수 있다. 병합 로직 섹션(175)은 카운트 쓰기 요청들(180)을 로컬 컬링 스테이지(130)로부터 수신할 수 있고, 그리고 압축된 카운트 스트림들을 할당 유닛(170)에 의해 할당된 메모리를 사용하여 업데이트할 수 있다. 몇몇 실시 예들에서, 글로벌 컬링 스테이지(150)는 시스템 메모리 캐시 계층 및/또는 메모리 서브시스템(미도시)와 통신하기 위해 넓고 그리고 좁은 네트워크-온-칩(Network-on-Chip; NOC; 185)을 포함한다.

온-칩 버퍼(165)는 프리페치(prefetch) 큐들(162), 디스크립터(descriptor) 데이터(164), 압축된 카운트 스트림 데이터 또는 비트스트림 데이터(166), 및 거친 깊이 정보 등과 같은 글로벌 컬링 데이터(168)를 포함할 수 있다. 프리페치 큐들(162)은 온-칩 버퍼(165)의 최대 활용을 확실하게 하는 지연 시간(latency) 선입선출(First-In-First-Out; FIFO)을 포함할 수 있다. 다시 말해서, 온-칩 데이터를 갖는 그러한 트랜잭션들은 메모리 서브시스템으로부터 페치될 데이터를 요구하는 다른 트랜잭션들에 비해 우선권이 주어질 수 있다. 온-칩 버퍼(165)는 레벨 2(Level 2; L2) 캐시(190)와 결합될 수 있다. 글로벌 컬링 데이터(168)는 후술되는 깊이 업데이트 로직 섹션(905)을 포함할 수 있다.

글로벌 컬링 스테이지(150)는 로컬 컬링 스테이지(130)로부터 얻어지는 현재 프리미티브들의 집합을 컬링하기 위해 모든 과거의 프리미티브들로부터의 거친 및/또는 미세 깊이 정보 및 커버리지 정보를 사용할 수 있다. 글로벌 컬링 스테이지(150)는 과거 및 현재의 프리미티브 집합들을 컬링하는 것이 가능하다.

도 2는 은면 제거(HSR) 기술을 보이는 예시적인 다이어그램(200)이다. HSR은 논의되고 있는 프리미티브들이 모두 불투명하다고 가정하며, 최종적으로 보이지 않을 프리미티브들을 렌더링할 때의 시간 및 자원들을 줄인다. 대부분의 현대 GPU들은 몇몇 은면 제거 기술을 포함한다. 페이즈(210)에 보이는 바와 같이, 렌더링 큐(202)는 프리미티브들 0, 1, 2, 및 3을 홀드하고, 그리고 스크린(205)은 최초에 비어 있다. 페이즈(215)에서, 프리미티브들 0 및 1이 스크린(205)에 보여지고, 그리고 프리미티브들 2 및 3은 렌더링 큐(202)에 남아 있다. 페이즈(220)에서, 렌더링 큐(202)는 비어 있고, 그리고 프리미티브들 2 및 3은 스크린(205) 상의 프리미티브들 0 및 1에 의해 가려진다. 다시 말해서, 프리미티브들 2 및 3은 더 가까운 깊이를 갖는 프리미티브들 0 및 1보다 더 먼 깊이를 가진다. 이에 따라, 프리미티브들 2 및 3의 표면들은 그러한 프리미티브들을 랜더링 할 때의 시간 및 자원들을 줄이기 위해 제거될 수 있다.

도 3은 몇몇 실시 예들에 따른 {prim, tile} 컬링 및 쿼드 컬링의 예시적인 다이어그램(300)이다. 비닝 패스 도중에, 이후의 프리미티브들은 선행하는 프리미티브들로부터의 깊이 정보에 의해 완전히 숨겨질 수 있다. 비닝 유닛(예를 들어, 도 1의 100)은 이 정보를 거친 방식으로 모을 수 있고, 그리고 비닝 패스 내에서 그들 전체의 타일들로부터 프리미티브들을 컬링하기 위해 이 정보를 사용할 수 있다. 이러한 종류의 컬링은 컬러 패스에서 프론트-엔드(VS, vertex shader) 및 백-엔드 처리(PS, pixel shader) 둘 다 절감될 수 있음을 의미하며, 압축된 카운트 스트림 그 자체로 표현될 수 있다.

비닝 유닛(100)에 의해 수행될 수 있는 컬링의 2차적인 형태는 초기-Z 컬링의 효능을 증가시키기 위해 이미지의 거친 깊이 표현을 제공하는 것을 포함한다. 이에 따라, 최종 또는 최종에 근접한 버전의 깊이 버퍼가 생성될 수 있다. 최종 또는 최종에 근접한 버전은 풀 컬러 패스 실행 전에 프리로드 될 수 있다. 이 형태의 컬링은 백-엔드 작업(PS)을 절감하나, 여전히 이 프리미티브들에 대한 프론트-엔드(VS) 실행의 페널티를 받는다.

도 3에 도시된 바와 같이. 타일(305)은 16x16 픽셀들의 블록(예를 들어, 310)으로 구성될 수 있다. 타일(305)은 32×16, 32×32, 64×32, 64×64 등과 같은 다른 사이즈들을 가질 수 있다. 다른 적절한 타일 크기들이 사용될 수 있음이 이해될 것이다. 페이즈(330)에 도시된 바와 같이, 프리미티브들 0 및 1이 처리될 수 있다. 비닝 유닛(예를 들어, 도 1의 100)은 프리미티브들 0 및 1을 래스터화할 수 있고, 그리고 거친 커버리지 및 깊이 정보를 누산할 수 있다. 깊이 정보는 미리 결정된 최소값 및 최대값 사이의 범위의 깊이일 수 있다. 페이즈(335)에서, 비닝 유닛(100)은 거친 커버리지 및 깊이 정보에 대해 후속 프리미티브들(예를 들어, 프리미티브들 2 및 3) 각각을 확인할 수 있다. 비닝 유닛(100)은 타일(305)로부터 프리미티브들 2 및 3을 거절할 수 있다. 이 거절은 압축된 카운트 스트림에 쓰일(note) 수 있다. 다시 말해서, 프리미티브들 2 및 3 전체가 컬링될 수 있다. {Prim, tile} 컬링은 이익들(benefits; 320) 중 하나인 315에 도시된 바와 같이 비닝 패스 도중에 발생한다.

페이즈(340)에서, 비닝 유닛(100)은 거친 커버리지 및 깊이 정보를 메모리에 쓸 수 있다. 비닝 유닛(100)은 거친 커버리지 및 깊이 정보를 타일 버퍼(350)에 컬러 패스 도중 프리로드할 수 있다. 타일 버퍼(350)는 때때로 여기에서 깊이 버퍼로 지칭된다. 타일 버퍼(350)는 컬러 패스들 도중에 타일들에 대한 모든 컬러 및 깊이(Z) 정보를 유지할 수 있다. 컬러 패스의 시작 전에 깊이 버퍼를 프리로드하는 것은 GPU로 하여금 불투명한 객체들이 최종 이미지에서 가시적인지 여부를 보기 위해 불투명한 객체들을 테스트하는 초기-Z 컬링을 위한 깊이 버퍼를 사용하는 것을 허용한다. 페이즈(345)에서, 타일 버퍼(350) 내에 존재하는 초기-Z 로직은 추가적인 픽셀들 또는 쿼드들을 컬러 패스 도중에 거절할 수 있다. 예를 들어, 프리미티브 K의 다수의 픽셀들 또는 쿼드들은 깊이 정보에 따라 초기-Z에 의해 컬링될 수 있다. 이 페이즈는 이익들(320)중 하나인 컬러 패스 중 쿼드 컬링(325)으로 지칭된다. 두 개의 굵게 처리된 픽셀들/쿼드들(355)이 실패했고, 따라서 프리미티브 K는 몇몇 픽셀들을 잃을 수 있으며, 이에 따라 픽셀 쉐이딩 작업이 절감된다. 점선으로 표시된 세 개의 픽셀들/쿼드들(360)은 패스됐고, 그리고 렌더링될 것이다.

비닝 유닛(100)은 상이한 모드들에서 동작할 수 있다. 예를 들어, 비닝 유닛(100)은 로컬 컬링 스테이지(130) 및 글로벌 컬링 스테이지(150)가 활성화(enable)된 모드에서 동작할 수 있다. 다른 모드에서, 로컬 컬링 스테이지(130) 및 글로벌 컬링 스테이지(150)는 비활성화(disable)될 수 있으나, 전체(full) 래스터화는 여전히 수행될 수 있다. 또 다른 모드에서, 로컬 컬링 스테이지(130) 및 글로벌 컬링 스테이지(150)는 활성화될 수 있고, 그리고 전체 래스터화도 수행될 수 있다. 깊이 버퍼를 타일 버퍼(350)로 프리로딩할 때 사용하기 위한 깊이는 미리 결정된 최소 깊이 및 미리 결정된 최대 깊이에 기반하여 결정될 수 있다. 예를 들어, 최소 깊이는 0으로 설정될 수 있고, 그리고 최대 깊이는 1로 설정될 수 있다. 또 다른 예시에 의하면, 최소 깊이는 0.3으로 설정될 수 있고, 그리고 최대 깊이는 0.6으로 설정될 수 있고, 그리고 이 범위 밖의 임의의 것들은 보이지 않는다(invisible). 또 다른 예시에 의하면, 0.5 에서 0.6의 깊이 범위는 처리를 더 저렴하게 만들 것이다. 픽셀 당 샘플들의 개수 또한 미리 결정되거나, 또는 설정될 수 있다.

비닝 유닛(100)은 내부적으로 픽셀 입도에서 커버리지를 유지할 수 있으나, 그러나 커버리지를 메모리에 쿼드 입도에서 저장할 수 있다. 이는 메모리 사용량을 줄이기 위해 수행될 수 있다. 저장할 때 쿼드 입도로의 커버리지의 거칠어짐으로 인하여, 부분적으로 커버된 쿼드들이 누락될 수 있다. 그 결과, 비닝 유닛(100)은 타일에 대한 커버리지의 국부성(locality)를 증가시키기 위해 {prim, tile}들을 순서 변경함으로써 부분적으로 커버된 쿼드들의 발생 가능성을 줄일 수 있다.

각각의 비교가 사소하지 않은(non-trivial) 에너지 및 처리량 비용을 발생시키기 때문에, 깊이 비교들의 수를 줄이기 위한 노력이 들여진다. 결과적으로, 프리미티브들 각각에 대한 것과 달리 프리미티브들의 클러스터에 대한 깊이 테스트들이 수행된다. 깊이 업데이트들은 또한 전체 쿼드들을 테스트 전에 모으기위한 노력이 들여지기 때문에 클러스터 레벨에서 내재적으로 수행될 수 있다. 중요한 노력이 온-칩 버퍼(예를 들어, 도 1의 165)로부터 메모리(예를 들어, 도 1의 190)로 향하는 깊이 업데이트들의 수를 줄이기 위해 들여진다. 유사한 노력이 메모리 트래픽의 증가를 최소화하도록 비닝 유닛(100) 거친 깊이 데이터의 타일-당 사용량을 줄이기 위해 들여진다.

도 4는 몇몇 실시 예들에 따른 메모리에 저장된 노드 깊이 및 커버리지 구조들의 예시적인 다이어그램(400)이다. 비록 내부적으로 비닝 유닛(100)이 깊이 및 커버리지 정보를 상이한 포맷으로 유지할 수 있으나, 메모리에 쓰여질 때, 정보는 도 4에 도시된 포맷으로 배치될 수 있다. 노드는 패드(pad; 예를 들어, 4 바이트)를 포함할 수 있고, 이에 따라 노드 각각은 전체적으로 32 바이트이다. 깊이 정보는 상위 16 바이트(4 바이트의 패딩과 함께)에 배치될 수 있고, 그리고 커버리지 정보는 하위 16 바이트에 배치될 수 있다. 도 4에 도시된 노드는 반드시 축적에 따라 그려진 것은 아니다. 다수의 노드들이 연속적으로, 임의의 두 노드들 사이에는 빈 공간이 없이 메모리에 배치될 수 있다.

이하의 수도(pseudo)-코드는 로컬 컬링 스테이지(130) 및 글로벌 컬링 스테이지(150)의 동작에 대한 상이한 제어들을 결정하는 논리 흐름을 보여준다.

/// 만약 상태가 활성화되면, 그럴 경우 깊이 테스트 및 업데이트를 활성화한다.

bool DepthModeEnable = (State.Mode == ENABLE_FULLRAS_ENABLE);

/// 변수들을 제어

/// 깊이 테스트가 활성화 되었는지 여부

bool depthTestEnable = DepthModeEnable;

/// 만약 깊이 테스트가 비활성화되면(즉, depthTestEnable == false), 그럴 경우

/// 깊이 테스트가 해결(Resolve)하는 것. True: 항상 패스, False: 항상 버림

bool alwaysPass = true;

/// 깊이 업데이트가 활성화되었는지 여부, 즉 깊이가 업데이트될 수 있는지

bool depthUpdateEnable = DepthModeEnable;

/// 단계 1, State.DepthTestModule에 의해 제어

/// 표기법 과부하, LHS가 {} 안의 *임의의* 값들과 동일하면 true를 의미

depthTestEnable &= (State.DepthTestMode == {EARLYZ, LATEZ_WITH_EARLYZ_COMPARE});

depthUpdateEnable &= (State.DepthTestMode == EARLYZ);

/// 보조적인 단계, 우리가 항상 패스할 것인지 아닌지 여부를 변경

alwaysPass = (State.DepthFunc != NEVER);

/// 단계 2, 다른 상태(State) 필드들에 의해 제어

/// 만약 임의의 State가 PS(pixel shader)가 커버리지를 수정할 수 있음을 나타내면,

/// 깊이 업데이트할 수 없으나, 여전히 우리는 깊이 테스트 수행할 수 있음

/// 표기 주의: !는 부울 not 연산을 의미한다

depthUpdateEnable &= (!State.PSUsesDiscard && !State.PSWritesCoverage &&

!State.SampleAlphaToCoverage);

/// 만약 임의의 State가 PS가 Z 값을 쓴다고 말하면, 그럴 경우 보간된 Z에 의존할 수 없고,

/// 만약 Z 쓰기가 비활성화되면, 우리는 업데이트할 수 없음

depthTestEnable &= (!State.PSWritesZ);

depthUpdateEnable &= (!State.PSWritesZ && State.DepthWriteEnable);

/// 만약 임의의 스텐실(stencil) 테스트가 활성화되면, 우리는 커버리지가

/// 래스터화된 커버리지와 끝에서 같다는 것을 보장할 수 없음. 그러나 여전히 깊이 테스트를 사용하여 컬링할 수 있음

depthUpdateEnable &= (!State.StencilTestEnable);

/// 만약 블렌딩이 활성화되면, 그렇다면 우리는 객체들을 “통해 볼(see through)”수 있다.

/// DSA/로컬 컬링 스테이지는 (depthTestEnable && (State.BlendEnable == 0)) 인 경우, 그리고 오직 그 경우에만 (if and only if; iff) 반드시 깊이 테스트를 활성화해야한다

/// 병합은 iff (depthTestEnable)인 경우, 그리고 오직 그 경우에만(iff) 깊이 테스트를 활성화한다

// depthTestEnable &= (State.BlendEnable == 0);

depthUpdateEnable &= (State.BlendEnable == 0);

/// 단계 3, 우세한 드라이버에 의해 제어

depthTestEnable &= (!State.SkipDepthTest);

depthUpdateEnable &= (!State.SkipDepthUpdate);

/// 완료

도 5는 몇몇 실시 예들에 따라 로컬 컬링 스테이지(130, 도 1)를 사용하여 깊이 및 커버리지 병합을 구현하는 경우들의 예시적인 다이어그램(500)이다. 도 6은 도 5에 도시된 다양한 블록들에 대한 범례(legend; 600)를 포함하는 다이어그램이다. 도 1, 5, 및 6이 이제 참조된다.

도 5에 다수의 축약 표시들이 사용되었다. 예를 들어, 하나의 프리미티브로부터의 인커밍(“IN”커버리지 및 깊이에 의해 영향을 받는, SA 엔트리(예를 들어, 135) 내의 하나 이상의 프리미티브들로부터의 일부 기존(“EX”커버리지 및 깊이. 다시 말해서, “”는 기존의 커버리지 및/또는 깊이의 줄임말이고, 그리고 “IN”은 인커밍 커버리지 및/또는 깊이의 줄임말이다. 다수의 등가 줄임말들이 병합 카테고리들(505)을 설명하기 위해 사용된다. 예를 들어, X == Y는 X와 Y가 정확하게 동일한 픽셀들/쿼드들을 커버함을 의미한다. X > Y는 X의 커버리지가 Y의 커버리지의 엄격한 상위 집합(strict superset)임을, 즉 X가 Y의 모든 픽셀들/쿼드들 및 추가적인 몇몇을 더 커버함을 의미한다. X < Y는 Y의 커버리지가 X의 커버리지의 엄격한 상위 집합임을, 즉 Y가 X의 모든 픽셀들/쿼드들 및 추가적인 몇몇을 더 커버함을 의미한다. ==, >, 또는 < 연산자들 내로 맞아떨어지지 않는 캐치-올(잡동사니, catch-all) 병합 카테고리인 기타 등등(ALL OTHERS) 카테고리가 포함된다.

로컬 컬링 스테이지(130)의 동작은 커버리지 병합 규칙들(510)에 의해 안내될 수 있다. 적용되는 특정 커버리지 병합 규칙은 병합 카테고리들(505) 및 깊이 정보(515)에 기초할 수 있다. 예를 들어, 로컬 컬링 스테이지(130)는 커버리지 규칙(520)을 IN.Cov(Coverage; 커버리지) == EX.Cov 이고 그리고 기존 깊이가 인커밍 깊이의 상위집합인 경우 적용할 수 있다. 이 예시에서, 로컬 컬링 스테이지(130)는 “keep both special depth”(“보유 양쪽, 특별 깊이”)할 수 있고, 이는 도 6을 참조하여 다른 가능한 커버리지 병합 규칙들의 각각의 정의와 함께 구체적으로 후술된다. 다른 예시에 의하면, 로컬 컬링 스테이지(130)는 커버리지 병합 규칙(525)을 IN.Cov < EX.Cov인 경우 및 기존 깊이가 인커밍 깊이보다 나은(better) 경우 적용할 수 있다. “keep both union depth”(“보유 양쪽, 통합 깊이”)의 커버리지 병합 규칙(525)은 도 6을 참조하여 구체적으로 더 후술된다.

깊이 정보(515)는 각각이 도 5에 도시된 여섯 개의 가능한 열들을 커버한다: 1) 인커밍 깊이가 매우(strictly) 나음, 2) 인커밍 깊이가 나음, 3) 기존 깊이가 상위 집합, 4) 인커밍 깊이가 상위 집합, 5) 기존 깊이가 나음, 및 6) 기존 깊이가 매우 나음. 도 5에 도시된 각각의 가능성들은 최소(minimum; MIN) 깊이 및 최대(maximum; MAX) 깊이 사이의 범위와 관련하여 보여진다.

도 6에 도시된 바와 같이, 범례(600)는 도 5의 각각의 커버리지 병합 규칙들(510)에 대한 추가적인 설명들을 제공한다. 도 6은 컬링 성능과 관련하여 이 규칙들의 관련성을 또한 보여 준다. 정확성을 유지하기 위해, 로컬 컬링 스테이지(130)는 컬링 성능을 최대화하는 병합 규칙 선택들을 할 수 있다.

규칙 유형(605)은 “discard X maintain Y.depth”(“버리기 X, 유지 Y.깊이”)로 일반화되고, 이때, 도 5에 보여진 바와 같이, X는 “EX” 또는 “IN” 중 어느 하나를 나타내고, 그리고 Y는 “EX”또는 “IN”의 다른 하나를 나타낸다. 유사하게, 규칙 유형(610)은 “keep both maintain X.depth”“보유 양쪽, 유지 X.깊이”)로 일반화되고, 이때 도 5에 보여진 바와 같이, X는 “EX”또는 “IN” 중 어느 하나를 나타낸다. 규칙 유형(615)은 “keep both special depth”“보유 양쪽, 특별 깊이”)이다. 그리고 규칙 유형(620)은 “keep both union depth”“보유 양쪽, 통합 깊이”)이다.

규칙 유형(605)은 “인커밍 또는 기존 프리미티브 커버리지 중 오직 하나 Y 를 킵(보유)하고 X를 버림; Y로부터 깊이를 복사함”을 의미하며, 이때 X와 Y는 위에서 정의된다. 규칙 유형(610)은 “인커밍 및 기존 프리미티브 커버리지 둘 다 보유; {IN, EX} 중 어느 하나로부터 깊이를 복사함”을 의미하여, 이때 X와 Y는 위에서 정의된다.

규칙 유형(615)은 “인커밍 및 기존 프리미티브 커버리지를 둘 다 보유; Special depth: minDepth = min(IN.minDepth, EX.minDepth); maxDepth = min(IN.maxDepth, EX.maxDepth)”을 의미하며 ,이때 X 및 Y는 위에서 정의된다; minDepth는 결정된 최소 깊이이다; min()는 최소 값을 결정하는 함수이다; min(IN.minDepth, EX.minDepth)는 IN.minDepth 및 EX.minDepth 사이에서 최소값을 결정하는 함수이다; IN.minDepth는 인커밍 커버리지의 최소 깊이이다; EX.minDepth는 기존 커버리지의 최소 깊이이다; maxDepth는 결정된 최대 깊이이다; min(IN.maxDepth, EX.maxDepth)는 IN.maxDepth 및 EX.maxDepth 사이에서 최소값을 결정하는 함수이다; IN.maxDepth은 인커밍 커버리지의 최대 깊이이다; 그리고 EX.maxDepth는 기존 커버리지의 최대 깊이이다.

규칙 유형(620)은 “인커밍 및 기존 프리미티브 커버리지를 둘 다 보유; union depth: minDepth = min(IN.minDepth, EX.minDepth); maxDepth = max(IN.maxDepth, EX.maxDepth)”를 의미하며, 이때 X 및 Y는 위에서 정의된다; minDepth는 위에서 정의된다; min()은 위에서 정의된다; min(IN.minDepth, EX.minDepth)는 위에서 정의된다; IN.minDepth는 위에서 정의된다; EX.minDepth는 위에서 정의된다; maxDepth는 결정된 최대 깊이이다; max(IN.maxDepth, EX.maxDepth)은 IN.maxDepth 및 EX.maxDepth 사이에서 최대값을 결정하는 함수이다; IN.maxDepth는 위에서 정의된다; 그리고 EX.maxDepth는 위에서 정의된다.

도 7은 몇몇 실시 예들에 따른 깊이 테스트 모듈(705)의 예시적인 다이어그램(700)이다. 도 8은 몇몇 실시 예들에 따른 도 7의 깊이 테스트 모듈(705)의 집합 테스터기(720)의 예시적인 다이어그램이다. 도 7 및 도 8이 이제 참조된다.

깊이 테스트 모듈(705)는 입력(710) 및 하나 이상의 커버리지 집합들(예를 들어, 718)을 수신한다. 커버리지 집합들(예를 들어, 718) 각각은 온-칩 버퍼(715)에 저장될 수 있다. 깊이 테스트 모듈(705)은, 대응하는 커버리지 집합(예를 들어, 718) 각각에 대해 두 개의 분리된 확인들을 완수할 수 있는 하나 이상의 집합 테스터기들(예를 들어, 720)을 포함할 수 있다. 먼저, 집합 테스터기(720)는, 깊이 테스터기(예를 들어, 740)를 사용하여, 입력(710)의 깊이 범위가 커버리지 집합(예를 들어, 718)의 깊이 범위를 통과(pass)하는지 여부를 결정할 수 있다. 두번째로, 집합 테스터기(720)는, 커버리지 테스터기(예를 들어, 745)를 사용하여, 입력(710)이 커버리지 집합(예를 들어, 718)과 오버랩되는 부분을 갖는지 여부를 결정할 수 있다. 집합 테스터기(예를 들어, 720) 각각의 출력(예를 들어, 725)은 AND 연산(예를 들어, 730)으로 입력(fed)될 수 있고, 그리고 깊이 테스트 모듈(705)은 깊이 테스트 패스(DEPTH TEST PASS) 신호(735)를 출력할 수 있다.

도 8을 참조하면, 집합 테스트 모듈(705)의 집합 테스터기(720)가 좀 더 상세하게 보여 진다. 집합 테스터기(720)는 입력(710) 및 커버리지 집합(718)을 수신할 수 있고, 그리고 대응하는 커버리지 집합(예를 들어, 718) 각각에 대한 두 개의 분리된 확인들을 완수할 수 있다. 먼저, 집합 테스터기(720)는, 깊이 테스터기(740)를 사용하여, 입력(710)의 깊이 범위가 커버리지 집합(718)의 깊이 범위를 통과하는지 여부를 결정할 수 있다. 두번째로, 집합 테스터기(720)는, 커버리지 테스터기(745)를 사용하여, 입력(710)이 커버리지 집합(718)과 오버랩되는 부분을 갖는지 여부를 결정할 수 있다.

첫 번째 결정과 관련하여, 깊이 테스터기(740)는 커버리지 집합(예를 들어, 718) 및 입력(예를 들어, 710)에 대해 옳은 깊이를 선택한다. 몇몇 실시 예들에서, 깊이 테스터기(740)는 룩-업 테이블(Look-Up Table; LUT)을 사용할 수 있다. 아래 표는 집합 테스터기(740)의 예시적인 동작을 보인다.

깊이 함수(805)	입력 MUX 출력 (830)	집합 MUX 출력 (815)	비교 (825)
미만(Less)	minDepth	maxDepth	입력 < 집합
이하(LessEqual)	minDepth	maxDepth	입력 <= 집합
초과(Greater)	maxDepth	minDepth	입력 > 집합
이상(GreaterEqual)	maxDepth	minDepth	입력 >= 집합

이에 따라, 깊이 함수(805)는 minDepth 및 maxDepth를 집합(718)으로부터 수신하고, 그리고 출력 신호(815)를 출력하는 집합 멀티플렉서(multiplexor; MUX; 812)를 제어한다. 집합 깊이(820) 로직 섹션은 출력 신호(815)에 기초하여 깊이를 설정하고, 그리고 깊이를 비교 로직 섹션(825)으로 패스한다. 깊이 함수(805)는 또한 입력(710)으로부터 minDepth 및 maxDepth를 수신하고, 그리고 출력 신호(830)를 출력하는 입력 멀티플렉서(828)를 제어한다. 출력 신호(815) 및 출력 신호(830)에 기초하여, 비교 로직 섹션(825)은 비교 연산을 위에 기술된 표 1에 따라 수행할 수 있다. 비교 로직 섹션(825)은 집합 깊이 테스트 패스 신호(SET DEPTH TEST PASS; 860)를 출력한다.

깊이 함수들 절대 아님(Never), 항상(Always), 동일(Equal), 및 동일하지 않음(NotEqual)은, 절대 아님 경우들은 업스트림(upstream)이고, 나머지들(즉, 항상, 동일, 및 동일하지 않음)은 항상 깊이 테스터기(740)를 패스하기 때문에, 반드시 표 1에 쓰일 필요는 없다.

커버리지 테스터기(745)는 AND 연산(예를 들어 845)을 두 커버리지 마스크들(예를 들어, 840 및 850)에 그들이 동일한 위치들을 커버하는지 여부를 결정하기 위해 적용하는, 오버랩 테스트이다. 커버리지 테스터기(745)는 OR 연산(미도시)을 결과들에 임의의 오버랩이 존재하는지 보기 위해 적용할 수 있다. AND 연산(845)의 출력은 855에서 0과 동일하지 않은지 확인되고, 이후에 커버리지 테스터기(745)는 커버리지 오버랩 정보(COVERAGE OVERLAP; 865)를 출력한다. 비교되는 상이한 입도의 마스크들(예를 들어, 840 및 850)에 대해, 집합 커버리지 마스크(880)는 쿼드 입도에 있고, 반면에 입력 커버리지 마스크(885)는 픽셀 입도에 있다. 그 결과, 커버리지 테스터기(745)에 대해, 입력 커버리지 마스크(885)는 875에서 거칠어(coarsen)진다. 예를 들어, 만약 2x2 쿼드 내의 임의의 픽셀이 커버리지를 가지면, 그렇다면 그 쿼드에 속한 쿼드 마스크 비트는 1로 설정된다. 따라서 거칠게 하는 로직(875)는 보수적이며 그리고 커버리지를 쿼드 입도로 확장한다. 이는 테스트 도중 임의의 거짓 부정(false negatives)을 방지하기 위해 수행된다.

깊이 테스터기(740)로부터 출력되는 집합 깊이 테스트 패스 정보(860) 및 커버리지 테스터기(745)로부터 출력되는 커버리지 오버랩 정보(865)는 테스트 패스 결과를 870에서 결정하기 위해 사용될 수 있다. 집합 테스트 패스 결과(Set Test Pass; 870)는 다음에 따라 결정될 수 있다: SetTestPass = (CoverageOverlap AND SetDepthTestPass) OR NOT (CoverageOverlap).

도 9는 몇몇 실시 예들에 따른 깊이 업데이트 로직 섹션(905)의 예시적인 다이어그램이다. 깊이 업데이트 로직 섹션(905)은 깊이 범위(910) 및 커버리지 마스크(915)를 포함할 수 있는 하나의 타일내의 프리미티브들의 범위(예를 들어, 도 1의 135) 를 수신한다. 깊이 업데이트 로직 섹션(905)은 깊이 테스트(예를 들어, 도 8의 740)에서 생존(survive)한 타일 내의 프리미티브들의 범위를 처리할 수 있다. 깊이 업데이트 로직 섹션(905)은 쿼드 입도를 가진 구성이 선택되거나, 픽셀 입도 커버리지를 가질 때 거친어진 커버리지를 고려한다. 깊이 테스트와는 대조적으로, 깊이 업데이트의 거칠기화는 픽셀 커버리지의 비트 단위 AND로, 즉 오직 전체 쿼드가 커버될 때만 수행된다. 결과적으로, 부분적으로 커버된 쿼드들은 깊이 업데이트 도중 잃어질 수 있다. 이 정보의 손실은 하드웨어 단순성을 증대한다. 깊이 업데이트 로직 섹션(905)은 선택된 구성에 기초한 쿼드 또는 픽셀 입도에서의 깊이 범위(910) 및 커버리지 마스크(915)를 포함하는 타일 내의 프리미티브들의 범위를 수신한다. 여기에서, 커버리지는 쿼드들에 대한 것으로 일반적으로 추정되나, 동일한 기술은 픽셀 커버리지에도 적용될 수 있음이 이해될 것이다.

깊이 업데이트 로직 섹션(905)은 두 업데이트 스테이지들을 수행한다. 제 1 스테이지는 타일 내의 프리미티브들의 범위 및 기존 집합들 사이의 커버리지에 겹치고, 그리고 쿼드 각각에 대해 타일 내의 프리미티브들의 범위 또는 집합이 최선의 컬링 동작을 위해 쿼드를 킵(보유)해야 하는지 여부를 결정한다. 제 2 스테이지는 남아있는 커버리지를 위해, 만약 존재한다면, 새로운 집합으로서 추가하고 허용된 최대까지 집합들의 개수를 줄이기 위해 작동된다. 만약 깊이 테스트(예를 들어, 도 8의 740)가 수행된 경우라면 깊이 업데이트 로직 섹션(905)의 제 2 스테이지는 몇몇 커버리지와 같이 존재함이 보장된다.

아래의 수도코드는 깊이 업데이트 로직 섹션(905)의 제 1 스테이지의 동작을 커버한다. 다음의 수도코드는 노드 각각, 즉 8x8, 또는 16x16 등과 같은 픽셀들의 블록과 관련된다. 다음의 수도코드는 거친 깊이가 업데이트 되지 않는, EQUAL 또는 NOT EQUAL 등의 경우들 등과 같은 다른 깊이 함수들의 정상 경우 밖의 정의들을 포함한다.

/// 어떤 깊이가 더 많은 컬링을 위해 “나은(better)” 지를 정의한다

/// 노드 깊이의 두 복제들을 사용한다 - 하나는 처리의 시작으로부터 온 것이고,

/// 다른 하나는 현재 버전이다. 전자는 비교 및 집합들의 업데이트를 위해 사용되고, 반면에

/// 후자는 노드의 깊이의 현재 표현으로서 사용된다.

bool has_better_coverage (uint16 &nodeMinDepth, uint16 &nodeMaxDepth, pair<uint16, uint16> &setDepth, const uint16 initialNodeMinDepth, const uint16 initialNodeMaxDepth, DepthFunc f) {

bool entry_better = false;

switch (f) {

case LESS: // < LESS implies the < or “less than” operation

case LEQUAL: //< LEQUAL implies the <= or “less than or equal to”

/// 새로운 프리미티브(prim)의 깊이를 동일성을 위해 우선화

entry_better = initialNodeMaxDepth <= setDepth.second;

/// 만약 엔트리가 나으면, 집합의 minDepth를 커버리지와 취해야 하고, 아닌 경우는 반대(vice versa)이다

if (entry_better) nodeMinDepth = min(nodeMinDepth, setDepth.first);

else setDepth.first = min(initialNodeMinDepth, setDepth.first);

break;

case GREATER: //< GREATER implies the > or “greater than” operation

case GEQUAL: //< GEQUAL implies the >= or “greater than or equal to” operation

/// 새로운 프리미티브(prim)의 깊이를 동일성 위해 우선화

entry_better = initialNodeMinDepth >= setDepth.first;

/// 만약 엔트리가 나으면, 집합의 maxDepth를 커버리지와 취해야 하고, 아닌 경우는 반대(vice versa)이다

if (entry_better) nodeMaxDepth = max(nodeMaxDepth, setDepth.second);

else setDepth.second = max(initialNodeMaxDepth, setDepth.second);

break;

};

return false;

}

/// 제 1 스테이지 깊이 업데이트를 표현하는 함수

void depth_update_stage1 (SAEntry &in, Node &curr, DepthFunc f) {

uint16 initialNodeMinDepth = in.minDepth;

uint16 initialNodeMaxDepth = in.maxDepth;

/// SA 엔트리의 커버리지를 반복(iterate) -

/// 필요하다면 이미 다운샘플 되었다고 가정

for (i = 0; i < NumCoverageBits; ++i) {

/// 커버되었을 때만 필수적으로 확인, 아니면 아무 것도 하지 않음

if (in.covMask[i] == 1) {

/// 현재(curr) 노드의 임의의 집합이 커버리지를 갖는가, 즉 id != 0으로 설정되었는지 봄

if (curr.coverage[i] != 0) {

/// 집합이 더 “나은” 커버리지 또는 SAEntry를 갖는지 확인

/// 처음의 깊이들을 사용하여 최종 결과가

///집합들, 또는 i에 따라 순회(traversing)하는 순서에 의존하지 않는 지 확실히 해야함

bool entry_better = has_better_coverage (in.minDepth, in.maxDepth, curr.depth[curr.coverage[i]], initialNodeMinDepth,

initialNodeMaxDepth, f);

if (entry_better) {

/// 집합으로부터 커버지리를 훔침(steal)

/// 변경들이 필요하지 않음, 우리는 curr.coverage[i]를 스테이지 2에서 수정할 것임

} else {

/// 커버리지를 SAEntry로부터 제거

in.covMask[i] = 0;

}

}

}

}

}

깊이 업데이트 로직 섹션(905)의 제 1 스테이지는 타일 내의 프리미티브들의 범위가 더 나은 선택지인 쿼드들/픽셀들에 대한 커버리지를 오직 갖는다는것을 확실하게 보장한다. 제 2 스테이지의 한 기능은, 이 새로운 깊이 및 커버리지 쌍이 구성에 의해 제시된 집합들의 일정한 최대 개수를 유지하면서도 커버리지 집합들에 삽입될 수 있다는 것을 확실하게 하는 것이다. 다음의 수도코드는 타일 내의 프리미티브들의 범위를 노드에 삽입하는 것과 관련된 깊이 업데이트 로직 섹션(905)의 제 2 스테이지와 관련된다.

void insert_saentry(SAEntry &in, Node &curr, uint index) {

curr.depth[index] = make_pair(in.minDepth, in.maxDepth);

for (i = 0; i < NumCoverageBits; ++i) {

/// 커버된 경우에만 확인이 필요하고, 아니면 아무 것도 하지 않음

if (in.covMask[i] == 1) curr.coverage[i] = index;

}

}

/// 가장 가까운 “나은” 깊이를 갖는 두 후보들을 반환

pair<uint, uint> find_candidates (Node &curr, SAEntry &in, DepthFunc f) {

int cand1 = 0, cand2 = 0;

uint16 mindiff = (1 << 16) - 1;

for (int i = 0; i < NumSets; ++i) for (int j = i+1; j <= NumSets; ++i) {

switch (f) {

case LESS:

case LEQUAL:

/// DepthFunc가 적거나(LESS) 유사할 때, 가장 가까운 최대 깊이는

/// 최선의 후보를 갖는다

uint16 depth2 = (j == NumSets) ? in.maxDepth : curr.depth[j].second;

uint16 pair_diff = abs(curr.depth[i].second - depth2);

if (pair_diff < mindiff) { cand1 = i; cand2 = j; }

case GREATER:

case GEQUAL:

/// DepthFunc가 크거나(GREATER) 유사할 때, 가장 가까운 최소 깊이는

/// 최선의 후보를 갖는다

uint16 depth2 = (j == NumSets) ? in.minDepth : curr.depth[j].first;

uint16 pair_diff = abs(curr.depth[i].first - depth2);

if (pair_diff < mindiff) { cand1 = i; cand2 = j; }

};

}

return make_pair (cand1, cand2)

}

/// 스테이지 2 깊이 업데이트. 스테이지 1 업데이트 이후 결과인 (in, curr) 쌍을 취함

void depth_update_stage2 (SAEntry &in, Node &curr, DepthFunc f) {

if (curr.numActiveSets < NumSets) {

/// 이는 모든 집합들이 0…(numActiveSets-1)로 패킹(packed)되었다고 추정한다.

/// RTL는 이 제한을 완화시키기 위해 선택할 수 있고, “홀들(holes)”

/// 즉 집합 인덱스 범위의 끝에 있지 않은 빈 집합들을, 다음 빈

/// 집합을 찾기 위한 방법이 존재하는 한, 가질 수 있다

insert_saentry(in, curr, numActiveSets++);

} else {

/// 축소(collapse)할 두 집합들, 또는 병합하기 위한 하나의 집합 및 SAEntry 를 찾는다

/// 함수는 두 집합들을 알리는 두 색인들(indices)을,

/// SA엔트리는 후보인 것을 나타내는 val == NumSets와 함께 반환한다

pair<uint, uint> candidates = find_candidates (curr, in, f);

if (candidates.second == NumSets) {

/// 후보를 SAEntry와 병합한다

/// 최소 깊이들의 min 및 최대 깊이들의 max를 취한다

curr.depth[candidates.first].first = min(curr.depth[candidates.first].first, in.minDepth);

curr.depth[candidates.first].second = max(curr.depth[candidates.first].second, in.maxDepth);

/// 제 1 후보 집합에 대한 커버리지를 마크(Mark)한다

for (i = 0; i < NumCoverageBits; ++i) {

if (in.covMask[i] == 1) curr.coverage[i] = candidates.first;

}

} else {

/// 두 후보 집합들을 병합한다

/// 최소 깊이들의 min 및 최대 깊이들의 max를 취한다

curr.depth[candidates.first].first = min(curr.depth[candidates.first].first, curr.depth[candidates.second].first);

curr.depth[candidates.first].second = max(curr.depth[candidates.first].second, curr.depth[candidates.second].second);

/// 커버리지를 제 2 후보로부터 제 1로 이동한다

for (i = 0; i < NumCoverageBits; ++i) {

if (curr.coverage[i] == candidates.second) curr.coverage[i] = candidates.first;

}

/// 병합 완료, SAEntry를 candidates.second로 삽입

insert_saentry (in, curr, candidates.second);

}

}

}

깊이 업데이트 로직 섹션(950) 집합 병합하기의 제 2 스테이지 뒤의 안내 원리는 이용 가능한 정보를 거칠기화할 때, 예를 들어, 유사한 “나은” 깊이를 갖는 정보를 병합함으로써, 손실이 최소화된다는 것이다. 특정한 깊이 함수에 대하여, 최선의 깊이 값들은 커버리지를 유지하면서 킵될 수 있다. 몇몇 정보가 손실되나, 하드웨어 단순성이 개선된다.

제 2 스테이지에 대한 수도코드와 관련하여, LESS 또는 LEQUAL 깊이 함수에 대해, 로직은 모든 커버된 픽셀들에 대해 시간에 따른(over time) 커버리지 집합들의 최대 깊이를 최소화하려고 시도한다. 이는 깊이 테스트 로직이 새로운 프리미티브의 최소 깊이를 집합의 최대 깊이에 대하여 테스트함에 따라 컬링을 최대화하기 위해 수행된다. 이에 대응하여, GREATER 및 GEQUAL에 대해, 로직은 모든 커버된 픽셀들에 대해 시간에 따른 커버리지 집합들의 최소 깊이를 최대화하려고 시도한다. 이 기술은 만약 깊이 함수가 이미지 내에서 기호(sign)를 변경하면 조악하게 작동할 수 있다, 즉 이미지 내에서 {LESS, LEQUAL}로부터

{GREATER, GEQUAL}로 전환하는 것은 데이터의 품질을 저하시킬 수 있다. 이는 상이하게 표현되었으나, SA 엔트리 커버리지의 병합에 대한 것과 동일한 논리이다. 완전히(Fully) 커버된 블록들/노드들은 로직 내에서 내재적으로 다루어질 수 있다.

선택적인 성능 향상은, 어디로 병합된 집합을 이동할지 및 어떤 집합을 SA 엔트리에 의해 사용되기 위해 자유롭게 할지를 고르는 제 2 스테이지에서의 집합 병합 코드를 포함한다. 예를 들어, 만약 병합된 집합이 항상 낮은 인덱스(index)를 사용하면, 그렇다면 집합 1이 계속 더 크게 성장하고(예를 들어, 커버리지 측면에서) 그리고 더 희석된(diluted) 깊이 범위를 가질 가능성이 있다. 그 결과, 이어지는 우선성 순서가 선호되나, 임의의 순환적(cyclical) 순서 매기기도 충분(suffice)하다. 만약 집합 1 및 2가 병합되면, 그렇다면 병합된 집합은 집합 1에 써라. 만약 집합 1 및 3이 병합되면, 그렇다면 병합된 집합은 집합 3에 써라. 만약 집합 2 및 집합 3이 병합되면, 병합된 집합은 집합 2에 써라. 인커밍 SA 엔트리는 그 결과 자유로워진 다른 집합 인덱스, 또는 임의의 다른 자유로운 집합 슬롯으로 대응적으로 갈 것이다.

도 10은 여기에서 개시된 몇몇 실시 예들에 따른 비닝 유닛(100)을 포함하는 GPU(1005)의 예시적인 블록도이다. 비닝 유닛(100)은 도 1의 비닝 유닛에 대응할 수 있다. 비닝 유닛(100)은 하나 이상의 프로세서 코어들(1010)에 전기적으로 연결될 수 있다. GPU(1005)는 또한 RAM(random access memory), 플래시 메모리(1015), 솔리드 스테이트 드라이브(solid state drive; SSD) 등과 같은 것일 수 있는 메모리 장치(1015)를 포함할 수 있다.

상술된 방법들의 다양한 동작들은 동작들을 수행하는 것이 가능한, 다양한 하드웨어 및/또는 소프트웨어 구성 요소(들), 회로들, 및/또는 모듈(들)과 같은 임의의 적절한 수단들에 의해 수행될 수 있다.

여기에서 개시된 실시 예와 관련된 방법 또는 알고리즘 및 함수들의 블록들 또는 단계들은 하드웨어, 프로세서에 의해 실행되는 소프트웨어 모듈, 또는 둘의 조합으로 직접 구현될 수 있다. 만약 소프트웨어로 구현되면, 함수들은 접촉하여 알 수 있는(tangible) 비-일시적 컴퓨터-판독 가능 매체(non-transitory computer-readable medium) 상에 하나 이상의 명령어들(instructions) 또는 코드로서 저장되거나 또는 이를 통해 전송될 수 있다. 소프트웨어 모듈은 RAM(Random Access Memory), 플래시 메모리, 읽기 전용 메모리(Read Only Memory; ROM), EPROM(Electrically Programmable ROM), EEPROM(Electrically Erasable Programmable ROM), 레지스터들, 하드 디스크, 제거 가능한 디스크, CD ROM, 또는 기술 분야에서 알려진 임의의 다른 형태의 저장 매체에 상주할 수 있다.

다음의 논의는 적절한 기계 또는 본 발명의 특정한 양상들이 구현될 수 있는 기계들에 대한 간략하고, 일반적인 설명을 제공하기 위해 의도되었다. 전형적으로, 기계 또는 기계들은 프로세서들, 메모리들, 예를 들어 RAM, ROM, 또는 다른 상태 보존적인(state preserving) 매체들, 저장 장치들, 비디오 인터페이스, 및 입력/출력 인터페이스 포트들을 붙이기 위한 시스템 버스를 포함한다. 기계 또는 기계들은, 적어도 부분적으로, 키보드들, 마이크들 등과 같은 기존의 입력 장치들로부터의 입력뿐만 아니라, 다른 기계로부터 수신되는 지시문들(directives), 가상 현실(Virtual Reality; VR) 환경과의 상호작용, 생체 인식(biometric) 피드백, 또는 다른 입력 신호들에 의해서도 제어될 수 있다. 여기에서 사용된, 용어 “기계”는 단일 기계, 가상 기계, 또는 통신적으로 결합된 기계들, 가상 기계들, 또는 함께 동작하는 장치들을 넓게 포함하도록 의도되었다. 예시적인 기계들은 개인 컴퓨터들, 워크스테이션들, 서버들, 휴대용 컴퓨터들, 휴대용 장치들, 전화들, 타블렛들 등과 같은 컴퓨팅 장치들뿐만 아니라 개인적 또는 대중 교통과 같은 운송 장치들, 예를 들어 자동차들, 기차들, 운전실 등을 포함한다.

기계 또는 기계들은 프로그램 가능한 또는 프로그램-불가능한 로직 장치들 또는 어레이들, 주문형 집적 회로(Application Specific Integrated Circuits; ASICs), 내장된 컴퓨터들, 스마트 카드들 등과 같은 내장(embedded) 제어기들을 포함할 수 있다. 기계 또는 기계들은 네트워크 인터페이스, 모뎀, 또는 다른 통신적인 커플링 등을 통해 하나 이상의 원격 기계들로의 하나 이상의 연결들을 이용(utilize)할 수 있다. 기계들은 인트라넷, 인터넷, 근거리 통신망(local area networks), 광역 통신망(wide area networks) 등과 같은 물리적인 및/또는 논리적인 네트워크 방식으로 상호연결될 수 있다. 통상의 기술자는 네트워크 통신이 무선 주파수(Radio Frequency; RF), 인공위성, 마이크로웨이브, IEEE(Institute of Electrical and Electronics Engineers) 545.11, 블루투스, 광학, 적외선, 케이블, 레이저 등을 포함하는 다양한 유선 및/또는 무선 단거리 또는 장거리 캐리어들 및 프로토콜들을 이용할 수 있다는 것을 이해할 것이다.

본 발명의 실시 예들은 기계에 의해 액세스될 때 기계가 작업들을 수행하거나 또는 추상적인 데이터 유형들 또는 저수준 하드웨어 컨텍스트들을 정의하도록 하는 함수들, 과정들, 데이터 구조들, 어플리케이션 프로그램들 등을 포함하는 관련된 데이터를 참조하거나 또는 이와 관련하여 설명될 수 있다. 관련된 데이터는 예를 들어, 휘발성 및/또는 비-휘발성 메모리, 예를 들어 RAM, ROM 등, 또는 다른 저장 장치들 및 하드-드라이브들, 플로피-디스크들, 광학 저장 장치, 테이프들, 플래시 메모리, 메모리 스틱들, 디지털 비디오 디스크들, 생물학적(biological) 저장 장치 등을 포함하는 그들과 연관된 저장 매체에 저장될 수 있다. 관련된 데이터는 패킷들, 직렬 데이터, 병렬 데이터, 전파된(propagated) 신호들 등의 형태로, 물리적인 및/또는 논리 네트워크를 포함하는 전송 환경들을 통해 전달될 수 있고, 그리고 압축되거나 암호화된 포캣으로 사용될 수 있다. 관련된 데이터는 분산 환경에서 사용될 수 있고, 그리고 기계 액세스를 위해 로컬적으로 및/또는 원격으로 저장될 수 있다.

도시된 실시 예들을 참조하여 본 발명의 원리들을 설명하고 예시하였으나, 도시된 실시 예들은 그러한 원리들을 벗어나지 않으면서도 배열 및 구체적인 부분이 수정될 수 있으며, 임의의 원하는 방식으로 조합될 수 있다고 인식될 것이다. 그리고 비록 전술한 논의가 특정 실시 예들에 초점이 맞추어졌으나, 다른 구성들도 고려된다. 특히, 비록 “본 발명의 일 실시 예에 따라” 등과 같은 표현들이 여기에서 사용되었더라도, 이 문구들은 일반적으로 실시 예의 가능성들을 참조하기 위한 것을 의미하고, 특정한 실시 예의 구성들로 본 발명을 한정하기 위해 의도되지 않는다. 여기에서 사용된 바와 같이, 이러한 용어들은 다른 실시 예들에 결합될 수 있는 동일하거나 상이한 실시 예들을 지칭할 수 있다.

본 발명의 실시 예들은 하나 이상의 프로세서들에 의해 실행 가능한, 여기에서 설명된 발명의 요소들을 수행하기 위한 명령어들을 포함하는, 명령어들을 포함하는 비-휘발성 기계-판독 가능 매체들을 포함할 수 있다.

전술한 예시적인 실시 예들은 본 발명의 개념을 한정하는 것으로 이해되지 않아야 한다. 비록 몇몇 실시 예들이 설명되었으나, 통상의 기술자들은 그 실시 예들에 대해 실질적으로 본 개시의 신규한 교시들 및 장점들을 벗어나지 않으면서도 많은 수정이 가능하다는 것을 쉽게 이해할 것이다. 따라서, 모든 그러한 수정들은 청구항들에 정의된 바와 같은 본 발명의 범위 내에 포함되도록 의도되었다.

100: 비닝 유닛
105: 래스터라이저
130: 로컬 컬링 스테이지
150: 글로벌 컬링 스테이지
510: 커버리지 병합 규칙들
600: 범례
705: 깊이 테스트 모듈
905: 깊이 업데이트 로직 섹션
1005: GPU

Claims (20)

1. 픽셀 지오메트리들(Pixel Geometries)의 비닝(Binning) 동안에 거친(Coarse) 깊이 컬링(cull)을 하는 비닝 유닛에 있어서:
   하나 이상의 프리미티브들(primitives)을 수신하고, 그리고 픽셀 커버리지 정보 및 깊이 정보를 생성하는 래스터라이저(rasterizer);
   상기 래스터라이저에 연결되고, 프리미티브들의 윈도우 내에서 로컬 컬링(local culling)을 수행하고, 그리고 생존(Surviving) 커버리지 및 생존 깊이 정보의 집합(set)을 출력하는 하나 이상의 로컬 컬링 스테이지들; 및
   a)상기 하나 이상의 로컬 컬링 스테이지들 또는 b)래스터라이저 중 적어도 하나에 연결되고, 이전에 수신된 픽셀 커버리지 정보 및 깊이 정보의 전부에 기초하여 더 컬링하기 위해 상기 생존 커버리지 및 상기 생존 깊이 정보의 상기 집합을 사용하는 하나 이상의 글로벌 컬링 스테이지들을 포함하는 비닝 유닛.
2. 제 1 항에 있어서,
   상기 하나 이상의 로컬 컬링 스테이지들은 상기 프리미티브들의 윈도우와 연관된 깊이 정보만을 상기 하나 이상의 프리미티브들의 상기 로컬 컬링을 상기 프리미티브들의 윈도우 내에서 수행할 때 사용하는 비닝 유닛.
3. 제 1 항에 있어서,
   상기 하나 이상의 글로벌 컬링 스테이지들은 모든 지난(past) 프리미티브들로부터, 커버리지 정보 및, a) 거친(coarse) 깊이 정보 또는 b) 미세한(fine) 깊이 정보 중 적어도 어느 하나를 이용하여 상기 하나 이상의 로컬 컬링 스테이지들로부터 수신된 상기 생존 커버리지 및 생존 깊이 정보의 집합을 더 컬링하는 비닝 유닛.
4. 제 1 항에 있어서,
   상기 래스터라이저, 상기 하나 이상의 로컬 컬링 스테이지들, 및 상기 하나 이상의 글로벌 컬링 스테이지들은 비닝 도중 이미지의 픽셀 각각의 거친 표현(representation)을 생성함으로써 오버드로우(overdraw)를 최소화하고, 그리고 초기-Z(Early-Z) 하드웨어가 상기 이미지의 나중의 프래그먼트들(fragments)에 의해 가려지는(occuluded) 상기 이미지의 조각들을 제거하도록 상기 거친 표현을 깊이 버퍼로 풀 컬러 패스(pass) 전에 프리로드(preload)하는 비닝 유닛.
5. 제 1 항에 있어서:
   상기 하나 이상의 로컬 컬링 스테이지들은 상기 로컬 컬링을 타일 내의 상기 프리미티브들의 윈도우 내에서 수행하고, 그리고
   상기 래스터라이저, 상기 하나 이상의 로컬 컬링 스테이지들, 및 상기 하나 이상의 글로벌 컬링 스테이지들은 어떤 프리미티브들 및 드로우콜들(drawcalls)이 상기 타일에 영향을 주는지 나타내는 표현을 생성하는 비닝 유닛.
6. 제 5 항에 있어서,
   상기 표현은 마지막 렌더링된 이미지에서 보이지 않는 대부분의 프리미티브들 및 드로우콜들을 포함하지 않는 비닝 유닛.
7. 제 1 항에 있어서,
   온-칩 버퍼를 더 포함하되,
   상기 하나 이상의 글로벌 컬링 스테이지들은 어떤 백킹 데이터(backing data)가 상기 온-칩 버퍼에 상주(resident)하는 지를 위한 트랜잭션들(transactions)을 우선화(prioritize)하는 리오더링 큐를 포함하는 비닝 유닛.
8. 제 7 항에 있어서,
   상기 하나 이상의 글로벌 컬링 스테이지들은 상기 트랜잭션들을 상기 배킹 데이터의 온-칩 버퍼 내의 메모리 상주성(residency)에 기초하여 리오더(reorder)하는 비닝 유닛.
9. 제 1 항에 있어서,
   상기 하나 이상의 글로벌 컬링 스테이지들은:
   그래픽 처리 장치(graphics processing unit; GPU)의 후속(subsequent) 렌더링 스테이지들에 의해 소모(consume)되는 커버된 드로우콜들 및 프리미티브들의 스트림을 생성하는 비닝 로직; 및
   워크로드-특정(workload-specific) 컬링을 위한 하나 이상의 사용자 확장들(custom extensions)을 포함하는 비닝 유닛.
10. 제 1 항에 있어서:
    상기 하나 이상의 로컬 컬링 스테이지들은 상기 프리미티브들의 윈도우 내에서 인커밍(incoming) 프리미티브의 깊이 정보에 기초하여 컬링하고, 그리고
    상기 하나 이상의 글로벌 컬링 스테이지들은 상기 프리미티브들의 윈도우 내에서 이전(prior) 프리미티브들의 깊이 정보에 기초하여 컬링하는 비닝 유닛.
11. 제 1 항에 있어서,
    상기 하나 이상의 글로벌 컬링 스테이지들 또는 상기 하나 이상의 로컬 컬링 스테이지들은 이전에 수신된 상기 커버리지 정보 및 깊이 정보의 전부를 상기 프리미티브들의 윈도우를 사용하며 컬링하는 비닝 유닛.
12. 제 1 항에 있어서,
    상기 하나 이상의 글로벌 컬링 스테이지들 또는 상기 하나 이상의 로컬 컬링 스테이지들은 상기 프리미티브들의 윈도우를 이전에 수신된 상기 커버리지 정보 및 깊이 정보의 전부를 사용하여 컬링하는 비닝 유닛.
13. 제 1 항에 있어서,
    워크로드-특정 컬링을 위한 하나 이상의 사용자 확장들을 더 포함하는 비닝 유닛.
14. 제 13 항에 있어서,
    상기 워크로드-특정 컬링을 위한 하나 이상의 사용자 확장들은 가시성 컬링(visibility culling)에 기초하지 않는 비닝 유닛.
15. 제 14 항에 있어서,
    상기 하나 이상의 로컬 컬링 스테이지들은 상기 하나 이상의 사용자 확장들을 사용하는 비닝 유닛.
16. 제 14 항에 있어서,
    상기 하나 이상의 글로벌 컬링 스테이지들은 상기 하나 이상의 사용자 확장들을 사용하는 비닝 유닛.
17. 픽셀 지오메트리들(geometries)의 비닝 도중에 깊이 컬링(culling)과 연관된 커버리지 병합 규칙을 선택하는 방법에 있어서:
    깊이 정보를 분석하는 단계;
    상기 깊이 정보를 1) 인커밍(incoming) 깊이가 매우(strictly) (더) 나음(좋음), 2) 인커밍 깊이가 나음 3) 기존 깊이가 상위 집합(superset), 4) 인커밍 깊이가 상위 집합, 5) 기존 깊이가 나음, 및 6)기존 깊이가 매우 나음을 포함하는 복수의 카테고리들로 분류하는 단계;
    인커밍 커버리지 정보를 기존 커버리지 정보와 비교하는 단계; 및
    상기 커버리지 병합 규칙을 상기 분류하는 단계 및 상기 비교하는 단계에 기초하여 선택하는 단계를 포함하되,
    상기 비교하는 단계는 1) 상기 인커밍 커버리지 정보가 상기 기존 커버리지 정보과 동일한지 여부, 2) 상기 인커밍 커버리지가 상기 기존 커버리지의 엄격한(strict) 상위 집합인지 여부, 또는 3) 상기 기존 커버리지가 상기 인커밍 커버리지의 엄격한 상위 집합인지 여부 중 적어도 어느 하나를 결정하는 단계를 포함하는 방법.
18. 제 17 항에 있어서:
    상기 비교하는 단계는 1) 상기 인커밍 커버리지 정보가 상기 기존 커버리지 정보와 동일하지 않다는 것, 2) 상기 인커밍 커버리지가 상기 기존 커버리지의 엄격한 상위 집합이 아니라는 것, 및 3) 상기 기존 커버리지가 상기 인커밍 커버리지의 엄격한 상위 집합이 아니라는 것을 결정하는 단계를 더 포함하고, 그리고
    상기 커버리지 병합 규칙을 선택하는 단계는 상기 결정하는 단계에 더 기초하는 방법.
19. 제 17 항에 있어서,
    상기 커버리지 병합 규칙을 선택하는 단계는 제 1 커버리지 병합 규칙을 복수의 커버리지 병합 규칙들 중에서 선택하는 단계를 더 포함하는 방법.
20. 제 19 항에 있어서,
    상기 커버리지 병합 규칙을 선택하는 단계는 제 2 커버리지 병합 규칙을 상기 복수의 커버리지 병합 규칙들 중에서 선택하는 단계를 더 포함하는 방법.

Images