KR102009906B1

KR102009906B1 - 고성능의 전력 효율적인 프로그래밍 가능 이미지 처리 하드웨어 플랫폼에 프로그램 코드를 매핑하기 위한 컴파일러 기술들

Info

Publication number: KR102009906B1
Application number: KR1020187022160A
Authority: KR
Inventors: 알버트 믹스너; 현철 박; 윌리엄 알. 마크; 다니엘 프레드릭 핀셸스테인; 오페르 샤참
Original assignee: 구글 엘엘씨
Priority date: 2016-02-26
Filing date: 2016-12-28
Publication date: 2019-08-12
Also published as: TW201810036A; EP3420527A1; EP3420527B1; US10387989B2; US20170249716A1; JP6704056B2; TW201800940A; US20170287103A1; TWI635443B; KR20180100372A; JP2020061168A; WO2017146816A1; CN108541321A; TWI614689B; CN108541321B; JP2019508802A; US10387988B2; US20200020069A1; JP6858239B2

Abstract

방법이 설명된다. 이 방법은 각각의 2차원 실행 레인 및 시프트 레지스터 회로 구조들로 구성된 프로그래밍 가능 스텐실 프로세서들을 갖는 이미지 프로세서의 타깃이 되는 프로그램 코드를 컴파일하는 단계를 포함한다. 프로그램 코드는 방향성 비순환 그래프를 구현하기 위한 것이며, 스텐실 프로세서들 중 각각의 스텐실 프로세서들 상에서 실행할 다수의 커널들로 구성되고, 여기서 컴파일하는 단계는: 이미지 프로세서 내의 스텐실 프로세서들과는 다른 수의 커널들이 프로그램 코드에 존재함을 인식하는 단계; 커널들 중 적어도 하나의 커널이 커널들 중 다른 하나의 커널보다 더 계산 집약적임을 인식하는 단계; 및 프로그램 코드가 이미지 프로세서의 메모리 용량을 초과하는 자원 요건들을 가짐을 인식하는 단계 중 임의의 단계를 포함한다. 컴파일하는 단계는 상기의 인식 중 임의의 인식에 대한 응답으로: 커널들의 수평 융합; 커널들의 수직 융합; 커널들 중 하나를 다수의 커널들로 분열시키는 것; 커널을 다수의 공간적으로 분할된 커널들로 공간 분할하는 것; 방향성 비순환 그래프를 더 작은 그래프들로 분할하는 것 중 임의의 것을 수행하는 단계를 더 포함한다.

Description

고성능의 전력 효율적인 프로그래밍 가능 이미지 처리 하드웨어 플랫폼에 프로그램 코드를 매핑하기 위한 컴파일러 기술들

본 출원은 "Compiler Techniques For Mapping Program Code To A High Performance, Power Efficient, Programmable Image Processing Hardware Platform"이라는 명칭으로 2016년 2월 26일자 출원된 미국 가출원 제62/300,684호를 우선권으로 주장하며, 이 가출원은 그 전체가 인용에 의해 포함된다.

[0001] 본 발명의 분야는 일반적으로 이미지 처리에 관한 것으로, 보다 구체적으로는 고성능의 전력 효율적인 프로그래밍 가능 이미지 처리 하드웨어 플랫폼과 같은 프로그래밍 가능 이미지 처리 하드웨어 플랫폼에 프로그램 코드를 매핑하기 위한 컴파일러 기술들에 관한 것이다.

[0002] 이미지 처리는 일반적으로 어레이로 구조화된 픽셀 값들의 처리를 수반한다. 여기서, 공간적으로 구조화된 2차원 어레이는 이미지들의 2차원 성질을 포착한다(추가 차원들은 시간(예컨대, 일련의 2차원 이미지들) 및 데이터 타입(예컨대, 색상들)을 포함할 수 있다). 일반적인 시나리오에서, 배열된 픽셀 값들은 모션의 이미지들을 캡처하기 위해 스틸 이미지 또는 일련의 프레임들을 생성한 카메라에 의해 제공된다. 종래의 이미지 프로세서들은 일반적으로 두 가지 극단적인 상태들 중 어느 한 상태에 처한다.

[0003] 첫 번째 극단적인 상태는 범용 프로세서 또는 범용 유사 프로세서(예컨대, 벡터 명령 강화들을 갖는 범용 프로세서) 상에서 실행되는 소프트웨어 프로그램들로서 이미지 처리 작업들을 수행한다. 첫 번째 극단적인 상태는 일반적으로 고도의 범용성(versatile) 애플리케이션 소프트웨어 개발 플랫폼을 제공하지만, 연관된 오버헤드(예컨대, 명령 페치(fetch) 및 디코드, 온 칩 및 오프 칩 데이터 처리, 추측 실행)와 결합된 보다 세분화된 데이터 구조들의 그 사용은 궁극적으로 프로그램 코드의 실행 중에 데이터 단위당 더 많은 양의 에너지가 소모되게 한다.

[0004] 두 번째의 반대 극단적인 상태는 고정 기능 하드와이어드 회로를 훨씬 더 큰 데이터 블록들에 적용한다. 커스텀 설계된 회로들에 직접 적용되는 (보다 세분화된 데이터 블록들과는 대조적인) 더 큰 데이터 블록들의 사용은 데이터 단위당 전력 소비를 크게 감소시킨다. 그러나 커스텀 설계된 고정 기능 회로의 사용은 일반적으로 프로세서가 수행할 수 있는 제한된 세트의 작업들을 야기한다. 이에 따라, (첫 번째 극단적인 상태와 연관된) 광범위한 범용성 프로그래밍 환경은 두 번째 극단적인 상태에서는 부족하다.

[0005] 데이터 단위당 개선된 전력 효율과 결합된 고도의 범용성 애플리케이션 소프트웨어 개발 기회들 모두를 제공하는 기술 플랫폼은 바람직하지만 여전히 아쉬운 해결책이다.

[0006] 방법이 설명된다. 이 방법은 각각의 2차원 실행 레인(lane) 및 시프트 레지스터 회로 구조들로 구성된 프로그래밍 가능 스텐실(stencil) 프로세서들을 갖는 이미지 프로세서의 타깃이 되는 프로그램 코드를 컴파일하는 단계를 포함한다. 프로그램 코드는 방향성 비순환 그래프(directed acyclic graph)를 구현하기 위한 것이며, 스텐실 프로세서들 중 각각의 스텐실 프로세서들 상에서 실행할 다수의 커널들로 구성되고, 여기서 컴파일하는 단계는: 이미지 프로세서 내의 스텐실 프로세서들과는 다른 수의 커널들이 프로그램 코드에 존재함을 인식하는 단계; 커널들 중 적어도 하나의 커널이 커널들 중 다른 하나의 커널보다 더 계산 집약적임을 인식하는 단계; 및 프로그램 코드가 이미지 프로세서의 메모리 용량을 초과하는 자원 요건들을 가짐을 인식하는 단계 중 임의의 단계를 포함한다. 컴파일하는 단계는 상기의 인식 중 임의의 인식에 대한 응답으로: 커널들의 수평 융합; 커널들의 수직 융합; 커널들 중 하나를 다수의 커널들로 분열시키는 것; 커널을 다수의 공간적으로 분할된 커널들로 공간 분할하는 것; 방향성 비순환 그래프를 더 작은 그래프들로 분할하는 것 중 임의의 것을 수행하는 단계를 더 포함한다.

[0007] 장치가 설명된다. 이 장치는 각각의 2차원 실행 레인 및 시프트 레지스터 회로 구조들로 구성된 프로그래밍 가능 스텐실 프로세서들을 갖는 이미지 프로세서의 타깃이 되는 프로그램 코드를 컴파일하기 위한 수단을 포함한다. 프로그램 코드는 방향성 비순환 그래프를 구현하기 위한 것이며, 스텐실 프로세서들 중 각각의 스텐실 프로세서들 상에서 실행할 다수의 커널들로 구성되고, 여기서 컴파일하기 위한 수단은: 이미지 프로세서 내의 스텐실 프로세서들과는 다른 수의 커널들이 프로그램 코드에 존재함을 인식하는 것; 커널들 중 적어도 하나의 커널이 커널들 중 다른 하나의 커널보다 더 계산 집약적임을 인식하는 것; 그리고 프로그램 코드가 이미지 프로세서의 메모리 용량을 초과하는 자원 요건들을 가짐을 인식하는 것 중 임의의 인식을 위한 수단을 포함한다. 컴파일하기 위한 수단은 상기의 인식 중 임의의 인식에 대한 응답으로: 커널들의 수평 융합; 커널들의 수직 융합; 커널들 중 하나를 다수의 커널들로 분열시키는 것; 커널을 다수의 공간적으로 분할된 커널들로 공간 분할하는 것; 방향성 비순환 그래프를 더 작은 그래프들로 분할하는 것 중 임의의 것을 수행하기 위한 수단을 더 포함한다.

[0008] 다음의 설명 및 첨부 도면들은 본 발명의 실시예들을 예시하는 데 사용된다. 도면들에서:
[0009] 도 1은 이미지 프로세서 하드웨어 아키텍처의 일 실시예를 도시한다.
[0010] 도 2a, 도 2b, 도 2c, 도 2d 및 도 2e는 라인 그룹으로의 이미지 데이터의 파싱, 시트로의 라인 그룹의 파싱 및 중첩 스텐실들을 갖는 시트 상에서 수행되는 동작을 도시한다.
[0011] 도 3a는 스텐실 프로세서의 일 실시예를 도시한다.
[0012] 도 3b는 스텐실 프로세서의 명령어의 일 실시예를 도시한다.
[0013] 도 4는 스텐실 프로세서 내의 데이터 계산 유닛의 일 실시예를 도시한다.
[0014] 도 5a, 도 5b, 도 5c, 도 5d, 도 5e, 도 5f, 도 5g, 도 5h, 도 5i, 도 5j 및 도 5k는 중첩 스텐실들을 갖는 한 쌍의 이웃하는 출력 픽셀 값들을 결정하기 위한 2차원 시프트 어레이 및 실행 레인 어레이의 사용의 일례를 도시한다.
[0015] 도 6은 통합된 실행 레인 어레이 및 2차원 시프트 어레이에 대한 단위 셀의 일 실시예를 도시한다.
[0016] 도 7은 이미지 처리 프로그램 코드를 개발하고 구현하기 위한 프로시저를 도시한다.
[0017] 도 8은 이미지 프로세서를 구성하기 위한 프로시저에 관한 것이다.
[0018] 도 9a 및 도 9b는 라인 버퍼 유닛의 동작에 관한 것이다.
[0019] 도 10a 및 도 10b는 DAG 프로그램 흐름에 관한 것이다.
[0020] 도 11a, 도 11b 및 도 11c는 파이프라인 프로그램 흐름에 관한 것이다.
[0021] 도 12a 및 도 12b는 수평 커널 융합 프로세스에 관한 것이다.
[0022] 도 13a, 도 13b 및 도 13c는 수직 커널 융합 프로세스에 관한 것이다.
[0023] 도 14는 커널 분열 프로세스에 관한 것이다.
[0024] 도 15는 그래픽 분할 프로세스에 관한 것이다.
[0025] 도 16은 DAG/파이프라인 분할 프로세스에 관한 것이다.
[0026] 도 17a는 컴파일 방법을 도시한다.
[0027] 도 17b는 프로그램 코드 개발 환경을 도시한다.
[0028] 도 18은 예시적인 컴퓨팅 시스템을 도시한다.

a. 이미지 프로세서 하드웨어 아키텍처 및 동작

[0029] 도 1은 하드웨어로 구현된 이미지 프로세서에 대한 아키텍처(100)의 일 실시예를 도시한다. 이미지 프로세서는 예를 들어, 시뮬레이션된 환경 내의 가상 프로세서용으로 작성된 프로그램 코드를 하드웨어 프로세서에 의해 실제로 실행되는 프로그램 코드로 변환하는 컴파일러에 의해 타깃화될 수 있다. 도 1에서 확인되는 바와 같이, 아키텍처(100)는 네트워크(104)(예컨대, 온 칩 스위치 네트워크, 온 칩 링 네트워크 또는 다른 종류의 네트워크를 포함하는 네트워크 온 칩(NOC: network on chip))를 통해 복수의 스텐실 프로세서 유닛들(102_1 내지 102_N) 및 대응하는 시트 생성기 유닛들(103_1 내지 103_N)과 상호 접속되는 복수의 라인 버퍼 유닛들(101_1 내지 101_M)을 포함한다. 일 실시예에서, 임의의 라인 버퍼 유닛은 네트워크(104)를 통해 임의의 시트 생성기 및 대응하는 스텐실 프로세서에 접속될 수 있다.

[0030] 일 실시예에서, 소프트웨어 개발자에 의해 미리 정의된 이미지 처리 동작들을 수행하도록 프로그램 코드가 컴파일되어 대응하는 스텐실 프로세서(102)에 로드된다(프로그램 코드는 또한 예컨대, 설계 및 구현에 따라 스텐실 프로세서의 연관된 시트 생성기(103)에 로드될 수 있다). 적어도 일부 경우들에는, 제1 파이프라인 스테이지에 대한 제1 커널 프로그램을 제1 스텐실 프로세서(102_1)에 로드하는 것, 제2 파이프라인 스테이지에 대한 제2 커널 프로그램을 제2 스텐실 프로세서(102_2)에 로드하는 것 등에 의해 이미지 처리 파이프라인이 실현될 수 있는데, 여기서 제1 커널은 파이프라인의 제1 스테이지의 기능들을 수행하고, 제2 커널은 파이프라인의 제2 스테이지의 기능들을 수행하는 식이고, 추가 제어 흐름 방법들이 설치되어 파이프라인의 한 스테이지로부터의 출력 이미지 데이터를 파이프라인의 다음 스테이지로 전달한다.

[0031] 다른 구성들에서, 이미지 프로세서는 동일한 커널 프로그램 코드를 동작시키는 2개 또는 그보다 많은 스텐실 프로세서들(102_1, 102_2)을 갖는 병렬 기계로서 실현될 수 있다. 예를 들어, 각각이 동일한 기능을 수행하는 다수의 스텐실 프로세서들에 걸쳐 프레임들을 확산시킴으로써 이미지 데이터의 고밀도 및 고 데이터 레이트 스트림이 처리될 수 있다.

[0032] 또 다른 구성들에서는, 각각의 스텐실 프로세서들을 이들 각자의 프로그램 코드 커널로 구성하고 적절한 제어 흐름 훅(hook)들을 하드웨어에 구성하여 DAG 설계에서 하나의 커널로부터의 출력 이미지들을 다음 커널의 입력으로 향하게 함으로써 본질적으로 커널들의 임의의 DAG가 하드웨어 프로세서로 로드될 수 있다.

[0033] 일반적인 흐름으로서, 이미지 데이터의 프레임들은 매크로 I/O 유닛(105)에 의해 수신되어 프레임 단위로 라인 버퍼 유닛들(101) 중 하나 이상으로 전달된다. 특정 라인 버퍼 유닛은 자신의 이미지 데이터 프레임을 "라인 그룹"으로 지칭되는 더 작은 이미지 데이터 영역으로 파싱한 다음, 라인 그룹을 네트워크(104)를 통해 특정 시트 생성기로 전달한다. 완전한 또는 "전체" 단일 라인 그룹은 예를 들어, 프레임의 다수의 연속적인 완전한 행들 또는 열들의 데이터로 구성될 수 있다(단순화를 위해, 본 명세서는 주로 연속적인 행들을 언급할 것이다). 시트 생성기는 이미지 데이터의 라인 그룹을 "시트"로 지칭되는 더 작은 이미지 데이터 영역으로 추가로 파싱하고, 시트를 그 대응하는 스텐실 프로세서에 제공한다.

[0034] 단일 입력을 갖는 DAG 흐름 또는 이미지 처리 파이프라인의 경우, 일반적으로 입력 프레임들은 동일한 라인 버퍼 유닛(101_1)으로 향하게 되는데, 이 라인 버퍼 유닛(101_1)은 이미지 데이터를 라인 그룹들로 파싱하고 라인 그룹들을, 파이프라인/DAG에서 대응하는 스텐실 프로세서(102_1)가 제1 커널의 코드를 실행하고 있는 시트 생성기(103_1)로 향하게 한다. 스텐실 프로세서(102_1)가 처리하는 라인 그룹들에 대한 스텐실 프로세서(102_1)에 의한 동작들의 완료시, 시트 생성기(103_1)는 출력 라인 그룹들을 "다운 스트림" 라인 버퍼 유닛(101_2)에 전송한다(일부 사용 경우들에는, 출력 라인 그룹이 더 이전에 입력 라인 그룹들을 전송했던 동일한 라인 버퍼 유닛(101_1)으로 다시 전송될 수 있다).

[0035] 그 다음, 자신들 각자의 다른 시트 생성기 및 스텐실 프로세서(예컨대, 시트 생성기(103_2) 및 스텐실 프로세서(102_2)) 상에서 실행 중인 파이프라인/DAG의 다음 스테이지/동작을 나타내는 하나 또는 그보다 많은 "소비자" 커널들은 제1 스텐실 프로세서(102_1)에 의해 생성된 이미지 데이터를 다운스트림 라인 버퍼 유닛(101_2)으로부터 수신한다. 이런 식으로, 제1 스텐실 프로세서 상에서 동작하는 "생산자" 커널은 자신의 출력 데이터를 제2 스텐실 프로세서 상에서 동작하는 "소비자" 커널에 포워딩되게 하며, 여기서 소비자 커널은 전체 파이프라인 또는 DAG의 설계와 일치하는 생산자 커널 이후에 다음 세트의 작업들을 수행한다.

