KR20130112009A

KR20130112009A - 벡터 분할 루프들의 성능 향상

Info

Publication number: KR20130112009A
Application number: KR1020130035807A
Authority: KR
Inventors: 제프리 이. 고니온
Original assignee: 애플 인크.
Priority date: 2012-04-02
Filing date: 2013-04-02
Publication date: 2013-10-11
Also published as: JP2013254484A; EP2648090A3; CN103383640B; CN103383640A; TW201403470A; BR102013007865A2; US9116686B2; US20130262833A1; WO2013151861A1; KR101511837B1; EP2648090A2; TWI512617B

Abstract

벡터 분할 루프(vector partitioning loop)에서 사용된 후방 분기 명령(backward branch instruction)의 예측을 억제하기 위한 방법은 술어 생성 명령(predicate generating instruction) 이후에 발생하는 제1 후방 분기 명령을 검출하는 단계를 포함한다. 술어 생성 명령은, 의존성 벡터(dependency vector)의 각 요소가 벡터 명령의 요소들 사이에 데이터 의존성이 존재하는지 여부를 표시하는 의존성 벡터에 의존하는 술어 벡터(predicate vector)를 생성한다. 방법은 또한 후방 분기 명령의 예측의 예측 정확도의 표시를 수신하는 단계를 포함한다. 예측 정확도가 임계 값을 만족하지 못하는 경우에, 술어 생성 명령이 의존하는 의존성 벡터가 사용가능할 때까지 후방 분기 명령의 예측이 억제된다.

Description

벡터 분할 루프들의 성능 향상{IMPROVING PERFORMANCE OF VECTOR PARTITIONING LOOPS}

본 발명은 프로세서들에 관한 것으로, 특히, 벡터 분할 루프들(vector partitioning loops)의 실행 동안 특정 분기 명령들(branch instructions)의 예측에 관한 것이다.

분기 예측(branch prediction)은 현대의 대부분의 프로세서들에서 보편화되었다. 많은 경우에 후방 분기들(backward branches)은 많이 예측가능한 것일 수 있지만, 일부 후방 분기들은 종래의 분기 예측자들에 의해 제대로 예측될 수 없다. 특히, 매크로스칼라(Macroscalar) 프로세서들 및 컴파일러들은, 예를 들어, 메모리 해저드(memory hazards)와 같은 가능한 루프-전이 의존성들(possible loop carried dependencies)을 정확하게 처리하는 벡터 분할 루프들에 의지한다. 벡터 분할 루프들은 루프에서 반복하는 후방 분기들(backward branches)을 사용한다. 벡터가 자주 분할되는 경우에, 종래의 분기 예측자는 제대로 수행할 수 없어, 프로세서 성능에 악영향을 미칠 수 있다.

벡터-분할 루프에서 사용된 후방 분기 명령의 예측을 억제하기 위한 방법에 대한 다양한 실시예들이 개시된다. 광범위하게 말해서, 술어 생성 명령(predicate generating instruction) 이후에 발행하는 제1 후방 분기 명령이 검출되는 방법이 고려된다. 술어 생성 명령은, 의존성 벡터(dependency vector)의 각 요소가 벡터 명령의 요소들 사이에 데이터 의존성이 존재하는지 여부를 표시하는 의존성 벡터에 의존하는 술어 벡터(predicate vector)를 생성한다. 후방 분기 명령의 예측의 예측 정확도에 대한 수신된 표시가 임계값을 만족하지 못하는 경우에, 술어 생성 명령이 의존하는 의존성 벡터가 사용가능하게 될 때까지 후방 분기 명령의 예측은 억제될 수 있다.

하나의 실시예에서, 방법은 술어 생성 명령을 뒤따르는 제1 조건부 분기 명령을 검출하는 단계를 포함한다. 술어 생성 명령은, 실행될 때, 의존성 벡터에 의존하는 술어 벡터를 생성한다. 의존성 벡터의 각 요소는 벡터 명령의 요소들 사이에 데이터 의존성이 존재하는지 여부를 표시하는 인덱스를 포함한다. 또한, 방법은 제1 조건부 분기 명령의 예측 정확도에 대한 표시를 수신하는 단계를 포함할 수 있다. 제1 조건부 분기 명령의 예측 정확도가 임계값을 만족하지 못한다는 결정에 응답하여, 술어 생성 명령이 의존하는 의존성 벡터가 사용가능하게 될 때까지 제1 조건부 분기 명령의 예측은 억제될 수 있다.

하나의 특정 구현에서, 방법은, 의존성 벡터에 표시된 데이터 의존성 정보를 사용하여, 의존성 벡터가 사용가능하다는 검출에 응답하여 제1 조건부 분기 명령을 예측하는 단계 또한 포함할 수 있다.

도 1은 컴퓨터 시스템에 대한 하나의 실시예의 블록 다이어그램이다.
도 2는 도 1에 도시된 프로세서에 대한 실시예의 추가 상세들을 도시하는 블록 다이어그램이다.
도 3은 프로그램 코드 루프의 예제 병렬화를 도시하는 다이어그램이다.
도 4a는 예제 1에 도시된 루프의 스칼라 실행 동안 가변 상태들에 대한 시퀀스를 도시하는 다이어그램이다.
도 4b는 예제 1의 루프의 매크로스칼라 벡터화된 프로그램 코드(Macroscalar vectorized program code)에 대한 실행의 진행을 도시하는 다이어그램이다.
도 5a 및 도 5b는 프로그램 소스 코드의 벡터화에 대한 하나의 실시예를 도시하는 다이어그램이다.
도 6a는 추측에 근거하지 않은(non-speculative) 벡터화된 프로그램 코드에 대한 하나의 실시예를 도시하는 다이어그램이다.
도 6b는 추측에 근거한 벡터화된 프로그램 코드에 대한 또 다른 실시예를 도시하는 다이어그램이다.
도 7은 벡터화된 프로그램 코드에 대한 하나의 실시예를 도시하는 다이어그램이다.
도 8은 벡터화된 프로그램 코드에 대한 또 다른 실시예를 도시하는 다이어그램이다.
도 9는 벡터-분할 루프를 형성하는 프로그램 명령들의 실행 동안 도 2의 프로세서의 하나의 실시예의 동작을 도시하는 흐름 다이어그램이다.

특정 실시예들이 도면들에 예로서 도시되고 여기에 자세히 설명될 것이다. 하나의 특정한 특징에 대하여 단지 단 하나의 실시예만 설명되지만, 도면들 및 상세한 설명은 개시된 특정한 실시예들로 청구항들을 제한하기 위해 의도된 것이 아니라는 것을 이해해야 한다. 그와는 반대로, 본 발명의 혜택을 갖는 당업자에게 명백한 모든 수정, 등가물 및 대안을 커버함을 의도한 것이다. 발명에 제공된 특징들에 대한 예제들은, 달리 언급되지 않는 한, 제한적이라기보다는 예시적인 것으로 의도된다.

본 출원 전체에 걸쳐 사용된, "~ 수 있다(may)"라는 단어는 필수의 의미(즉, ~ 라야한다(must)는 것을 의미)보다는 허용의 의미(즉, ~ 일 가능성을 갖는다(having the potential to)는 것을 의미)로 사용된다. 유사하게, "포함한다(include, includes)" 및 "포함하는(including)"이라는 단어는 포함하고 있다는 것을 의미하지만, 이로 제한되지 않는다.

다양한 유닛, 회로, 또는 다른 컴포넌트는 태스크 또는 태스크들을 수행"하도록 구성된(configured to)"으로 설명될 수 있다. 이러한 맥락에서, "하도록 구성된(configured to)"은 동작 동안 태스크 또는 태스크들을 수행"하는 회로를 갖는(having circuitry that)"다는 것을 일반적으로 의미하는 구조에 대한 폭넓은 열거이다. 이에 따라, 유닛/회로/컴포넌트는 유닛/회로/컴포넌트가 현재 온(on)이 아닐 때조차 태스크를 수행하도록 구성될 수 있다. 일반적으로, "하도록 구성된"에 대응하는 구조를 형성하는 회로는 하드웨어 회로들을 포함할 수 있다. 유사하게, 다양한 유닛/회로/컴포넌트는, 설명에 있어서의 편의를 위해, 태스크 또는 태스크들을 수행하는 것으로서 설명될 수 있다. 이러한 설명은 "하도록 구성된"이라는 문구를 포함하는 것으로 해석되어야 한다. 하나 이상의 태스크를 수행하도록 구성되는 유닛/회로/컴포넌트를 열거하는 것은, 그 유닛/회로/컴포넌트에 대한 해석을, 미국 특허법 35 U.S.C. §112조, 여섯째 단락에 적용하지 않도록 분명히 의도된다.

본 발명의 범위는, 그것이 여기에서 다루어진 문제들의 일부 또는 전부를 완화시키든 완화시키지 않던 간에, (명시적 또는 묵시적으로) 여기에 개시된 임의의 특징이나 특징들의 조합, 또는 그것의 임의의 일반화를 포함한다. 따라서, 본 출원(또는 그를 우선권으로 주장하는 출원)의 진행 동안에는 특징들에 대한 임의의 그러한 조합으로 새로운 청구항들이 만들어질 수 있다. 특히, 첨부된 청구항들을 참조하면, 종속항들로부터의 특징들이 독립항들의 특징들과 조합될 수 있고, 각각의 독립항들로부터의 특징들은 단순히 첨부된 청구항들에 열거된 특정 조합들이 아니라 임의의 적절한 방식으로 조합될 수 있다.

컴퓨터 시스템 개요(Computer System Overview)

이제, 도 1을 참조하면, 컴퓨터 시스템에 대한 하나의 실시예의 블록 다이어그램이 도시된다. 컴퓨터 시스템(100)은 프로세서(102), L2(level two) 캐시(106), 메모리(108), 및 대용량-저장 디바이스(mass-storage device; 110)를 포함한다. 도시된 바와 같이, 프로세서(102)는 L1(level one) 캐시(104)를 포함한다. 컴퓨터 시스템(100)에는 특정 컴포넌트들이 도시되고 설명되지만, 대안적인 실시예에서, 컴퓨터 시스템(100)에 다른 컴포넌트들 및 다른 수의 컴포넌트들이 제시될 수 있다는 것에 주목한다. 예를 들어, 컴퓨터 시스템(100)은 메모리 계층(memory hierarchy)의 일부(예컨대, 메모리(108) 및/또는 대용량-저장 디바이스(110))를 포함하지 않을 수 있다. 대안적으로, L2 캐시(106)가 프로세서(102)의 외부에 도시되지만, 다른 실시예들에서는, L2 캐시(106)가 프로세서(102)의 내부에 있을 수도 있다는 것이 고려된다. 그러한 실시예에서는, L3(level three) 캐시(미도시) 또한 사용될 수 있다는 것에 주목한다. 또한, 컴퓨터 시스템(100)은 그래픽 프로세서, 비디오 카드, 비디오-캡처 디바이스, 사용자-인터페이스 디바이스, 네트워크 카드, 광 드라이브, 및/또는 버스나 네트워크나 또 다른 적절한 통신 채널(간략화를 위해 모두 도시되지 않음)을 사용하여 프로세서(102)에 결합되는 다른 주변 디바이스들을 포함할 수 있다.

다양한 실시예들에서, 프로세서(102)는 계산 동작들을 수행하는 범용 프로세서를 나타낼 수 있다. 예를 들어, 프로세서(102)는 마이크로프로세서, 마이크로컨트롤러, ASIC(application-specific integrated circuit), 또는 FPGA(field-programmable gate array)와 같은 CPU(central processing unit)일 수 있다. 그러나, 아래에 더 설명되는 바와 같이, 프로세서(102)는 벡터 처리를 위한 하나 이상의 메커니즘(예컨대, 벡터 실행 유닛들)을 포함할 수 있다. 프로세서(102)의 예제 벡터 실행 유닛은 도 2의 설명과 함께 아래 더 자세히 설명된다.

대용량-저장 디바이스(110), 메모리(108), L2 캐시(10), 및 L1 캐시(104)는 프로세서(102)를 위한 데이터 및 명령들을 저장하는 메모리 계층을 집합적으로 형성하는 저장 디바이스들이다. 특히, 대용량-저장 디바이스(110)는, 긴 액세스 시간을 갖는, 고-용량, 비-휘발성 메모리, 이를테면, 디스크 드라이브 또는 대형 플래시 메모리 유닛일 수 있는 한편, L1 캐시(104), L2 캐시(106), 및 메모리(108)는, 더 짧은 액세스 시간을 갖는, 더 작은 것일 수 있다. 이러한 더 빠른 반도체 메모리들은 자주 사용된 데이터의 복사본들을 저장한다. 메모리(108)는 메모리 디바이스들의 DRAM(dynamic random access memory) 패밀리에 있는 메모리 디바이스를 나타낼 수 있다. 메모리(108)의 크기는 일반적으로 L1 캐시(104) 및 L2 캐시(106)보다 더 크지만, L1 캐시(104) 및 L2 캐시(106)는 일반적으로 디바이스들의 SRAM(static random access memories) 패밀리에 있는 더 작은 디바이스들을 사용하여 구현된다. 일부 실시예들에서, L2 캐시(106), 메모리(108), 및 대용량-저장 디바이스(110)는 컴퓨터 시스템(100)에서 하나 이상의 프로세서 사이에서 공유된다.

일부 실시예들에서, 메모리 계층 내의 디바이스들(즉, L1 캐시(104) 등)은 사이클 당 다수의 캐시 라인에 액세스(즉, 판독 및/또는 기록)할 수 있다. 이러한 실시예들은, 불연속 메모리 어드레스들로의 어레이 인덱스들이나 포인터들의 벡터에 근거하여 발생하는 메모리 액세스들의 좀더 효과적인 처리를 가능하게 할 수 있다.

아래 설명된 데이터 구조들 및 프로그램 명령들(즉, 코드)은, 컴퓨터 시스템(예컨대, 컴퓨터 시스템(100))에 의한 사용을 위한 코드 및/또는 데이터를 저장할 수 있는 임의의 디바이스 또는 저장 매체일 수 있는, 비-일시적인 컴퓨터-판독가능한 저장 디바이스에 저장될 수 있다는 것에 주목한다. 일반적으로 말해서, 비-일시적인 컴퓨터-판독가능한 저장 디바이스는, 이로 제한되는 것은 아니지만, 휘발성 메모리, 비-휘발성 메모리, 디스크 드라이브와 같은 자기 및 광 저장 디바이스들, 자기 테이프, CD(compact discs), DVD(digital versatile discs 또는 digital video discs), 또는 지금 알려져 있거나 나중에 개발될 컴퓨터-판독가능한 매체를 저장할 수 있는 다른 매체를 포함한다. 그에 따라, 대용량-저장 디바이스(110), 메모리(108), L2 캐시(10), 및 L1 캐시(104)는 비-일시적인 컴퓨터 판독가능한 저장 디바이스들의 모든 예제들이다.

프로세서(Processor)

도 2를 참조하면, 도 1의 프로세서에 대한 실시예의 추가 상세를 도시하는 블록 다이어그램이 도시된다. 간결하게 하기 위해, 도 2에는 모든 것이 도시되진 않았지만, 도 2에 도시된 실시예에서, 프로세서(102)는 다수의 파이프 라인 스테이지를 포함할 수 있다. 따라서, 도시된 바와 같이, 프로세서(102)는 L1 캐시(104), 명령 페치 유닛(instruction fetch unit; 201), 분기 예측 유닛(branch prediction unit; 210), 예측실패 유닛(misprediction unit; 212), 정수 실행 유닛(integer execution unit; 202), 부동-소수점 실행 유닛(floating-point execution unit; 206), 및 벡터 실행 유닛(204)을 포함한다. 정수 실행 유닛(202), 부동-소수점 실행 유닛(206), 및 벡터 실행 유닛(204)은, 하나의 그룹으로서, "실행 유닛들"로 번갈아서 지칭될 수도 있다는 것에 주목한다.

다양한 실시예에서, 실행 유닛들은, 관련된 피연산자(operand)의 유형에 대해, 예를 들어, 논리 연산(logical operations), 수학적 연산(mathematical operations), 또는 비트 연산(bitwise operations)과 같은 계산 동작들(computational operations)을 수행할 수 있다. 더 구체적으로, 정수 실행 유닛(202)은 정수 피연산자를 수반하는 계산 동작들을 수행할 수 있고, 부동-소수점 실행 유닛(206)은 부동-소수점 피연산자를 수반하는 계산 동작들을 수행할 수 있으며, 벡터 실행 유닛(204)은 벡터 피연산자를 수반하는 계산 동작들을 수행할 수 있다. 정수 실행 유닛 및 부동-소수점 실행 유닛은 본 기술 분야에서 일반적으로 알려진 것으로, 간결성을 위해 더 설명되지 않는다. 위에서 언급된 바와 같이, 도 2에 도시된 프로세서(102)의 실시예는 특정한 세트의 컴포넌트들을 포함하지만, 대안적인 실시예들에서는, 프로세서(102)가 다른 수나 유형의 실행 유닛들, 기능 유닛들, 및 실행 유닛들에 결합될 수 있는 명령 디코드 유닛, 스케줄러나 예약 스테이션, 재배열 버퍼(reorder buffer), 메모리 관리 유닛, I/O 인터페이스 등과 같은 파이프라인 스테이지들을 포함할 수 있다는 것이 고려된다.

벡터 실행 유닛(204)은, 그것이 다수의 데이터 요소들에서 동일한 동작을 병렬로 수행할 수 있다는 점에서, 고전적인 의미에서, SIMD(single-instruction-multiple-data) 실행 유닛을 나타낼 수 있다. 그러나, 일부 실시예들에서는, 여기에 설명된 벡터 명령들이 SIMD 명령들의 다른 구현과 다를 수 있다는 것에 주목한다. 예를 들어, 일 실시예에서, 벡터 명령에 의해 동작된 벡터의 요소들이 벡터에 있는 요소들의 수에 따라 달라지지 않는 크기를 가질 수 있다. 반대로, 일부 SIMD 구현에서는, 데이터 요소 크기가 동작되는 데이터 요소들의 수에 따라 달라진다(예컨대, SIMD 아키텍처는 8개의 8-비트 요소들은 물론, 4개의 16-비트 요소들, 2개의 32-비트 요소들 등에 대한 동작들을 지원할 수 있다). 하나의 실시예에서, 벡터 실행 유닛(204)은 피연산자들의 벡터들에 포함되는 데이터 요소들의 일부 또는 전부에서 동작할 수 있다. 특히, 벡터 실행 유닛(204)은 벡터 프로그램 명령의 벡터 피연산자의 다른 요소들에서 동시에 동작하도록 구성될 수 있다.

하나의 실시예에서, 벡터 실행 유닛(204)은, 벡터 실행 유닛(204)을 위한 피연산자 벡터들 및 결과 벡터들을 보유할 수 있는 벡터 레지스터들을 포함할 수 있는 벡터 레지스터 파일(미도시)을 포함할 수 있다. 일부 실시예들에서, 벡터 레지스터 파일에 32개의 벡터 레지스터가 존재할 수 있고, 각 벡터 레지스터는 128 비트를 포함할 수 있다. 그러나, 대안적인 실시예에서, 다른 수의 벡터 레지스터 및/또는 레지스터 당 다른 수의 비트가 존재할 수 있다.

벡터 실행 유닛(204)은 벡터 레지스터로부터 피연산자를 검색하고, 벡터 실행 유닛(204)이 피연산자 벡터에 있는 데이터 요소들의 일부 또는 전부에서 병렬로 동작들을 수행하게 하는 벡터 명령들을 실행하도록 구성될 수 있다. 예를 들어, 벡터 실행 유닛(204)은 벡터에 있는 요소들에서 논리 연산, 수학적 연산, 또는 비트 연산을 수행할 수 있다. (위에서 설명된 바와 같이, "사이클"은, 벡터 실행 유닛(204)의 계산 동작들을 트리거, 동기화, 및/또는 제어하는데 사용될 수 있는 하나 보다 많은 클록 사이클을 포함할 수 있지만) 벡터 실행 유닛(204)은 명령 사이클 당 하나의 벡터 동작을 수행할 수 있다.

하나의 실시예에서, 벡터 실행 유닛(204)은 N개의 데이터 요소들(예컨대, 바이트들(bytes), 워드들(words), 더블워드들(doublewords) 등)을 보유하는 벡터들을 지원할 수 있는데, 여기서 N은 임의의 양의 정수일 수 있다. 이러한 실시예들에서, 벡터 실행 유닛(204)은 피연산자 벡터에 있는 데이터 요소들 중 N개 이하에서 동작들을 병렬로 수행할 수 있다. 예를 들어, 벡터의 길이가 256 비트이고, 동작되는 데이터 요소들이 4-바이트 요소들이고, 동작이 데이터 요소들에 값을 추가하는 실시예에서, 이러한 실시예들은 벡터에 있는 임의의 수의 요소들에 값을 추가할 수 있다. N은 프로세서(102)의 다른 구현들에서 달라질 수 있다는 것에 주목한다.

벡터 실행 유닛(204)은, 다양한 실시예에서, 벡터 실행 유닛(204)이 동작하는 피연산자 벡터에 있는 데이터 요소들에 대한 동적 제한을 가능하게 하는 적어도 하나의 제어 신호를 포함할 수 있다. 구체적으로, 제어 신호의 상태에 따라, 벡터 실행 유닛(204)은 벡터에 있는 데이터 요소들의 일부 또는 전부에서 선택적으로 동작할 수 있다. 예를 들어, 벡터의 길이가 512 비트이고 동작중인 데이터 요소들이 4-바이트 요소들인 실시예에서, 피연산자 벡터에서 16개의 데이터 요소들 중 일부 또는 전부에서 동작들이 수행되는 것을 방지하기 위해 제어 신호가 어서트될 수 있다. 동작들이 수행되는 피연산자 벡터의 데이터 요소들을 "동적으로" 제한하는 것은 런타임시에 각 사이클에 대해 별도로 제어 신호를 어서트하는 것을 포함할 수 있다는 것에 주목한다.

일부 실시예들에서는, 아래 더 자세히 설명되는 바와 같이, 술어들(predicates)이나 하나 이상의 스칼라 술어들(scalar predicates)의 벡터에 포함된 값들에 근거하여, 벡터 실행 유닛(204)은 단지 선택된 벡터 데이터 요소들에게만 벡터 동작들을 적용한다. 일부 실시예들에서, 결과 벡터의 나머지 데이터 요소들은 계속 영향을 받지 않거나("단정(predication)"으로 지칭될 수도 있음) 강제로 제로가 된다("제로화(zeroing)" 또는 "제로화 단정(zeroing predication)"으로 지칭될 수도 있음). 일부 실시예들에서, 벡터 실행 유닛(204)에서 단정이나 제로화로 인해 사용되지 않은 데이터 요소 처리 서브시스템들("레인들(lanes)")에 대한 클록들은 파워 및/또는 클록-게이트될 수 있어, 벡터 실행 유닛(204)에서 동적 전력 소모를 줄일 수 있다.