[0036] 스텐실 프로세서(102)는 이미지 데이터의 다수의 중첩 스텐실들에 대해 동시에 동작하도록 설계된다. 스텐실 프로세서의 다수의 중첩 스텐실들 및 내부 하드웨어 처리 용량이 시트의 크기를 효과적으로 결정한다. 여기서는, 스텐실 프로세서(102) 내에서, 실행 레인들의 어레이들이 일제히 동작하여 다수의 중첩 스텐실들에 의해 커버되는 이미지 데이터 표면 영역을 동시에 처리한다.

[0037] 아래에서 더 상세히 설명되는 바와 같이, 다양한 실시예들에서는, 이미지 데이터의 시트들이 스텐실 프로세서(102) 내의 2차원 레지스터 어레이 구조에 로드된다. 시트들 및 2차원 레지스터 어레이 구조의 사용은 예컨대, 단일 로드 동작으로서 많은 양의 데이터를 많은 양의 레지스터 공간으로 이동시키고, 그 직후에 실행 레인 어레이에 의해 데이터에 대해 직접 수행되는 작업들을 처리함으로써 전력 소모 개선을 효과적으로 제공하는 것으로 여겨진다. 추가로, 실행 레인 배열 및 대응하는 레지스터 어레이의 사용은 쉽게 프로그래밍 가능한/구성 가능한 여러 스텐실 크기들을 제공한다.

[0038] 도 2a 내지 도 2e는 라인 버퍼 유닛(101)의 파싱 활동, 시트 생성기 유닛(103)의 보다 세분화된 파싱 활동뿐만 아니라, 시트 생성기 유닛(103)에 결합된 스텐실 프로세서(102)의 스텐실 처리 활동 모두의 실시예들을 고 레벨로 예시한다.

[0039] 도 2a는 이미지 데이터(201)의 입력 프레임의 일 실시예를 도시한다. 도 2a는 또한 스텐실 프로세서가 동작하도록 설계된 (각각 3개의 픽셀들 × 3개의 픽셀들의 치수를 갖는) 3개의 중첩 스텐실들(202)의 아웃라인을 도시한다. 각각의 스텐실이 출력 이미지 데이터를 각각 생성하는 출력 픽셀은 진한 검정색으로 강조된다. 단순화를 위해, 3개의 중첩 스텐실들(202)은 수직 방향으로만 중첩하는 것으로 도시된다. 실제로 스텐실 프로세서는 수직 방향과 수평 방향 모두에서 중첩 스텐실들을 갖도록 설계될 수 있다고 인식하는 것이 적절하다.

[0040] 도 2a에서 확인되는 바와 같이, 스텐실 프로세서 내의 수직 중첩 스텐실들(202) 때문에, 단일 스텐실 프로세서가 동작할 수 있는 프레임 내에는 넓은 범위의 이미지 데이터가 존재한다. 아래에서 보다 상세히 논의되는 바와 같이, 일 실시예에서, 스텐실 프로세서들은 이들의 중첩 스텐실들 내의 데이터를 이미지 데이터 전체에 걸쳐 좌측에서 우측 방식으로 처리한다(그리고 그 다음에, 다음 세트의 라인들에 대해 위에서 아래 순서로 반복한다). 따라서 스텐실 프로세서들이 이들의 동작에 따라 앞으로 진행할 때, 진한 검정색 출력 픽셀 블록들의 수는 오른쪽 방향으로 수평으로 증가할 것이다. 앞서 논의한 바와 같이, 라인 버퍼 유닛(101)은 확장된 수의 다가오는 사이클들 동안 스텐실 프로세서들이 동작하기에 충분한 착신 프레임으로부터 입력 이미지 데이터의 라인 그룹을 파싱하는 역할을 한다. 라인 그룹의 예시적인 도시는 음영 영역(203)으로서 예시된다. 일 실시예에서, 라인 버퍼 유닛(101)은 시트 생성기로/로부터 라인 그룹을 전송/수신하기 위한 서로 다른 역학 관계를 이해할 수 있다. 예를 들어, "전체 그룹"으로 지칭되는 하나의 모드에 따르면, 이미지 데이터의 완전한 전체 폭의 라인들이 라인 버퍼 유닛과 시트 생성기 사이에서 전달된다. "가상 높이(virtually tall)"로 지칭되는 두 번째 모드에 따르면, 라인 그룹이 처음에는 전체 폭의 행들의 서브세트로 전달된다. 그 다음, 나머지 행들이 (전체 폭보다 작은) 더 작은 부분들로 순차적으로 전달된다.

[0041] 입력 이미지 데이터의 라인 그룹(203)이 라인 버퍼 유닛에 의해 정의되어 시트 생성기 유닛으로 전달되면, 시트 생성기 유닛은 스텐실 프로세서의 하드웨어 한계들에 보다 정확하게 맞는 보다 미세한 시트들로 라인 그룹을 추가로 파싱한다. 보다 구체적으로는, 아래에서 추가로 더 상세히 설명되는 바와 같이, 일 실시예에서, 각각의 스텐실 프로세서는 2차원 시프트 레지스터 어레이로 구성된다. 2차원 시프트 레지스터 어레이는 본질적으로 이미지 데이터를 실행 레인들의 어레이 "아래로" 시프트하는데, 여기서 시프트 패턴은 각각의 실행 레인이 그 자체의 각각의 스텐실 내의 데이터에 대해 동작하게 한다(즉, 각각의 실행 레인이 그 자체의 스텐실의 정보를 처리하여 해당 스텐실에 대한 출력을 생성한다). 일 실시예에서, 시트들은 2차원 시프트 레지스터 어레이를 "채우는" 또는 다르게는 2차원 시프트 레지스터 어레이에 로드되는 입력 이미지 데이터의 표면 영역들이다.

[0042] 아래에서 더 상세히 설명되는 바와 같이, 다양한 실시예들에서는, 임의의 사이클에서 시프트될 수 있는 2차원 레지스터 데이터의 다수의 층들이 실제로 존재한다. 편의상, 본 설명의 대부분은 시프트될 수 있는 2차원 레지스터 데이터의 하나 또는 그보다 많은 그러한 계층들을 갖는 구조들을 지칭하기 위해 간단히 "2차원 시프트 레지스터" 등의 용어를 사용할 것이다.

[0043] 따라서 도 2b에서 확인되는 바와 같이, 시트 생성기는 라인 그룹(203)으로부터 초기 시트(204)를 파싱하고 그것을 스텐실 프로세서에 제공한다(여기서, 데이터의 시트는 일반적으로 참조 번호 204로 식별되는 음영 영역에 대응한다). 도 2c 및 도 2d에서 확인되는 바와 같이, 스텐실 프로세서는 시트 위에서 중첩 스텐실들(202)을 좌측에서 우측으로 효과적으로 이동시킴으로써 입력 이미지 데이터의 시트에 대해 동작한다. 도 2d에서와 같이, 시트 내의 데이터로부터 출력 값이 계산될 수 있는 픽셀들의 수는 소진된다(다른 픽셀 위치들은 시트 내의 정보로부터 결정된 출력 값을 가질 수 없다). 단순화를 위해, 이미지의 경계 영역들은 무시되었다.

[0044] 도 2e에서 확인되는 바와 같이, 다음에 시트 생성기는 스텐실 프로세서가 동작들을 계속할 다음 시트(205)를 제공한다. 스텐실들이 다음 시트에 대한 동작을 시작할 때 스텐실들의 초기 위치들은 (도 2d에서 이전에 도시된 바와 같이) 첫 번째 시트 상의 소진 지점으로부터 우측으로의 다음 진행이라는 점에 주목한다. 새로운 시트(205)에서는, 스텐실 프로세서가 첫 번째 시트의 처리와 동일한 방식으로 새로운 시트에 대해 동작하므로 스텐실들은 간단히 오른쪽으로 계속 이동할 것이다.

[0045] 출력 픽셀 위치를 둘러싸는 스텐실들의 경계 영역들 때문에 첫 번째 시트(204)의 데이터와 두 번째 시트(205)의 데이터 사이에 약간의 중첩이 있다는 점에 주목한다. 시트 생성기가 중첩 데이터를 두 번 재송신함으로써 중첩이 간단히 처리될 수 있다. 대체 구현들에서는, 스텐실 프로세서에 다음 시트를 공급하기 위해, 시트 생성기는 단지 스텐실 프로세서에 새로운 데이터를 전송하는 것으로 진행할 수 있고 스텐실 프로세서는 이전 시트로부터의 중첩 데이터를 재사용한다.

b. 스텐실 프로세서 설계 및 동작

[0046] 도 3은 스텐실 프로세서 아키텍처(300)의 일 실시예를 도시한다. 도 3에서 확인되는 바와 같이, 스텐실 프로세서는 데이터 계산 유닛(301), 스칼라 프로세서(302) 및 연관된 메모리(303) 그리고 I/O 유닛(304)을 포함한다. 데이터 계산 유닛(301)은 실행 레인들의 어레이(305), 2차원 시프트 어레이 구조(306) 및 어레이의 특정 행들 또는 열들과 연관된 개별 랜덤 액세스 메모리들(307)을 포함한다.

[0047] I/O 유닛(304)은 시트 생성기로부터 수신된 데이터의 "입력" 시트들을 데이터 계산 유닛(301)에 로드하고 스텐실 프로세서로부터의 데이터의 "출력" 시트들을 시트 생성기에 저장하는 역할을 한다. 일 실시예에서, 시트 데이터를 데이터 계산 유닛(301)에 로드하는 것은 수신된 시트를 이미지 데이터의 행들/열들로 파싱하고 이미지 데이터의 행들/열들을 (아래에서 보다 상세히 설명되는) 실행 레인 어레이의 행들/열들의 각각의 랜덤 액세스 메모리들(307)에 또는 2차원 시프트 레지스터 구조(306)에 로드하는 것을 수반한다. 시트가 메모리들(307)에 처음 로드된다면, 실행 레인 어레이(305) 내의 개개의 실행 레인들은 적절할 때 (예컨대, 시트의 데이터에 대한 동작 직전에 로드 명령으로서) 시트 데이터를 랜덤 액세스 메모리들(307)로부터 2차원 시프트 레지스터 구조(306)로 로드할 수 있다. (직접적으로 시트 생성기로부터든 아니면 메모리들(307)로부터든) 레지스터 구조(306)로의 데이터 시트의 로드의 완료시, 실행 레인 어레이(305)의 실행 레인들이 데이터에 대해 동작하고 결국 완성된 데이터를 시트로서 시트 생성기에 다시 직접 "후기록(write back)"하거나 랜덤 액세스 메모리들(307)에 "후기록"한다. 후자라면, I/O 유닛(304)이 랜덤 액세스 메모리들(307)로부터 데이터를 페치하여 출력 시트를 형성하며, 그 다음에 출력 시트가 시트 생성기로 포워딩된다.

[0048] 스칼라 프로세서(302)는 스텐실 프로세서의 프로그램 코드의 명령들을 스칼라 메모리(303)로부터 판독하고 실행 레인 어레이(305)의 실행 레인들에 명령들을 내리는 프로그램 제어기(309)를 포함한다. 일 실시예에서, 하나의 동일한 명령이 어레이(305) 내의 모든 실행 레인들로 브로드캐스트되어, 데이터 계산 유닛(301)으로부터의 SIMD 유사 동작을 수행한다. 일 실시예에서, 스칼라 메모리(303)로부터 판독되어 실행 레인 어레이(305)의 실행 레인들로 내려진 명령들의 명령 포맷은 명령마다 하나보다 많은 연산 코드(opcode)를 포함하는 매우 긴 명령어(VLIW: very-long-instruction-word) 타입 포맷을 포함한다. 추가 실시예에서, VLIW 포맷은 각각의 실행 레인의 ALU에 의해 수행되는 수학 함수를 지시하는 (아래에서 설명되는 바와 같이, 일 실시예에서는 하나보다 많은 종래의 ALU 연산을 특정할 수 있는) ALU 연산 코드와 (특정 실행 레인 또는 실행 레인들의 세트에 대한 메모리 연산을 지시하는) 메모리 연산 코드 모두를 포함한다.

[0049] "실행 레인"이라는 용어는 명령을 실행할 수 있는 하나 또는 그보다 많은 실행 유닛들의 세트(예컨대, 명령을 실행할 수 있는 논리 회로)를 의미한다. 그러나 실행 레인은 다양한 실시예들에서, 단지 실행 유닛들 이상의 보다 많은 프로세서 유사 기능을 포함할 수 있다. 예를 들어, 하나 또는 그보다 많은 실행 유닛들 외에도, 실행 레인은 수신된 명령을 디코딩하는 논리 회로, 또는 더 많은 MIMD 유사 설계들의 경우, 명령을 페치하여 디코딩하는 논리 회로를 또한 포함할 수 있다. MIMD 유사 접근 방식들과 관련하여, 본 명세서에서는 중앙 집중식 프로그램 제어 접근 방식이 대부분 기술되었지만, 다양한 대안적인 실시예들에서는 (예컨대, 어레이(305)의 각각의 실행 레인 내에 프로그램 코드 및 프로그램 제어기를 포함하는) 보다 분산된 접근 방식이 구현될 수 있다.

[0050] 실행 레인 어레이(305), 프로그램 제어기(309) 및 2차원 시프트 레지스터 구조(306)의 결합은 광범위한 프로그래밍 가능 기능들을 위한 광범위하게 적응 가능한/구성 가능한 하드웨어 플랫폼을 제공한다. 예를 들어, 개개의 실행 레인들이 매우 다양한 기능들을 수행할 수 있고 임의의 출력 어레이 위치에 근접한 입력 이미지 데이터에 쉽게 액세스할 수 있다면, 애플리케이션 소프트웨어 개발자들은 광범위한 다양한 기능적 성능뿐만 아니라 치수(예컨대, 스텐실 크기)도 갖는 커널들을 프로그래밍할 수 있다.

[0051] 실행 레인 어레이(305)에 의해 연산되고 있는 이미지 데이터에 대한 데이터 저장소로서 작용하는 것 외에, 랜덤 액세스 메모리들(307)은 또한 하나 또는 그보다 많은 룩업 테이블들을 유지할 수 있다. 다양한 실시예들에서는, 하나 또는 그보다 많은 스칼라 룩업 테이블들이 또한 스칼라 메모리(303) 내에서 인스턴스화될 수 있다.

[0052] 스칼라 룩업은 동일한 인덱스로부터의 동일한 룩업 테이블로부터의 동일한 데이터 값을 실행 레인 어레이(305) 내의 실행 레인들 각각에 전달하는 것을 수반한다. 다양한 실시예들에서, 앞서 설명한 VLIW 명령 포맷은 스칼라 프로세서에 의해 수행된 룩업 동작을 스칼라 룩업 테이블로 향하게 하는 스칼라 연산 코드를 또한 포함하도록 확장된다. 연산 코드에 사용하도록 지정된 인덱스는 즉시 피연산자(immediate operand)일 수 있거나 다른 어떤 데이터 저장 위치로부터 페치될 수 있다. 어떻든지, 일 실시예에서, 스칼라 메모리 내의 스칼라 룩업 테이블로부터의 룩업은 본질적으로, 동일한 클록 사이클 동안 실행 레인 어레이(305) 내의 모든 실행 레인들에 동일한 데이터 값을 브로드캐스트하는 것을 수반한다. 룩업 테이블들의 사용 및 동작에 관한 추가 세부사항들은 아래에서 더 제공된다.

[0053] 도 3b는 앞서 논의한 VLIW 명령어 실시예(들)를 요약한다. 도 3b에서 확인되는 바와 같이, VLIW 명령어 포맷은 3개의 개별 명령들: 1) 스칼라 프로세서에 의해 실행되는 스칼라 명령(351); 2) 실행 레인 어레이 내의 각각의 ALU들에 의해 SIMD 방식으로 브로드캐스트되고 실행되는 ALU 명령(352); 및 3) 부분 SIMD 방식으로 브로드캐스트되고 실행되는 메모리 명령(353)(예컨대, 실행 레인 어레이의 동일한 행에 따른 실행 레인들이 동일한 랜덤 액세스 메모리를 공유한다면, 서로 다른 행들 각각으로부터 하나의 실행 레인이 실제로 명령을 실행한다(메모리 명령(353)의 포맷은 각각의 행으로부터 어느 실행 레인이 명령을 실행하는지를 식별하는 피연산자를 포함할 수 있다))에 대한 필드들을 포함한다.

[0054] 하나 또는 그보다 많은 즉시 피연산자들에 대한 필드(354)도 또한 포함된다. 명령들(351, 352, 353) 중 어떤 것이 어떤 즉시 피연산자 정보를 사용하는지는 명령 포맷에서 식별될 수 있다. 명령들(351, 352, 353) 각각은 또한 이들 각자의 입력 피연산자 및 결과 정보(예컨대, ALU 연산들을 위한 로컬 레지스터들 및 메모리 액세스 명령에 대한 로컬 레지스터 및 메모리 어드레스)를 포함한다. 일 실시예에서, 스칼라 명령(351)은 실행 레인 어레이 내의 실행 레인들이 다른 두 명령들(352, 353) 중 어느 하나를 실행하기 전에 스칼라 프로세서에 의해 실행된다. 즉, VLIW 워드의 실행은 스칼라 명령(351)이 실행되는 제1 사이클과, 이어서 다른 명령들(352, 353)이 실행될 수 있는 제2 사이클을 포함한다(다양한 실시예들에서 명령들(352, 353)은 병렬로 실행될 수 있다는 점에 주목한다).

[0055] 일 실시예에서, 스칼라 프로세서에 의해 실행되는 스칼라 명령들은 데이터 계산 유닛의 메모리들 또는 2D 시프트 레지스터로부터/로 시트들을 로드/저장하도록 시트 생성기에 내려진 커맨드들을 포함한다. 여기서, 시트 생성기의 동작은 라인 버퍼 유닛의 동작 또는 스칼라 프로세서에 의해 내려진 임의의 커맨드를 시트 생성기가 완료하게 하는데 필요할 사이클들의 수의 런타임 전 파악을 방해하는 다른 변수들에 의존할 수 있다. 이에 따라, 일 실시예에서, 스칼라 명령(351)이 시트 생성기에 내려질 커맨드에 대응하거나 아니면 시트 생성기에 커맨드가 내려지게 하는 임의의 VLIW 워드는 또한 다른 두 명령 필드(352, 353)에 무연산(NOOP: no-operation) 명령들을 포함한다. 그 다음, 프로그램 코드는 시트 생성기가 데이터 계산 유닛으로의/으로부터의 로드/저장을 완료할 때까지 명령 필드들(352, 353)에 대한 NOOP 명령들의 루프를 입력한다. 여기서, 시트 생성기에 커맨드를 내릴 때, 스칼라 프로세서는 커맨드의 완료시 시트 생성기가 재설정하는 인터록 레지스터의 비트를 설정할 수 있다. NOOP 루프 동안 스칼라 프로세서는 인터록 비트의 비트를 모니터링한다. 스칼라 프로세서가 시트 생성기가 자신의 커맨드를 완료했음을 탐지하면, 정상 실행이 다시 시작된다.

[0056] 도 4는 데이터 계산 컴포넌트(401)의 일 실시예를 도시한다. 도 4에서 확인되는 바와 같이, 데이터 계산 컴포넌트(401)는 논리적으로 2차원 시프트 레지스터 어레이 구조(406) "위에" 위치되는 실행 레인들의 어레이(405)를 포함한다. 앞서 논의한 바와 같이, 다양한 실시예들에서, 시트 생성기에 의해 제공되는 이미지 데이터의 시트는 2차원 시프트 레지스터(406)에 로드된다. 그 다음, 실행 레인들은 레지스터 구조(406)로부터의 시트 데이터에 대해 동작한다.

[0057] 실행 레인 어레이(405) 및 시프트 레지스터 구조(406)는 서로에 대해 위치가 고정된다. 그러나 시프트 레지스터 어레이(406) 내의 데이터는 전략적이고 조정된 방식으로 시프트되어 실행 레인 어레이의 각각의 실행 레인이 데이터 내의 서로 다른 스텐실을 처리하게 한다. 이에 따라, 각각의 실행 레인은 생성되는 출력 시트 내의 서로 다른 픽셀에 대한 출력 이미지 값을 결정한다. 도 4의 아키텍처로부터, 실행 레인 어레이(405)는 수직으로 인접한 실행 레인들뿐만 아니라 수평으로 인접한 실행 레인들도 포함하기 때문에 중첩 스텐실들은 수직뿐만 아니라 수평으로도 배열된다는 것이 명확해야 한다.

[0058] 데이터 계산 유닛(401)의 일부 주목할 만한 구조적 특징들은 실행 레인 어레이(405)보다 더 넓은 치수들을 갖는 시프트 레지스터 구조(406)를 포함한다. 즉, 실행 레인 어레이(405) 외부에 레지스터들의 "무리(halo)"(409)가 있다. 무리(409)는 실행 레인 어레이의 양측에 존재하는 것으로 도시되어 있지만, 구현에 따라 실행 레인 어레이(405)의 더 적은(1개) 또는 더 많은(3개 또는 4개) 측면들에 무리가 존재할 수 있다. 무리(409)는, 데이터가 실행 레인들(405) "아래에서" 시프트되고 있을 때 실행 레인 어레이(405)의 경계들 외부로 유출되는 데이터를 위한 "유출(spill-over)" 공간을 제공하는 역할을 한다. 간단한 경우로서, 실행 레인 어레이(405)의 우측 가장자리를 중심으로 하는 5 × 5 스텐실은 스텐실의 가장 왼쪽 픽셀들이 처리될 때 오른쪽에 4개의 무리 레지스터 위치들을 더 필요로 할 것이다. 도면의 편의상, 도 4는 명목상의 실시예에서, 어느 한쪽(우측, 아래)의 레지스터들이 수평 및 수직 연결들 모두를 가질 때, 무리의 우측의 레지스터들이 수평 시프트 연결들만을 갖는 것으로 그리고 무리의 아래쪽의 레지스터들이 수직 시프트 연결들만을 갖는 것으로 도시한다. 다양한 실시예들에서, 무리 영역은 이미지 처리 명령들을 실행하기 위한 대응하는 실행 레인 로직을 포함하지 않는다(예컨대, ALU가 존재하지 않음). 그러나 개개의 무리 레지스터 위치들이 개별적으로 메모리로부터 데이터를 로드하고 데이터를 메모리에 저장할 수 있도록 무리 영역 위치들 각각에 개개의 메모리 액세스 유닛들(M)이 있다.

[0059] 어레이의 각각의 행 및/또는 각각의 열 또는 그 일부분들에 결합된 랜덤 액세스 메모리들(407)에 의해 추가 유출 공간이 제공된다(예컨대, 행 방향으로 4개의 실행 레인들 그리고 열 방향으로 2개의 실행 레인에 걸친 실행 레인 어레이의 "영역"에 랜덤 액세스 메모리가 할당될 수 있다. 단순화를 위해, 애플리케이션의 나머지는 주로 행 및/또는 열 기반 할당 방식들을 참조할 것이다). 여기서, 실행 레인의 커널 동작들이 (일부 이미지 처리 루틴들이 필요로 할 수 있는) 2차원 시프트 레지스터 어레이(406) 외부의 픽셀 값들을 처리할 것을 요구한다면, 이미지 데이터의 평면은 예컨대, 무리 영역(409)으로부터 랜덤 액세스 메모리(407)로 추가로 유출될 수 있다. 예를 들어, 하드웨어가 실행 레인 어레이의 우측 가장자리 상에서 실행 레인의 우측에 단지 4개의 저장 엘리먼트들의 무리 영역을 포함하는 6X6 스텐실을 고려한다. 이 경우, 데이터는 스텐실을 완전히 처리하기 위해 무리(409)의 우측 가장자리에서 오른쪽으로 더 시프트될 필요가 있을 것이다. 무리 영역(409) 외부로 시프트된 데이터는 그 다음에 랜덤 액세스 메모리(407)로 유출될 것이다. 도 3의 스텐실 프로세서 및 랜덤 액세스 메모리들(407)의 다른 애플리케이션들이 아래에서 더 제공된다.

[0060] 도 5a 내지 도 5k는 위에서 암시한 바와 같이 이미지 데이터가 실행 레인 어레이 "아래"의 2차원 시프트 레지스터 어레이 내에서 시프트되는 방식의 작동 예를 설명한다. 도 5a에서 확인되는 바와 같이, 2차원 시프트 어레이의 데이터 내용들은 제1 어레이(507)에 도시되고, 실행 레인 어레이는 프레임(505)으로 도시된다. 또한, 실행 레인 어레이 내의 2개의 이웃하는 실행 레인들(510)이 간략하게 도시된다. 이러한 단순한 묘사(510)에서, 각각의 실행 레인은 시프트 레지스터로부터 데이터를 받거나, (예컨대, 사이클들에 걸쳐 누산기로서 작동하는) ALU 출력으로부터 데이터를 받거나, 또는 출력 데이터를 출력 목적지에 기록할 수 있는 레지스터(R1)를 포함한다.

[0061] 각각의 실행 레인은 또한, 로컬 레지스터(R2)에서 2차원 시프트 어레이의 그 "아래"에 있는 내용들을 이용할 수 있다. 따라서 R1은 실행 레인의 물리적 레지스터인 한편, R2는 2차원 시프트 레지스터 어레이의 물리적 레지스터이다. 실행 레인은 R1 및/또는 R2에 의해 제공되는 피연산자들에 대해 연산할 수 있는 ALU를 포함한다. 아래에서 추가로 더 상세히 설명되는 바와 같이, 일 실시예에서, 시프트 레지스터는 실제로 어레이 위치당 다수의("깊이"의) 저장/레지스터 엘리먼트들로 구현되지만, 시프트 활동은 저장 엘리먼트들의 하나의 평면으로 제한된다(예컨대, 저장 엘리먼트들의 단 하나의 평면만이 주기당 시프트할 수 있다). 도 5a 내지 도 5k는 각각의 실행 레인들로부터의 결과적인 X를 저장하는 데 사용되는 것으로 이러한 더 깊은 이러한 더 깊은 레지스터 위치들 중 하나를 도시한다. 예시의 편의상, 더 깊은 결과적인 레지스터는 그 상대 레지스터(R2) 아래보다는 그에 나란히 그려진다.

[0062] 도 5a 내지 도 5k는 실행 레인 어레이 내에 도시된 한 쌍의 실행 레인 위치들(511)과 중심 위치가 정렬되는 2개의 스텐실들의 계산에 초점을 맞추고 있다. 예시의 편의상, 한 쌍의 실행 레인들(510)은 실제로 다음의 예에 따라, 이들이 수직 이웃들이 될 때 수평 이웃들로서 그려진다.

[0063] 처음에 도 5a에서 확인되는 바와 같이, 실행 레인들은 이들의 중앙 스텐실 위치들에 집중된다. 도 5b는 두 실행 레인들에 의해 실행되는 목적 코드를 도시한다. 도 5b에서 확인되는 바와 같이, 두 실행 레인들의 프로그램 코드는 시프트 레지스터 어레이 내의 데이터를 한 위치 아래로 시프트되게 하고 한 위치 오른쪽으로 시프트되게 한다. 이는 두 실행 레인들을 이들 각각의 스텐실들의 왼쪽 상단 모서리에 정렬한다. 그런 다음, 프로그램 코드는 이들 각각의 위치들에(R2에) 위치된 데이터를 R1에 로드되게 한다.

[0064] 도 5c에서 확인되는 바와 같이, 프로그램 코드는 다음에, 한 쌍의 실행 레인들이 시프트 레지스터 어레이 내의 데이터를 좌측으로 한 단위 시프트하게 하며, 이는 각각의 실행 레인의 각각의 위치의 우측에 있는 값이 각각의 실행 레인의 위치로 시프트되게 한다. 그 다음, R1 내의 값(이전 값)은 실행 레인의 위치(R2)로 시프트된 새로운 값으로 추가된다. 결과는 R1에 기록된다. 도 5d에서 확인되는 바와 같이, 도 5c에 대해 앞서 설명한 것과 동일한 프로세스가 반복되어, 결과적인 R1이 이제 상위 실행 레인에 A+B+C 값을 포함하고 하위 실행 레인에 F+G+H 값을 포함하게 한다. 이 시점에서 두 실행 레인들 모두가 이들 각각의 스텐실들의 상위 행을 처리했다. (무리 영역이 좌측에 존재한다면) 실행 레인 어레이의 좌측에 있는 무리 영역으로의 또는 실행 레인 어레이의 좌측에 무리 영역이 존재하지 않는다면 랜덤 액세스 메모리로의 유출에 주목한다.

[0065] 도 5e에서 확인되는 바와 같이, 프로그램 코드는 다음에, 시프트 레지스터 어레이 내의 데이터를 한 단위 위로 시프트시키며, 이는 두 실행 레인들 모두가 이들 각각의 스텐실들의 중간 행의 우측 가장자리와 정렬되게 한다. 두 실행 레인들의 레지스터(R1)는 현재 스텐실의 맨 위 행과 중간 행의 가장 오른쪽 값의 합계를 포함한다. 도 5f 및 도 5g는 두 실행 레인의 스텐실들의 중간 행을 가로질러 좌측 방향으로 이동하는 연속적인 진행을 설명한다. 누적 가산이 계속되어 도 5g의 처리의 종료시 두 실행 레인들 모두는 이들 각각의 스텐실들의 맨 위 행과 중간 행의 값들의 합산을 포함한다.

[0066] 도 5h는 각각의 실행 레인을 그에 대응하는 스텐실의 가장 낮은 행과 정렬하기 위한 다른 시프트를 도시한다. 도 5i 및 도 5j는 두 실행 레인들의 스텐실들 동안의 처리를 완료하기 위한 연속적인 시프트를 도시한다. 도 5k는 각각의 실행 레인을 데이터 어레이 내의 그 정확한 위치와 정렬하고 그에 대한 결과를 기록하기 위한 추가 시프트를 도시한다.

[0067] 도 5a - 도 5k의 예에서, 시프트 동작들을 위한 목적 코드는 (X, Y) 좌표들로 표현된 시프트의 방향 및 크기를 식별하는 명령 포맷을 포함할 수 있다는 점에 주목한다. 예를 들어, 한 위치씩 위로 시프트하기 위한 목적 코드는 SHIFT 0, +1인 목적 코드로 표현될 수 있다. 다른 예로서, 한 위치씩 오른쪽으로의 시프트는 SHIFT +1, 0인 목적 코드로 표현될 수 있다. 다양한 실시예들에서, 더 큰 크기의 시프트들이 목적 코드(예컨대, SHIFT 0, + 2)에 또한 지정될 수 있다. 여기서, 2D 시프트 레지스터 하드웨어가 사이클당 한 위치씩의 시프트들만을 지원한다면, 명령은 기계에 의해 다중 사이클 실행을 필요로 하는 것으로 해석될 수 있거나 2D 시프트 레지스터 하드웨어는 사이클당 하나보다 많은 위치씩의 시프트들을 지원하도록 설계될 수 있다. 후자의 실시예들은 아래에서 추가로 더 상세히 설명된다.

[0068] 도 6은 어레이 실행 레인 및 시프트 레지스터 구조(무리 영역의 레지스터들은 대응하는 실행 레인을 포함하지 않음)에 대한 단위 셀의 보다 상세한 다른 도시를 보여준다. 실행 레인 어레이의 각각의 위치와 연관된 실행 레인 및 레지스터 공간은 일 실시예에서, 실행 레인 어레이의 각각의 노드에서 도 6에서 확인되는 회로를 인스턴스화함으로써 구현된다. 도 6에서 확인되는 바와 같이, 단위 셀은 4개의 레지스터들(R2 내지 R5)로 구성된 레지스터 파일(602)에 결합된 실행 레인(601)을 포함한다. 임의의 사이클 동안, 실행 레인(601)은 레지스터들(R1 내지 R5) 중 임의의 레지스터로부터 판독하거나 그에 기록할 수 있다. 2개의 입력 피연산자들을 요구하는 명령들의 경우, 실행 레인은 R1 내지 R5 중 임의의 레지스터로부터 피연산자들 모두를 리트리브할 수 있다.

[0069] 일 실시예에서, 2차원 시프트 레지스터 구조는 단일 사이클 동안, 레지스터들(R2 내지 R4) 중 임의의 (단지) 하나의 레지스터의 내용들이 출력 멀티플렉서(603)를 통해 그 이웃의 레지스터 파일들 중 하나로 시프트 "아웃"되게 허용하고, 레지스터들(R2 내지 R4) 중 임의의 (단지) 하나의 레지스터의 내용들을, 이웃들 간의 시프트들이 동일한 방향이 되도록(예컨대, 모든 실행 레인들이 왼쪽으로 시프트되고, 모든 실행 레인이 오른쪽으로 시프트되는 식으로) 입력 멀티플렉서들(604)을 통해 그 이웃들 중 대응하는 것으로부터 시프트 "인"되는 내용으로 대체시킴으로써 구현된다. 동일한 레지스터가 자신의 내용들을 시프트 아웃시키고 동일 사이클 상에서 시프트 인되는 내용으로 대체시키는 것이 일반적일 수 있지만, 멀티플렉서 배열(603, 604)은 동일한 사이클 동안 동일한 레지스터 파일 내에서 서로 다른 시프트 소스 및 시프트 타깃 레지스터들을 허용한다.

[0070] 도 6에 도시된 바와 같이, 시프트 시퀀스 동안 실행 레인은 자신의 레지스터 파일(602)로부터 내용을 그 좌측, 우측, 상부 및 하부 이웃들 각각으로 시프트 아웃시킬 것이라는 점에 주목한다. 동일한 시프트 시퀀스와 함께, 실행 레인은 또한 내용을 그 좌측, 우측, 상부 및 하부 이웃들 중 특정 이웃으로부터 그 레지스터 파일로 시프트할 것이다. 다시, 시프트 아웃 타깃 및 시프트 인 소스는 모든 실행 레인들에 대해 동일한 시프트 방향과 일치해야 한다(예컨대, 시프트 아웃이 우측 이웃으로 진행한다면, 시프트 인은 좌측 이웃으로부터 진행해야 한다).