다양한 실시예에서, 아키텍처는 런타임시에 병렬성(parallelism)에 적응할 수 있도록 하기 위해 벡터-길이 불가지론적(vector-length agnostic)일 수 있다. 특히, 명령들 또는 동작들이 벡터-길이 불가지론적일 때, 동작(즉, 명령 등)은, 지원 하드웨어(supporting hardware)에 의해 부과된 한계까지, 임의의 길이의 벡터들을 사용하여 실행될 수 있다. 예를 들어, 벡터 실행 하드웨어가 8개의 별도의 4-바이트 요소들을 포함할 수 있는 벡터들(따라서 8개의 요소들의 벡터 길이를 가짐)을 지원하는 실시예들에서, 벡터-길이 불가지론적 동작은 벡터에 있는 8개의 요소들 중 임의의 수에서 동작할 수 있다. 다른 벡터 길이(예컨대, 4개의 요소들)를 지원하는 다른 하드웨어 구현에서, 벡터-길이 불가지론적 동작은 기본적인 하드웨어(underlying hardware)에 의해 그것에 사용가능하게 만들어진 다른 수의 요소들에서 동작할 수 있다. 따라서, 컴파일러 또는 프로그래머는 기본적인 하드웨어(예컨대, 벡터 실행 유닛(204))에 의해 지원된 벡터 길이에 대한 명시적 지식을 가질 필요가 없다. 그러한 실시예들에서, 특정 벡터 길이에 의지(또는 사용)할 필요가 없는 프로그램 코드를 컴파일러가 생성하거나 프로그래머가 기록한다. 일부 실시예들에서, 프로그램 코드에서 특정 벡터의 크기를 지정하는 것은 금지될 수 있다. 따라서, 이러한 실시예에서 컴파일된 코드(즉, 이진 코드)는 다른 벡터 길이들을 가질 수 있는 그 외 실행 유닛들에서 실행하는 한편, 잠재적으로 실현하는 성능은 더 긴 벡터들을 지원하는 프로세서들로부터 얻는다. 이러한 실시예에서, 프로세서와 같은 주어진 하드웨어 유닛에 대한 벡터 길이는 런타임 동안 시스템 레지스터로부터 판독될 수 있다. 결과적으로, 프로세스 기술이 더 긴 벡터들을 허용함에 따라, 소프트웨어 개발자들에 의한 어떠한 노력 없이 간단히 레거시 이진 코드의 실행이 가속화된다.

일반적으로, 벡터 길이들은 2의 거듭제곱(예컨대, 2, 4, 8 등)으로 구현될 수 있다. 그러나, 일부 실시예들에서, 벡터 길이는 2의 거듭제곱일 필요가 없다. 구체적으로, 3, 7, 또는 또 다른 수의 데이터 요소들의 벡터들이, 2의 거듭제곱 수의 데이터 요소들을 갖는 벡터들과 동일한 방식으로 사용될 수 있다.

다양한 실시예들에서, 벡터에 있는 각 데이터 요소는 메모리 액세스들의 세트를 병렬로 수행하기 위해 벡터 실행 유닛(204)에 의해 사용되는 어드레스를 포함할 수 있다. 그러한 실시예들에서, 벡터의 하나 이상의 요소가 무효 메모리 어드레스들(invalid memory addresses)을 포함하는 경우에, 무효 메모리-판독 동작들이 발생할 수 있다. 그에 따라, 그렇지 않았으면 프로그램 종료를 야기했을 무효 메모리-판독 동작들이 대신하여 유효 어드레스들을 갖는 임의의 요소들이 판독되고 무효 요소들을 갖는 요소들이 플래그되게 할 수 있어, 추측에 근거한 것으로 지나고 보니 불법인 판독 동작들에도 불구하고 프로그램 실행이 계속되는 것을 허용한다.

일부 실시예들에서, 프로세서(102)(및 따라서 벡터 실행 유닛(204))는 포인터들의 벡터들에서 동작할 수 있고 그들을 사용할 수 있다. 그러한 실시예들에서, 벡터당 데이터 요소들의 수는, 데이터 유형의 크기에 상관없이, 벡터당 포인터들의 수와 동일하다. 메모리에서 동작하는 명령들은 메모리 액세스의 크기를 표시하는 변형들을 가질 수 있지만, 프로세서 레지스터들에 있는 요소들은 포인터 크기와 동일해야 한다. 이러한 실시예들에서, 32-비트 및 64-비트 어드레싱 모드들 둘 다를 지원하는 프로세서들은 32-비트 모드에서 벡터당 2배의 요소를 허용하도록 선택할 수 있어, 더 큰 처리량을 달성한다. 이는, 동일한 폭의 데이터 경로라고 가정하면, 32-비트 어드레싱에 유리한 별개의 처리량을 암시한다. 요구사항을 완화하기 위해 구현-특정 기술들이 사용될 수 있다. 예를 들어, 2배-정밀 부동-소수점 수들은 레지스터 페어링(pairing) 또는 일부 다른 전문화된 메커니즘을 통해 32-비트 모드에서 지원될 수 있다.

하나의 실시예에서, 분기 예측 유닛(210)은 조건부 분기 명령들에 대해 페치 유닛(201)을 위한 분기 대상 프로그램 카운터 어드레스들(branch target program counter addresses)(PC들)을 생성하도록 구성될 수 있다. 특히, 조건부 분기 명령들에 대해, 분기 예측 유닛(210)이 분기가 취해질 것인지 취해지지 않을 것인지 여부를 예측할 수 있고, 제어 논리(미도시)는 예측에 근거하여 페치 유닛(201)을 위한 PC를 생성할 수 있다. 그 다음, 명령들은 분기에 대한 예측 결과(outcome)에 의존적인 추측에 근거한 방식(speculative manner)으로 페치(fetch), 발행(issue), 및 실행(execute)될 수 있다. 다양한 실시예들에서, 분기 예측 유닛(210)은 예측을 생성하는 다양한 예측 메커니즘들 중 임의의 것을 사용할 수 있다. 예를 들어, 분기 예측 유닛(210)은 개개의 분기들에 대해 예측 상태를 유지하는 로컬 예측자(예컨대, 상태 머신, 테이블, 카운터, 또는 그 외의 데이터 구조), 전체적으로 고려된 다수의 분기를 통해 예측을 수행하는 글로벌 예측자, 로컬 및 글로벌 예측자들의 요소들을 조합하는 하이브리드 예측자들, 또는 그 외의 적절한 접근법들을 사용할 수 있다. 일부 실시예들에서, 분기 예측 유닛(210)은 (예컨대, 하나의 기술에 따라 더 잘 예측되었던 분기가 다른 기술에 따라 더 잘 예측되게 될 때를 검출하고 적응하기 위해) 실행 동안 변경되는 분기 행동(branch behavior)에 동적으로 적응하는 예측자들을 이용할 수 있다.

하나의 실시예에서, 예측실패 유닛(misprediction unit; 212)은 분기 예측이 잘못될 때를 검출하도록 구성된다(예컨대, 그것이 실행되는 시간에 분기의 실제 행동이 분기의 예측된 행동과 다르면, 분기가 예측실패된 것으로 표시함). 또한, 예측실패 유닛(212)은 실행 유닛들(202, 206, 및 204)은 물론 분기 예측 유닛(210)에 대한 예측실패에 대한 표시를 제공하도록 구성될 수 있다. 예측실패 유닛(212)은 별도의 유닛으로 도시되지만, 다른 실시예들에서는, 예측실패 유닛(212)이 분기 예측 유닛(210)의 일부이거나, 페치 유닛(201)의 일부이거나, 다양한 실행 유닛들(예컨대, 202, 204 및 206)의 일부나 전부의 일부일 수 있다는 것이 고려된다.

위에서 설명된 바와 같이, 종래의 프로세서가 분기 명령에 대해 예측실패할 때, 파이프라인은 예측실패된 경로에 있는 명령들로 플러시되는데, 그 이유는, 이러한 추측에 근거하여 발행된 명령들이 잘못된 추측의 관점에서 프로세서의 상태를 수정하도록 허용되어서는 안 되기 때문이다. 그 다음, 페치 유닛(201)은 정확하고 추측에 근거하지 않은(non-speculative) 경로에 대한 명령들을 페치할 수 있다. 그러나, 플러시(flush) 및 필(fill) 동작에 대한 페널티가 존재하는데: 유용한 작업이 재개될 수 있기 이전에 수백의 실행 사이클이 필요할 수 있다는 것이다.

따라서, 도 7의 설명과 함께 아래 더 자세히 설명되는 바와 같이, 하나의 실시예에서, 분기 예측 유닛(210)은 다양한 예측에 대한 예측 정확도 정보를 유지할 수 있다. 주어진 분기 명령에 대한 정확도 정보는, 분기 명령이 행동할 것으로 예측되는 방식보다는, 그것이 실행될 때, 분기 명령의 실제 행동에 근거하여 적응될 수 있다. 벡터 분할 루프들(vector partitioning loops)에서 사용된 후방 분기들을 예측실패하는 것과 관련된 페널티의 일부를 피하기 위해, 예측 정확도가 낮을 때, 분기 예측 유닛(210)은 예측을 억제하고, 루프의 반복 수에 대응하는 정보가 사용가능하게 되기를 기다리도록 구성될 수 있다.

매크로스칼라 아키텍처 개요( Macroscalar Architecture Overview )

명령 세트 아키텍처(매크로스칼라 아키텍처로 지칭됨) 및 지원 하드웨어(supporting hardware)는, 컴파일-시간(compile-time)에 병렬성을 완전히 결정할 필요 없이, 유용한 정적 분석 정보(static analysis information)를 폐기하지 않고, 컴파일러들이 루프들을 위한 프로그램 코드를 생성하도록 허용할 수 있다. 매크로스칼라 아키텍처의 다양한 실시예들이 이제 설명될 것이다. 구체적으로, 아래에 더 설명되는 바와 같이, 루프들에 대한 병렬성을 요구하지 않고, 그 대신, 동적 조건들이 허용하는 경우에 런타임시에 병렬성이 이용되는 것을 가능하게 하는 명령들의 세트가 제공된다. 그에 따라, 아키텍처는, 사용된 병렬성의 양을 전환하여 런타임시에 조건에 따른 루프 반복을 위해, 컴파일러에 의해 생성된 코드가 비-병렬(스칼라) 및 병렬(벡터) 실행 사이에서 동적으로 전환하는 것을 가능하게 하는 명령들을 포함한다.

따라서, 아키텍처는 루프 반복들에 대하여 양이 결정되지 않은 벡터 병렬성을 가능하게 하면서도, 런타임시에 병렬성이 사용되는 것을 요구하지 않는 명령들을 제공한다. 보다 구체적으로, 아키텍처는 효율적인 벡터의 길이가 런타임 조건에 따라 달라질 수 있는 벡터-길이 불가지론적 명령들의 세트를 포함한다. 따라서, 런타임 의존성이 코드의 비-병렬 실행을 요구하는 경우에, 실행은 하나의 요소의 효율적인 벡터 길이에 의해 발생한다. 마찬가지로, 런타임 조건이 병렬 실행을 허가하는 경우에, 동일한 코드는 런타임 의존성(및 기본적인 하드웨어의 벡터 길이)에 의해 허용되는 정도의 벡터-병렬 방식으로 실행된다. 예를 들어, 벡터의 8개 요소 중 2개는 안전하게 병렬로 실행할 수 있는 경우에, 프로세서(102)와 같은 프로세서는 2개의 요소를 병렬로 실행할 수 있다. 이러한 실시예에서, 벡터-길이 불가지론적 포맷으로 프로그램 코드를 표현하는 것은, 기존 시스템에 존재하지 않은 광범위한 벡터화 기회를 가능하게 한다.