[0071] 일 실시예에서는, 사이클마다 실행 레인당 단 하나의 레지스터의 내용만이 시프트되는 것이 허용되지만, 다른 실시예들은 하나보다 많은 레지스터의 내용이 시프트 인/아웃되도록 허용할 수 있다. 예를 들어, 도 6에서 확인되는 멀티플렉서 회로(603, 604)의 제2 인스턴스가 도 6의 설계에 통합된다면, 동일한 사이클 동안 2개의 레지스터들의 내용이 시프트 아웃/인될 수 있다. 물론, 사이클당 단 하나의 레지스터의 내용만이 시프트되도록 허용되는 실시예들에서는, 수학 연산들 사이의 시프트들을 위해 더 많은 클록 사이클들을 소비함으로써 수학 연산들 사이에서 다수의 레지스터들로부터의 시프트들이 일어날 수 있다(예컨대, 수학 연산들 사이에서 2개의 시프트 연산들을 소비함으로써 수학 연산들 사이에서 2개의 레지스터들의 내용들이 시프트될 수 있다).

[0072] 시프트 시퀀스 중에 실행 레인의 레지스터 파일들의 전부보다는 적은 내용이 시프트 아웃된다면, 각각의 실행 레인의 시프트 아웃되지 않은 레지스터들의 내용이 그대로 유지된다(시프트하지 않음)는 점에 주목한다. 이에 따라, 시프트 인 된 내용으로 대체되지 않은 임의의 시프트되지 않은 내용은 시프트 사이클 전반에 걸쳐 실행 레인에 국부적으로 유지된다. 각각의 실행 레인에서 확인되는 메모리 유닛("M")은 실행 레인 어레이 내의 실행 레인의 행 및/또는 열과 연관된 랜덤 액세스 메모리 공간으로부터/으로 데이터를 로드/저장하는 데 사용된다. 여기서, M 유닛은 실행 레인의 자체 레지스터 공간으로부터/으로 로드/저장될 수 없는 데이터를 로드/저장하는 데 자주 사용된다는 점에서 표준 M 유닛의 역할을 한다. 다양한 실시예들에서, M 유닛의 주요 동작은 로컬 레지스터로부터 메모리로 데이터를 기록하고, 메모리로부터 데이터를 판독하여 이를 로컬 레지스터에 기록하는 것이다.

[0073] 다양한 실시예들에서, 하드웨어 실행 레인(601)의 ALU 유닛에 의해 지원되는 ISA 연산 코드들과 관련하여, 하드웨어 ALU에 의해 지원되는 수학 연산 코드들은 가상 실행 레인에 의해 지원되는 수학 연산 코드들(예컨대, ADD, SUB, MOV, MUL, MAD, ABS, DIV, SHL, SHR, MIN/MAX, SEL, AND, OR, XOR, NOT)과 완전하게 관련된다(예컨대, 실질적으로 동일하다). 위에서 방금 설명한 바와 같이, 메모리 액세스 명령들은 실행 레인(601)에 의해 이들의 연관된 랜덤 액세스 메모리로부터/로 데이터를 페치/저장하도록 실행될 수 있다. 추가로, 하드웨어 실행 레인(601)은 2차원 시프트 레지스터 구조 내의 데이터를 시프트하기 위한 시프트 연산 명령들(우측, 좌측, 위, 아래)을 지원한다. 앞서 설명한 바와 같이, 프로그램 제어 명령들은 주로 스텐실 프로세서의 스칼라 프로세서에 의해 실행된다.

c. 이미지 프로세서 및 라인 버퍼 유닛 동작의 구성

[0074] 도 7은 가상 이미지 처리 환경(701), 실제 이미지 처리 하드웨어(703), 및 가상 처리 환경(701)을 위해 작성된 상위 레벨 코드를 실제 하드웨어(703)가 물리적으로 실행하는 목적 코드로 변환하기 위한 컴파일러(702)를 포함하는 이미지 프로세서 기술 플랫폼의 고 레벨 도면을 도시한다. 아래에서 보다 상세히 설명되는 바와 같이, 가상 처리 환경(701)은 개발될 수 있는 애플리케이션들의 측면에서 광범위하게 범용성이 있으며 애플리케이션의 구성 프로세스들의 용이한 시각화를 위해 맞춤화된다. 개발자(704)에 의한 프로그램 코드 개발 노력의 완료시, 컴파일러(702)는 가상 처리 환경(701) 내에서 작성된 코드를 실제 하드웨어(703)의 타깃이 되는 목적 코드로 변환한다.

[0075] 다양한 실시예들에서, 하드웨어 플랫폼용으로 작성된 프로그램 코드는, 명령 포맷이 예컨대 X, Y 좌표들로서 입력 및 출력 어레이 위치들을 식별하는 로드 및 저장 명령들을 갖는 명령 세트를 포함하는 고유 가상 코드로 작성된다. 다양한 구현들에서, X, Y 좌표 정보는 실제로 하드웨어 플랫폼에 프로그래밍될 수 있고, 그 컴포넌트들 중 다양한 컴포넌트들에 의해 인식/이해될 수 있다. 이것은 예를 들어, (예컨대, 컴파일러 내에서) X, Y 좌표를 다른 정보로 변환하는 것과는 분명히 다르다. 예를 들어, 스텐실 프로세서 내의 2차원 시프트 레지스터 구조의 경우, X, Y 좌표 정보는 레지스터 시프트 이동들로 변환된다. 대조적으로, 하드웨어 플랫폼의 다른 부분들은 원래 더 상위의 가상 코드 레벨에서 표현된 X, Y 좌표 정보를 구체적으로 수신하고 이해할 수 있다.

[0076] 도 8에서 확인되는 바와 같이, 프로그램 코드 개발자는 가상 코드 레벨(810)에서 특수한 명령 포맷으로 X, Y 좌표들로서 데이터 위치들을 표현한다. 컴파일 스테이지 동안, 가상 코드는 하드웨어에 의해 실제로 처리되는 프로그램 코드(목적 코드) 및 하드웨어의 구성(예컨대, 레지스터) 공간으로 로드되는 대응하는 구성 정보로 변환된다. 도 8에서 확인되는 바와 같이, 일 실시예에서, 특정 커널에 대한 목적 코드가 스텐실 프로세서의 스칼라 프로세서(805)의 프로그램 공간으로 로드된다.

[0077] 구성 프로세스의 일부로서, 스칼라 프로세서(805) 상에서 실행되는 구성 소프트웨어는 적절한 구성 정보(811, 812)를 스텐실 프로세서(802)에 결합된 시트 생성기 유닛(803), 및 스텐실 프로세서(802)가 작용할 새로운 시트들을 생성하거나 스텐실 프로세서(802)에 의해 생성된 처리된 시트를 수신할 라인 버퍼 유닛(801) 모두에 로드한다. 여기서 일반적으로는, 전체 이미지의 X, Y 좌표들에 관해서 여전히 시트들이 고려될 수 있다. 즉, (예컨대, 행당 픽셀들의 수, 행들의 수, 열당 픽셀들의 수 그리고 열들의 수에 관하여) 이미지 또는 프레임이 정의되면, 이미지의 임의의 부분 또는 위치가 여전히 X, Y 좌표들에 참조될 수 있다.

[0078] 이에 따라, 다양한 실시예들에서, 시트 생성기 유닛(803) 및 라인 버퍼 유닛(801) 중 어느 하나 또는 둘 다는 이들 각각의 구성 공간(806, 807) 내의 정보(811, 812)로 구성되는데, 이 정보는 이미지 또는 프레임의 특정 위치들 및/또는 영역들(예컨대, 라인 그룹들, 시트들)이 X, Y 좌표들로 식별되는 정보 플랫폼을 설정한다. 다양한 구현들/용도들에서, X, Y 좌표들은 가상 코드 레벨로 표현된 동일한 X, Y 좌표들일 수 있다.

[0079] 이러한 정보의 예들은 예컨대, 라인 버퍼 유닛의 활성 라인 그룹들의 수, (예컨대, (각각의 모서리에 하나씩) 4개의 X, Y 좌표들의 세트 또는 한 쌍의 X, Y 좌표들(더 가까운 하부 모서리에 대해 하나 그리고 더 먼 상부 모서리에 대해 하나) 또는 절대 이미지 폭 및 이미지 높이로서) 각각의 라인 그룹에 대한 이미지 크기, (단일 스텐실의 크기 및/또는 스텐실 프로세서의 중첩 스텐실들의 면적을 정의하는 X, Y 값들로서 표현된) 스텐실 크기, (예컨대, 이미지 크기와 동일한 용어들로 지정되지만 더 작은 치수들을 갖는) 시트 및/또는 라인 그룹 크기 등을 포함한다. 추가로, 라인 버퍼 유닛(801)은 적어도, 라인 버퍼 유닛(801)에 의해 관리되는 라인 그룹들을 기록하는 생산자 커널들의 수 및 판독하는 소비자 커널들의 수와 같은 추가 구성 정보로 프로그래밍될 수 있다. 이미지 데이터와 연관된 치수들 및/또는 채널들의 수는 또한 일반적으로 구성 정보로서 포함된다.

[0080] 도 9a는 이미지 내의 라인 그룹들을 단지 하나의 예로서 정의하기 위한 X, Y 좌표들의 사용을 도시한다. 여기서는, N개의 라인 그룹들(901_1, 901_2, …, 901_N)이 이미지(901) 내에서 확인 가능하다. 도 9a로부터 알 수 있는 바와 같이, 각각의 라인 그룹은 예컨대, 라인 그룹의 모서리 점들 중 하나 또는 그보다 많은 점을 정의하는, 이미지 내의 X, Y 좌표들을 참조로 쉽게 정의될 수 있다. 이에 따라, 다양한 실시예들에서, 특정 라인 그룹을 정의하는 데 사용되는 라인 그룹의 이름 또는 다른 데이터 구조는 라인 그룹을 특별히 식별하기 위해 라인 그룹과 연관된 X, Y 좌표 위치들을 포함할 수 있다.

[0081] 다시 도 8을 잠시 참조하면, 도 8은 런타임 동안 시트 생성기(803)가 예컨대, 원하는 데이터 영역을 정의하는 X, Y 좌표 정보를 포함시킴으로써 라인 버퍼 유닛(801)으로부터 "다음" 라인 그룹(또는 라인 그룹의 일부분)을 요청할 수 있음을 보여준다는 점에 주목한다. 도 9a는 이미지 데이터의 완전한 행들로만 구성된 공칭 "전체 폭" 라인 그룹들을 도시한다. "가상 높이"로 지칭되는 대안적인 구성에서, 라인 버퍼 유닛(801)은 초기에 이미지 데이터의 전체 폭 행들로서 라인 그룹의 제1 상위 부분만을 통과시킨다. 그런 다음, 라인 그룹의 다음 하위 행들이 전체 폭 행보다 작고 별도로 요청되는 인접한 청크들에서 시트 생성기에 의해 구체적으로 요청된다. 이에 따라, 전체 라인 그룹을 얻기 위해 시트 생성기에 의해 여러 요청들이 이루어진다. 여기서, 이러한 각각의 요청은 다음 부분에 기인하는 X, Y 좌표들에 의해 다음 부분을 정의할 수 있다.

[0082] 도 9b에서 확인되는 바와 같이, 라인 버퍼 유닛은 라인 그룹들(902_1 내지 902_N)이 저장되는 메모리(901)(예컨대, 정적 또는 동적 랜덤 액세스 메모리(SRAM 또는 DRAM))를 포함한다. 메모리(901)는 라인 버퍼 유닛(및 예컨대, 시트 생성기들 및 스텐실 프로세서들)을 구현하는 동일한 회로와 함께 온 칩, 또는 오프 칩 구현될 수 있다. 도 9b는 메모리(901) 내의 특정 이미지/프레임에 대한 라인 그룹들(902_1 내지 902_N)을 생성하고 소비하는 다양한 커널들 사이의 활동을 도시한다.

[0083] 도 9b에서 확인되는 바와 같이, 생산자 커널(K1)은 개별적인 시간 인스턴스들(P1, P2 내지 PN)을 통해 메모리(901)에 저장할 새로운 라인 그룹들을 라인 버퍼 유닛(901)으로 전송한다. 생산자 커널(K1)은 새로운 데이터 시트들을 생성하는 스텐실 프로세서 상에서 실행된다. 스텐실 프로세서에 결합된 시트 생성기는 시트들을 누산하여 라인 그룹들을 형성하고 라인 그룹들을 라인 버퍼 유닛으로 포워딩하며, 라인 버퍼 유닛은 라인 그룹들을 메모리에 저장한다.

[0084] 또한, 도 9b에 도시된 바와 같이, 생산자 커널(K1)에 의해 생성된 라인 그룹들(902_1 내지 902_N) 상에서 동작하는 2개의 소비자 커널들(K2, K3)이 있다. 여기서, 소비자 커널(K2, K3)은 각각 C21 시점 및 C31 시점에 제1 라인 그룹(902_1)을 수신한다. 명백하게, C21 시점 및 C31 시점은 P1 시점 후에 발생한다. 다른 제한들은 존재하지 않을 수 있다. 예를 들어, C21 시점 및/또는 C31 시점은 P2 시점 내지 PN 시점 중 어느 한 시점 이전 또는 이후에 발생할 수 있다. 여기서, 커널들(K2, K3)에 대한 각각의 시트 생성기들은 이들 각각의 커널에 적절한 시점에 다음 라인 그룹을 요청한다. 커널들(K2, K3) 중 임의의 커널이 P1 시점 전에 라인 그룹(902_1)을 요청한다면, 라인 그룹(902_1)이 메모리(901)에 실제로 기록된 이후까지 요청은 유휴 상태가 된다.

[0085] 가능하게는, 모든 라인 그룹들(902_1 내지 902_N)에 대한 커널들(K2, K3) 중 어느 하나 또는 둘 다로부터의 요청들은 P1 시점 이전에 도착할 수 있다. 따라서 라인 그룹들은 언제든지 소비자 커널들에 의해 요청될 수 있다. 소비자 커널들이 라인 그룹들을 요청할 때, 그러나 생산자 커널(K1)이 라인 그룹들을 생성할 수 있는 레이트로 라인 그룹들이 소비자 커널들로 포워딩된다. 다양한 실시예들에서, 소비자 커널들은 라인 그룹들을 순서대로 요청하고 마찬가지로 라인 그룹들을 순서대로 수신한다(커널(K2)은 C22 시점에서부터 C2N 시점까지 순서대로 라인 그룹들(902_2 내지 902_N)을 수신한다). 단순화를 위해, 특정 라인 그룹에 대해 단 하나의 생산자 커널만이 도시된다. 서로 다른 생산자들이 (예컨대, 모든 생산자들이 라인 그룹에 기록한 이후까지 소비자들이 서비스를 받는 것이 허용되지 않는) 동일한 라인 그룹에 기록하는 것을 허용하도록 다양한 실시예들이 설계될 수 있다고 생각할 수 있다.

[0086] (소비자 커널(들)이 프로세서의 DAG 처리 흐름의 첫 번째 커널들이기 때문에) 생산자 커널이 없는 경우들에, 이미지 데이터의 프레임들은 (예컨대, 직접 메모리 액세스(DMA: direct memory access)를 통해 또는 카메라로부터) 메모리(901)로 전달되고 라인 그룹들로 파싱될 수 있다. (생산자 커널이 프로세서의 전체 프로그램 흐름에서 마지막 커널이기 때문에) 소비자 커널(들)이 없는 경우들에, 결과적인 라인 그룹들이 결합되어 출력 프레임들을 형성할 수 있다.

d. 커널들의 애플리케이션 및 구조

[0087] 도 10a는 가상 환경 내에서 작성된 애플리케이션 소프트웨어가 취할 수 있는 구조 및 형태의 일례를 도시한다. 도 10a에서 확인되는 바와 같이, 프로그램 코드는 입력 이미지 데이터(1001)의 하나 또는 그보다 많은 프레임들을 처리하여 입력 이미지 데이터(1001)에 대한 어떤 전체적인 변환을 수행할 것으로 예상될 수 있다. 변환은 개발자에 의해 표현된 조직된 순서로 입력 이미지 데이터에 대해 동작하는 프로그램 코드 (1002)의 하나 또는 그보다 많은 커널들의 동작에 의해 실현된다.

[0088] 예를 들어, 도 10a에서 확인되는 바와 같이, 전체 변환은 제1 커널(K1)로 각각의 입력 이미지를 먼저 처리함으로써 수행된다. 그 다음, 커널(K1)에 의해 생성된 출력 이미지들은 커널(K2)에 의해 연산된다. 그 다음, 커널(K2)에 의해 생성된 출력 이미지들 각각은 커널(K3_1 또는 K3_2)에 의해 연산된다. 그 다음, 커널(들)(K3_1/K3_2)에 의해 생성된 출력 이미지들은 커널(K4)에 의해 연산된다. 커널들(K3_1, K3_2)은 K3 스테이지에서 병렬 처리를 도입함으로써 전체 처리 속도를 높이도록 설계된 동일한 커널들일 수 있고, 또는 서로 다른 커널들일 수 있다(예컨대, 커널(K3_1)은 제1 특정 타입의 입력 이미지들에 대해 동작하고 커널(K3_2)은 다른 제2 타입의 입력 이미지들에 대해 동작한다).