다양한 실시예에서, 컴파일 동안, 컴파일러는 먼저 프로그램 코드에서 주어진 루프의 루프 구조를 분석하고, 정적 의존성 분석을 수행한다. 그 다음, 컴파일러는 정적 분석 정보를 유지하는 프로그램 코드를 생성하고, 예를 들어, 프로세서(102)와 같은 프로세서에게, 런타임 의존성을 해결하고 가능한 최대 양의 병렬성을 갖는 프로그램 코드를 처리하는 방법을 지시한다. 보다 구체적으로, 컴파일러는 루프 반복의 대응하는 세트들을 병렬로 수행하기 위한 벡터 명령들을 제공할 수 있고, 오류를 야기하는 루프의 반복들 사이의 데이터 의존성을 방지하기 위해 벡터 명령들의 실행을 동적으로 제한하기 위한 벡터-제어 명령들을 제공할 수 있다. 이러한 접근법은 병렬성에 대한 결정을 런타임때로 연기하는데, 여기서 런타임 의존성에 대한 정보가 사용가능하고, 이로써, 동적으로 변하는 조건들에 대해 소프트웨어 및 프로세서가 병렬성에 적응하는 것을 허용한다. 프로그램 코드 루프 병렬화의 예제는 도 3에 도시된다.

도 3의 좌측을 참조하면, 실행 패턴은 병렬화되지 않은 루프의 4회 반복(예컨대, 반복 1-4)으로 도시되는데, 여기서 각 루프는 명령들 A-G를 포함한다. 직렬 동작들은 수직으로 쌓아 놓은 명령들로 도시된다. 도 3의 우측에는 병렬화된 루프의 버전이다. 이 예제에서, 반복 내의 각 명령은 그 이전의 적어도 하나의 명령에 의존하므로, 주어진 반복의 명령들 사이에는 정적 의존성 체인(static dependency chain)이 존재한다. 따라서, 주어진 반복 내의 명령들은 병렬화될 수 없다(즉, 주어진 반복 내의 명령들 A-G는 반복에서 다른 명령들에 대하여 항상 순차적으로 실행된다). 그러나, 대안적인 실시예에서, 주어진 반복 내의 명령들의 병렬화가 가능할 수도 있다.

도 3에서 루프의 반복들 사이에 화살표로 도시된 바와 같이, 주어진 반복 내의 명령 E과 후속하는 반복의 명령 D 사이에는 런타임 데이터 의존성의 가능성이 있다. 그러나, 컴파일 동안, 컴파일러는 단지, 이러한 명령들 사이에 데이터 의존성의 가능성이 존재한다는 것을 결정할 수 있지만, 이러한 정보는 단지 런타임에서만 사용가능하기 때문에, 컴퍼일러는 반복 의존성이 실제로 구체화될 것이라고 말할 수 없다. 이 예제에서, 런타임에 실제로 구체화하는 데이터 의존성이 1E에서 2D로, 및 3E에서 4D로의 실선 화살표에 의해 도시되는 한편, 런타임에 구체화하지 않는 데이터 의존성은 2E에서 3D로의 점선 화살표를 사용하여 도시된다. 따라서, 도시된 바와 같이, 런타임 데이터 의존성은 실제로 제1/제2 및 제3/제4 반복 사이에 발생한다.

제2 및 제3 반복 사이에는 어떠한 데이터 의존성도 존재하지 않기 때문에, 제2 및 제3 반복은 안전하게 병렬로 처리될 수 있다. 또한, 주어진 반복의 명령들 A-C 및 F-G는 반복 내에서만 의존성을 갖고, 따라서, 주어진 반복의 명령 A는 모든 다른 반복의 명령 A와 병렬로 실행할 수 있고, 명령 B는 또한 모든 다른 반복의 명령 B와 병렬로 실행할 수 있는 등이다. 그러나, 제2 반복에서 명령 D는 제1 반복에서 명령 E에 의존하므로, 제1 반복에서 명령 D와 E는 제2 반복에 대한 명령 D가 실행될 수 있기 이전에 실행되어야 한다.

그에 따라, 우측의 병렬화된 루프에서, 그러한 루프의 반복들은 정적 및 런타임 데이터 의존성 둘 다를 수용하도록 실행되는 한편, 최대 병렬성을 달성할 수 있다. 특히, 모든 4개의 반복의 명령들 A-C 및 F-G는 병렬로 실행된다. 그러나, 제2 반복에서 명령 D는 제1 반복에서 명령 E에 의존하므로, 제1 반복에서 명령 D 및 E는 제2 반복에 대한 명령 D가 실행될 수 있기 전에 실행되어야 한다. 그러나, 제2 및 제3 반복 사이에 어떠한 데이터 의존성도 존재하지 않기 때문에, 이러한 반복들에 대한 명령들 D와 E은 병렬로 실행될 수 있다.

매크로스칼라 아키텍처의 예제들( Examples of the Macroscalar Architecture )

다음 예제들은 매크로스칼라 동작들을 소개하고, 병렬화된 루프 예제에서 위에서 설명되고 도 3에 도시된 루프와 같은 루프들을 벡터화하는데 있어서 그들의 사용을 보여준다. 이해의 편의를 위해, 이러한 예제들은 C++ 포맷으로 의사코드(pseudocode)를 사용하여 제시된다.

다음의 예제 실시예는 논의를 목적으로 한 것임에 주목한다. 실제 명령들 및 동작들은 단순히 아키텍처의 이해를 돕도록 의도된 것이다. 그러나, 대안적인 실시예에서, 명령들 또는 동작들은 다른 방식으로, 예를 들어, 더 원시 동작(primitive operation)들의 마이크로코드 시퀀스를 사용하거나 서브-동작들의 다른 시퀀스를 사용하여, 구현될 수 있다. 매크로-동작 및 대응하는 사용 모델에 관한 정보가 모호해지지 않도록 하기 위해 명령들의 추가 분해는 피할 것임에 주목한다.

표기법(Notation)

아래 예제들을 설명하는데 있어서, 달리 언급되지 않는 한, 벡터량인, 변수들에 대해 다음과 같은 포맷이 사용된다:

벡터 p5의 요소들은 테스팅 a<b의 결과에 따라 0 또는 1로 설정된다. 벡터 p5는, 아래에 더 자세히 설명되는 바와 같이, "술어 벡터(predicate vector)"일 수 있다는 것이 주목한다. 술어 벡터들을 생성하는 일부 명령들은 결과로 얻은 술어들을 반영하기 위해 프로세서 상태 플래그들을 또한 설정한다. 예를 들어, 프로세서 상태 플래그 또는 조건-코드는 FIRST, LAST, NONE, 및/또는 ALL 플래그를 포함할 수 있다.

술어 벡터 p5에서 활성(즉, 제로가 아닌) 요소들에 의해 지정된 벡터 'a'의 요소들만 b+c의 결과를 수신한다. a의 나머지 요소들은 변경되지 않는다. 이러한 동작은 "단정(predication)"이라고 불리고, 술어 벡터 이전에 물결표("~") 기호를 사용하여 표기된다.

술어 벡터 p5에서 활성(즉, 제로가 아닌) 요소들에 의해 지정된 벡터 'a'의 요소들만 b+c의 결과를 수신한다. a의 나머지 요소들은 제로로 설정된다. 이러한 동작은 "제로화(zeroing)"로 불리고, 술어 벡터 이전에 느낌표("!") 기호를 사용하여 표기된다.

다음의 명령들은 그에 따라 프로세서 상태 플래그들 및 분기를 테스트한다.

VECLEN은 벡터당 요소들의 개수를 전달하는 기계값이다. 그 값은, 어셈블러에 의해 결정되기보다, 코드를 실행하는 프로세서에 의해 런타임에 결정된다.

많은 공통 프로그래밍 언어들과 유사한 방식으로, 다음의 예제들은 코멘트들을 표시하기 위해 앞쪽에 2개의 슬래시(double forward slash)를 사용한다. 이러한 코멘트들은 표시된 벡터에 포함된 값들 또는 대응하는 예제에서 수행되는 동작들의 설명에 관한 정보를 제공할 수 있다.

이러한 예제들에서, 그 외의 C++ 포맷 오퍼레이터들은 그들의 종래의 의미를 유지하지만, 벡터에 걸쳐 요소별로(element-by-element basis) 적용된다. 함수 호출이 이용되는 경우에, 그들은 목적 레지스터에 리턴된 임의의 값을 배치하는 단일 명령을 시사한다. 이해에 있어서의 간소함을 위해, 모든 벡터는 정수의 벡터이지만, 대안적인 실시예들은 다른 데이터 포맷을 지원한다.

구조적 루프-전이 의존성(Structural Loop-Carried Dependencies)

아래의 코드 예제 1에서, 종래의 벡터 아키텍처를 사용하는 "벡터화할 수 없(non-vectorizable)" 프로그램 코드 루프가 도시된다. (벡터화할 수 없는 것에 더해, 이 루프는 또한 데이터 의존성들의 파인-그레인 본질(fine-grain nature)로 인해 종래의 멀티-스레딩 아키텍처들에서 멀티-스레딩할 수 없다는 것에 주목한다.) 명확하게 하기 위해, 이 루프는 루프를 벡터화할 수 없게 만드는 근본적인 루프-전이 의존성들로 디스틸(distill)된다.

이 예제에서, 변수들 r 및 s는 종래의 아키텍처들을 사용하는 벡터화를 방지하는 루프-전이 의존성을 갖는다. 그러나, 조건(A[x]<FACTOR)이 항상 진실이거나 항상 거짓으로 알려지는 한 루프는 벡터화가능하다는 것에 주목한다. 조건이 실행 동안 달라지도록 허용될 때(흔한 경우(common case)) 이러한 가정은 변경된다. 이러한 예제에서 간략화를 위해, 우리는 A[]와 B[] 사이에 어떠한 에일리어싱도 존재하지 않는 것으로 간주한다.

매크로스칼라 아키텍처를 사용하면, 예제 1의 루프는 조건(A[X]<FACTOR)이 변경되지 않는 세그먼트들로 벡터를 분할하여 벡터화될 수 있다. 이러한 벡터들을 분할하기 위한 프로세스들의 예제들은 물론, 분할을 가능하게 하는 명령들의 예가 아래 제시된다. 이 예제에 대해, 설명된 분할은 단지 조건절(conditional clause) 내에 있는 명령들에 적용될 필요가 있다는 것에 주목한다. 처음 판독 A[x]과 최종 동작 B[x]=r+s는, 잠재적으로 최종 루프 반복에서를 제외하고, 전체 벡터에 걸쳐 항상 병렬로 실행될 수 있다.

벡터화된 코드의 예제들 및 명령들은, 매크로스칼라 아키텍처와 함께, 도 2의 프로세서(102)와 같은 벡터 프로세서의 동작을 설명하도록 도시 및 설명된다. 다음과 같은 설명은 일반적으로 다수의 명령들이 기술되고 그 다음에 명령들을 사용하는 하나 이상의 벡터화된 코드 샘플들이 제시되도록 구조화된다. 일부 경우에, 벡터화 이슈의 특정한 유형은 주어진 예제에서 탐색된다.

dest=VectorReadInt(Base, Offset)

VectorReadInt는 메모리 판독 동작을 수행하기 위한 명령이다. 데이터 크기(이 경우에 정수)에 의해 스케일링된, 오프셋의 벡터(Offset)는 스칼라 기본 어드레스(Base)에 추가되어, 목표 벡터(destination vector)로 판독되는 메모리 어드레스들의 벡터를 형성한다. 명령이 단정되거나(predicated) 제로화되는(zeroed) 경우, 활성 요소들에 대응하는 어드레스들만 판독된다. 설명된 실시예에서, 무효 어드레스들에 대한 판독은 폴트(fault)로 허용되지만, 제1 활성 어드레스가 무효인 경우에 그러한 폴트들은 단지 결과적으로 프로그램 종료를 야기한다.

VectorWriteInt(Base, Offset, Value)