[0089] 이에 따라, 보다 큰 전체 이미지 처리 시퀀스는 이미지 처리 파이프라인 또는 방향성 비순환 그래프(DAG)의 형태를 취할 수 있고, 개발 환경은 이에 따라 개발되고 있는 프로그램 코드의 표현을 실제로 개발자에게 제시하도록 구비될 수 있다(여기서, 파이프라인은 DAG의 한 형태인 것으로 이해된다). 커널들은 개발자에 의해 개별적으로 개발할 수 있으며 그리고/또는 임의의 기반 기술을 공급하는 엔티티(이를테면, 실제 신호 프로세서 하드웨어 및/또는 그 설계)에 의해 그리고/또는 제3자(예컨대, 개발 환경용으로 작성된 커널 소프트웨어의 판매 업체)에 의해 제공될 수 있다. 이에 따라, 명목상의 개발 환경은 개발자들이 자신들의 더 큰 개발 노력의 전반적인 흐름에 영향을 주기 위해 다양한 방식들로 자유롭게 "연결(hook-up)"하는 커널들의 "라이브러리"를 포함될 것으로 예상된다. 이러한 라이브러리의 일부가 될 것으로 예상되는 일부 기본 커널들은 다음의 기본 이미지 처리 작업들: 컨볼루션들, 잡음 제거, 색 공간 변환들, 가장자리 및 모서리 탐지, 선명화, 화이트 밸런스, 감마 보정, 톤 매핑, 행렬 곱셈, 이미지 등록, 피라미드 구성, 웨이블릿 변환, 블록 단위 이산 코사인 및 푸리에 변환들 중 임의의 하나 이상을 제공할 커널들을 포함할 수 있다.

[0090] 앞서 논의한 바와 같이, 다양한 실시예들에서, 각각의 커널은 그 자체적인 스텐실 프로세서 상에서 실행된다. 예를 들어, 도 10a를 참조하면, 커널(K1)은 제1 스텐실 프로세서 상에서 실행되고, 커널(K2)은 제2 스텐실 프로세서 상에서 실행되는 식이다. 추가로, 앞서 논의한 바와 같이, 생산 및 소비 커널들은 라인 버퍼 유닛들을 통해 인터페이스한다.

[0091] 도 10b는 도 10a의 DAG 흐름을 구현하기 위해 이미지 프로세서가 어떻게 구성될 수 있는지를 도시한다. 도 10b에서 확인되는 바와 같이, 라인 버퍼 유닛(1001_1)(LBU_1)은 입력 이미지 스트림을 수신하고 수신된 프레임들을 라인 그룹들로 파싱한다. 스위칭 네트워크는 라인 그룹들을 LBU_1로부터 커널(K1)이 실행되는 제1 스텐실 프로세서(1002_1)로 라우팅하도록 구성된다. 커널(K1)로부터의 출력 이미지들은 라인 그룹들로 포맷화되어 제2 라인 버퍼 유닛(1001_2)(LBU_2)으로 포워딩된다. 그런 다음, 이러한 라인 그룹들은 커널(K2)이 실행되는 제2 스텐실 프로세서로 포워딩된다.

[0092] 도 10a로부터, 이미지 정보는 커널(K2)로부터 커널들(K3_1 또는 K3_2) 중 어느 하나로 "분할"될 수 있다. 여기서, 예컨대, 커널들(K3_1, K3_2)은 처리되고 있는 전체 이미지와 연관된 서로 다른 채널들을 처리할 수 있다. 예를 들어, 커널(K3_1)은 적색(R) 이미지들을 처리할 수 있는 한편, 커널(K3_2)은 녹색(G) 및 청색(B) 이미지들을 처리할 수 있다. 대안으로, K3_1은 시각 이미지들을 처리할 수 있는 한편, 커널(K3_2)은 (예컨대, 시각 이미지들과 함께 전파 시간 깊이 이미징 카메라로부터 얻은) 깊이 이미지들을 처리할 수 있다. 그럼에도 불구하고, 이미지의 모든 채널들은 커널들(K1, K2)에 의해 처리되지만, 이미지의 서로 다른 채널들은 서로 다른 커널들(K3_1, K3_2)로 처리된다. 또 추가로, 커널들(K3_1, K3_2)은 동일한(예컨대, 매우 수치 집약적인) 프로그램 코드의 개별 인스턴스들일 수 있고, 2개의 스텐실 프로세서들이 이를 병렬로 실행함으로써 K3 기능의 처리 속도를 높이는 데 사용된다.

[0093] 그럼에도 불구하고, 앞서 언급한 "분할"은 커널(K2)로부터의 일부 라인 그룹 이미지 정보를 제3 라인 버퍼 유닛(1001_3)(LBU_3)에 버퍼링되게 하고 커널(K2)로부터의 다른 라인 그룹 이미지 정보를 제4 라인 버퍼 유닛(1001_4)(LBU_4)으로 버퍼링되게 한다. LBU_3 라인 버퍼 유닛에 버퍼링되는 라인 그룹들은 커널(K3_1)이 실행되는 제3 스텐실 프로세서(1002_3)로 포워딩된다. LBU_4 라인 버퍼 유닛에 버퍼링되는 라인 그룹들은 커널(K3_2)이 실행되는 제4 스텐실 프로세서(1002_4)로 포워딩된다. 커널들(K3_1, K3_2)로부터의 출력 라인 그룹들은 각각 제5 라인 버퍼 유닛(1001_5)(LBU_5) 및 제6 라인 버퍼 유닛(1001_6(LBU_6))에 버퍼링된다. 그 다음, LBU_5 및 LBU_6 라인 버퍼 유닛들로부터의 라인 그룹들은 커널(K4)을 실행하는 제5 스텐실 프로세서(1002_5)로 전달된다. 분할된 라인 그룹들은 제5 스텐실 프로세서(1002_5)에서 다시 병합된다는 점에 주목한다.

[0094] 도 11a 및 도 11b는 각각의 스텐실 프로세서가 직전 스테이지로부터 라인 그룹을 수신하고 직후 스테이지를 위한 라인 그룹을 제공하는 보다 간단한 파이프라인 접근 방식에 관한 것이다. 구체적으로, 라인 버퍼 유닛들(1101_1(LBU_1), 1101_2(LBU_2), 1101_3(LBU_3), 1101_4(LBU_4))은 각각 커널들(K1, K2, K3, K4)을 각각 실행하는 스텐실 프로세서들(1102_1, 1102_2, 1102_3, 1102_4)을 공급한다. 스텐실 프로세서들(1102_1, 1102_2, 1102_3, 1102_4)은 또한 각각, 라인 버퍼 유닛들(1101_2(LBU_2), 1101_3(LBU_3), 1101_4(LBU_4), 1101_5(LBU_5))을 공급한다.

[0095] 도 11c는 본질적으로 2개의 파이프라인들을 병렬로((K1-K3-…) 및 (K2-K4-…)) 실행하는 다른 파이프라인 접근 방식을 도시한다. 이 구성은 병렬 실행(예컨대, 커널들(K1, K2)이 동일하고 커널들(K3, K4)이 동일함)을 통해 파이프라인 속도를 높이는 데 사용될 수 있거나, 이미지 데이터 콘텍스트에 따라 2개의 서로 다른 파이프라인들이 사용된다(예컨대, 하나의 파이프라인은 한 종류의 채널을 처리하고 다른 파이프라인은 다른 종류의 채널을 처리한다).

[0096] 도 11a, 도 11b 및 도 11c의 각각에서, 적절한 방식으로 스텐실 프로세서들을 소스 및 싱크 라인 그룹들에 접속하기 위해 접속 네트워크(1004/1104)에 만들어질 필요가 있을 서로 다른 구성들에 주목한다.

[0097] 다양한 실시예들에서, 이미지 프로세서는 무수히 많은 다양한 구성들(예컨대, DAG, 이미지 처리 파이프라인) 중 임의의 구성을 구현하도록 구성 정보를 유지할 (예컨대, (스칼라 프로세서의 스칼라 메모리와 같은) 구성 레지스터들 및/또는 랜덤 액세스 메모리로 구현된) 적절한 구성 공간을 포함한다. 일부 예시적인 구성 파라미터들은: 1) 소스 이미지들의 수(예컨대, 카메라 또는 더 대형 컴퓨터 시스템의 메인 메모리로부터 시스템으로 스트리밍되는 소스 이미지 프레임들의 수); 2) 라인 그룹들의 수(시스템의 라인 버퍼 유닛들 내에 구성된 라인 그룹들의 총 수); 3) 활성 스텐실 프로세서들의 수(시스템의 활성 스텐실 프로세서들의 총 수); 4) 스텐실 프로세서당 입력 라인 그룹들의 수(하나의 스텐실 프로세서가 하나보다 많은 입력 이미지 프레임을 처리할 수 있으며, Num_Input_LGs_perStencil은 본질적으로 스텐실 프로세서가 얼마나 많은 서로 다른 입력 이미지 프레임들을 처리할 것인지를 표시함); 5) 스텐실 프로세서당 출력 라인 그룹들의 수(하나의 스텐실 프로세서가 하나보다 많은 출력 이미지 프레임을 처리할 수 있으며, Num_Output_LGs_perStencil은 본질적으로 스텐실 프로세서가 얼마나 많은 서로 다른 출력 이미지 프레임들을 처리할 것인지를 표시함); 6) 라인 그룹당 소비자들의 수(각각의 라인 버퍼 유닛으로 구성된 각각의 라인 그룹에 대해, Num_Cons_per_LG는 라인 그룹이 얼마나 많은 소비자들을 갖는지를 표시함)를 포함한다. 앞서 설명한 시스템의 특징들, 구조들 또는 동작들 중 임의의 것에 기초하여 다른 타입들의 구성 정보가 시스템에 의해 수용될 수 있다.

e. 자동화된 DAG/파이프라인 코드 재구성 프로세스들

[0098] 이전 섹션들에서는 이미지 프로세서 구성 및 동작의 앞에서 언급한 기본 원리들이 설명되었고, 이 섹션은 컴파일러가 DAG의 보다 효율적인 전반적인 구현을 이루기 위해 커널들의 DAG에 대해 수행할 수 있는 특정 재구성 프로세스들을 설명한다. 위에서 암시한 바와 같이, 파이프라인은 DAG의 한 형태로 이해된다.

[0099] 여기서, 컴파일러는 특정한 비효율적이거나 아니면 문제가 있는 DAG 구조들을 인식하고 DAG를 자동으로 재구성하여 비효율성을 줄이고 그리고/또는 문제를 제거하도록 프로그래밍될 수 있다. 다양한 실시예들에서, 소프트웨어 프로그램 개발 툴은 비효율성들을 해결하기 위해 컴파일러가 아래 더 설명되는 프로그램 코드에 대한 하나 또는 그보다 많은 변환들을 수행하는 데 사용할 수 있다는 힌트들을 프로그램 개발자가 제공할 수 있게 한다.

[00100] 컴파일러에 의해 탐지되고 응답될 수 있는 DAG의 비효율성들 또는 문제들의 예들은: 1) DAG의 다른 커널들과 비교하여 특히 계산상 더 복잡한 커널; 2) 이미지 프로세서의 스텐실 프로세서들보다 더 많거나 더 적은 커널들을 포함하는 DAG; 3) 제한된 라인 버퍼 유닛 메모리 공간 및/또는 제한된 명령 메모리 공간을 포함한다(그러나 이에 국한되지는 않는다). 도 12a/도 12b/도 12c 내지 도 16은 컴파일러가 이러한 비효율성들/문제들에 대한 응답으로 구현하도록 설계될 수 있는 가능한 재구성들 중 일부를 설명한다.

[00101] 도 12a 및 도 12b는 "수평 융합" 코드 재구성에 관한 것이다. 수평 융합의 경우, 도 12a에서 확인되는 바와 같이, 예컨대, 각각이 동일한 커널로부터 흘러나오는 DAG의 다수의 커널들이 단일 커널로 병합된다. 여기서, 도 12a는 별도의 K2 커널 및 K3 커널을 갖는 원래의 코드 시퀀스(1201)를 도시한다. 컴파일러에 의한 재구성 후에, 커널들(K2, K3)이 단일 커널(K2/K3)로 결합되는 새로운 코드 시퀀스(1202)가 생성된다.

[00102] 수평 융합은 예컨대, 다른 커널들과 비교하여 DAG/파이프라인에서의 더 적은 커널들의 존재에 대한 응답으로 컴파일러에 의해 수행될 수 있다. 여기서, 커널들의 융합은 크기/계산 강도가 다른 커널들에 더 비슷한 더 큰 커널을 생성할 것이다. 선택적으로 또는 결합하여, 컴파일러는 스텐실 프로세서들보다 원래의 DAG에 더 많은 커널들이 있다는 것에 대한 응답으로 수평 융합을 수행할 수 있다. 여기서, 융합은 (이상적으로는, 더는 이미지 프로세서의 스텐실 프로세서들의 수를 초과하지 않도록) DAG에서 커널들의 총 수를 줄일 것이다.

[00103] 다양한 실시예들에서, 수평 융합은 서로 독립적인 다수의 커널들의 프로그램 코드를 병합한다(예컨대, 병합되는 2개의 커널들 중에서, 제1 커널은 제2 커널에 의해 생성된 입력 정보로서 받아들여지지 않는다). 추가로, 수평적으로 융합된 커널들은 동일한 커널로부터의 입력 정보를 받아들일 수 있고 그리고/또는 동일한 커널에 의해 소비되는 출력 정보를 제공할 수 있다. 전자는 도 12a에 예시되어 있으며, 여기서 융합된 커널들(K2, K3)은 모두 커널(K1)로부터의 입력 정보를 받아들인다.

[00104] 도 12b는 수평 융합의 구현의 일 실시예를 도시한다. 여기서, 새로 구성된 K2/K3 커널은 융합되는 커널들의 연결로서 설계된다. 즉, 도 12b의 실시예에서, 새로운 커널(K2/K3)은 커널(K2)에 대한 프로그램 코드가 실행된 직후에 실행을 시작하는 커널(K3)에 대한 프로그램 코드(1203)로 구성된다. 특히, 새로운 커널(K2/K3)은 커널들(K2, K3)의 결합과 동일한 입력 정보를 받아들이며, 커널들(K2, K3)의 결합과 동일한 출력 정보를 제공한다. 또한, 입력들은 동일한 또는 서로 다른 라인 버퍼 유닛들로부터 수신될 수 있으며, 출력들은 이들 각각의 출력들을 동일한 또는 서로 다른 라인 버퍼 유닛들에 제공할 수 있다.

[00105] 여기서, 도 12a를 참조하면, 커널(K1)이 2개의 서로 다른 라인 버퍼 유닛들(K2를 공급하는 제1 라인 버퍼 유닛 및 K3을 공급하는 제2 라인 버퍼 유닛)에 대한 라인 버퍼 데이터를 생성한다면, 프로그램 흐름의 변경은 필요 없다(커널(K2/K3)의 K2 부분은 K2에 대해 생성하는 라인 버퍼 유닛으로부터 판독하고, 커널(K2/K3)의 K3 부분은 K3에 대해 생성하는 라인 버퍼 유닛으로부터 판독한다). 두 커널들(K2, K3) 모두가 커널(K1)로부터의 동일한 데이터의 소비자들이라면(즉, 커널(K1)이 하나의 라인 버퍼 유닛에만 기록하고 K2와 K3 모두 해당 라인 버퍼 유닛으로부터 판독한다면), 또 프로그램의 데이터 흐름의 변경이 필요 없다. 이 경우, 커널(K2/K3)의 K2 부분과 K3 부분은 모두 동일한 라인 버퍼 유닛으로부터 소비한다. 비슷한 유추가 커널(K2/K3)의 출력 라인 버퍼 유닛(들)에 적용된다.

[00106] 다양한 실시예들에서, 컴파일러는 공간 레이트들(커널 호출당 처리된 픽셀들)을 의식해야 하는데, 융합된 커널들은 그 공간 레이트들에 따라 동작한다. 여기서, 융합되는 커널들은 원래 작성된 것과 반드시 동일한 레이트로 동작하는 것은 아닐 수 있다. 예를 들어, 이미지 해상도의 차이들로 인해, 커널들은 그 각각의 알고리즘들의 수행시 동일한 수의 사이클들을 소비하지 않을 수 있다. 예를 들어, 다운샘플링 커널은 다운샘플링을 하지 않는 다른 커널보다 더 많은 2차원 시프트 레지스터 시프트 연산들을 요구하는 더 넓은 이미지 영역에 걸쳐 동작해야 할 수 있다.

[00107] 결과적으로, 다운샘플링 커널은 완료 전에, 다운샘플링을 하지 않는 커널보다 더 많은 호출들을 소비한다. 예컨대, 다운샘플링 커널은 완료 전에 16개의 사이클들을 소비할 수 있지만, 비-다운샘플링 커널은 완료 전에 4개의 사이클들만을 소비할 수 있다. 완료 레이트들의 차이는 완료당 사이클들이 전체 커널의 실행 길이에 걸쳐 일정할 것으로 예상하는 라인 버퍼 유닛에 타이밍 문제들을 일으킬 수 있다. 따라서 컴파일러는 커널들이 그 각각의 알고리즘들을 완전히 실행하는 데 거의 동일한 수의 사이클들을 소비하도록 커널(들)의 코드를 수정한다. 이렇게 함으로써, 라인 버퍼는 커널 중간 실행 동안 완전히 다른 커널 알고리즘 완료 레이트로 조정해야 하는 것을 피하게 된다.

[00108] 따라서 일 실시예에서, 컴파일러는 완료당 더 적은 사이클들을 소비하는 커널에 하나 또는 그보다 많은 루프들을 추가하여 커널이 예컨대, 완료당 더 많은 사이클들을 소비하는 커널과 동일한 수의 완료당 사이클들을 소비하게 한다. 예컨대, 앞서 언급한 예에서, 비-다운샘플링 커널은 완료 전에 자신의 알고리즘의 4개의 루프들을 실행하도록 수정될 것이다. 1회의 실행 진행에 대해 그 원래 버전과 비교하여, 수정된 커널에 의해 데이터의 4배가 생성되지만, 수정된 커널은 완료 전에, 다운샘플링 커널과 동일한 16개의 사이클들을 소비할 것이다. 생각할 수 있는 바로는, 컴파일러는 모든 커널들이 레이트들을 맞출 수 있는 사이클들의 공통 지배자에 도달하도록 하나보다 많은 커널의 레이트를 수정할 수 있다.

[00109] 도 13a 내지 도 13c는 수직 융합에 관한 것이다. 수직 융합의 경우, 도 13a에서 확인되는 바와 같이, 융합되는 커널들 간에 생산자/소비자 관계가 존재한다. 예를 들어, 도 13a에서 확인되는 바와 같이, 커널(K1)은 커널(K2)에 대한 생산자이다(커널(K2)은 커널(K1)의 소비자이다). 커널에 의한 재구성 이후, 새로운 커널(K1/K2)이 생성되어, 융합된 커널들(K1, K2)의 기능을 수행한다.

[00110] 도 13b는 새로운 커널의 구성을 도시한다. 여기서는, 소비 커널(K2)이 커널(K1) 다음에 연결되어 올바른 생산자/소비자 관계를 이룬다. 새로운 커널(K1/K2)에 대한 입력은 커널(K1)에 대한 입력에 대응하고 새로운 커널(K1/K2)의 출력은 커널(K2)의 출력에 대응한다. 컴파일러는 예컨대, 융합되는 커널들이 DAG의 다른 커널들보다 계산상 덜 복잡하고 그리고/또는 이미지 프로세서 내의 스텐실 프로세서들보다 DAG에 더 많은 커널들이 존재한다는 것에 대한 응답으로 수직 융합을 도입하기로 결정할 수 있다.

[00111] 수직으로 융합된 커널의 소비 커널 부분이 그의 작업(들)을 수행하기 위해 무리 영역을 필요로 한다면, 수직 융합의 경우에 문제가 발생할 수 있다. 위의 도 4의 논의로부터, 다양한 실시예들에서 스텐실 프로세서 내의 2차원 시프트 레지스터의 치수들은 출력 픽셀 값들이 저장되는 영역 외부로 확장되는 무리 영역(409)을 수용할 수 있다는 점을 상기한다.

[00112] 여기서, 수직으로 융합된 커널의 소비 커널 부분이 무리 영역에서 내용을 필요로 한다면, 이 소비 커널 부분은 생산 커널 부분의 출력에 즉시 동작할 수 없다. 즉, 생산자에 의해 생성된 출력 데이터는 실행 레인들 "아래에" 유지될 것이고 무리 영역으로 확장되지 않을 것이다. 소비 커널 부분이 무리 영역에서 이미지 데이터를 필요로 한다면, 소비 커널 부분이 생산자 부분으로부터의 결과로서 생기는 출력에 대해 이것이 생성된 직후에 동작을 시작하는 경우에는 무리 데이터가 사용 가능하지 않을 것이다.

[00113] 해결책은 소비 커널 부분의 시작을 지연시켜, 소비 커널이 동작을 시작하는 시점까지 생산자 커널 부분에 의해 무리 영역 데이터가 생성되는 것을 보장하는 것이다. 도 13c는 해결책의 예시적인 묘사를 도시한다. 여기서, 테두리가 표시된 영역(1301)은 생산자 커널 부분의 실행 레인 영역에 대응하고, 테두리가 표시된 영역(1302)은 생산자 커널 부분의 실행 레인 영역(1301) 외부에 존재하는 무리 영역에 대응한다.

[00114] 대조적으로, 테두리가 표시된 영역(1303)은 생산자 커널 부분이 영역(1301) 내에서 출력을 생성한 후에 소비 커널 부분이 동작하고 있는 실행 레인 영역에 대응한다. 테두리가 표시된 영역(1304)은 소비자 커널 부분의 실행 레인 영역(1303) 주위에 존재하는 무리 영역에 대응한다. 도 13c는 동일한 행의 시트들에 대한 처리가 완료될 때까지 그 행의 시트들을 따라 왼쪽에서 오른쪽 방식으로 시트들에 대해 스텐실 처리가 동작한다고 가정하며, 처리의 완료시 다음 열의 시트들에 대해 처리가 개시될 것이다.

[00115] 영역(1301)과 영역(1303) 사이에 존재하는 오프셋 또는 위상 차는 소비 커널 부분에 이용 가능한 생산 커널 부분에 의해 출력이 생성될 때까지 소비 커널 부분의 시작을 지연시킴으로써 의도적으로 도입될 수 있으며, 도 13c에서 확인되는 상대적 포지셔닝 오프셋을 갖는다. 특히, 이러한 오프셋으로, 생산자 커널에 의해 생성되었고 소비 커널 부분에 이용 가능한 이미지 데이터 출력은 소비 커널 부분의 실행 레인 영역(1303)뿐만 아니라 그 무리 영역(1304)을 또한 "채운다". 이에 따라, 소비 커널 부분은 영역(1303)에 대한 출력 값들을 적절히 계산하는 데 필요한 데이터를 가지며, K1의 다음 실행이 시도되기 전에 K1에 이어지는 K2의 연결된 연산이 허용될 수 있다.

[00116] 명목상의 실시예에서, 생산자 커널은 자신의 출력 데이터를 라인 버퍼 유닛에 기록하고, 소비 커널은 동일한 라인 버퍼 유닛으로부터 데이터를 판독한다. 그러나 생산 커널 부분 및 소비 커널 부분이 현재 융합되어 동일한 스텐실 프로세서 상에서 실행되는 결과로서, 생산 커널 부분에 의해 생성된 출력 데이터는 라인 버퍼 유닛에 후기록되기보다는 스텐실 프로세서에(예컨대, 스텐실 프로세서 RAM(407) 및/또는 시트 생성기 메모리 내에) 계속 로컬로 있을 수 있다. 이에 따라, 소비 커널 부분은 라인 버퍼 유닛으로부터 데이터를 판독하기보다는, 대신에 스텐실 프로세서에 로컬인 메모리로부터 출력 데이터를 판독한다.

[00117] 따라서 스텐실 프로세서와 라인 버퍼 유닛 사이의 전체 기록/판독 시퀀스들이 회피될 수 있다. 생산 커널 부분의 출력의 다른 소비자들이 생산 커널 부분과 융합되지 않은 실시예들에서, 생산 커널 부분의 출력은 라인 버퍼 유닛에 외부적으로 기록되어 외부 소비 커널들이 생산자의 데이터를 수신할 수 있다.

[00118] 도 13c는 또한 유사한 이유들로, 스텐실 프로세서에 의해 실제로 처리되는 이미지 데이터의 치수들이 처리되고 있는 이미지의 치수들을 초과한다는 것을 보여준다. 구체적으로, 추가 공간 영역들(1305, 1306)이 생산자 커널 부분에 의해 처리되어 생산자 커널 부분이 소비자 커널 부분에 의해 요구되는 무리 데이터를 생성할 수 있다.

[00119] 도 14는 "분열 분할"로 지칭될 수 있는 다른 제약을 도시한다. 분열 분할의 경우, 더 큰 커널이 다수의 더 작은 커널들로 분해된다. 예를 들어, 도 14에서 확인되는 바와 같이, 하위 그래프들(A 내지 F)을 갖는 큰 초기 커널(K)은 2개의 커널들(K1, K2)로 분해되는데, 여기서 새로운 커널(K1)은 하위 그래프들(A 내지 D)을 포함하고 새로운 커널(K2)은 하위 그래프들(E, F)을 포함한다. 예컨대, 분할되는 커널(K)이 DAG의 다른 커널들보다 더 계산 집약적이고 그리고/또는 그 명령 풋프린트가 너무 커서 스텐실 프로세서 명령 메모리에 맞출 수 없다면, 컴파일러에 의해 분열 분할이 도입될 수 있다.

[00120] 재구성의 일부로서, 더 큰 커널 코드가 분할된 연결부에서 전체 코드에 "store_sheet" 커맨드들/명령들 및 "load_sheet" 커맨드들/명령들이 새로 삽입된다는 점에 주목한다. 구체적으로, 도 14의 예로부터, 더 큰 커널(K)이 연결부(1401)에서 분할된다는 것을 확인하면, 하위 그래프(D)의 출력은 정보의 시트를 저장하도록 수정되고 하위 그래프(E)의 입력은 정보의 시트를 로드하도록 수정된다는 점에 주목한다.

[00121] 앞서 상세히 논의한 바와 같이, 스텐실 프로세서 내에서의 2차원 시프트 레지스터 어레이의 존재 때문에, 이미지 데이터의 시트는 커널에 대한 기본 입력 데이터 구조 및 출력 데이터 구조이다. 이에 따라, 커널이 데이터 시트에 대해 동작하기 전에, 커널은 먼저 스텐실 프로세서의 2차원 레지스터 공간에 데이터 시트를 로드해야 한다. 마찬가지로, 커널이 자신의 코어 알고리즘의 1회 실행을 완료하면, 커널은 2차원 시프트 레지스터로부터의 데이터의 출력 시트를 스텐실 프로세서 RAM 및/또는 시트 생성기 RAM에 기록한다.

[00122] 이러한 기본 데이터 구조 요건들과 일치하게, 분열 분할을 도입하는 부분은 새로 생성된 커널 출력(도 14의 하위 그래프(D)의 출력) 및 새로 생성된 커널 입력(도 14의 하위 그래프(E)의 입력)이다. 전자는 2차원 시프트 레지스터 어레이로부터의 출력 데이터의 시트를 기록하기 위해 시트 저장 커맨드를 필요로 하는 한편, 후자는 2차원 시프트 레지스터 어레이로의 입력 데이터의 시트를 판독하기 위해 시트 로드 커맨드를 요구한다. Store_Sheet 커맨드 및 Load_Sheet 커맨드는 또한 커널과 라인 버퍼 유닛 간의 통신에도 또한 해당한다(라인 버퍼들은 다수의 시트들로 구성된다)는 점에 주목한다. 이에 따라, 분열 이전에는 하위 그래프(D)가 라인 버퍼 유닛을 직접 공급하지 않았던 반면에, 분열 이후에는 하위 그래프(D)가 라인 버퍼 유닛을 직접 공급한다. 마찬가지로, 분열 이전에는 하위 그래프(E)가 라인 버퍼 유닛으로부터 직접 수신하지 않았던 반면에, 분열 이후에는 하위 그래프(E)가 라인 버퍼 유닛으로부터 직접 수신할 것이다.

[00123] 일 실시예에서, 컴파일러는 새로 생성된 개개의 커널들(K1, K2)이 크기/계산 강도가 대략 동일하도록 영역 또는 더 큰 커널(K)에 분할 연결부(1401)를 도입하도록 설계된다. 일부 경우들에, 이것은 컴파일러가 반복적인 루프를 통해 분할 연결부(1401)를 도입하게 할 수 있다. 예를 들어, 하위 그래프들(D, E)은 루프가 완료될 때까지 프로그램 흐름이 하위 그래프(E)에서 다시 하위 그래프(D)로 돌아오는 루프를 구현할 수 있다.

[00124] 분할 연결부(1401)가 루프를 가로지르는 경우, 컴파일러는 루프 자체가 분할되도록 프로그램 코드를 추가로 수정한다. 여기서, 도 14에서 확인되는 분열 분할(1401)은 본질적으로 생산자/소비자 관계를 갖는 새로운 커널을 생성한다는 점에 주목한다. 즉, 새로 생성된 커널(K2)은 커널(K1)에 의해 생성된 라인 버퍼들을, 커널(K1)이 출력 라인 버퍼들을 기록하는 라인 버퍼 유닛으로부터 판독한다. 이에 따라, 루프의 선두 반복들은 K1에 의해 수행되고 루프의 후행 반복들은 K2에 의해 수행된다.

[00125] 다른 실시예에서, 컴파일러는 이전 반복들과 다음 반복들 간에 데이터 의존성을 갖는 루프들을 분할하려고 시도하지 않고, 대신 동일한 커널 내에 루프 전체를 유지한다. 이에 따라, 루프들의 존재는 컴파일러가 분할 연결부(1401)를 어디에(루프들을 거치지 않고 루프들 주위에) 도입하기로 선택하는지에 영향을 줄 수 있다.

[00126] 도 15는 "공간 분할"로 지칭되는 다른 컴파일러 재구조화 프로세스를 도시한다. 도 15에서 확인되는 바와 같이, 공간 분할은 더 큰 이미지에 대해 동작하도록 원래 설계된 커널을 이미지의 일부분에만 동작하도록 설계된 동일한 코어 알고리즘의 다수의 커널들로 복제하는 것을 수반한다.

[00127] 여기서, 도 15의 예시적인 도면에서, 원래의 커널(K1)은 전체 이미지(1501)에 대해 동작하도록 설계된다. 컴파일러는 DAG가 K1의 코드(K1_1, K1_2)의 2개의 인스턴스들을 포함하도록 본질적으로 커널(K1)을 복제한다. 컴파일러는 새로 생성된 커널들의 기본 K1 코드를, 이 커널들이 처리하기로 되어 있는 이미지의 부분만을 참조하도록 추가로 수정한다. 도 15의 예에서, 커널(K1_1)은 이미지(1501)의 좌측 절반(1501_1)에 대해서만 동작하고 커널(K1_2)은 이미지(1501)의 우측 절반(1501_2)에 대해서만 동작한다.

[00128] 이에 따라, 컴파일러는 이미지(1501) 좌측 절반(1501_1) 내에 존재하는 라인 버터 데이터만을 요청하도록 커널(K1_1)의 커널 코드를 재구성할 것이고, 이미지(1501)의 우측 절반(1501_2) 내에 존재하는 라인 버퍼 데이터만을 요청하도록 커널(K1_2)의 코드를 재구성할 것이다. 커널 소프트웨어가 라인 버퍼의 X, Y 좌표들로 라인 버퍼를 참조함으로써 라인 버퍼를 요청할 수 있다는 것을 상기하면, 다양한 실시예들에서 커널들(K1, K2)의 컴파일러의 재구성들은 커널이 처리하기로 되어 있는 이미지의 부분에 대응하는 좌표들을 특정하도록 라인 버퍼 요청들을 재포맷화하는 것을 수반한다.

[00129] 예를 들어, 커널(K1_1)은 전체 이미지의 폭에 걸친 좌표들의 요청을 피할 것이고, 이미지의 좌측 절반(1501_1)을 처리하기에 충분한 입력 라인 버퍼 데이터가 수신되면 이미지 데이터의 다음 하위 행을 대신 요청할 것이다. 마찬가지로, 처리할 라인 버퍼 데이터의 다음 하위 행을 시작하면, 커널(K1_2)은 이미지 절반에 대응하는 X 축 오프셋을 가질 것이다(예컨대, 좌표 0, Y에서 다음 하위 라인 버퍼를 요구하는 대신, 커널이 좌표 W/2, Y에서 다음 하위 라인 버퍼를 요청할 것이며, 여기서 W는 X 축에 따른 전체 이미지(1501)의 폭이다).

[00130] 요청된 라인 버퍼 데이터의 좌표 값들을 변경하는 앞서 언급한 원리들에 따라 다른 이미지 분할 배열들이 가능하다.

[00131] 일반적인 실시예에서, 원래의 커널(K1)은 단일 라인 버퍼 유닛으로부터 전체 이미지를 판독하고 그 출력 데이터를 다른 단일 라인 버퍼 유닛에 기록하도록 설계되었다. 공간 분할 후에, 커널들(K1_1, K1_2) 둘 다는 이미지 데이터가 상주하는 단일 소스 라인 버퍼 유닛을 참조할 수 있다(또는 커널들(K1_1, K1_2)에 대한 입력 이미지의 생산자 커널이 이미지의 두 사본들을 2개의 개별 라인 버퍼 유닛들에 기록하도록 재구성될 수 있는데, 이러한 라인 버퍼 유닛들로부터 커널들(K1_1, K1_2)이 개별적으로 판독한다). 그러나 도 15에서 확인되는 바와 같이, 일 실시예에서, 커널들(K1_1, K1_2) 각각은 이들의 출력 데이터를 2개의 개별 라인 버퍼 유닛들(LB_1, LB_2)에 기록한다.

[00132] 일 실시예에서는, 도 9a 및 9b와 관련하여 위에서 언급한 바와 같이, 라인 버퍼 유닛이 다수의 소비자들을 서빙할 수 있지만 하나의 생산자만을 취급할 수 있기 때문에 이러한 제약이 부과된다. 이에 따라, 단일 라인 버퍼 유닛은 커널들(K1_1, K1_2) 둘 다로부터의 출력을 처리할 수 없다(각각의 커널은 그 각자의 라인 버퍼 유닛에 기록해야 한다). 따라서 도 15에서 확인되는 바와 같이, 소비 커널(K2)은 또한 2개의 서로 다른 라인 버퍼 유닛들(LB_1은 좌측 편 이미지 데이터를 유지하고 LB_2는 우측 편 이미지 데이터를 유지함)로부터 이미지의 2개의 서로 다른 절반들에 대해 자신이 원하는 이미지 데이터를 판독하도록 공간 분할 재구성의 일부로서 재구성된다. 즉, 커널(K2)은 자신이 좌측 편 이미지를 원한다면 LB_1에 요청을 하고, 자신이 우측 편 이미지 데이터를 원한다면 LB_2에 요청을 하도록 재구성된다. 예컨대, K2의 알고리즘이 전체 이미지에 대해 동작한다면, 이미지 절반들을 단일 이미지로 병합하도록 K2가 또한 재구성될 수 있다.