VectorWriteInt는 메모리 기록 동작을 수행하기 위한 명령이다. 데이터 크기(이 경우에 정수)에 의해 스케일링된, 오프셋의 벡터(Offset)는 스칼라 기본 어드레스(Base)에 추가되어, 메모리 어드레스들의 벡터를 형성한다. 값들의 벡터(Value)는 이러한 메모리 어드레스들에 기록된다. 이 명령이 단정되거나 제로화되는 경우, 데이터는 단지 활성 어드레스들로만 기록된다. 설명된 실시예들에서, 불법 어드레스들로의 기록들은 항상 폴트들을 생성한다.

dest=VectorIndex(Start, Increment)

VectorIndex는 Start로 지정된 스칼라 시작 값으로부터 증가(increment)에 의해 단조롭게 조정하는 값들의 벡터들을 생성하기 위한 명령이다. 이 명령은 인덱스 조정이 일정할 때 루프 인덱스 변수들을 초기화하기 위해 사용될 수 있다. 단정 또는 제로화가 적용될 때, 제1 활성 요소는 시작 값을 수신하고, 증가는 단지 후속 활성 요소들에만 적용된다. 예를 들면:

dest=PropagatePostT(dest, src, pred)

PropagatePostT 명령은, pred에 의해 결정되는 바와 같은, src에 있는 활성 요소들의 값을, dest의 후속 비활성 요소들로 전파한다. 활성 요소들, 및 제1 활성 요소에 선행하는 임의의 비활성 요소들은 dest에서 계속 변경되지 않는다. 이 명령의 목적은 조건부로 계산되는 값을 구하고, 조건부로 계산된 값을, 등가의 스칼라 코드로 발생하는 후속 루프 반복들에게 전파한다. 예를 들면:

dest=PropagatePriorF(src, pred)

PropagatePriorF 명령은, pred에 의해 결정된 바와 같은, src의 비활성 요소들의 값을, dest 내의 후속 활성 요소들로 전파한다. 비활성 요소들은 src에서 dest로 복사된다. 술어의 제1 요소가 활성인 경우, src의 마지막 요소는 그 위치로 전파된다. 예를 들면:

dest=ConditionalStop(pred, deps)

ConditionalStop 명령은 술어들의 벡터(pred)를 평가하고, deps에 의해 지정된 바와 같은 데이터 의존성을 시사하는 인접한 술어 요소들 사이의 전환(transitions)을 식별한다. 스칼라 값(deps)은, 왼쪽에서 오른쪽으로 처리되는 것과 같은, pred에서 참/거짓 요소들 사이의 가능한 전환을 각각 지정하는, 4 비트의 어레이로 생각될 수 있다. 이러한 비트들은, 설정되면, 표시된 의존성의 존재를 전달하고, 설정되지 않으면, 의존성의 부재를 보장한다. 그들은 다음과 같다:

kTF - 술어가 참인 반복에서 술어의 값이 거짓인 후속 반복으로의 루프-전이 의존성을 시사한다.

kFF - 술어가 거짓인 반복에서 술어의 값이 거짓인 후속 반복으로의 루프-전이 의존성을 시사한다.

kFT - 술어가 거짓인 반복에서 술어의 값이 참인 후속 반복으로의 루프-전이 의존성을 시사한다.

kTT - 술어가 참인 반복에서 술어의 값이 참인 후속 반복으로의 루프-전이 의존성을 시사한다.

의존하는 데이터를 생성하는 반복에 대응하는 요소 위치는, 데이터에 의존하는 반복에 대응하는 요소 위치에서 목표 벡터에 저장된다. 어떠한 데이터 의존성도 존재하지 않는 경우에, 그 요소에서 목표 벡터에 0의 값이 저장된다. 결과로 얻은 의존성 인덱스 벡터, 또는 DIV는 의존성을 나타내는 요소-위치 인덱스들의 벡터를 포함한다. 아래에 설명된 이유로, 벡터의 제1 요소는 요소 번호 1(0 보다는)이다.

예로서, 위의 예제 1의 루프에서 의존성을 고려한다. 이 루프에서, 조건절의 참과 거짓 반복 사이의 전환은 병렬성으로 브레이크를 요구하는 루프-전이 의존성을 나타낸다. 이는 다음과 같은 명령들을 사용하여 처리될 수 있다:

4번째 반복은 필요한 데이터를 생성하고, 5번째 반복이 이에 의존하기 때문에, 4는 출력 벡터 p2(이는 DIV임)의 위치 5에 저장된다. 동일한 것이, 6번째 반복으로부터의 데이터에 의존하는, 7번째 반복에 대해 적용된다. DIV의 그 외의 요소들은 의존성의 부재를 표시하기 위해 0으로 설정된다. (이 예제에서, 벡터의 제1 요소는 요소 번호 1임에 주목한다.)

dest=GeneratePredicates(Pred, DIV)

GeneratePredicates는 의존성 인덱스 벡터(DIV)를 구하고, pred에 의해 표시된, 처리된 이전의 그룹을 고려하여, 병렬로 안전하게 처리될 수 있는 요소들의 다음 그룹에 대응하는 술어들을 생성한다. pred의 어떠한 요소도 활성이 아닌 경우, 안전하게 병렬로 처리될 수 있는 요소들의 제1 그룹에 대해 술어들이 생성된다. Pred가 벡터의 최종 요소들이 처리되었다는 것을 표시하는 경우, 명령은 어떠한 요소도 처리되지 않고 ZF 플래그가 설정된다는 것을 표시하는 비활성 술어들의 결과 벡터를 생성한다. CF 플래그는 결과물들의 마지막 요소가 활성이라는 것을 표시하도록 설정된다. 제1 예제에서 값들을 사용하여, GeneratePredicates는 다음과 같이 동작한다:

모두 0인 초기화된 술어 p2로부터, GeneratePredicates는 후속 벡터 계산을 3개의 서브-벡터들(즉, p', p", 및 p'")로 분할하는 p2의 새로운 인스턴스들을 생성한다. 이는 하드웨어가, 루프의 데이터 의존성을 위반하지 않고, 그룹들에서 벡터를 처리하는 것을 가능하게 한다.

도 4a에는, 예제 1에서 루프의 스칼라 실행 동안 변수 상태에 대한 시퀀스를 도시하는 다이어그램이 도시된다. 특히, 조건식(conditional expression)의 방향의 무작위적 50/50 분포를 사용하면, 예제 1의 루프의 변수 상태들의 진행이 도시된다. 도 4b에는, 예제 1의 루프의 매크로스칼라 벡터화된 프로그램 코드에 대한 실행의 진행을 도시하는 다이어그램이 도시된다. 도 4a 및 4b에서, A[]로부터 판독된 값들은 왼쪽으로 기울어진 해시 마크를 사용하여 도시되는 한편, B[]에 기록된 값들은 오른쪽으로 기울어진 해시 마크를 사용하여 도시되고, (주어진 반복에서 변경되는 것에 따른) "r" 또는 "s"에 대한 값들은 음영 배경을 사용하여 도시된다. "r"은 결코 변경되지 않는 한편 "s"는 변경중이거나, 그 반대인 것으로 관찰된다.

모든 값들이 A[]로부터 병렬로 판독되거나 B[]로 병렬로 기록되는 것을 방지하는 것이 아무것도 없는데, 그 이유는 값들의 세트 중 어느 것도 루프-전이 의존성 체인에 참가하지 않기 때문이다. 그러나, r 및 s의 계산을 위해, 조건식의 값은 계속 동일(즉, 참 또는 거짓의 실행)하면서 요소들은 단지 병렬로 처리될 수 있다. 이 루프에 대한 프로그램 코드의 실행을 위한 패턴이 도 4b에 도시된다. 예제는 길이에 있어서 8개의 요소를 갖는 벡터들을 사용한다는 것에 주목한다. 제1 벡터 명령을 처리할 때, 제1 반복은 혼자 수행(즉, 벡터 실행 유닛(204)은 단지 제1 벡터 요소를 처리)하는 반면, 반복들 1-5는 벡터 실행 유닛(204)에 의해 병렬로 처리되고, 반복들 6-7은 벡터 실행 유닛(204)에 의해 병렬로 처리된다.

도 5a 및 도 5b를 참조하면, 프로그램 코드의 벡터화에 대한 하나의 실시예를 도시하는 다이어그램이 도시된다. 도 5a는 원래의 소스 코드를 도시하는 한편, 도 5b는 매크로스칼라 아키텍처를 사용하여 수행될 수 있는 동작들을 나타내는 벡터화된 코드를 도시한다. 도 5b의 벡터화된 코드에서, 루프 1은 소스 코드로부터의 루프인 한편, 루프 2는 서브-벡터 파티션들을 처리하는 벡터-분할 루프이다.

예에서, 어레이 A[]가 전체-길이 벡터들에서 판독되고 비교된다(즉, N개의 요소들의 벡터에 대해, 어레이 A[]의 N개의 위치들이 한 번에 판독된다). 벡터 i2는 벡터의 분할을 제어하는 DIV이다. 분할은, 관찰되는 루프-전이 의존성들을 표시하는, 거짓과 참 사이의 전환들에 대한 술어 p1을 모니터링하여 결정된다. 술어 벡터 p2는, 임의의 시점에서 행동을 취하는 요소들을 결정한다. 이러한 특정 루프에서, p1은 임의의 서브-벡터 분할의 모든 요소들에 동일한 값을 갖고; 따라서, 업데이트할 변수를 결정하기 위해 단지 파티션의 첫 번째 요소만 체크될 필요가 있다.

변수 "s"가 업데이트된 후에, PropagatePostT 명령은 활성 파티션에서의 최종 값을 벡터에서의 후속 요소들로 전파한다. 루프의 상단에서, PropagatePriorF 명령은, 다음 패스에 대비하여 벡터의 모든 요소에 걸쳐 최종 벡터 위치에서 "s"의 마지막 값을 복사한다. 변수 "r"은, 특정 경우에 PropagatePriorF 명령을 사용하는 것의 효율성을 보여주는, 다른 방법을 사용하여 전파된다.

소프트웨어 추측(Software Speculation)

이전의 예제에서, 제어-흐름 결정은 루프-전이 의존성들에 독립적이기 때문에, 벡터-분할 루프의 시작 이전에 벡터 파티션들이 결정될 수 있다. 그러나, 항상 그런 것은 아니다. 예제 2A 및 2B에 도시된 다음과 같은 두 가지 루프를 고려하자:

예 2A에서, 제어-흐름 결정은 루프-전이 의존성 체인에 독립적인 한편, 예제 2B에서, 제어 흐름 결정은 루프-전이 의존성 체인의 일부이다. 일부 실시예들에서, 예제 2B에 있는 루프는, "j"의 값이 계속 변경되지 않을 것이고, 이 예측이 부정확하다는 것이 입증되는 경우에 나중에 보상할 것이라는 추측을 야기할 수 있다. 그러한 실시예에서, "j"의 값에 대한 추측은 루프의 벡터화를 크게 변경하지 않는다.

일부 실시예들에서, 컴파일러는 루프의 반복들 사이에서 어떠한 데이터 의존성도 항상 예측하지않도록 구성될 수 있다. 이러한 실시예에서, 런타임 데이터 의존성이 존재하는 경우, 병렬로 처리된 활성 요소들의 그룹은, 그때에 병렬로 안전하게 처리될 수 있는 요소들의 그룹을 나타내도록 감소될 수 있다. 이러한 실시예들에서, 어떠한 병렬성도 실제로 손실되지 않기 때문에, 실제로 존재하는 것보다 더 많은 병렬성을 잘못 예측할 페널티는 거의 없다(즉, 필요한 경우, 반복은, 비-병렬 방식으로, 한 번에 하나의 요소를 처리할 수 있다.) 이러한 실시예들에서, 병렬성의 실제량은 간단히 나중 스테이지에서 인식된다.

dest=VectorReadIntFF(Base, Offset, pf)

VectorReadIntFF는 VectorReadInt의 제1-폴팅(faulting) 변형이다. 이 명령은, 적어도 제1 활성 요소가 유효 어드레스인 경우에 폴트를 생성하지 않는다. 무효 어드레스에 대응하는 결과들은 강제로 제로가 되고, 플래그들(pf)은 이 데이터를 사용하는 나중 명령들에게 술어들을 마스크하는데 사용될 수 있도록 리턴된다. 어드레스의 제1 활성 요소가 매핑되지 않은 경우, 이 명령은 컴퓨터 시스템(100)의 가상 메모리 시스템(미도시)이 대응하는 페이지를 채우는 것을 허용하도록 폴트하여, 프로세서(102)가 계속 전진(forward progress)하게 만들 수 있도록 보장한다.

dest=Remaining(Pred)

나머지 명령은 술어들의 벡터(Pred)를 평가하고, 벡터에서 나머지 요소들을 계산한다. 이는 마지막 활성 술어에 뒤따르는 비활성 술어들의 세트에 대응한다. Pred에 어떠한 활성 요소도 존재하지 않는 경우, 모든 활성 술어들의 벡터는 리턴된다. 마찬가지로, Pred가 모든 활성 술어들의 벡터인 경우, 비활성 술어들의 벡터가 리턴된다. 예를 들면:

도 6a 및 도 6b는 예제 벡터화된 프로그램 코드의 실시예들을 도시하는 다이어그램들이다. 특히, 도 6a에 도시된 코드 샘플은 (위에서 제시된 바와 같은) 예제 2A에 있는 코드의 벡터화된 버전이다. 도 6b에 도시된 코드 샘플은 예제 2B에 있는 코드의 벡터화된 버전이다. 도 6b를 참조하면, A[]의 판독 및 후속 비교는 벡터-분할 루프 내측에서 이동했다. 따라서, 이러한 동작들은 "j"의 값이 변경되지 않는 것으로 추정(추측)한다. 단지 사용중인 "j"가 존재하는 이후에만, "j"가 값을 변경할 수 있는 곳을 결정하는 것이 가능하다. "j"가 업데이트된 이후에, 나머지 벡터 요소들은 전체 벡터를 통해 반복할 필요에 따라 재-계산된다. 추측에 근거한 코드 샘플에서 나머지 명령의 사용은, 프로그램으로 하여금, 처리하기에 실제로 안전한(즉, 미해결된 데이터 의존성들을 갖지 않는) 요소들의 서브-그룹을 프로그램이 결정할 수 있기 전에 벡터-분할 루프에서 계속 처리될 요소들을 결정하는 것을 허용한다.

다양한 실시예들에서, 폴트-허용 판독 지원(fault-tolerant read support)이 제공된다. 따라서, 이러한 실시예들에서, 프로세서(102)는, 나중에 계산에 사용될 값들을 로드하기 위해 벡터 명령(예컨대, VectorReadFF)의 무효 요소들로부터의 어드레스들을 사용하여 추측에 근거하여 메모리로부터 데이터를 판독할 수 있다. 그러나, 무효 판독이 발생했음을 발견하면, 이러한 값들은 궁극적으로 폐기되고, 따라서 정확한 프로그램 행동에 밀접한 관계가 없다. 이러한 판독들은 존재하지 않거나(non-existent) 보호된(protected) 메모리를 참조할 수 있기 때문에, 이러한 실시예들은, 메모리로부터 실수로 판독된 무효이지만 무관한 데이터의 존재시에 계속 정상 실행(normal execution)하도록 구성될 수 있다. (가상 메모리를 지원하는 실시예들에서, 이는, 페이징할 필요성이 확실해질 때까지 페이징하지 않는 것(not paging)의 추가 이득을 가질 수 있다.)

도 6a 및 도 6b에 도시된 프로그램 루프에서, 나중 반복들에 대한 술어 값에 무관하게, 조건이 참인 반복들과 후속 반복들 사이에 루프-전이 의존성이 존재한다. 이것은 ConditionalStop 명령의 파라미터들에서 반영된다.

도 6a 및 도 6b에서 샘플 프로그램 코드는 추측에 근거하지 않은 및 추측에 근거한 벡터 분할 사이의 차이를 강조한다. 특히, 예제 2A에서, ConditionalStop 이전에 메모리가 판독되고 술어가 계산된다. 분할 루프는 ConditionalStop 명령 이후에 시작한다. 그러나, 예제 2B에서, ConditionalStop 명령은 분할 루프 내측에서 실행되고, 이전 동작들을 무효로 만드는 의존성을 인식하는 역할을 한다. 두 경우에, GeneratePredicates 명령은 분할 루프의 나머지에 사용되는 요소들을 제어하는 술어들을 계산한다.

메모리-기반 루프-전이 의존성(Memory-based loop-carried dependencies)

이전 예제에서, 컴파일러는, 컴파일 시에 어떠한 어드레스 에일리어싱도 존재하지 않도록 구축할 수 있다. 그러나, 이러한 결정은 종종 행하기 어렵거나 불가능하다. 아래의 예제 3에 도시된 코드 세그먼트는, 메모리를 통해 발생하는 루프-전이 의존성(에일리어싱을 포함할 수 있는)이 매크로스칼라 아키텍처의 다양한 실시예들에서 어떻게 다루어지는지를 도시한다.

예 3의 코드 세그먼트에서, 컴파일러는 A[x]가 A[r] 또는 A[s]와 에일리어싱하는지 여부를 결정할 수 없다. 그러나, 매크로스칼라 아키텍처에 의해, 컴파일러는, 하드웨어가 런타임에 메모리 해저드에 대해 체크하게 하고, 정확한 프로그램 행동을 보장하기 위해 런타임에 그에 따라 벡터를 분할하게 하는 명령들을 간단히 삽입한다. 메모리 해저드에 대해 체크하는 하나의 그러한 명령이 아래에 설명되는 CheckHazardP 명령이다.

dest=CheckHazardP(first, second, pred)

CheckHazardP 명령은 메모리를 통해 잠재적인 데이터 의존성에 대한 두 개의 메모리 동작에 대응하는 메모리 어드레스(또는 인덱스들)의 두 개의 벡터를 검사한다. 벡터 'first'는 제1 메모리 동작에 대한 어드레스들을 보유하고, 벡터 'second'는 제2 동작에 대한 어드레스들을 보유한다. 술어 'pred'는 'second'의 요소들 중 동작될 것을 표시 또는 제어한다. 스칼라 루프 반복들이 시간상 전진함에 따라, 순차 반복을 나타내는 벡터 요소들은 벡터들 내에서 왼쪽에서 오른쪽으로 등장한다. CheckHazardP 명령은 이러한 맥락에서 평가할 수 있다. 명령은 대응하는 제1 및 제2 메모리 동작들의 쌍 사이에서 메모리 해저드를 나타내는 DIV를 계산할 수 있다. 명령은 판독 후 기록(write-after-read), 기록 후 판독(read-after-write), 및 기록 후 기록(write-after-write) 메모리 해저드들을 정확하게 평가할 수 있다.

위에서 설명된 ConditionalStop 명령에 의해, 의존하는 데이터를 생성하는 반복에 대응하는 요소 위치는 데이터에 의존적인 반복에 대응하는 요소 위치에서 목표 벡터에 저장될 수 있다. 데이터 의존성이 존재하지 않는 경우, 제로는 의존성이 없는 반복에 대응하는 요소 위치에서 목표 벡터에 저장될 수 있다. 예를 들면:

위에서 도시된 바와 같이, 제1 벡터("first")의 요소 5 및 제2 벡터("second")의 요소 3 둘 다 어레이 인덱스 6에 액세스한다. 따라서, 3은 DIV의 위치 5에 저장된다. 마찬가지로, first의 요소 6 및 second의 요소 2 둘 다 어레이 인덱스 위치 7에 액세스하여, 2가 DIV의 위치 6에 저장되게 하는 등이다. 제로는 데이터 의존성이 존재하지 않는 DIV에 저장된다.

일부 실시예들에서, CheckHazardP 명령은 다양한 크기의 데이터 유형을 설명할 수 있다. 그러나, 명확성을 위해, 우리는 단지 어레이 인덱스 유형을 사용하는 명령의 함수를 설명한다.

위의 예제에서 메모리 액세스는 3가지의 메모리 해저드를 갖는다. 그러나, 설명된 실시예에서, 관련된 메모리 동작을 안전하게 처리하는데 단지 2개의 파티션이 필요할 수 있다. 특히, 요소 위치 3에서 제1 해저드를 처리하는 것은, 낮거나 동일하게 넘버링된 요소 위치들에서의 후속 의존성을 고려할 가치가 없게 만든다. 예를 들면:

벡터가 차단되어야 하는 곳을 결정하기 위해 DIV를 분석하는, 설명된 실시예들에서 사용된 프로세스가 아래에 의사코드로 도시된다. 일부 실시예들에서, 프로세서(102)의 벡터 실행 유닛(204)은 이 계산을 병렬로 수행할 수 있다. 예를 들면:

벡터는 간격 [STARTPOS,x)에 걸쳐 병렬로 안전하게 처리될 수 있는데, x는 DIV[x]>0인 위치이다. 즉, STARTPOS에서 위치 x까지(그러나 포함하지는 않음), STARTPOS는 요소들의 세트가 사전에 처리된 이후의 제1 벡터 요소를 지칭한다. 사전에 처리된 요소들의 세트가 비어 있으면, 그 다음 STARTPOS는 제1 요소에서 시작한다.

일부 실시예들에서, 다수의 DIV는 ConditionalStop 및/또는 CheckHazardP 명령을 사용하는 코드에서 생성될 수 있다. GeneratePredicates 명령은 그러나 벡터를 분할하기 위해 단일 DIV를 사용한다. 이러한 상황에 대처하는 방법에는 두 가지가 있다: (1) 분할 루프가 네스트될 수 있고; 또는 (2) DIV들이 조합되고 단일 분할 루프에서 사용될 수 있다. 이들 중 어느 접근법이라도 정확한 결과를 산출하지만, 최적의 접근법은 문제의 루프의 특성에 따른다. 더 구체적으로, 다수의 DIVS가 의존성을 갖지 않는 것으로 예상되는 경우에, 이를테면, 컴파일러가 간단히 입력 파라미터들에서 에일리어싱을 결정할 수 없을 때, 이러한 실시예들은 다수의 DIV를 하나로 조합할 수 있고, 따라서 분할 오버헤드를 줄일 수 있다. 한편, 많은 실현된 메모리 해저드를 예상한 경우에, 이러한 실시예들은 분할 루프들을 네스트할 수 있어, 가능한 최대 병렬성을 추출할 수 있다(추가 병렬성의 가능성이 존재한다고 가정).

일부 실시예들에서, DIV들은 아래 도시된 바와 같이 VectorMax(A,B) 명령들을 사용하여 조합될 수 있다.

DIV의 요소들은, 시간상 더 이른 의존성들을 나타내는 그 요소의 위치보다 단지 적은 수만 포함해야 하기 때문에, 나중 의존성들은 분할을 더 제약하는 역할을 할 뿐이며, 이는 GeneratePredicates 명령의 관점에서 낮은 값들을 중복시키게 된다. 따라서, 모든 DIV들의 최대를 구하는 것은, GeneratePredicates 명령이, 안전하게 병렬로 처리될 수 있는 요소들의 세트들의 교집합(intersection)을 효과적으로 리턴하게 한다.

도 7은 예제 벡터화된 프로그램 코드에 대한 하나의 실시예를 도시하는 다이어그램이다. 특히, 도 7에 도시된 코드 샘플은 (위에서 제시된 바와 같은) 예제 3에 있는 코드의 벡터화된 버전이다. 도 7을 참조하면, C[] 또는 D[]와 A[] 사이에 어떠한 에일리어싱도 존재하지 않지만, A[]에서의 동작들은 서로 에일리어싱할 수 있다. 컴파일러가 C[] 또는 D[]와의 에일리어싱을 배제할 수 없는 경우에, 컴파일러는 추가의 해저드 체크들을 생성할 수 있다. 이러한 경우에 에일리어싱의 위험이 없기 때문에, 어레이들 C[] 및 D[]에서의 판독 동작들은 벡터-분할 루프의 외측에 위치하는 한편, A[]에서의 동작들은 분할 루프 내에 계속 있다. 실제로 A[]와의 어떠한 에일리어싱도 존재하지 않는 경우, 파티션들은 전체 벡터 크기를 유지하고, 분할 루프는 반복 없이는 단지 실패로 끝나는 것이다. 그러나, 에일리어싱이 발생하는 반복들에 대해, 분할 루프는 데이터 의존성을 존중하기 위해 벡터를 분할하여, 정확한 동작을 보장한다.

도 7의 코드 세그먼트에 도시된 실시예에서, 해저드 체크는 어드레스들의 전체 벡터에 걸쳐 수행된다. 그러나, 일반적인 경우에, 종종 조건부로 실행된 메모리 동작들 사이에 해저드를 체크할 필요가 있다. CheckHazardP 명령은 제2 메모리 동작의 요소들이 활성임을 표시하는 술어를 취한다. 제1 동작의 모든 요소들이 활성이 아니라면, CheckHazardP 명령 자체는 활성인 제1 피연산자의 요소들에 대응하는 제로화 술어(zeroing predicate)로 단정될 수 있다. (이는 제1 메모리 동작이 단정되는 경우에 대해 정확한 결과물들을 산출할 수 있다는 것을 주목한다.)

아래의 예제 4에서 코드 세그먼트는 어레이 E[] 상에 메모리 해저드를 갖는 루프를 도시한다. 코드 세그먼트는 어레이 내에 있는 예측할 수 없는 위치들을 조건부로 판독 및 기록한다. 도 8에서, 예제 벡터화된 프로그램 코드에 대한 하나의 실시예를 도시하는 다이어그램이 도시된다. 특히, 도 8에 도시된 코드 샘플은 예제 4(위에 제시된 바와 같은)에서 코드의 벡터화된 매크로스칼라 버전이다.

도 8을 참조하면, 벡터화된 루프는 어레이 E[]가 각각 판독되는지 기록되는지를 표시하는 술어들 p1 및 p2를 포함한다. CheckHazardP 명령은 메모리 해저드들에 대한 어드레스들(h 및 i)의 벡터들을 체크한다. 파라미터 p2는 제2 메모리 동작(기록)을 제어하는 술어로서 CheckHazardP로 전달된다. 따라서, CheckHazardP는 p2에서 단정된 무조건 판독 및 조건 기록 사이에서 메모리 해저드(들)를 식별한다. CheckHazardP의 결과는 p1에서 제로-단정된(zero-predicated) 것이다. 이는 E[]로부터 판독되지 않은 요소 위치들에 대한 DIV(ix)에 제로들을 배치한다. 제로는 어떠한 해저드도 없음을 표시한다는 것을 상기한다. 따라서, ix에 저장된 결과물은 p1에서 단정된 조건 판독들과 p2에서 단정된 조건 기록들 사이의 해저드를 나타내는 DIV이다. 이는, 해저드가 없는(non-hazard) 조건들이 DIV에서 제로로 표현되기 때문에 가능하게 된다.

위의 실시예에서, 메모리-기반 해저드를 체크하기 위해, CheckHazardP 명령이 사용된다는 것에 주목한다. 위에서 설명한 바와 같이, CheckHazardP 명령은 동작되는 제2 벡터의 요소들을 제어하는 파라미터로서 술어를 취한다. 그러나, 다른 실시예들에서, 다른 유형의 CheckHazard 명령이 사용될 수 있다. 예를 들어, 아래의 다양한 예제들에서 사용된 바와 같이, 원하는 특정 코드 구현에 따라, 술어 파라미터를 생략하는 CheckHazard 명령이 사용될 수 있다. 하나의 실시예에서, CheckHazard 명령의 버전은 두 개의 입력 벡터들에서 무조건적으로 간단히 동작할 수 있다. CheckHazard 명령의 어떤 버전이 이용되는지에 무관하게, 결과 단정 및/또는 제로화를 지원하는 임의의 매크로스칼라 명령에 의해, 결과 벡터의 주어진 요소가 CheckHazard 명령의 실행에 의해 수정되는지 여부는, 위에서 설명된 바와 같이, 술어 벡터 또는 제로화 벡터의 사용을 통해 별도로 제어될 수 있다는 것에 주목한다. 즉, CheckHazardP 명령의 술어 파라미터는 위에서 설명된 일반적인 술어/제로화 벡터와는 다른 측면의 명령 실행을 제어한다.

술어 생성 명령 이후의 제1 후방 분기의 검출( Detection of a First Backward Branch After a Predicate Generating Instruction )

위에서 설명한 바와 같이, 코드 세그먼트를 벡터화할 때, 벡터-분할 루프는, 예를 들어, 메모리 해저드들과 같은, 가능한 루프-전이 의존성을 정확하게 처리하기 위해 벡터화를 수행하는 프로그램 코드에서 사용될 수 있다. 이러한 프로그램 코드에서, 예를 들어, CheckHazard 명령과 같은 매크로스칼라 명령(위에서 설명한)은, 벡터-분할 루프의 일부인 매크로스칼라 GeneratePredicates 명령에 의해 나중에 사용될 수 있는 DIV를 생성할 수 있다. 또한, 벡터-분할 루프는 루프의 일부로서 후방 분기를 사용한다. 위에서 언급한 바와 같이, 이러한 후방 분기가 정확하게 예측되는 경우, 프로세서 성능은 유지될 수 있다. 그러나, 이러한 분기가 제대로 예측되지 못하는 경우(대부분의 경우에 그러함), 성능에 지장이 있을 수 있다. 따라서, 특정한 경우들에는 분기의 예측을 억제하고 DIV가 사용가능하게 되기를 기다리는 것이 유익할 수 있다. 즉, 일부 인스턴스들에서, DIV가 사용가능하게 될 때까지 실행을 효과적으로 스톨링하는 페널티는 벡터-분할 루프의 경계를 형성하는 분기를 예측실패하는 페널티보다 더 적을 수 있다.

여기에 설명된 기술로부터 이익을 얻을 수 있는 벡터-분할 루프의 특정한 예제로서, B[]에 있는 아이템들을 나타내는 히스토그램 A[]을 생성하는 코드 세그먼트의 예제는 아래 예제 5에 도시된다.

컴파일러가 예제 5의 코드 세그먼트를 벡터화할 때, B[]의 벡터의 임의의 요소들이 동일한 값을 포함하는지 여부를 인식해야 한다. 이 작업을 수행하지 않으면, 코드는 A[]의 요소들이 수정될 것임을 인식하지 못할 것이고, 동일한 벡터 내의 A[]의 나중 수정에 영향을 미칠 것이다. 예제 5의 코드 세그먼트에서 임의의 루프-전이 의존성들을 처리하는 벡터-분할 루프를 포함하는 매크로스칼라 코드 세그먼트가 예제 6에 도시된다.

예제 6의 코드 세그먼트에서, CheckHazard 명령은 (V2에 저장된 DIV를 생산하는) 메모리 해저드를 검출하기 위해 메모리 어드레스를 평가하고, GeneratePredicates 명령은 이러한 정보를 사용하여 병렬로 안전하게 처리될 수 있는 요소들의 수를 제어하는 술어를 계산한다. 전체 벡터가 병렬로 안전하게 처리될 수 없는 경우에, 전체 벡터가 처리될 때까지 벡터-분할 루프(PartLoop)는 반복한다(설정되는 캐리-플래그(Carry-flag)와 같이 프로세서 플래그들 중 하나에 의해 지정됨).

루프에 메모리 해저드가 실제로 존재하지 않을 때조차, 컴파일러가 컴파일 시간에 이를 확실하게 결정할 수 없는 경우가 종종 있다. 따라서, 컴파일러가 벡터-분할 루프를 방출하도록 강요되더라도, 전체 벡터는 종종 런타임에 병렬로 처리된다. 종래의 분기 예측자들은 이러한 경우에 효율적으로 동작할 수 있어, 루프가 결코 반복하지 않을 것임을 예측하고, 전체 성능은 유지된다.

그러나, 벡터가 자주 분할되는 경우에, 종래의 분기 예측자들은 종종 제대로 예측하지 못해, 성능에 악영향을 미친다. 이는 벡터-분할 루프들의 본질 때문에 해로울 수 있다. 벡터-분할 루프는 일반적으로 서로에게 순차적으로 의존적인 명령들의 체인을 포함할 것이다. 코드의 이러한 섹션의 성능은 따라서 분기 예측이 완벽한 경우에도 직렬 코드에 의해 제약될 수 있다. 위에서 설명한 바와 같이, 루프의 본질로 인해, 분기들을 제대로 예측하지 못하는 것에 대한 성능 페널티가 존재하고, 잘 예측하는 것에 대한 긍정적인 면(upside)이 제한된다. 또한, 분할 루프가 실제로 한 번보다 많이 반복하는 경우에, 그것은 단지 제한된 횟수(보통 아주 조금의 반복들)만큼 반복할 것이다. 이는 이러한 경우에 높은 예측실패율(mispredict rate)로 이어질 수 있고, 이는 전력과 성능 둘 다에 악영향을 미친다. 따라서, 벡터-분할 루프의 분기 예측 정확도가 매우 중요할 수 있다. 따라서, 아래 더 설명되는 바와 같이, 술어 생성 명령에 뒤따르는 제1 후방 흐름 제어 명령의 검출시에, 그 흐름 제어 명령의 예측은, 예측 정확도에 대한 수신된 표시에 따라, DIV가 사용가능하게 될 때까지 억제될 수 있다.

도 9에서, 벡터-분할 루프를 형성하는 프로그램 명령들의 실행 동안 도 2의 프로세서에 대한 하나의 실시예의 동작을 도시하는 흐름 다이어그램이 도시된다. 도 2 내지 도 9 및 도 9의 블록 901에서 처음을 집합적으로 참조하면, 분기 예측 유닛(210)은 술어 생성 명령에 뒤따르는 제1 조건부 후방 분기 명령을 검출한다. 특히, 하나의 실시예에서, 조건부 후방 분기 명령은 분기 명령에 선행하는 대상 어드레스로(예컨대, 벡터-분할 루프의 시작으로) 분기하는 조건부 분기 명령일 수 있고, 이는 조건문(conditional statement)이 참이라고 평가할 때 분기한다. 예제 6에 도시된 실시예에서, 조건문은 캐리-클리어 조건-코드(carry-clear condition-code)에 의존적이다. 또한, 술어 생성 명령은, 위에서 설명한 바와 같이, DIV와 같은 의존성 벡터에 의존하는 술어 벡터를 만들 수 있는 매크로스칼라 GeneratePredicates 명령일 수 있다. 하나의 구현에서, GeneratePredicates 명령 후에 검출되는 후방 분기 명령은, 둘 다 위에서 자세히 설명되는, 매크로스칼라 CheckHazard 명령 또는 매크로스칼라 ConditionalStop 명령에 의해 설정되는 조건-코드에 근거하는 분기 명령일 수 있다. 매크로스칼라 CheckHazard 명령이 예제 6과 함께 사용되지만, 예를 들어, 단정된 CheckHazardP 명령과 같은 매크로스칼라 CheckHazard 명령의 다른 버전들이 대신 사용될 수 있다는 것이 고려된다는 것에 주목한다.

위에서 설명한 바와 같이, 분기 예측 유닛(210)은 다양한 분기 예측에 대한 예측 정확도 정보를 생성 및 관리할 수 있다. 따라서, 분기 예측 유닛(210)은 후방 분기 명령의 예측 정확도의 표시를 생성 및/또는 수신하도록 구성될 수 있다(블록 903). 하나의 구현에서, 정확도 표시는 정확도를 표시하는 정확도 값일 수 있는 한편, 다른 구현에서, 정확도 표시는 예측 정확도가 미리 결정된 정확도 임계값을 만족하는지 여부를 나타내는 이진 신호일 수 있다.

다양한 실시예에서, 주어진 분기가 예측을 억제할 목적으로 정확하게 예측되는지 아닌지 여부를 결정하는 임계값은 암시적 또는 하드-코딩된 값, 펌웨어 또는 프로세스의 테스트-모드 동작을 통해 수정될 수 있는 값, 또는 소프트웨어에 의해 자유롭게 수정될 수 있는 값일 수 있다. 임계치는 런-타임 행동의 결과에 따라 다양하게 고정되거나 동적으로 달라지도록 허용될 수 있다. 일부 실시예들에서, 상이한 임계값들은 분기 예측 유닛(210)에 의해 유지된 분기 히스토리 테이블에서 주어진 분기와 관련된 통계의 일부로서, 예를 들어, 분기들의 상이한 인스턴스들에 대해 별도로 유지될 수 있다. 대안적으로, 상이한 분기들에 대한 임계치를 명시적으로 저장하는 대신, 분기 예측 유닛(210)은, 위에서 언급된 바와 같이, 주어진 분기가 정확하게 예측되는지 아닌지 여부에 대한 이진 표시를 간단히 저장할 수 있다.

하나의 실시예에서, 후방 분기 명령의 예측 정확도가 미리 결정된 임계치를 만족하지 못한다는 결정에 응답하여, 분기 예측 유닛(210)은 DIV가 사용가능할 때까지 예측을 억제하도록 구성될 수 있다(블록 905). 특히, DIV 정보는 루프가 반복할 정확한 횟수를 표시하므로, 하나의 실시예에서, 분기 예측 유닛(210)은 임의의 향후 분기들을 예측하기 위해 DIV 정보를 사용하도록 구성될 수 있다. 예를 들어, DIV는 벡터가 루프를 통해 3개의 패스를 요구할 수 있다는 것을 표시할 수 있다. 이 정보를 사용하면, 분기 예측 유닛(210)은 후방 분기를 예측실패하는 것을 피할 수 있는데, 그 이유는 루프 반복의 수를 DIV를 통해 확실히 알 수 있기 때문이다.

하나의 구현에서, 분기 예측 유닛(210)은 DIV를 기다리는 동안 파이프라인을 스톨할 수 있어, 임의의 추가 명령들이 페치되는 것을 막을 수 있다. 또 다른 구현에서, 분기 예측 유닛(210)은 사용가능하게 될 DIV를 기다리는 동안 프로세서(102)가 컨텍스트들을 전환하게 할 수 있다. 또 다른 실시예에서, DIV 정보가 사용가능할 때, 분기 예측 유닛(210)은 페치 유닛(201)으로 루프 페치 통지를 보낼 수 있다. 표시에 응답하여, 페치 유닛(201)은 벡터-분할 루프의 각 반복에 대해 명령들을 로드하기 위해 DIV 정보를 사용할 수 있다.

그들은 둘 다 동일한 명령에 의해 생성되기 때문에, 사용가능하게 될 DIV를 기다리는 것과 사용가능하게 될 분기를 제어하는 조건-코드를 기다리는 것은 실질적으로 같을 수 있다는 것에 주목한다. 이로 인해, DIV를 분석하고 그에 따라 분기 예측 유닛(210)을 구성하는데 여러 사이클이 걸릴 수 있더라도, 프로세서(102)의 페치 유닛(201)이 조건-코드에 근거하여 즉시 페칭을 재개하는 것을 허용한다. 이는, 파이프라인이 DIV를 기다리기 위해 스톨되는 경우에 파이프라인 스톨을 최소화할 수 있다. 또한, 하나의 실시예에서, 분기가 억제되고 DIV 정보가 사용되더라도, 분기 예측의 정확도는 이 분기에 대해 계속해서 추적될 수 있다. 이는, 분기 예측 유닛(210)이, 예측의 정확도가 임계치를 만족할 때를 검출하는 것을 허용하고, 사용가능하게 될 DIV를 기다리기보다 오히려 분기를 예측하기 위해 그의 동작 모드를 변경하는 것을 허용한다. 즉, 낮은 정확도에 근거하여 주어진 분기의 예측을 억제하는 결정은 정확도가 개선되는 경우에 나중 시간에 되돌릴 수 있다.

위의 실시예가 상당한 자세히 설명되었지만, 위의 발명이 완전히 인정되면, 수많은 변형 및 수정이 당업자에게 명백해질 것이다. 다음과 같은 청구항들은 이러한 모든 변형 및 수정을 수용하는 것으로 해석되도록 의도된다. 또한, 다음과 같은 청구항들과 양립가능한 것들이 임의의 적절한 조합으로 실행될 수 있도록 의도되고, 이러한 조합은 여기에 명시적으로 개시되도록 명확히 의도된다.

Claims

술어 생성 명령(predicate-generating instruction)에 뒤따르는 제1 조건부 분기 명령(first conditional branch instruction)을 검출하는 단계 - 상기 제1 조건부 분기 명령은 취해질 때 후방으로 분기하고, 상기 술어 생성 명령은 실행될 때 의존성 벡터(dependency vector)에 의존하는 술어 벡터(predicate vector)를 생성하고, 상기 의존성 벡터의 각 요소는 벡터 명령의 요소들 사이에 데이터 의존성이 존재하는지 여부를 표시하는 인덱스를 포함함 - ;
상기 제1 조건부 분기 명령의 예측 정확도의 표시를 수신하는 단계; 및
상기 예측 정확도의 표시에 기초하여, 상기 제1 조건부 분기 명령의 예측 정확도가 임계값을 만족하지 못한다는 결정에 응답하여, 상기 술어 생성 명령이 의존하는 상기 의존성 벡터가 사용가능할 때까지 상기 제1 조건부 분기 명령의 예측을 억제하는 단계
를 포함하는 방법.
제1항에 있어서, 상기 의존성 벡터가 사용가능함을 검출한 것에 응답하여, 상기 의존성 벡터에 표시된 데이터 의존성 정보를 사용하여 상기 제1 조건부 분기 명령을 예측하는 단계를 더 포함하는 방법.
제1항에 있어서, 상기 술어 생성 명령은 매크로스칼라(Macroscalar) GeneratePredicates 명령인 방법.
제1항에 있어서, 상기 제1 조건부 분기 명령의 예측을 억제하는 단계는 상기 제1 조건부 분기 명령을 예측하는 단계 및 상기 예측을 폐기하는 단계를 포함하는 방법.
제1항에 있어서, 상기 제1 조건부 분기 명령의 예측을 억제하는 단계는, 상기 의존성 벡터가 사용가능할 때까지 새로운 명령들이 실행되는 것을 방지하는 단계를 포함하는 방법.
제1항에 있어서, 상기 제1 조건부 분기 명령의 예측을 억제하는 단계는, 프로그램 명령 실행의 제어의 흐름이 상기 제1 조건부 분기 명령의 실행에 의해 변경되지 않는, 이전에 생성된 예측을 폐기하는 단계를 포함하는 방법.
제1항에 있어서, 프로그램 명령 실행의 제어의 흐름이 상기 제1 조건부 분기 명령의 각 실행에 응답하여 변경되는 횟수를 결정하기 위해 상기 의존성 벡터가 사용가능하게 될 때에 상기 의존성 벡터를 사용하는 단계를 더 포함하는 방법.
제1항에 있어서, 상기 제1 조건부 분기 명령의 예측을 억제하는 단계는, 상기 의존성 벡터가 사용가능하게 될 때까지 새로운 명령들이 실행 파이프라인으로 페치되는 것을 방지하는 단계를 포함하는 방법.
제1항 내지 제8항 중 어느 한 항의 방법을 수행하도록 구성된 프로세서.
실행을 위한 명령들을 선택적으로 페치하도록 구성된 페치 유닛(fetch unit); 및
상기 페치 유닛에 결합되고, 술어 생성 명령에 뒤따르는 제1 조건부 분기 명령을 검출하도록 구성된 예측 유닛(prediction unit) - 상기 제1 조건부 분기 명령은 취해질 때 후방으로 분기하고, 상기 술어 생성 명령은 실행될 때 의존성 벡터에 의존하는 술어 벡터를 생성하고, 상기 의존성 벡터의 각 요소는 벡터 명령의 요소들 사이에 데이터 의존성이 존재하는지 여부를 표시하는 인덱스를 포함함 -
을 포함하고,
상기 예측 유닛은 상기 제1 조건부 분기 명령의 예측 정확도의 표시를 생성하도록 구성되고,
상기 예측 유닛은, 상기 제1 조건부 분기 명령의 예측 정확도가 임계값을 만족하지 못한다는 결정에 응답하여, 상기 술어 생성 명령이 의존하는 상기 의존성 벡터가 사용가능할 때까지 상기 제1 조건부 분기 명령의 예측을 억제하도록 구성되는 프로세서.
제10항에 있어서, 상기 예측 유닛은 상기 의존성 벡터에 표시된 데이터 의존성 정보의 수신에 응답하여 상기 제1 조건부 분기 명령을 예측하도록 구성되는 프로세서.
제10항에 있어서, 상기 페치 유닛은 상기 의존성 벡터가 사용가능하게 되기를 기다리는 동안에 스톨(stall)하도록 구성되는 프로세서.
제10항에 있어서, 상기 페치 유닛에 결합되고, 상기 의존성 벡터가 사용가능하게 되기를 기다리는 동안에 컨텍스트들을 전환하도록 구성된 실행 유닛을 더 포함하는 프로세서.
제10항에 있어서, 상기 예측 유닛은 상기 제1 조건부 분기에 대한 예측을 생성하도록 구성되고, 상기 제1 조건부 분기의 예측을 억제하기 위해, 상기 예측 유닛은, 상기 제1 조건부 분기 명령의 예측 정확도가 상기 임계값을 만족하지 못한다는 결정에 응답하여, 상기 제1 조건부 분기 명령의 예측을 폐기하도록 구성되는 프로세서.
제10항에 있어서, 상기 제1 조건부 분기 명령은 명령 루프의 경계를 정의하고, 상기 의존성 벡터는 상기 명령 루프가 실행될 정확한 횟수를 표시하는 프로세서.
제15항에 있어서, 상기 의존성 벡터가 사용가능함을 검출한 것에 응답하여, 상기 예측 유닛은 루프 페치 표시를 제공하도록 구성되고, 상기 페치 유닛은 상기 루프 페치 표시의 수신에 응답하여 상기 명령 루프의 각 반복에 대해 명령들을 페치하도록 구성되는 프로세서.
제10항에 있어서, 상기 제1 조건부 분기 명령의 예측을 억제하기 위해, 상기 예측 유닛은, 상기 의존성 벡터가 사용가능할 때까지 새로운 명령들의 실행을 방지하도록 또한 구성되는 프로세서.
제10항에 있어서, 상기 술어 생성 명령은 매크로스칼라(Macroscalar) GeneratePredicates 명령인 프로세서.
프로그램 명령들을 저장하도록 구성된 메모리; 및
상기 메모리에 결합된, 제10항 내지 제18항 중 어느 한 항의 프로세서의 하나 이상의 인스턴스
를 포함하는 시스템.