[00133] 도 16은 "그래프 분할"로 지칭되는 다른 코드 재구성 프로세스에 관한 것이다. 그래프 분할의 경우, DAG에 의해 처리되는 데이터의 양은 이미지 프로세서의 내부 메모리 요건들을 초과한다. 이에 따라, DAG는 다수의 DAG들로 분할되어야 하는데, 각각의 DAG는 이미지 프로세서의 내부 저장 공간 제한들 내에 있는 양의 데이터를 처리한다. 여기서는, 다양한 실시예들에서, 라인 버퍼 유닛들, 시트 생성기들 및 스텐실 프로세서들 각각은 연관된 메모리를 갖는다. 단일 DAG의 저장 요건들이 이러한 메모리들 중 하나 또는 그보다 많은 메모리의 용량을 초과한다면, 다수의 DAG들이 생성된다.

[00134] 매우 큰 입력 이미지(1601)를 훨씬 더 작은 저밀도 출력 이미지(1607)로 반복해서 다운샘플링하는 것을 목적으로 하는 DAG(1608)가 생성되는 예가 도 16에서 확인된다. DAG/파이프라인(1608)은 6개의 커널들(K1 내지 K6)로 구성되는데, 이들 각각은 더 큰 입력 이미지를 더 작은 출력 이미지로 다운샘플링한다(예컨대, 커널(K1)은 더 큰 입력 이미지(1601)를 더 작은 이미지(1602)로 다운샘플링하고, 커널(K2)은 이미지(1602)를 더 작은 이미지(1603)로 다운샘플링하고, 커널(K3)은 이미지(1603)를 더 작은 이미지(1604)로 다운샘플링하는 식이다).

[00135] 예컨대, 초기 입력 이미지(1601)가 극히 큰 구현에서는, 모든 데이터/명령들/콘텍스트를 이미지 프로세서의 내부 메모리 공간에 맞추는 것이 가능하지 않을 수 있다. 이에 따라, 응답으로, 컴파일러는 커널들(K1 내지 K6)의 메모리 자원 요구들을 분석하고, 초기의 더 큰 DAG/파이프라인(1608)을 더 작은 DAG들/파이프라인들(1609, 1610, 1611)의 그룹으로 파싱할 것이며, 이러한 더 작은 DAG들/파이프라인들은 순차적으로 동작할 것이고 이들 각각은 이미지 프로세서 내에서 이용 가능한 것보다 더 많은 내부 메모리 자원들을 필요로 하지 않는다.

[00136] 도 1의 논의로부터, DAG는 외부 메모리로부터 라인 버퍼 유닛(들)으로의 입력 데이터의 로드에서 시작하여 라인 버퍼 유닛(들)으로부터 외부 메모리로의 출력 데이터의 기록으로 종료된다는 것을 상기한다. 따라서 도 16의 초기 DAG/파이프라인(1608)은 커널(K1)에 대한 입력에서 외부 메모리로부터 라인 버퍼 유닛(들)으로 입력 데이터를 전송하기 위한 커맨드들/명령들을 포함하였고, 커널(K6)의 출력에서 라인 버퍼 유닛(들)으로부터 외부 메모리로 출력 데이터를 전송하기 위한 커맨드들/명령들을 또한 포함하였다.

[00137] 컴파일러가 원래의 더 큰 DAG/파이프라인(1608)을 더 작은 DAG/파이프라인들(1609, 1610, 1611)로 파싱한 후에, 컴파일러는 커널들(K2, K4)의 입력들에서(즉, 새로운 더 작은 DAG/파이프라인들(1610, 1611)의 입력에서) 외부 메모리로부터 라인 버퍼 유닛(들)으로 입력 데이터를 로드하기 위한 커맨드들/명령들을 추가로 삽입할 것이다. 컴파일러는 또한 커널들(K1, K3)의 출력들에서(즉, 새로운 더 작은 DAG/파이프라인들(1609, 1610)의 출력에서) 라인 버퍼 유닛(들)으로부터 외부 메모리로 출력 데이터를 로드하기 위한 커맨드들/명령들을 삽입할 것이다. 새로운 커맨드들/명령들의 이러한 삽입들이 위치되는 경우, 원래의 DAG/파이프라인(1608)은 (동일한 DAG/파이프라인 내의 커널들은 라인 버퍼 유닛들을 통해 서로 공급/소싱하기 때문에) 외부 메모리가 아닌 라인 버퍼 유닛으로/으로부터 데이터의 기록/판독을 지정했다는 점에 주목한다. 이에 따라, 이러한 원래의 커맨드들/명령들은 컴파일러에 의해 제거될 것이다.

[00138] 설명된 재구성들 중 다양한 재구성들은 궁극적으로 위에 논의된 비효율성들 중 임의의 비효율성에 대한 응답으로 수행될 수 있다는 점에 주목한다. 예컨대, 일련의 융합들 후에, 컴파일러는 궁극적으로 그래프 분할을 수행할 수 있다.

[00139] 앞서 언급한 논의들에서, 커널들 자체는, 결국 목적 코드로 컴파일될 때 많은 브랜치들 및 연관된 기본 코드 블록들로 구성된 매우 복잡한 소프트웨어 루틴들일 수 있다는 점에 주목한다. 이에 따라, 커널들 내의 하위 그래프들은, 결국 목적 코드로 컴파일될 때 다수의 브랜치들 및 기본 목적 코드 블록들로 구성될 수 있다.

[00140] 도 17a는 앞서 논의한 바와 같이, 예컨대 컴파일러에 의해 수행되는 방법을 도시한다. 도 17a에서 확인되는 바와 같이, 이 방법은 각각의 2차원 실행 레인 및 시프트 레지스터 회로 구조들로 구성된 프로그래밍 가능 스텐실 프로세서들을 갖는 이미지 프로세서의 타깃이 되는 프로그램 코드를 컴파일하는 단계(1701)를 포함하며, 프로그램 코드는 방향성 비순환 그래프를 구현하기 위한 것이며, 상기 스텐실 프로세서들 중 각각의 스텐실 프로세서들 상에서 실행할 다수의 커널들로 구성되고, 여기서 컴파일하는 단계는: 이미지 프로세서 내의 스텐실 프로세서들과는 다른 수의 커널들이 프로그램 코드에 존재함을 인식하는 단계; 커널들 중 적어도 하나의 커널이 커널들 중 다른 하나의 커널보다 더 계산 집약적임을 인식하는 단계; 프로그램 코드가 이미지 프로세서의 메모리 용량을 초과하는 자원 요건들을 가짐을 인식하는 단계 중 임의의 단계를 포함한다. 이 방법은 또한, 앞서 언급한 인식 중 임의의 인식에 대한 응답으로: 커널들의 수평 융합; 커널들의 수직 융합; 커널들 중 하나를 다수의 커널들로 분열시키는 것; 커널을 다수의 공간적으로 분할된 커널들로 공간 분할하는 것; 방향성 비순환 그래프를 더 작은 그래프들로 분할하는 것 중 임의의 것을 수행하는 단계(1702)를 포함한다.

[00141] 도 17b는 앞서 논의한 하드웨어 특징들 중 임의의 특징을 갖는 이미지 프로세서와 같은 이미지 프로세서 상에서 실행하기 위한 프로그램 코드를 컴파일할 때 앞서 언급한 컴파일러 프로세스들 중 임의의 프로세스로 사용될 수 있는 애플리케이션 소프트웨어 개발 및 시뮬레이션 환경(1721)을 도시한다. 여기서, 개발자는 의도된 전반적인 이미지 변환과 일치하는 전략적 시퀀스로 커널들을 배열함으로써 포괄적인 이미지 처리 기능(예컨대, 파이프라인의 각각의 단계가 전용 이미지 처리 작업을 수행하는 이미지 처리 파이프라인, 루틴들의 다른 어떤 DAG 규정 세트 등)을 개발할 수 있다. 커널들은 라이브러리(1722)로부터 호출될 수 있으며 그리고/또는 개발자는 하나 또는 그보다 많은 커스텀 커널들을 개발할 수 있다.

[00142] 라이브러리(1722) 내의 커널들은 커널들의 제3자 판매 업체 및/또는 임의의 기반 기술의 제공자(예컨대, 타깃이 되는 하드웨어 이미지 프로세서를 포함하는 하드웨어 플랫폼의 판매 업체 또는 (예컨대, 그 설계로서 또는 실제 하드웨어로서 제공되는) 타깃이 되는 하드웨어 이미지 프로세서의 판매 업체)에 의해 제공될 수 있다.

[00143] 커스텀 개발된 커널들의 경우에, 많은 상황들에서, 개발자는 단일 스레드(1723)에 대한 프로그램 코드를 작성할 필요가 있을 뿐이다. 즉, 개발자는 (예컨대, 앞서 언급한 위치 상대적인 메모리 액세스 명령 포맷을 갖는) 출력 픽셀 위치에 대한 입력 픽셀 값들을 참조함으로써 단일 출력 픽셀 값을 결정하는 프로그램 코드를 작성할 필요만 있을 뿐이다. 단일 스레드(1723)의 동작의 충족시, 개발 환경은 다음에, 각각의 가상 프로세서 상에서 스레드 코드의 다수의 인스턴스들을 자동으로 인스턴스화하여, 이미지 표면 영역 상에서 동작하는 프로세서들의 어레이 상에서 커널을 실행시킬 수 있다. 이미지 표면 영역은 (라인 그룹과 같은) 이미지 프레임의 섹션일 수 있다.

[00144] 다양한 실시예들에서, 커스텀 스레드 프로그램 코드는 가상 프로세서 ISA의 목적 코드(또는 가상 프로세서 ISA 목적 코드로 컴파일 다운되는 더 상위 레벨의 언어)로 작성된다. 커스텀 커널의 프로그램 코드의 실행 시뮬레이션은 메모리 모델에 따라 구조화된 메모리에 액세스하는 가상 프로세서를 포함하는 시뮬레이션된 런타임 환경에서 수행될 수 있다. 여기서, 가상 프로세서의 소프트웨어 모델들(객체 지향 또는 기타)(1724) 및 모델을 통합하는 메모리(1725)가 인스턴스화된다.

[00145] 그 다음, 가상 프로세서 모델(1724)은 스레드 코드(1723)의 실행을 시뮬레이션한다. 스레드, 스레드의 더 큰 커널 및 커널이 속하는 임의의 더 큰 기능의 성능의 충족시, 전체가 기반 하드웨어의 실제 목적 코드로 컴파일된다. 시뮬레이션 환경(1721)의 전체는 컴퓨팅 시스템(예컨대, 워크스테이션)(1726) 상에서 실행되는 소프트웨어로서 구현될 수 있다.

f. 구현 실시예들

[00146] 앞서 설명한 다양한 이미지 프로세서 아키텍처 특징들은 반드시 종래의 의미에서의 이미지 처리로 제한되는 것은 아니며, 따라서 이미지 프로세서가 다시 특성화되게 할 수 있는(또는 다시 특성화되게 하지 않을 수 있는) 다른 애플리케이션들에 적용될 수 있다는 점을 지시하는 것이 적절하다. 예를 들어, 앞서 설명한 다양한 이미지 프로세서 아키텍처 특징들 중 임의의 특징이 실제 카메라 이미지들의 처리와는 대조적으로 애니메이션의 생성 및/또는 발생 및/또는 렌더링에 사용된다면, 이미지 프로세서는 그래픽 처리 유닛으로서 특성화될 수 있다. 추가로, 앞서 설명한 이미지 프로세서 아키텍처 특징들은 비디오 처리, 비전 처리, 이미지 인식 및/또는 기계 학습과 같은 다른 기술적 애플리케이션들에 적용될 수 있다. 이런 식으로 적용되면, 이미지 프로세서는 (예컨대, 컴퓨팅 시스템의 CPU이거나 그 일부인) 보다 범용적인 프로세서와 (예컨대, 보조 프로세서(co-processor)로서) 통합될 수 있거나, 컴퓨팅 시스템 내의 독립형 프로세서일 수 있다.

[00147] 앞서 논의한 하드웨어 설계 실시예들은 반도체 칩 내에서 그리고/또는 반도체 제조 프로세스를 향한 최종 타깃화를 위한 회로 설계의 기술(description)로서 구현될 수 있다. 후자의 경우, 이러한 회로 기술들은 (예컨대, VHDL 또는 Verilog) 레지스터 전송 레벨(RTL: register transfer level) 회로 기술, 게이트 레벨 회로 기술, 트랜지스터 레벨 회로 기술 또는 마스크 기술, 또는 이들의 다양한 결합들의 형태를 취할 수 있다. 회로 기술들은 일반적으로 (CD-ROM 또는 다른 타입의 저장 기술과 같은) 컴퓨터 판독 가능 저장 매체 상에 구현된다.

[00148] 이전 섹션들로부터, 앞서 설명한 바와 같은 이미지 프로세서는 (예컨대, 핸드헬드 디바이스의 카메라로부터의 데이터를 처리하는 핸드헬드 디바이스의 시스템 온 칩(SOC: System on Chip)의 일부로서) 컴퓨터 시스템 상의 하드웨어로 구현될 수 있음을 인식하는 것이 적절하다. 이미지 프로세서가 하드웨어 회로로서 구현되는 경우들에, 이미지 프로세서에 의해 처리되는 이미지 데이터는 카메라로부터 직접 수신될 수 있다는 점에 주목한다. 여기서, 이미지 프로세서는 개별 카메라의 일부이거나, 통합된 카메라를 갖는 컴퓨팅 시스템의 일부일 수 있다. 후자의 경우에, 이미지 데이터는 카메라로부터 또는 컴퓨팅 시스템의 시스템 메모리로부터 직접 수신될 수 있다(예컨대, 카메라는 자신의 이미지 데이터를 이미지 프로세서가 아닌 시스템 메모리로 전송한다). 이전 섹션들에서 설명한 특징들 중 다수는 (애니메이션을 렌더링하는) 그래픽 프로세서 유닛에 적용 가능할 수 있다는 점에 또한 주목한다.

[00149] 도 18은 컴퓨팅 시스템의 예시적인 도시를 제공한다. 아래에서 설명되는 컴퓨팅 시스템의 컴포넌트들 중 다수는 통합된 카메라 및 연관된 이미지 프로세서(예컨대, 스마트폰 또는 태블릿 컴퓨터와 같은 핸드헬드 디바이스)를 갖는 컴퓨팅 시스템에 적용 가능하다. 당해 기술분야에서 통상의 지식을 가진 자들은 이 두 가지를 쉽게 파악할 수 있을 것이다. 추가로, 도 18의 컴퓨팅 시스템은 또한, 도 17c와 관련하여 앞서 논의한 개발 환경을 구현하는 데 사용되는 워크스테이션과 같은 고성능 컴퓨팅 시스템의 많은 특징들을 포함한다.

[00150] 도 18에서 확인되는 바와 같이, 기본 컴퓨팅 시스템은 (예컨대, 멀티 코어 프로세서 또는 애플리케이션 프로세서 상에 배치된 복수의 범용 프로세싱 코어들(1815_1 내지 1815_N) 및 메인 메모리 제어기(1817)를 포함할 수 있는) 중앙 처리 유닛(1801), 시스템 메모리(1802), 디스플레이(1803)(예컨대, 터치 스크린, 평면 패널), 로컬 유선 점대점 링크(예컨대, USB) 인터페이스(1804), (이더넷 인터페이스 및/또는 셀룰러 모뎀 서브시스템과 같은) 다양한 네트워크 I/O 기능들(1805), 무선 근거리 네트워크(예컨대, WiFi) 인터페이스(1806), 무선 점대점 링크(예컨대, 블루투스) 인터페이스(1807) 및 글로벌 포지셔닝 시스템 인터페이스(1808), 다양한 센서들(1809_1 내지 1809_N), 하나 또는 그보다 많은 카메라들(1810), 배터리(1811), 전력 관리 제어 유닛(1812), 스피커 및 마이크로폰(1813) 그리고 오디오 코더/디코더(1814)를 포함할 수 있다.

[00151] 애플리케이션 프로세서 또는 멀티 코어 프로세서(1850)는 자신의 CPU(1801) 내의 하나 또는 그보다 많은 범용 프로세싱 코어들(1815), 하나 또는 그보다 많은 그래픽 처리 유닛들(1816), 메모리 관리 기능(1817)(예컨대, 메모리 제어기), I/O 제어 기능(1818) 및 이미지 처리 유닛(1819)을 포함할 수 있다. 범용 프로세싱 코어(1815)는 일반적으로 컴퓨팅 시스템의 운영 시스템 및 애플리케이션 소프트웨어를 실행한다. 그래픽 처리 유닛들(1816)은 일반적으로 그래픽 집중 기능들을 실행하여, 예컨대 디스플레이(1803) 상에 제시되는 그래픽 정보를 생성한다. 메모리 제어 기능(1817)은 시스템 메모리(1802)와 인터페이스하여 시스템 메모리(1802)로/로부터 데이터를 기록/판독한다. 전력 관리 제어 유닛(1812)은 일반적으로 시스템(1800)의 전력 소비를 제어한다.

[00152] 이미지 처리 유닛(1819)은 이전 섹션들에서 앞서 상세히 설명한 이미지 처리 유닛 실시예들 중 임의의 실시예에 따라 구현될 수 있다. 대안으로 또는 결합하여, IPU(1819)는 GPU(1816) 및 CPU(1801) 중 어느 하나 또는 둘 다에 이들의 보조 프로세서로서 연결될 수 있다. 추가로, 다양한 실시예들에서, GPU(1816)는 앞서 상세히 설명한 이미지 프로세서 특징들 중 임의의 특징으로 구현될 수 있다.

[00153] 터치 스크린 디스플레이(1803), 통신 인터페이스들(1804-1807), GPS 인터페이스(1808), 센서들(1809), 카메라(1810) 및 스피커/마이크로폰 코덱(1813, 1814) 각각은 모두, 적절한 경우에는, 통합된 주변 디바이스들(예컨대, 하나 또는 그보다 많은 카메라(1810))을 또한 포함하는 전체 컴퓨팅 시스템에 대한 다양한 형태들의 I/O(입력 및/또는 출력)로서 보일 수 있다. 구현에 따라, 이러한 I/O 컴포넌트들 중 다양한 컴포넌트들은 애플리케이션 프로세서/멀티 코어 프로세서(1850) 상에 통합될 수 있거나 다이에서 벗어나 또는 애플리케이션 프로세서/멀티 코어 프로세서(1850)의 패키지 외부에 위치될 수 있다.

[00154] 일 실시예에서, 하나 또는 그보다 많은 카메라들(1810)은 그 시야에서 카메라와 객체 사이의 심도를 측정할 수 있는 심도 카메라를 포함한다. 애플리케이션 프로세서 또는 다른 프로세서의 범용 CPU 코어(또는 프로그램 코드를 실행하기 위한 명령 실행 파이프라인을 갖는 다른 기능 블록) 상에서 실행되는 애플리케이션 소프트웨어, 운영 시스템 소프트웨어, 디바이스 드라이버 소프트웨어 및/또는 펌웨어는 앞서 설명한 기능들 중 임의의 기능을 수행할 수 있다.

[00155] 본 발명의 실시예들은 위에서 제시된 바와 같은 다양한 프로세스들을 포함할 수 있다. 프로세스들은 기계 실행 가능 명령들로 구현될 수 있다. 명령들은 범용 또는 특수 목적 프로세서가 특정 프로세스들을 수행하게 하는 데 사용될 수 있다. 대안으로, 이러한 프로세스들은 프로세스들을 수행하기 위한 하드와이어드 및/또는 프로그래밍 가능 로직을 포함하는 특정 하드웨어 컴포넌트들에 의해, 또는 프로그래밍된 컴퓨터 컴포넌트들과 커스텀 하드웨어 컴포넌트들의 임의의 결합에 의해 수행될 수 있다.

[00156] 본 발명의 엘리먼트들은 또한 기계 실행 가능 명령들을 저장하기 위한 기계 판독 가능 매체로서 제공될 수 있다. 기계 판독 가능 매체는 플로피 디스켓들, 광 디스크들, CD-ROM들 및 광자기 디스크들, 플래시 메모리, ROM들, RAM들, EPROM들, EEPROM들, 자기 또는 광학 카드들, 전파 매체들, 또는 전자 명령들을 저장하기에 적합한 다른 타입의 매체/기계 판독 가능 매체를 포함할 수 있지만 이에 한정된 것은 아니다. 예를 들어, 본 발명은 통신 링크(예컨대, 모뎀 또는 네트워크 접속)를 통해 반송파 또는 다른 전파 매체로 구현된 데이터 신호들에 의해 원격 컴퓨터(예컨대, 서버)로부터 요청 컴퓨터(예컨대, 클라이언트)로 전송될 수 있는 컴퓨터 프로그램으로서 다운로드될 수 있다.

[00157] 상기한 명세서에서, 본 발명은 이들의 특정한 예시적인 실시예들을 참조로 설명되었다. 그러나 첨부된 청구항들에서 제시되는 바와 같은, 본 발명의 보다 넓은 사상 및 범위를 벗어나지 않으면서 이에 대해 다양한 수정들 및 변경들이 이루어질 수 있음이 명백할 것이다. 명세서 및 도면들은 이에 따라, 제한적인 의미보다는 예시적인 의미로 여겨져야 한다.

Claims

컴퓨팅 시스템에 의해 프로세싱될 때, 상기 컴퓨팅 시스템으로 하여금 동작들을 수행하게 하는 프로그램 코드가 저장된 하나 이상의 비-일시적 기계 판독가능 저장 매체로서, 상기 동작들은:
프로그래밍 가능 스텐실(stencil) 프로세서들을 갖는 이미지 프로세서의 타깃이 되는 프로그램 코드를 컴파일하는 동작을 포함하고,
각각의 스텐실 프로세서는 개별적인 2차원 실행 레인(lane) 및 시프트 레지스터 회로 구조들을 포함하고,
상기 프로그램 코드는 방향성 비순환 그래프(directed acyclic graph)를 구현하고, 상기 스텐실 프로세서들 중 개별적인 스텐실 프로세서들 상에서 실행되도록 초기에 할당되는 다수의 커널들을 포함하며,
그래프 내의 노드들 사이의 각각의 에지는 특정 라인 버퍼를 참조하는 하나의 커널의 하나 이상의 저장 명령들 및 동일한 특정 라인 버퍼를 참조하는 다른 커널의 하나 이상의 로드 명령들에 의해 구현되고,
상기 컴파일하는 동작은:
상기 방향성 비순환 그래프를 다수의 방향성 비순환 그래프들로 분할하는 동작;
그래프 내의 제1 커널 및 제2 커널의 수평 융합을 수행하는 동작 ― 상기 수평 융합을 수행하는 동작은, 상기 제1 커널 및 상기 제2 커널 둘 다로부터의 명령들을 갖는 수평적으로 융합된 커널들의 명령들을 생성하는 동작을 포함하고, 상기 제1 커널은 상기 제2 커널 보다 더 적은 사이클들을 소비함 ―; 및
상기 제1 커널 및 상기 제2 커널에 의해 각각 소비되는 사이클들 간의 차이를 감소시키기 위해, 상기 제1 커널에 하나 이상의 루프들을 추가하는 동작을 포함하는,
하나 이상의 비-일시적 기계 판독가능 저장 매체.
제1 항에 있어서,
상기 수평적으로 융합된 커널의 명령들을 생성하는 동작은, 상기 제1 커널의 다수의 명령들이 상기 제2 커널의 다수의 명령들을 선행하거나, 또는 상기 제2 커널의 다수의 명령들이 상기 제1 커널의 다수의 명령들을 선행하도록 하는 명령들을 생성하는 동작을 포함하는,
하나 이상의 비-일시적 기계 판독가능 저장 매체.
삭제
삭제
제1 항에 있어서,
상기 동작들은 상기 그래프 내의 생산 커널 및 소비 커널의 수직 융합을 수행하는 동작을 더 포함하고,
상기 수직 융합을 수행하는 동작은, 상기 생산 커널이 상기 소비 커널에 대한 무리(halo) 영역에 대한 데이터를 생성한 이후까지 상기 소비 커널의 시작을 지연시키기 위한 프로그램 코드를 추가하는 동작을 포함하는,
하나 이상의 비-일시적 기계 판독가능 저장 매체.
삭제
제1 항에 있어서,
상기 프로그램 코드를 컴파일하는 동작은, 커널들보다 더 많은 스텐실 프로세서들이 존재하는 실행 환경에 대해 상기 프로그램 코드를 컴파일하는 동작을 포함하는,
하나 이상의 비-일시적 기계 판독가능 저장 매체.
제1 항에 있어서,
상기 동작들은 상기 그래프 내의 특정 커널 상에 다수의 공간적으로 분할된 커널들로 공간 분할을 수행하는 동작을 더 포함하고,
상기 공간 분할을 수행하는 동작은, 상기 다수의 공간적으로 분할된 커널들이 상이한 개별 이미지 부분들을 참조하도록 상기 특정 커널의 상기 로드 명령들의 X, Y 좌표 값들을 조정하는 동작을 포함하는,
하나 이상의 비-일시적 기계 판독가능 저장 매체.
삭제
삭제
컴퓨터-구현 방법으로서,
프로그래밍 가능 스텐실 프로세서들을 갖는 이미지 프로세서의 타깃이 되는 프로그램 코드를 컴파일하는 단계를 포함하고,
각각의 스텐실 프로세서는 개별적인 2차원 실행 레인 및 시프트 레지스터 회로 구조들을 포함하고,
상기 프로그램 코드는 방향성 비순환 그래프를 구현하고, 그리고 상기 스텐실 프로세서들 중 개별적인 스텐실 프로세서들 상에서 실행되도록 초기에 할당되고 개별적인 다수의 명령들을 가지는 다수의 커널들을 포함하며,
그래프 내의 노드들 사이의 각각의 에지는 특정 라인 버퍼를 참조하는 하나의 커널의 하나 이상의 저장 명령들 및 동일한 특정 라인 버퍼를 참조하는 다른 커널의 하나 이상의 로드 명령들에 의해 구현되고,
상기 컴파일하는 단계는:
상기 방향성 비순환 그래프를 다수의 방향성 비순환 그래프들로 분할하는 단계;
그래프 내의 제1 커널 및 제2 커널의 수평 융합을 수행하는 단계 ― 상기 수평 융합을 수행하는 단계는, 상기 제1 커널 및 상기 제2 커널 둘 다로부터의 명령들을 갖는 수평적으로 융합된 커널의 명령들을 생성하는 단계를 포함하고, 상기 제1 커널은 상기 제2 커널 보다 더 적은 사이클들을 소비함 ―; 및
상기 제1 커널 및 상기 제2 커널에 의해 각각 소비되는 사이클들 간의 차이를 감소시키기 위해, 상기 제1 커널에 하나 이상의 루프들을 추가하는 단계를 포함하는,
컴퓨터-구현 방법.
제11 항에 있어서,
상기 수평적으로 융합된 커널의 명령들을 생성하는 단계는, 상기 제1 커널의 다수의 명령들이 상기 제2 커널의 다수의 명령들을 선행하거나, 또는 상기 제2 커널의 다수의 명령들이 상기 제1 커널의 다수의 명령들을 선행하도록 하는 명령들을 생성하는 단계를 포함하는,
컴퓨터-구현 방법.
제11 항에 있어서,
상기 그래프 내의 생산 커널 및 소비 커널의 수직 융합을 수행하는 단계를 더 포함하고,
상기 수직 융합을 수행하는 단계는, 상기 생산 커널이 상기 소비 커널에 대한 무리 영역에 대한 데이터를 생성한 이후까지 상기 소비 커널의 시작을 지연시키기 위한 프로그램 코드를 추가하는 단계를 포함하는,
컴퓨터-구현 방법.
제11 항에 있어서,
상기 그래프의 상기 다수의 커널들 중 원래의 커널의 복수의 분할 커널들로의 분열을 수행하는 단계를 더 포함하고,
각각의 분할 커널은 상기 원래의 커널의 다수의 명령들 중 명령들의 서브세트를 포함하고,
분열은, 제1 분할 커널의 출력을 저장하기 위해 이미지 프로세서 외부의 메모리를 참조하는 저장 명령을 추가하는 것, 및 상기 제1 분할 커널의 출력을 로드하기 위해 제2 분할 커널의 명령들에 상기 이미지 프로세서 외부의 메모리를 참조하는 로드 명령을 추가하는 것을 포함하는,
컴퓨터-구현 방법.
제11 항에 있어서,
상기 그래프 내의 특정 커널 상에 다수의 공간적으로 분할된 커널들로 공간 분할을 수행하는 단계를 더 포함하고,
상기 공간 분할을 수행하는 단계는, 상기 다수의 공간적으로 분할된 커널들이 상이한 개별 이미지 부분들을 참조하도록 상기 특정 커널의 상기 로드 명령들의 X, Y 좌표 값들을 조정하는 단계를 포함하는,
컴퓨터-구현 방법.
삭제
시스템으로서,
명령들이 저장된 하나 이상의 저장 디바이스들 및 하나 이상의 컴퓨터들을 포함하고,
상기 명령들은, 상기 하나 이상의 컴퓨터들에 의해 실행될 때 상기 하나 이상의 컴퓨터들로 하여금 동작들을 수행하게 하도록 동작 가능하고, 상기 동작들은:
프로그래밍 가능 스텐실 프로세서들을 갖는 이미지 프로세서의 타깃이 되는 프로그램 코드를 컴파일하는 동작을 포함하고,
각각의 스텐실 프로세서는 개별적인 2차원 실행 레인 및 시프트 레지스터 회로 구조들을 포함하고,
상기 프로그램 코드는 방향성 비순환 그래프를 구현하고, 그리고 상기 스텐실 프로세서들 중 개별적인 스텐실 프로세서들 상에서 실행되도록 초기에 할당되고 개별적인 다수의 명령들을 가지는 다수의 커널들을 포함하며,
그래프 내의 노드들 사이의 각각의 에지는 특정 라인 버퍼를 참조하는 하나의 커널의 하나 이상의 저장 명령들 및 동일한 특정 라인 버퍼를 참조하는 다른 커널의 하나 이상의 로드 명령들에 의해 구현되고,
상기 컴파일하는 동작은:
상기 방향성 비순환 그래프를 다수의 방향성 비순환 그래프들로 분할하는 동작;
그래프 내의 제1 커널 및 제2 커널의 수평 융합을 수행하는 동작 ― 상기 수평 융합을 수행하는 동작은, 상기 제1 커널 및 상기 제2 커널 둘 다로부터의 명령들을 갖는 수평적으로 융합된 커널의 명령들을 생성하는 동작을 포함하고, 상기 제1 커널은 상기 제2 커널 보다 더 적은 사이클들을 소비함 ―; 및
상기 제1 커널 및 상기 제2 커널에 의해 각각 소비되는 사이클들 간의 차이를 감소시키기 위해, 상기 제1 커널에 하나 이상의 루프들을 추가하는 동작을 포함하는,
시스템.
제17 항에 있어서,
상기 동작들은 상기 그래프 내의 특정 커널 상에 다수의 공간적으로 분할된 커널들로 공간 분할을 수행하는 동작을 더 포함하고,
상기 공간 분할을 수행하는 동작은, 상기 다수의 공간적으로 분할된 커널들이 상이한 개별 이미지 부분들을 참조하도록 상기 특정 커널의 상기 로드 명령들의 X, Y 좌표 값들을 조정하는 동작을 포함하는,
시스템.
삭제
삭제
제1 항에 있어서,
컴파일링 후의 상기 프로그램 코드는, 상기 이미지 프로세서 내부의 라인 버퍼들을 사용하는 상기 그래프의 일부 에지들 및 상기 이미지 프로세서 외부의 메모리를 사용하는 상기 그래프의 일부 에지들을 구현하는,
하나 이상의 비-일시적 기계 판독가능 저장 매체.
제11 항에 있어서,
컴파일링 후의 상기 프로그램 코드는, 상기 이미지 프로세서 내부의 라인 버퍼들을 사용하는 상기 그래프의 일부 에지들 및 상기 이미지 프로세서 외부의 메모리를 사용하는 상기 그래프의 일부 에지들을 구현하는,
컴퓨터-구현 방법.
제17 항에 있어서,
컴파일링 후의 상기 프로그램 코드는, 상기 이미지 프로세서 내부의 라인 버퍼들을 사용하는 상기 그래프의 일부 에지들 및 상기 이미지 프로세서 외부의 메모리를 사용하는 상기 그래프의 일부 에지들을 구현하는,
시스템.
제1 항에 있어서,
상기 방향성 비순환 그래프를 다수의 방향성 비순환 그래프들로 분할하는 동작은, 상기 프로그래밍 가능 스텐실 프로세서들과 연관된 메모리의 용량을 초과하는 상기 방향성 비순환 그래프에 의해 프로세싱되는 이미지 데이터 양의 결과인,
하나 이상의 비-일시적 기계 판독가능 저장 매체.
제1 항에 있어서,
상기 방향성 비순환 그래프를 다수의 방향성 비순환 그래프들로 분할하는 동작은, 상기 이미지 프로세서 내 프로그래밍 가능 스텐실 프로세서들의 수를 초과하는 다수의 커널들의 수의 결과인,
하나 이상의 비-일시적 기계 판독가능 저장 매체.
제11 항에 있어서,
상기 프로그램 코드를 컴파일하는 단계는, 커널들보다 더 많은 스텐실 프로세서들이 존재하는 실행 환경에 대해 상기 프로그램 코드를 컴파일하는 단계를 포함하는,
컴퓨터-구현 방법.
제17 항에 있어서,
상기 프로그램 코드를 컴파일하는 동작은, 커널들보다 더 많은 스텐실 프로세서들이 존재하는 실행 환경에 대해 상기 프로그램 코드를 컴파일하는 동작을 포함하는,
시스템.
제17 항에 있어서,
상기 수평적으로 융합된 커널의 명령들을 생성하는 동작은, 상기 제1 커널의 다수의 명령들이 상기 제2 커널의 다수의 명령들을 선행하거나, 또는 상기 제2 커널의 다수의 명령들이 상기 제1 커널의 다수의 명령들을 선행하도록 하는 명령들을 생성하는 동작을 포함하는,
시스템.
제17 항에 있어서,
상기 동작들은 상기 그래프 내의 생산 커널 및 소비 커널의 수직 융합을 수행하는 동작을 더 포함하고,
상기 수직 융합을 수행하는 동작은, 상기 생산 커널이 상기 소비 커널에 대한 무리 영역에 대한 데이터를 생성한 이후까지 상기 소비 커널의 시작을 지연시키기 위해 프로그램 코드를 상기 소비 커널에 추가하는 동작을 포함하는,
시스템.