KR20180067582A

KR20180067582A - 벡터 로드 명령어

Info

Publication number: KR20180067582A
Application number: KR1020187012811A
Authority: KR
Inventors: 니겔 존 스테펜스
Original assignee: 에이알엠 리미티드
Priority date: 2015-10-14
Filing date: 2016-09-05
Publication date: 2018-06-20
Also published as: JP2018534672A; GB201518154D0; EP3362908A1; GB2543302A; US20180253310A1; GB2543302B; WO2017064452A1; IL257899B; IL257899A; TWI740851B; CN108140011B; CN108140011A; JP6908601B2; TW201716988A; US10564968B2

Abstract

제1 및 제2 타입의 벡터 로드 명령어들이 제공된다. 상기 제1 타입의 명령어에 대해서, 응답 액션은 적어도 하나의 벡터 레지스터의 제1 액티브 데이터 요소에 대해 행해진 로드 연산을 위한 예외 조건을 검출할 때 행해지지만, 그 응답 액션은 상기 제1 액티브 데이터 요소이외의 액티브 데이터 요소를 위한 상기 예외 조건이 검출될 때 억제되고, 상기 예외 조건의 원인이 된 상기 요소를 식별하는 요소 식별 정보가 기억된다. 상기 제2 타입의 명령어에 대해서, 임의의 액티브 데이터 요소에 대해 상기 예외 조건이 일어날 때, 상기 응답 액션은 억제되고 상기 요소 식별 정보는 기억된다. 이러한 해결방법은, 벡터화된 코드의 성능을 향상시키기 위해 루프 추론과 루프 언롤링을 함께 사용되게 하는데 유용하다.

Description

벡터 로드 명령어

본 발명은, 데이터 처리 분야에 관한 것이다. 보다 구체적으로, 본 발명은, 데이터 스토어의 기억장소들로부터 적어도 하나의 벡터 레지스터의 다수의 데이터 요소에 데이터를 로딩하는 벡터 로드 명령어에 관한 것이다.

일부의 데이터 처리장치는, 벡터의 각 데이터 요소에 대해 주어진 처리 연산을 행하여 결과 벡터의 대응한 데이터 요소들을 생성할 수도 있는 벡터 처리를 지원하기도 한다. 이에 따라 다수의 상이한 데이터 값을 단일의 명령어로 처리할 수 있어, 주어진 수의 데이터 값을 처리하는데 필요한 프로그램 명령어들의 수를 감소시킬 수 있다. 벡터 처리를, SIMD(단일 명령어, 다중 데이터) 처리라고도 할 수 있다. 벡터 로드 명령어들은, 데이터 스토어에서 대응한 기억 장소들로부터 적어도 하나의 벡터 레지스터의 각각의 요소들에 데이터를 로딩하는데 사용되어도 된다.

적어도 일부의 예의 장치는,

벡터 로드 명령어에 응답하여, 데이터 스토어로부터 적어도 하나의 벡터 레지스터의 복수의 요소에 데이터를 전송하기 위해 로드 연산들을 행하는 처리회로를 구비하고;

제1 타입의 벡터 로드 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 제1 액티브 데이터 요소에 대해 소정의 순서로 행해진 상기 로드 연산을 위해 예외 조건을 검출할 때, 상기 처리회로는 응답 액션을 행하도록 구성되고, 상기 제1 액티브 데이터 요소 이외의 액티브 데이터 요소에 대해 상기 소정의 순서로 행해진 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 처리회로는, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 요소 식별정보를 기억하도록 구성되고;

제2 타입의 벡터 로드 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 임의의 액티브 데이터 요소에 대해 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 처리회로는, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 상기 요소 식별정보를 기억하도록 구성되고;

상기 제1 타입의 벡터 로드 명령어와 상기 제2 타입의 벡터 로드 명령어는 그들의 명령어 인코딩에 의해 구별된다.

적어도 일부의 예의 데이터 처리방법은,

벡터 로드 명령어에 응답하여, 데이터 스토어로부터 적어도 하나의 벡터 레지스터의 복수의 요소에 데이터를 전송하기 위해 로드 연산들을 행하는 단계;

상기 벡터 로드 명령어가 제1 타입이고, 또 상기 적어도 하나의 벡터 레지스터의 제1 액티브 데이터 요소에 대해 소정의 순서로 행해진 상기 로드 연산을 위해 예외 조건이 검출될 때, 응답 액션을 행하는 단계;

상기 벡터 로드 명령어가 상기 제1 타입이고, 또 상기 제1 액티브 데이터 요소 이외의 액티브 데이터 요소에 대해 상기 소정의 순서로 행해진 상기 로드 연산을 위해 상기 예외 조건이 검출될 때, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 요소 식별정보를 기억하는 단계; 및

상기 벡터 로드 명령어가 제2 타입이고, 또 상기 적어도 하나의 벡터 레지스터의 임의의 액티브 데이터 요소에 대해 상기 로드 연산을 위해 상기 예외 조건이 검출될 때, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 상기 요소 식별정보를 기억하는 단계를 포함하고,

적어도 일부의 예의 장치는,

벡터 로드 명령어에 응답하여, 데이터 스토어로부터 적어도 하나의 벡터 레지스터의 복수의 요소에 데이터를 로딩하기 위해 로드 연산들을 행하는 수단을 구비하고;

제1 타입의 벡터 로드 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 제1 액티브 데이터 요소에 대해 소정의 순서로 행해진 상기 로드 연산을 위해 예외 조건을 검출할 때, 상기 로드 연산들을 행하는 수단은, 응답 액션을 행하도록 구성되고, 상기 제1 액티브 데이터 요소 이외의 액티브 데이터 요소에 대해 상기 소정의 순서로 행해진 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 로드 연산들을 행하는 수단은, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 요소 식별정보를 기억하도록 구성되고;

제2 타입의 벡터 로드 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 임의의 액티브 데이터 요소에 대해 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 로드 연산들을 행하는 수단은, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 상기 요소 식별정보를 기억하도록 구성되고;

또한, 적어도 일부의 예는, 상기 장치에 대응한 가상 머신 실행환경을 컴퓨터가 제공하도록 제어하는 컴퓨터 프로그램도 제공한다. 상기 컴퓨터 프로그램은, 비일시적 기억매체이어도 되는 컴퓨터 판독 가능한 기억매체에 기억되어도 된다.

적어도 일부의 예는, 소스 프로그램에 근거하여, 처리회로에 의해 처리하기 위한 명령어들을 생성하는 컴퓨터 구현 방법을 제공하고, 이 구현 방법은,

상기 소스 프로그램내에서 복수의 반복으로 이루어진 소스 루프를 검출하는 단계로서, 각 반복이 상기 처리회로를 기동시켜 데이터 스토어로부터 적어도 하나의 벡터 레지스터의 복수의 요소에 데이터를 로딩하기 위해 로드 연산들을 행하는 제1 타입의 벡터 로드 명령어로 이루어지고, 상기 제1 타입의 벡터 로드 명령어는, 상기 적어도 하나의 벡터 레지스터의 제1 액티브 데이터 요소에 대해 소정의 순서로 행해진 상기 로드 연산을 위해 예외 조건을 상기 처리회로에서 검출할 때, 상기 처리회로가 응답 액션을 행하는 것과, 상기 제1 액티브 데이터 요소 이외의 액티브 데이터 요소에 대해 상기 소정의 순서로 행해진 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 처리회로가, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 요소 식별정보를 기억하는 것을, 나타내는 인코딩을 갖는, 상기 검출하는 단계; 및

상기 소스 루프를 검출하는 것에 응답하여, 상기 소스 루프보다 적은 반복으로 이루어진 언롤(unrolled) 루프를 위한 명령어들을 생성하는 단계로서, 상기 언롤 루프의 각 반복이 상기 소스 루프의 적어도 2개의 반복에 해당하고, 이 각 반복이,

상기 제1 타입의 벡터 로드 명령어; 및

상기 적어도 하나의 벡터 레지스터의 임의의 액티브 데이터 요소에 대해 행해진 상기 로드 연산을 위한 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 처리회로가, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 상기 요소 식별정보를 기억하는 것을 나타내는 인코딩을 갖는 제2 타입의 적어도 하나의 벡터 로드 명령어로 이루어지는, 상기 생성하는 단계를 포함한다.

적어도 일부의 예는, 상술한 명령어들을 생성하는 방법을 행하도록 구성된 데이터 처리장치도 제공한다.

상술한 명령어들을 생성하는 방법을 컴퓨터가 행하도록 제어하는 명령어들로 이루어진 컴퓨터 프로그램이 제공되어도 된다. 상기 컴퓨터 프로그램은, 비일시적 기억매체이어도 되는 컴퓨터 판독 가능한 기억매체에 기억되어도 된다.

본 기술의 또 다른 측면, 특징 및 이점은, 아래의 첨부도면과 관련지어 이해될 수 있는 다음의 예들의 설명으로부터 명백해질 것이다:
도 1은 벡터 데이터 전송 명령어들을 지원하는 데이터 처리장치의 일례를 개략적으로 도시한 것이고,
도 2는 적어도 하나의 벡터 레지스터의 다수의 데이터 요소와, 인접한 어드레스들의 블록에 대응한 데이터 스토어의 기억장소와의 사이에서 데이터 전송을 행하는 일례를 도시한 것이고,
도 3은 주어진 사이즈의 데이터 요소를 상이한 사이즈의 어드레스들의 블록들에 매핑하는 3개의 예를 도시한 것이고,
도 4는 어드레스들의 블록의 사이즈의 배수로서 지정된 즉시 오프셋 값과, 기본 레지스터를 사용하여, 액세스되는 어드레스들의 블록의 시작 어드레스를 식별하는 벡터 데이터 전송 명령어의 일례를 도시한 것이고,
도 5는 상기 벡터 데이터 전송 명령어를 처리하는 방법을 도시한 것이고,
도 6은 상기 벡터 데이터 전송 명령어를 사용하여 상기 처리회로에 의해 처리되는 명령어들을 생성하는 방법을 도시한 것이고,
도 7 및 도 8은 제1 타입의 벡터 로드 명령어를 위한 예외 조건들의 처리를 도시한 것이고,
도 9는 제2 타입의 벡터 로드 명령어를 위한 예외 조건들의 처리를 도시한 것이고,
도 10 및 도 11은 상기 제1 및 제2 타입의 벡터 로드 명령어를 구별하는 2개의 예를 도시한 것이고,
도 12는 데이터 요소가 명령어들의 시퀀스를 위한 예외 조건을 기동한 것을 식별하는 누적 폴트(fault) 정보를 기록하기 위한 폴트 레지스터의 이용을 도시한 것이고,
도 13은 그 폴트 정보를 사용하여, 폴트가 검출되었던 벡터 로드 명령어를 실행하려고 하는 반복된 시도를 제어하기 위한 2개의 상이한 기술을 도시한 것이고,
도 14는 벡터 로드 명령어를 위한 예외 조건들을 처리하는 방법을 도시한 것이고,
도 15는 상기 제1 및 제2 타입의 로드 명령어를 사용하여 처리회로에 의해 처리하기 위한 명령어들을 생성하는 방법을 도시한 것이고,
도 16은 가상 머신 구현을 도시한 것이다.

이제, 일부의 구체적인 예들에 대해서 설명한다. 본 발명은 이들의 특별한 예들에 한정되지 않는다는 것을 알 것이다.

도 1은 상기 실시예들의 기술들을 이용하여도 되는 시스템의 블록도다. 도 1에 도시된 예에 있어서, 상기 시스템은, 파이프라인식 프로세서의 형태를 취한다. 페치회로(10)가 (하나 이상의 또 다른 레벨의 캐시 이를테면 레벨 2 캐시(50)를 거쳐 메모리(55)에 결합되는 것이 일반적인) 명령어 캐시(15)로부터 명령어들을 불러와, 이 페치회로로부터 각 명령어를 디코딩하는 디코드 회로(20)를 통과시켜, 상기 파이프라인식 프로세서내의 다운스트림 실행 자원들을 제어하여 상기 명령어들에서 필요로 한 연산들을 행하기 위한 적절한 제어신호들을 생성한다. 그 디코딩된 명령어들을 형성하는 제어신호들은, 상기 파이프라인식 프로세서내의 하나 이상의 실행 파이프라인(30, 35, 40, 80)에 발행하기 위한 이슈 스테이지 회로(25)에 보내진다. 그 실행 파이프라인(30, 35, 40, 80)은, 총괄적으로 처리회로를 형성한다고 할 수도 있다.

상기 이슈 스테이지 회로(25)는, 상기 연산들에서 필요로 한 데이터 값들을 기억할 수 있는 레지스터들(60)에게 접근할 수 있다. 특히, 벡터 연산들을 위한 소스 오퍼랜드들은 상기 벡터 레지스터들(65)내에 기억되어도 되고, 스칼라 연산들을 위한 소스 오퍼랜드들은 스칼라 레지스터들(75)에 기억되어도 된다. 추가로, 하나 이상의 서술어(마스크)는, 특정한 벡터 연산들을 행할 때 처리된 벡터 오퍼랜드들의 상기 데이터 요소들을 위한 제어정보로서 사용하기 위한, 서술어 레지스터들(70)에 기억되어도 된다. 또한, 상기 스칼라 레지스터들 중 하나 이상은, 특정한 벡터 연산들의 수행동안에 사용하기 위한 상기 제어정보를 얻는데 사용된 데이터 값들을 기억하는데 사용되어도 된다(예를 들면, 벡터 로드/스토어 명령어는 아래에 설명된 것처럼 스칼라 레지스터를 기본 레지스터로서 지정하여도 된다).

상기 레지스터들(16)은, 각종 제어정보, 이를테면, 상기 처리 파이프라인의 연산을 제어하기 위한 콘피규레이션(configuration) 정보, 또는 처리시에 일어나는 조건들이나 명령어들의 결과들의 특성들을 나타내는 상태 정보를 제공하는 다수의 제어 레지스터(76)도 구비할 수도 있다. 예를 들면, 제어 레지스터(76)는, 보다 상세히 후술할 제1 폴팅(faulting) 레지스터(FFR)(78)와 벡터 사이즈 레지스터(VS)(79)를 구비할 수도 있다.

상기 소스 오퍼랜드들과 임의의 관련된 제어 정보는, 경로(47)를 거쳐 상기 이슈 스테이지 회로(25)에 경로 배정될 수 있어, 각 디코딩된 명령어를 구현하게 행해지는 상기 연산(들)을 식별하는 상기 제어신호들과 함께 상기 적절한 실행 유닛에 발송될 수 있다. 도 1에 도시된 각종 실행 유닛(30, 35, 40, 80)를 벡터 오퍼랜드들에 관해 연산하는 벡터 처리유닛들이라고 가정하지만, 상기 장치에서 지원한 임의의 스칼라 연산들을 처리하길 원하면 (미도시된) 별도의 실행 유닛들을 제공할 수 있다.

상기 각종 벡터 연산들을 생각하면, 산술연산들은, 예를 들면, 필요로 한 소스 오퍼랜드들에 관해 산술 또는 논리 연산을 행할 수 있도록, 상기 소스 오퍼랜드들(및 서술어와 같은 임의의 제어정보)와 함께 산술 논리유닛(ALU)(30)에 전송되어도 되고, 이때 그 결과 값은 일반적으로 상기 벡터 레지스터 뱅크(65)의 지정 레지스터에 기억하는 목적지 오퍼랜드로서 출력된다.

상기 ALU(30)와 아울러, 부동소수점 유닛(FPU)(35)은 디코딩된 부동 소수점 명령어들에 응답하여 부동소수점 연산을 행하도록 구성되어도 되고, 벡터 치환 유닛(80)은 벡터 오퍼랜드들에 관해 특정한 치환 연산들을 행하도록 구성되어도 된다. 추가로, 로드/스토어 유닛(LSU)(40)은, (상기 데이터 캐시(45)와 임의의 중재하는 또 다른 레벨의 캐시, 이를테면, 레벨 2 캐시(50)를 거쳐) 상기 메모리(55)로부터의 데이터 값들을 상기 레지스터 세트들(60)내의 지정 레지스터들에 로딩하도록 로드 연산들을 행하고, 그 레지스터들로부터의 데이터 값들을 상기 메모리(55)에 역으로 기억시키기 위해 스토어 연산들을 행하는데, 사용된다. 도 1에 도시되지 않은 그 밖의 타입의 실행 유닛도 제공될 수 있다는 것을 알 것이다.

도 1에 도시된 시스템은, 명령어들의 시퀀스를 프로그램순으로 실행하는 순차적 처리 시스템이어도 되거나, 이와는 달리 비순차적 시스템이어도 됨에 따라, 성능을 향상시키는 목적으로 상기 각종 명령어들을 실행하는 순서를 기록할 수 있다. 당업자라면 알 수 있듯이, 비순차적 시스템에서는, 상기 명령어들에 의해 지정된 아키텍처 레지스터들을 상기 레지스터 뱅크(45)내의 물리 레지스터들의 풀(pool)(그 물리 레지스터들의 상기 풀은 아키텍처 레지스터들의 수보다 큰 것이 일반적이다)로부터의 물리 레지스터들에 매핑하는 레지스터 리네이밍 회로 등의 (도 1에 명시적으로 도시되지 않은) 추가의 구조를 제공할 수도 있음에 따라서, 특정한 위험을 제거할 수 있고, 비순차 처리에 보다 많은 이용을 용이하게 한다. 추가로, 리오더(reorder) 버퍼는, 비순차 실행을 추적하여, 그 각종 명령어들의 실행의 결과를 순서적으로 적어둘 수 있다.

상술한 실시예들에 있어서, 도 1의 상기 회로는, 상기 벡터 레지스터들(65)에 기억된 벡터 오퍼랜드들에 관해 벡터 연산들을 실행하도록 배치되고, 여기서 벡터 오퍼랜드는 복수의 데이터 요소로 이루어진다. 이러한 벡터 오퍼랜드들에 관해 행해진 특정한 벡터 연산들(이를테면, 산술연산들)에서는, 상기 벡터 오퍼랜드내의 각종 데이터 요소들과 병렬로(또는 반복적으로) 상기 필요한 연산을 적용하여도 된다. (마스크로서도 알려진) 서술어 정보는, 벡터내의 데이터 요소들이 특별한 벡터 연산을 위한 액티브 데이터 요소들이기 때문에, 그 연산을 적용해야 하는 데이터 요소들인 것을 식별하는데 사용되어도 된다.

벡터 처리는, 처리될 데이터의 큰 어레이가 있고 동일한 세트의 연산들이 상기 어레이의 각 구성원에 적용될 필요가 있을 때 특히 유용할 수 있다. 순 스칼라 해결방법에 의해, 명령어들의 시퀀스는, 상기 데이터 캐시(45) 또는 메모리(55)로부터 상기 어레이의 각 요소를 로딩하고, 그 요소를 처리하고 나서, 그 결과를 메모리에 역으로 기억시키고, 이때의 상기 시퀀스는 상기 어레이의 매 요소마다 반복된다. 벡터 처리와 대조하여, 단일 명령어는 상기 어레이의 다수의 요소들을 하나 이상의 벡터 레지스터(65)의 다수의 데이터 요소에 로딩하고 나서, 그 벡터 레지스터들에서의 그 요소들의 각각은 공통 세트의 명령어들에 의해 처리된 후 그 결과들이 상기 데이터 스토어에 역으로 기억된다. 이에 따라, 명령어들의 단일의 시퀀스에 응답하여 다수의 요소를 처리되게 할 수 있어(바람직하게는, 병렬로 적어도 일부의 요소가 처리되게 할 수 있어), 불러오고, 발행하여 실행되는 명령어의 수를 감소시킴으로써 성능을 향상시킬 수 있다.

그러므로, 도 2에 도시된 것처럼, 상기 벡터 처리 시스템은, 어드레스들의 인접한 블록(100)에 해당한 데이터 스토어에서의 기억 장소들과, 적어도 하나의 벡터 레지스터(65)의 다수의 데이터 요소와의 사이에서 데이터를 전송하는 벡터 로드 또는 스토어 명령어들(여기서는, 총칭하여 벡터 데이터 전송 명령어들이라고 함)을 지원할 수도 있다. 로드 명령어의 경우, 상기 적어도 하나의 벡터 레지스터(65)의 각 액티브 요소(102)에, 상기 어드레스들의 인접한 블록(100)의 대응한 부분(104)으로부터 판독된 데이터를 로딩한다. 스토어 명령어의 경우, 주어진 액티브 데이터 요소(102)로부터의 데이터는, 상기 인접한 블록(100)의 상기 대응한 부분(104)에 해당한 기억 장소들에 기억된다.

주어진 벡터 데이터 전송 명령어에 응답하여 접근된 상기 어드레스들의 블록(100)의 특정한 사이즈는 SB다. 그 블록 사이즈 SB=NR×NE×SS이고, 여기서,

· NR은 상기 명령어가 대상으로 하는 레지스터들의 수,

· NE는 각 레지스터에서의 데이터 요소들의 수, 및

· SS는 상기 레지스터(65)의 단일의 데이터 요소(102)에 대응한 상기 어드레스 블록의 서브부분들(104) 중 하나로 표현된 어드레스들의 유닛의 사이즈다.

상기 파라미터 NR, NE, SS 각각은,

· 주어진 프로세서(예를 들면, 일부의 프로세서는, 단일의 벡터 레지스터를 대상으로 하는 로드/스토어 명령어만을 지원하여도 좋다)를 위해 고정 배선된 고정값,

· 상기 제어 레지스터들(76) 중 하나에 (또 다른 변수의 종속성에 의해 명시적으로 또는 묵시적으로) 지정된 변수값, 또는

· 상기 벡터 데이터 전송 명령어의 인코딩에서 (또 다른 변수의 종속성에 의해 명시적으로 또는 묵시적으로) 지정된 변수값 중, 어느 한쪽이어도 된다. 예를 들면, 상기 명령어 인코딩의 연산부호나 또 다른 필드 중 어느 한쪽은, 어느 값을 NR, NE 및/또는 SS에 사용할지를 식별하여도 된다.

따라서, 상이한 명령어 세트 아키텍처들은, 이들 파라미터들을 나타내는 다른 방식을 선택하여도 된다.

예를 들면, 도 1에 도시된 것처럼, 상기 벡터 사이즈 레지스터(79)는 하나의 벡터 레지스터(65)에서 총 비트 수에 해당한 벡터 사이즈 VS를 식별하도록 제공되어도 되고, 상기 명령어 인코딩은, 현재의 연산에 사용되는 데이터 요소 사이즈 ES(즉, 하나의 데이터 요소에서 비트들 또는 바이트들의 수)를 식별하여도 된다. 가변 제어 레지스터에서의 상기 벡터 사이즈 VS를 식별하는 것은, 다른 벡터 사이즈를 사용하여 구현되어도 되는 다양한 플랫폼들에 걸쳐 동일한 코드가 실행되게 하는데 유용하다. 레지스터당 데이터 요소의 수인 NE를, 데이터 요소 사이즈 ES의 사양에 의해 상기 명령어에서 묵시적으로 식별하여도 되는 이유는, 상기 처리회로가 NE=VS/ES를 결정할 수 있기 때문이다. 이 경우에, 상기 인접한 어드레스 블록 사이즈 SB는, SB=NR×VS/ES×SS로서도 표현될 수도 있다.

이때, SB, VS, ES 및 SS는, 주어진 길이의 특정한 단위로, 예를 들면, 비트들의 수 또는 바이트들의 수, 또는 비트들 또는 바이트들의 배수의 수, 또는 일부의 다른 데이터의 유닛으로서 표현될 수 있다. SB가 아래의 예들에서와 같이 바이트로 표현되면, SS도 바이트로 표현되어야 하지만, VS와 ES는 동일한 것이면 다른 단위(예를 들면, 비트들, 바이트들)로 표현될 수 있다. 일반적으로, SB 및 SS는 동일한 단위이어야 하고, VS 및 ES는 동일한 단위이어야 하지만, SB 및 SS는 VS 및 ES와 다른 단위일 수 있다.

한편, 상기 레지스터들의 수 NR은, 상기 명령어 인코딩으로부터 구해져도 된다. 예를 들면, 상기 연산부호는, 이것이 단일, 이중, 또는 삼중 레지스터 로드/스토어인지를 지정하여도 되거나, 상기 명령어는 레지스터들의 수 NR을 지정하는 필드를 포함하여도 된다.

또한, 기억유닛 사이즈 SS는, 명령어 인코딩으로부터도 식별되어도 된다(다시, 상이한 연산부호는 상이한 기억유닛 사이즈 SS에 매핑할 수 있거나, SS를 식별하는 인코딩에서의 필드가 있을 수 있다). 도 3은 상기 기억 유닛 사이즈 SS가 왜 상기 데이터 요소 사이즈 ES와 다를 수 있는가 라는 일례를 도시한 것이다. 도 3의 파트 A)에 도시된 것처럼, 일부의 명령어들은, 주어진 데이터 요소 사이즈(예를 들면, ES=32비트=4바이트)의 데이터 요소에 상기 데이터 스토어로부터 대응한 양의 데이터를 채워, SS=ES=32비트=4바이트가 된다. 그렇지만, 도 3의 파트 B)와 파트 C)에 도시된 것처럼, 일부의 프로세서는, 상기 데이터 스토어로부터의 보다 적은 양의 데이터가 보다 큰 데이터 요소에 또는 요소로부터 전송되는 것도 허가할 수도 있다. 예를 들면, 도 3의 파트 B)와 파트 C)는, 상기 기억 유닛 사이즈 SS가 각각 2바이트 및 1바이트인 경우를 도시한 것이다. 이러한 벡터 로드에 의해, 사이즈 SS의 메모리의 유닛으로부터의 상기 데이터가 사이즈 ES의 하나의 데이터 요소를 채우도록 부호 확장 또는 제로 확장된다. 마찬가지로, 스토어 명령어의 경우, 데이터 요소로부터의 4바이트 값은, 상기 데이터를 상기 데이터 스토어에 기억할 때 2바이트 또는 1바이트로 절단될 수 있다.

한편, 그 밖의 시스템은, 메모리에 로딩하거나 기억할 때 데이터의 확장 또는 절단을 지원하지 않을 수도 있고, 이 경우에, SS는 상기 데이터 요소 사이즈 ES와 같은 고정값일 수 있고, 또 이 경우에 SB는 NR×VS와 같을 뿐이고, 상기 명령어 또는 제어 레지스터에서의 SS를 지정하는 것이 필요하지 않을 것이다.

또한, 상기 블록 사이즈 SB가 NR×NE×SS이지만, 반드시 이들 파라미터를 곱하여서 결정될 필요는 없다. 상기 도시된 것처럼, 이들 파라미터의 하나 이상은, 고정될 수 있거나, 또 다른 관련된 파라미터에 근거하여 결정될 수 있어서, 동등한 결과를 생성하는 그 밖의 방식이 있어도 된다. 또한, 요소들의 수 NE, 기억 유닛 사이즈 SS 및 임의의 다른 관련된 파라미터 이를테면 벡터 사이즈 VS 또는 데이터 요소 사이즈 ES가 대개 2의 거듭제곱일 경우, 그 값들을 곱하는 것이 아니라, 시프트 연산을 사용하여 동등한 결과를 생성할 수 있다.

이러한 타입의 인접한 벡터 로드/스토어 명령어는, 반복적으로 상기 데이터 스토어로부터 데이터의 블록 SB를 로딩하여, 일부의 방식으로 일련의 벡터 데이터 처리 명령어들(예를 들면, 벡터 가산, 벡터 곱셈 등)을 사용하여 처리하고 나서, 그 결과 벡터를 메모리에 역으로 기억시킨 후, 이후의 반복을 위해 상기 블록 사이즈 SB에 대응한 양만큼 상기 블록(100)의 시작 어드레스를 증분시키는, 프로그램 루프를 형성하는데 사용되어도 된다. 따라서, 벡터화된 코드는 아래에 도시된 형태의 루프를 포함하는 경우도 있다:

또한, 이러한 간단한 예는 1개의 반복에 대하여 단일의 벡터 로드만을 도시한 것이고, 실제로는 이후의 데이터 처리에서 그 벡터들을 조합되게 하는 각 반복에서 로딩되는 상이한 벡터들이 일부 있을 수도 있다.

그렇지만, 이러한 루프들을 제공하는 것은, 상기 루프를 도는 상기 프로그램 흐름을 제어하기 위한 명령어들을 실행할 때에 성능대 가격을 초래한다. 상기 로드/스토어 명령어 및 실제의 데이터 처리 명령어들과 아울러, 상기 루프를 관리하기 위한 추가의 명령어들, 이를테면 상기 루프를 몇번 실행하였는지를 나타내는 포인터나 루프 카운터(예를 들면, 위에서 [x0])를 증분/감분하는 명령어와, 상기 루프를 언제 종료할지를 결정하는 한계값과 상기 포인터나 카운터를 비교하는 명령어와, 상기 종료 조건이 아직 충족되지 않을 때 다시 상기 루프의 시작으로 분기하는 조건적 분기 명령어도 필요할 것이다. 이 명령어들은 상기 루프의 반복마다 실행되어야 할 것이고, 이것은 특히 실제의 데이터 처리를 위한 벡터 명령어들의 수와 비교하여 루프 제어 명령어들의 수가 클 때, 성능을 저하시킨다.

상기 루프 제어의 비용을 저감시키기 위해서, 루프 언롤링을 행하여 소스 코드에서의 주어진 프로그램 루프를 더 적은 반복을 하는 언롤 루프로 대체하는 것이 가능하다. 상기 언롤 루프의 각 반복은 원래의 소스 루프의 다수의 반복의 처리를 효과적으로 실시할 명령어들이 보다 많아도 된다. 예를 들면, 상기 언롤 루프의 각 반복이 메모리에서 데이터의 4개의 상이한 블록들에 대응한 데이터를 처리하기 위해 로드 명령어, 데이터 처리 명령어 및 스토어 명령어의 4개의 시퀀스를 포함하는 경우, 상기 루프 제어 오버헤드는 3/4만큼 감소될 수 있다. 이하, 상기와 같은 언롤 루프의 일례가 도시되어 있다:

상기 루프의 개별적인 반복이 보다 길긴 하지만, 상기 제어 명령어들(예를 들면, incb, cmp, bge)을 덜 실행함으로써 전반적인 성능이 향상될 수 있는 경우가 많다. 상기 루프 제어 오버헤드의 감소뿐만 아니라, 루프 언롤링은 프로세서 자원들을 보다 잘 활용할 수도 있는 소프트웨어 파이프라이닝이나 모듈로 스케쥴링과 같은 그 밖의 최적화 기술들을 가능하게 함으로써 성능도 향상시킬 수 있다. 예를 들면, 상기 언롤 루프의 하나의 반복내에서 별개의 벡터 명령어들 중 2개 이상은, 적어도 부분적으로 병렬로(예를 들면, 보다 큰 벡터 사이즈를 사용함으로써) 처리 가능할 수도 있고, 원래의 소스 루프에서 하나의 명령어만은 그 향상이 이용가능하지 않을 시간에 마주칠 것이다. 일부의 경우에, 상기 루프 언롤링은, 소프트웨어로, 예를 들면, 소스 코드를 상기 프로세서 하드웨어에 의해 실행되는 실행 가능 코드로 컴파일링하는 컴파일러에 의해 행해져도 된다. 그렇지만, 하드웨어로, 예를 들면, 루프들을 검출하여 언롤 루프로 대체하여도 되는 상기 파이프라인의 조기의 스테이지에 의해, 루프 언롤링을 행하는 것도 가능하다.

그러나, 레지스터 값들을 사용하여 상기 전송의 시작 어드레스를 지정하는 인접한 벡터 데이터 전송 명령어들은, 단지 몇몇의 이유로 루프 언롤링을 제대로 지원하지 못한다. 인접한 벡터 데이터 전송 명령어들은, 접근되는 어드레스들의 상기 블록(100)의 시작 어드레스 #A를 형성하기 위해, 기본 어드레스를 지정하는 스칼라 기본 레지스터와 상기 기본 레지스터에 가산되는 인덱스 값을 지정하는 스칼라 인덱스 레지스터를 사용하여 상기 시작 어드레스 #A를 지정하여도 된다. 그렇지만, 이 해결방법은 루프 언롤링에 대해 단점이 있는데, 그 이유는, 상기 루프를 행하여 상기 언롤 루프내의 각각의 벡터 데이터 전송 명령어 각각에서 사용한 상기 인덱스 레지스터 전부를 초기화하기 전에 추가의 오버헤드를 필요로 하고, 또한 추가의 명령어가 상기 루프내에서 각 인덱스 레지스터를 증분하는데 필요할 수도 있기 때문이다. 또한, 추가의 인덱스 레지스터들의 이용은, 보다 큰 수의 레지스터들이 상기 루프의 각 반복에서 참조될 필요가 있으므로 상기 스칼라 레지스터 파일에 압력을 증가시킨다. 상기 루프의 하나의 반복내에서 필요로 한 값들 전부를 수용하기에 충분한 스칼라 레지스터들이 없는 경우, 이것은 일부의 레지스터들로부터의 데이터를 상기 메모리나 캐시에 기억되게 하는(예를 들면, 스택에 밀어 넣어지게 하는) 것이 필요할 수도 있고, 상기 스택상에 레지스터들의 이 스필링(spilling)과 필링(filling)은 성능을 손상시킬 수 있으므로 바람직하지 못하다.

대신에, 도 4에 도시된 것처럼, 기본 레지스터(120)와 즉시 오프셋 값(122)을 사용하여 어드레스들의 인접한 블록(100)의 시작 어드레스 #A를 식별하는 벡터 데이터 전송 명령어가 제공된다. 즉시값은, 레지스터를 참조하는 아니라 상기 명령어의 인코딩에서 직접 지정되는 값이다. 상기 기본 레지스터(120) 및 상기 즉시 오프셋 값(122)과 아울러, 상기 명령어 인코딩은, 행해지는 연산의 타입을 식별하는 연산부호(124)와, 하나 이상의 목표레지스터(126)의 표시와, 상기 벡터 연산을 제어하기 위한 서술어 값을 기억하는 서술어 레지스터(128)의 표시도 포함하여도 된다.

기본 레지스터(120)와 즉시 오프셋(122)을 사용하여 목표 어드레스를 지정하는 인접한 벡터 데이터 전송 명령어가 사용 가능할 것이 놀라워 보일지도 모른다. 인덱스 레지스터 대신에, 상기 오프셋을 지정하기 위해 즉시값을 사용하는 것은, 상기 언롤 루프에서의 인덱스 레지스터들과, 보다 많은 레지스터들과 관련된 상기 증가된 레지스터를, 초기화 및 증분하는 비용을 피하지만, 실제로 벡터 프로세서들의 벡터 사이즈는 매우 길 수 있고(예를 들면, 256바이트) 명령어마다의 블록 사이즈 SB는 상대적으로 클 수 있다. 상기 원래의 루프의 4 또는 8개의 반복이 상기 언롤 루프의 단일의 반복으로 풀리는 경우, 상기 루프의 최종 데이터 전송을 위한 필요한 오프셋은, 클 수 있고, 이것을 상기 명령어 인코딩내에서 즉시 오프셋으로 표현하기 위해 상당한 수의 비트들을 필요로 할 수도 있다. 실제로, 많은 벡터 명령어들 세트 아키텍쳐들은 이용 가능한 제한된 인코딩 공간이 있는데, 그 이유는, 상기 명령어 인코딩의 대부분의 비트들이, 상기 연산부호, 상기 목표 레지스터들, 상기 서술어 값, 상기 기본 레지스터, 및 주어진 명령어에서 필요로 할 수도 있는 임의의 다른 파라미터를 지정하기 위해 이미 필요로 하여서, 단지, 큰 즉시 오프셋을 위한 충분한 여유가 없을 수도 있기 때문이다. 또한, 상기 명령어 인코딩에서 비트들의 수를 증가시키는 것은 선택사항일 수 있는데, 그 이유는, 이것이 상기 처리 파이프라인내에서 명령어들을 전송하기 위한 버스들의 사이즈들을 증가시키고 소비전력과 회로면적의 관점에서 너무 비쌀 수도 있는 주어진 프로그램을 기억하는데 필요한 메모리 공간의 양을 증가시킬 것이기 때문이다. 즉시 오프셋 값을 사용하면서 또 다른 이슈는, 상기 언롤 루프내에서 연속적인 데이터 전송 명령어들의 시작 어드레스끼리의 차이가 상기 언롤 루프를 생성하고 있을 때에 알려지지 않을 수도 있는 것이고, 그 이유는, 상술한 것처럼 상이한 하드웨어 구현이 상이한 벡터 사이즈들을 사용할 수도 있거나, 상기 벡터 사이즈가 단일의 구현내에서 가변적일 수 있어서, 상기 컴파일러(또는 상기 루프 언롤링을 행하는 그 밖의 소프트웨어나 하드웨어)가 주어진 명령어를 위해 무슨 오프셋을 지정할 수 있는지를 알리는 것이 가능하지 않을 수도 있기 때문이다. 이들의 이유로, 기본 레지스터와 단순한 즉시 바이트 오프셋을 사용하여 주어진 명령어의 시작 어드레스를 지정하는 것은, 실행 가능한 선택사항으로 보이지 않을 것이다.

그렇지만, 도 4에 도시된 상기 벡터 데이터 전송 명령어에서는, 상기 즉시 오프셋이 절대치가 아니라, 로딩되는 어드레스들의 인접한 블록의 상기 블록 사이즈 SB의 배수로서 지정되어 있다. 상기 로드/스토어 유닛(40)은, 상기 스칼라 기본 레지스터 Xb에 기억된 기본 어드레스를 상기 즉시 오프셋값 imm과 상기 블록 사이즈 SB와의 곱에 가산하는 결과와 동일한 값을 갖는 상기 시작 어드레스 #A를 생성하는 어드레스 생성유닛을 구비하여도 된다. 상기 블록 사이즈 SB는, 도 2에 대해 상술한 것처럼 NR×NE×SE와 같게 결정될 수 있다. 상기 즉시값 imm과 상기 블록 사이즈 SB와의 곱은 다양한 방식으로 결정될 수 있었다. 일부의 구현은 실제로 상기 즉시값 imm과 상기 블록 사이즈 SB를 곱할 수 있었지만, 그 블록 사이즈 SB가 2의 거듭제곱인 경우, 또 다른 선택사항은 log₂(SB)에 대응한 비트들의 수만큼 상기 즉시값 imm을 왼쪽으로 시프트시키는 것이다. 그 후, 그 곱은 상기 기본 어드레스에 가산되어 상기 시작 어드레스 #A를 생성할 수 있다.

도 5는 인접한 벡터 데이터 전송 명령어를 처리하는 방법을 도시한 것이다. 단계 130에서는, 상기 명령어가 기본 레지스터와 즉시 오프셋을 지정하는 인접한 벡터 데이터 전송 명령어인지를 판정한다. 아닐 경우, 상기 명령어는 다른 방식으로 처리된다. 그 명령어가 기본 레지스터와 즉시 오프셋을 지정하는 인접한 벡터 데이터 전송 명령어일 경우, 단계 132에서, 상기 로드/스토어 유닛(40)은, 상기 기본 어드레스 #base를 상기 곱 imm×SB에 가산하는 결과와 동일한 값을 갖는 상기 시작 어드레스 #A를 산출한다. 이때, 그 시작 어드레스 #A는 #base+imm×SB와 동일한 결과를 제공하는 임의의 방식으로 결정될 수 있지만 실제로 이렇게 산출될 필요가 없다(예를 들면, 상기 곱셈은 대신에 상술한 것처럼 시프트를 사용하여 구현될 수 있었다). 단계 134에서, 상기 로드/스토어 유닛은, 각 데이터 요소가 어드레스 #A에서 시작하는 어드레스들의 상기 인접한 블록(100)의 각각의 부분에 대응하고 그 데이터 요소가 서술어 레지스터(128)에서의 서술어에 의해 액티브 데이터 요소로서 나타내어질 때 주어진 데이터 요소와 상기 어드레스 블록(100)의 상기 대응한 부분(104)과의 사이에서 데이터 전송이 행해지는, 일련의 데이터 전송을 기동시킨다. 예를 들면, 상기 목표 레지스터의 최하위 요소는 어드레스 #A에서의 상기 데이터에 매핑할 수 있고, 다음 요소는 어드레스 #A+SS에서의 상기 데이터에 매핑할 수 있는 등을 매핑할 수 있고, 이때 상기 하나 이상의 목표 레지스터(65)의 n번째 요소는 어드레스 #A+n*SS(여기서, O≤n<NR×NE)에 대응한다.

이러한 해결방법은, 블록 사이즈 SB의 배수로서 상기 즉시 오프셋을 지정함으로써, 상기 프로그램 코드를 기록하거나 상기 코드를 컴파일링하는 시간에 상기 벡터 사이즈 VS를 아는 것이 필요하지 않기 때문에 상술한 문제들을 해결한다. 이에 따라, 벡터 사이즈가 상이한 다양한 상이한 하드웨어 구현으로 동일한 명령어들이 실행될 수 있다. 또한, 실제로 즉시 오프셋을 지정하는 인접한 벡터 로드/스토어 명령어가 루프 언롤링에만 유용하고, 레지스터 압력이 상기 언롤 루프의 단일의 반복으로 풀릴 수 있는 상기 원래의 소스 루프의 반복들의 수를 제한하게 될 것이기 때문에, 실제로 상기 즉시 오프셋(122)은, 매우 작게 할 수 있다. 예를 들면, 많은 시스템에 있어서, 상기 원래의 루프의 8보다 많은 반복을 단일의 반복으로 푸는데 특이할 수 있어, 범위값 0 내지 7에서 포지티브 값들을 나타내는 3비트의 부호없는 즉시값이 충분할 수도 있다. 이것이 의미하는 것은, 상기 명령어 세트 아키텍처들의 인코딩 공간이 제한되었을 때에도, 매우 작은 즉시 오프셋(122)은 상기 명령어 세트 인코딩내에 맞추어도 된다는 것이다.

도 4는 상기 명령어의 주어진 비트들의 패턴을 사용하여 명령어의 인코딩을 도시한 것이지만, 어셈블러 구문에서 그 명령은 아래와 같이 표현될 수 있다:

여기서, 상기 예들 모두에서 상기 즉시값은, 4비트 이진값 Ob0001로서 인코딩되지만, 메모리로부터 로딩되는 레지스터들의 수의 배로서 상기 구문으로 표현된다. 연상기호 LD1H, LD2H, LD3H를, 로딩되는 레지스터들의 수(즉, 각각, NR=1, 2 및 3)를 말한다. 이와는 달리, 상기 어셈블러 구문은, 상기 도시된 3가지 경우 모두에 대해 상기 즉시값을 #1로서 규정할 수 있다.

이하에는 루프 언롤링을 위한 명령어의 이러한 형태를 사용하는 예가 도시되어 있다:

본 예에서, 상기 언롤 루프의 제1 벡터 로드 명령어는 0의 즉시 오프셋을 갖고, 연속적인 또 다른 로드들은 1, 2, 3 등의 즉시 오프셋을 지정하여 상기 블록 사이즈 SB의 그 유닛들의 수만큼 각각 변위된 어드레스들의 블록으로부터 각 로드가 데이터를 로딩할 것을 가리킨다.

그렇지만, 실제로, 상기 언롤 루프의 제1 로드가 0 오프셋을 지정하는 것이 필수적이지 않다. 소프트웨어 파이프라이닝 기술들은, 상기 루프의 시작과 종료이외의 상기 루프내 위치에서의 상기 루프 포인터를 증분하는 것을 바람직하게 할 수도 있고, 그래서, 이 경우에 상기 기본 레지스터의 참조점은 상기 언롤 루프의 중간 로드 명령어들 중 하나의 어드레스일 수 있다. 이것은, 네가티브 오프셋들이 지정되게 하는 것을 유용하게 할 수 있다. 이 때문에, 상기 즉시 오프셋 값(122)은, 주어진 수의 비트로 2의 보수 형태로 인코딩될 수 있는 부호있는 정수값으로서 지정될 수 있다. 예를 들면, 4비트는, -8 내지 +7의 범위내에서 2의 보수값을 인코딩할 수 있었다. 예를 들면, 제1의 2개의 로드(load) 후이지만 최종의 2개의 로드 전에 상기 루프를 증분하는 경우, 상기 오프셋들은 다음과 같이 규정될 수 있었다:

도 6은 루프 언롤링을 행하는 방법을 도시한 것이다. 이 방법은, 주어진 소스 프로그램에 응답하여 상기 처리회로에 의해 처리하기 위한 명령어들을 생성하는 임의의 소프트웨어나 하드웨어에 의해 행해져도 된다. 예를 들면, 이 방법은, 소스 프로그램을 가지고 가 실행되는 컴파일링된 코드를 생성하는 컴파일러에 의해 행해질 수 있었거나, 상기 방법은 실제로 상기 명령어들을 실행할 동일한 처리 파이프라인내에서 상기 회로에 의해 즉시 행해질 수 있었다. 일반적으로, 상기 루프 언롤링을 행하는 상기 하드웨어나 소프트웨어를, 루프 언롤러라고 한다.

단계 140에서는, 상기 소스 프로그램의 명령어들을 수신한다. 단계 142에서는, 상기 소스 프로그램이 다수의 반복을 갖는 소스 루프를 포함하는지를 검출하고, 이때의 각 반복 i는 사이즈 SB의 어드레스들의 인접한 블록을 대상으로 하고 시작 어드레스 A[i]를 갖는 벡터 데이터 전송 명령어를 포함한다. 상기 소스 프로그램이 이와 같은 루프를 포함하지 않는 경우, 본 방법은 종료하고 상기 소스 프로그램이 다른 방식으로 처리된다. 그렇지만, 상기 소스 프로그램이 이와 같은 루프를 포함하는 경우, 단계 144에서, 상기 루프 언롤러는, 그 소스 루프보다 반복이 적은 언롤 루프용 명령어들을 생성하고, 이때의 언롤 루프의 각 반복은, 상기 소스 루프의 N개의 반복에 해당하고, 시작 어드레스를 기본 레지스터와 제로 오프셋을 사용하여 지정하는 적어도 참조 벡터 데이터 전송 명령어와, 시작 어드레스를 상기 블록 사이즈 SB의 배수로서 지정된 즉시값과 기본 레지스터를 사용하여 지정하는 적어도 하나의 또 다른 벡터 로드 또는 스토어 명령어를 포함한다. 상기 언롤 루프의 각 반복은, 상기 기본 레지스터를 N×SB에 해당한 양만큼 증분하기 위한 증분 명령어도 포함할 수도 있다. 상기 루프내에서 상기 기본 레지스터를 증분하는 타이밍에 따라, 상기 참조 명령어는 상기 루프의 그 밖의 벡터 데이터 전송 명령어들보다 조기, 나중 또는 도중일 수 있다. 후술하듯이 상술한 것과 같은 방식으로 즉시 오프셋을 사용하거나 레지스터 레퍼런스를 사용하여 상기 참조 벡터 데이터 전송을 위한 제로 오프셋이 지정될 수 있었다.

단계 146에서는, 상기 처리회로에 의해 처리하기 위해 상기 생성된 명령어들을 출력한다. 예를 들면, 그 명령어들은, 컴파일된 프로그램으로서 출력되고 나서 상기 처리회로에 의해 처리하기 위해 메모리(55)에 기억될 수 있다. 또는, 파이프라인내에서 즉시 상기 언롤링을 행하고 있는 중일 경우, 상기 출력된 명령어들은, 이후의 스테이지에 보내져 처리된다.

상기 즉시 오프셋 필드(122)의 특별한 사이즈는, 사용되고 있는 상기 특별한 명령어 세트 아키텍처에 좌우될 수도 있다. 실제로, 상기 벡터 레지스터들(60), 스칼라 레지스터들(75) 또는 서술어 레지스터들(70)의 수는, 상기 언롤 루프의 단일의 반복으로 풀릴 수 있는 상기 소스 루프의 반복들의 수에 효과적 한계를 둘 수도 있어서, 이 한계보다 큰 어떠한 값도 수용하는 즉시 오프셋 필드(122)를 제공하는데 유용하지 않을 수도 있다. 예를 들면, 상기 소스 루프의 각 반복이 R개의 스칼라 레지스터의 최대를 사용하고 상기 아키텍처가 M개의 스칼라 레지스터를 규정한다고 예상하는 경우, 실제로 단일의 반복으로 풀릴 수 있는 상기 소스 루프의 반복의 최대수는 M/R일 것이기 때문에 상기 즉시 오프셋 필드(122)의 사이즈는 표현 가능한 최대값이 M/R-1이도록 선택될 수 있었다. 또한, 추가의 비트는, 네가티브 및 포지티브 오프셋의 양쪽을 규정할 수 있도록 부호있는 값들을 수용하게 할당될 수 있었다. 예를 들면, R은 2 또는 4인 경우가 많을 수도 있어서, M/2-1 또는 M/4-1의 오프셋 값들을 인코딩하기 위해 충분한 비트 공간을 제공하는 것이 충분할 수 있다. 예를 들면, M=32이면, 8개 반복보다 많은 언롤링이 드문 경우도 많아서, 3비트의 부호없는 오프셋 필드 또는 4비트의 부호있는 필드는 즉시 오프셋을 갖는 상기 벡터 데이터 전송 명령어가 사용될 가능성이 높은 가장 실용적인 상황을 수용하기에 충분할 수 있다. 한편, 스칼라 레지스터들보다 서술어 레지스터들(70)이 적게 있을 경우, 그것은, 실제로 언롤 루프의 단일의 반복으로 풀릴 수 있는 루프의 반복들의 수에 관한 제한 인자(factor)인 서술어 레지스터들의 수이어도 된다. 따라서, 일반적으로, 언롤링의 수를 제한하는 제약들이 약간 있어도 좋고, 상기 즉시 오프셋 필드(122)의 사이즈는 주어진 구현을 위해 생기는 그 제약들에 근거하여 선택되어도 좋다.

요약하면, 기본 레지스터와 즉시 오프셋 값을 사용하여 어드레스들의 인접한 블록의 시작 어드레스를 식별하는 벡터 데이터 전송 명령어는, 의외로, 벡터들이 상대적으로 길거나 벡터 길이가 가변인 시스템에서도 유용하다. 상기 즉시 오프셋 값은 상기 하드웨어에서 사용한 상기 벡터 길이에 따라 가변적으로 선택되어도 되는 상기 어드레스들의 인접한 블록의 사이즈의 배수로서 규정되므로, 절대 블록 사이즈를 미리 알 필요가 없어, 상이한 벡터 길이를 사용한 상이한 플랫폼들에 걸쳐서, 또는 가변 벡터 길이를 지원하는 하나의 플랫폼상에서, 동일한 코드가 실행될 수 있다. 루프 언롤링을 위해, 언롤된 반복들의 수가 상대적으로 작다고 예상되므로, 상기 즉시 오프셋 값은, 상기 명령어 인코딩에서 큰 필드를 필요로 하지 않아서 이용 가능한 인코딩 공간이 제한된 명령어 세트 아키텍처에서도 사용될 수 있다.

이러한 형태의 벡터 데이터 전송 명령어를, 상기 어드레스들의 인접한 블록의 고정된 사이즈를 사용하는 장치에서 사용할 수 있었지만, 상기 어드레스들의 블록의 가변 사이즈를 제공하는 장치에서 특히 유용하다. 상기 장치는, 상기 즉시 오프셋 값에 적용되는 승수를 결정하여 상기 기본 어드레스에 대한 상기 오프셋을 형성하기 위해서 상기 명령어를 실행할 때 판독되어도 되는 가변 제어 파라미터를 기억하기 위한 기억소자를 가져도 된다. 예를 들면, 상기 가변 제어 파라미터는, 하나의 벡터 레지스터의 사이즈를 식별하는 벡터 사이즈일 수 있다.

접근되는 상기 인접한 블록의 시작 어드레스는, 상기 어드레스들의 인접한 블록의 사이즈에 대응한 승수와 상기 즉시 오프셋 값과의 곱에, 상기 기본 어드레스를 가산하는 것과 동일한 다양한 방식으로 결정될 수 있었지만, 실제로 이렇게 결정될 필요는 없다. 상기 승수의 값은 곱 NR×NE×SS와 같아도 되고, 여기서, NR은 데이터가 상기 벡터 데이터 전송 명령어에 응답하여 전송되기 위한 것인 벡터 레지스터들의 수이고, NE는 각 벡터 레지스터에서 포함한 데이터 요소들의 수이고, SS는 단일의 데이터 요소에 대응한 어드레스들의 유닛의 기억 유닛 사이즈다. NR, NE, SS 각각은, 고정되고, 상기 명령어 인코딩에서 규정되고, 또는, 제어 레지스터에 기억된 가변 파라미터에 따라 규정될 수 있었다.

하나의 유용한 해결방법은, 벡터 사이즈VS(하나의 벡터 레지스터의 사이즈)가 제어 레지스터에 규정되기 위한 것과, 상기 명령어 인코딩이 NR, SS 및 ES(하나의 데이터 요소의 사이즈)를 (상기 연산부호를 거쳐 명시적으로 또는 묵시적으로) 식별하기 위한 것과, 상기 승수가 NR×VS/ES×SS와 같게 결정되기 위한 것이다. NR, SS, ES를 실시될 필요가 있는 상기 연산들에 따라 프로그래머/컴파일러가 모두 미리 알 가능성이 높고, VS는 특별한 하드웨어 구현에 좌우된다. 따라서, 제어 레지스터에서는 VS이지만 상기 명령어 인코딩을 사용하여 그 밖의 파라미터 NR, SS, ES를 규정하는 것은, 동일한 코드가, 상이한 벡터 사이즈들을 사용한 다양한 하드웨어 구현에 걸쳐 실행되게 한다.

실제로 상기 즉시 오프셋을 곱하기 위한 승수를 결정하기 위해서 곱셈을 행할 필요는 없다. NE, SE, ES, VL의 가능한 값들은 2의 거듭제곱에 해당하는 경우가 많을 수도 있어서, 특정한 수의 비트들만큼의 좌측 시프트는, 곱셈과 같을 수도 있다.

상기 즉시 오프셋 값은, 네가티브 오프셋들을 필요로 하지 않는 보다 작은 즉시 필드를 고려하는 부호없는 정수값일 수 있다. 또는, 상기 즉시 오프셋 값은, 네가티브 오프셋들의 사용을 허가하는 부호있는 정수값일 수 있고, 이 부호있는 정수값은, 네가티브 오프셋들을 허가하는 것이 예를 들면 소프트웨어 파이프라이닝 기술들을 사용하여 성능을 향상시키는데 유용할 수 있는 상기 루프의 다른 점들에서 상기 기본 어드레스를 갱신하는데 보다 많은 융통성을 제공하기 때문에, 유용하다.

상기 벡터 데이터 전송 명령어에서 참조한 기본 레지스터는, (로딩/기억되는 상기 목표 벡터의 요소마다 상이한 어드레스들을 식별하기 위해 벡터 레지스터를 지정하여도 되는 스캐터-게더형 로드/스토어 명령어와는 대조적으로) 스칼라 레지스터이어도 된다.

일부의 경우에, 상기 벡터 데이터 전송 명령어가 벡터 로드 명령어일 경우, 상기 벡터의 주어진 데이터 요소에 대해 행해진 상기 로드 연산을 위해 예외 조건이 검출될 때, 그 예외 조건를 처리하는 응답 액션이 억제될 수 있고, 대신에, 데이터 요소가 상기 예외 조건을 기동시키는 상기 주어진 데이터 요소인지를 식별하는 요소 식별 정보가 기억될 수 있다. 이 해결방법은, 일부의 요소들이, 실제로 처리되어야 하는지를 통제하는 연관 조건이 해결되어 있기 전에 처리되는 루프 추론을 허가하는데 유용하여, 성능 향상에 도움이 될 수 있다. 이를 보다 상세히 후술하겠다.

상기 즉시 오프셋 값을 지정하는 상기 벡터 데이터 전송 명령어는, 로드 명령어 또는 스토어 명령어이어도 좋다.

벡터화된 코드를 처리하면서 또 다른 이슈는, 어드레스 변환 폴트(fault)들 또는 메모리 허가 폴트들과 같은 예외 조건들을 처리하는 것이다. 상기 벡터화된 코드로 처리하는 데이터의 어레이는, 상기 블록 사이즈 SB의 정확한 배수를 포함하지 않아서, 상기 루프의 최종 반복은 유효 데이터를 처리하는 일부의 요소들만을 가져도 좋은 경우가 많다. 일부의 벡터화된 루프들에 있어서, 상기 루프의 각 반복은, 로딩된 데이터 요소들 중 하나가 상기 어레이의 끝에 도달하였다는 것을 가리키는 정지 조건을 충족하는지를 확인하는 적어도 하나의 명령어를 가져도 좋고, 이러한 조건을 충족하면 상기 루프를 종료하여도 된다. 다음 요소를 로딩하기 전에 각 요소가 상기 정지 조건에 대해 별도로 로딩 및 시험되어야 했으면, 벡터화의 성능 이점들이 손실되었을 것이고, 그래서 일반적으로 상기 벡터 로드 명령어들은 데이터의 블록을 로딩하고 나서, 그 로딩된 데이터의 임의의 요소가 상기 정지 조건을 충족시키는지를 시험한다. 이 때문에, 일부의 요소들은, 그 요소들이 처리될 필요가 있는 유효 요소들인지를 실제로 알려지기 전에 로딩되어도 된다. 그 요소가 처리되어야 하는지를 결정하기 위한 연관 조건이 해결되기 전에 적어도 하나의 요소가 처리되는 본 기술을, 루프 추론이라고 부르기도 한다.

주어진 상기 루프의 반복이 처리되는 상기 어레이의 끝을 지나 연장되는 데이터를 로딩하는 경우, 이것은, 상기 어레이의 끝을 지나 어드레스들을 위한 페이지 테이블들에 어드레스 변환 데이터가 규정되어 있지 않을 수도 있기 때문에, 어드레스 변환 폴트를 일으키는 폴트의 원인이 될 수도 있고, 또는 실행중인 상기 프로세스는 상기 어레이의 끝을 지나 상기 어드레스들에의 접근을 허가하지 않을 수도 있어, 메모리 허가 폴트의 원인이 된다. 따라서, 어드레스 변환 폴트들 또는 메모리 허가 폴트들과 같은 예외 조건은, 루프 추론을 사용할 때 보다 가능성이 높을 수도 있다.

예외 조건이 주어진 데이터 요소에 대해 일어나지만 상기 어레이의 끝에 아직 도달되지 않았을 경우, 이것은 유효 예외 조건이고, 폴트를 다루는 예외 처리 루틴을 실행하는 것과 같은 대응한 응답 액션이 취해질 필요가 있기도 하다. 예를 들면, 상기 예외 처리 루틴은, 운영체계를 기동하여, 상기 필요한 어드레스에 대해 어드레스 변환 매핑을 규정하기 위해 상기 페이지 테이블들을 갱신할 수 있었다. 그렇지만, 상기 필요한 어레이의 끝을 지나 어드레스로부터 로딩된 요소에 대해서는, 예외 조건이 일어나면, 그 응답 액션을 기동하는 것이 바람직하지 않을 것인데, 그 이유는, 어쨌든 그 어드레스에 접근되지 않았어야 하고 그 어드레스에서의 로드가 상기 어레이의 끝을 한단계 뛰어넘는 주어진 벡터 길이VL 또는 블록 사이즈SB를 갖는 코드를 벡터화하는 아티팩트로서만 기동되었기 때문이다. 그러므로, 상기 루프 추론을 행할 때, 예외 조건 전부에 대한 응답 액션을 기동하는 것이 바람직하지 않을 수도 있다.

도 7 및 도 8은, 이를 해결하기 위한 제1 타입의 벡터 로드 명령어의 연산을 도시한 것이다. 제1 타입의 명령어는, 로딩되고 있는 상기 벡터의 제1 액티브 요소에 대한 예외 조건이 검출될 때 응답 액션을 기동하지만, 그 밖의 요소들에 대한 예외 조건이 일어날 때 그 응답 액션을 기동하지 않기 때문에, 제1 폴팅(First-Faulting)(FF) 로드 명령어라고도 불린다. 본 예에서는, 최하위 요소로부터 최상위 요소까지 진행하는 소정의 시퀀스에서 상기 요소들을 고려하므로, 상기 제1 액티브 요소는, 상기 서술어 값 Pg만큼 액티브로서 나타내어진 최하위 요소다. 예를 들면, 도 7에 있어서, 요소 0은 0의 서술어 비트를 갖고, 요소 1은 1의 서술어 비트들을 가져서, 제1 액티브 요소가 요소 1이다.

도 7에서, 예외 조건은, 제1 액티브 요소(요소 1)에 대해 행해진 상기 로드 연산을 위해 일어나서, 상기 예외 처리 루틴을 실행하는 것과 같은 상기 응답 액션이 기동된다. 일반적으로, 상기 제1 액티브 요소는, 상기 정지 조건이 만족되게 할 수 있는 조기의 액티브 요소들이 없기 때문에 비추론적으로 로딩될 것이고, 그래서 폴트가 일어나면 이것은 유효 폴트이고 상기 응답 액션은 이것을 다루도록 기동된다.

한편, 도 8에 도시된 것처럼, 상기 제1 폴팅 벡터 로드 명령어에 대해서는, 상기 제1 액티브 요소이외의 요소(예를 들면, 본 예에서 요소 2)를 위한 예외 조건이 일어나는 경우, 상기 응답 액션이 억제된다. 대신에, 상기 처리회로는 상기 제1 폴팅 레지스터(FFR)(78)를 갱신하여 어느 요소가 그 폴트의 원인이었는지를 식별한다. 이후의 데이터 요소들 중 하나이상이 (상기 제1 액티브 요소이외에) 폴트가 있었을 경우, 이 요소들 중 제1 요소의 위치는 상기 FFR(78)에 식별될 수 있거나, 아래에 설명된 것처럼 상기 FFR은 그 폴트가 있던 상기 제1 요소와 임의의 이후의 요소들을 식별하여도 된다.

이 해결방법은, 일반적으로, 상기 제1 액티브 요소이외의 요소를 위한 예외 조건이 일어날 때 상기 응답 액션이 즉시 기동되지 않는다는 것을 의미하기 때문에 루프 추론에 유용하다. 상기 FFR(78)을 갱신하였으면, 일부의 명령어들은 폴트가 있던 상기 요소보다 조기의 요소를 위한 상기 정지 조건이 충족되는지를 확인할 수 있고, 충족될 경우, 상기 예외 조건을 처리하지 않고 상기 루프를 종료할 수 있는데, 그 이유는, 상기 예외 조건이, 상기 벡터 루프가 처리되는 상기 데이터의 끝을 지나 연장되었기 때문에만 일어났기 때문이다. 한편, 상기 정지 조건이 아직 충족되지 않았을 경우, 상기 FFR(78)은 어느 요소가 상기 예외 조건을 기동하였는지를 식별하는데 사용될 수 있고, 이것은, 상기 예외 조건이 다시 일어나는 경우, 상기 폴트 요소가 상기 제1 액티브 요소이기 때문에 상기 응답 액션이 기동될 수 있도록 지금 폴트가 있던 상기 요소가 상기 제1 액티브 요소이면서 상기 루프로 된 명령어들의 시퀀스의 반복을 기동하는데 사용될 수 있다. 따라서, 상기 제1 폴팅 해결방법이 처리중인 유효 예외 조건들을 지연하여도 되지만(그 이유는, 상기 명령어들의 시퀀스가 수회 반복될 필요가 있음에 따라서 폴트가 있는 각기 각각의 요소가 상기 제1 액티브 요소로서 취급될 수 있기 때문이다), 이 오버헤드는, 상기 정지 조건을 해결하기 전에 상기 루프의 반복당 데이터의 큰 블록을 로딩하는 경우에도, 상기 제1 폴팅 메카니즘이 나중에 판명될 필요가 없는 추론적을 처리된 요소들에 의해 의사 응답 액션들이 기동되지 못하게 하기 때문에 가능한 (루프 제어 오버헤드가 덜 들게 되는) 상기 루프의 반복당 보다 많은 요소들이 처리되게 허가함으로써 이루어진 성능 이득만큼 보다 더 커지는 것이 일반적이다.

도 8에 도시된 것처럼, 상기 FFR(78)은, 로딩중인 상기 벡터의 상기 요소들 중 하나에 각기 대응한 다수의 비트를 포함하는 요소 마스크로서 규정되어도 된다. 상기 폴팅 요소와 임의의 이후의 요소에 대응한 비트들은 제1 값(본 예에서는 0)을 갖고, 상기 폴팅 요소보다 조기의 요소의 비트들은 제2 값(본 예에서는 1)을 갖는다. 이렇게 상기 FFR(78)를 규정하는 것은 명령어들의 시퀀스를 실행하려고 하는 이후의 시도에 대해 새로운 서술어나 어드레스를 결정되는 것을 가능하는데 유용하여(이하 도 13을 참조), 상기 폴팅 요소는 상기 이후의 시도에 대한 제1 폴팅 요소가 된다. 따라서, 상기 FFR(78)은, 폴트를 기동하지 않았던 요소들에 대해 이미 행해진 연산들을 불필요하게 반복하지 않고, 상기 폴트의 해결 후 상기 데이터 요소들의 처리를 재개시키는데 유용하다.

따라서, 이러한 형태의 제1 폴팅 명령어는, 벡터화된 코드가, 운용체계 또는, 벡터화의 아티팩트로서 도입된 예외 조건들을 처리하는 그 밖의 소프트웨어에 대한 불필요한 트랩들을 방지하는데 유용하다. 그렇지만, 루프 언롤링을 행할 때, 상기 명령어의 상기 제1 폴팅 형태는, 상기 언롤 루프의 제1 명령어이외의 명령어들에 대해 작용하지 않는다. 상기 언롤 루프의 상기 제1 로드의 상기 제1 액티브 요소가 (상기 정지 조건이 만족되게 될 수 있는 조기의 액티브 요소들이 없으므로) 비추론적일 가능성이 높지만, 이후의 로드들에 대해서는, 상기 제1 액티브 요소가 추론적으로 로딩된 요소일 수도 있다. 전형적으로, 상기 언롤 루프의 상기 정지 조건은 상기 언롤 루프내의 상기 로드들의 전부가 완료되었으면 해결될 수도 있어서, 상기 언롤 루프의 바로 그 제1 로드에 의해 로딩된 상기 제1 액티브 요소이외의 임의의 요소는 추론적 요소일 수 있어, 상기 언롤 루프내의 로드마다의 상기 제1 액티브 요소의 응답 액션들을 기동하는 것이 바람직하지 않을 것이다.

도 9에 도시된 것처럼, 논폴팅(NF) 벡터 로드 명령어라고 하는 제2 타입의 벡터 로드 명령어를 제공할 수 있다. 논폴팅 벡터 로드 명령어를 실행할 때, 예외 조건이 상기 제1 액티브 요소에 대해 일어날 때도, 상기 응답 액션은 그래도 억제되고, 상기 FFR(78)은 폴트가 있는 상기 요소를 식별하기 위해 도 8과 마찬가지의 방식으로 갱신된다. 따라서, 상기 논폴팅 타입의 로드 명령어에 대해서, 어느 요소가 폴트를 기동하는가에 상관없이, 응답 액션이 기동되지 않고, 상기 제1 폴팅 레지스터(78)는 상기 폴트의 원인이 된 상기 요소를 식별하도록 갱신된다. 아래의 본 예에 도시된 것처럼, 이에 따라, 루프 언롤링은 상기 언롤 루프에서의 바로 그 제1 로드용 상기 명령어(예를 들면, ldffld)의 제1 폴팅 형태를 사용하고 상기 언롤 루프내의 이후의 로드용 상기 명령어(예를 들면, ldnfld)의 논폴팅 형태를 사용할 수 있다:

2개의 타입의 명령어는 상기 명령어 인코딩내에서 임의의 방식으로 구별될 수 있다. 이 명령어들에 대해 2개의 전체적으로 다른 연산부호를 제공하거나, 공통 연산부호에, 상기 명령어가 제1 폴팅 또는 논폴팅인지를 지정하는 상기 명령어 인코딩에서의 플래그를 제공하는 것이 가능하다. 그렇지만, 이것은 상기 명령어 세트 아키텍처내의 추가의 인코딩 공간을 필요로 하고, 그 명령어 세트 아키텍처내에 다른 종류의 연산이 포함되는 것을 방지할 수도 있는 이 명령어들에 할당되는 추가의 연산부호를 필요로 하거나, 그 플래그를 표현하기 위해 상기 인코딩의 추가의 비트를 필요로 한다.

이 때문에, 상기 제1 및 제2 타입의 명령어를 인코딩하는 보다 효율적인 방식은, 상기 명령어가 상기 제1 또는 제2 타입의 명령어인지의 신호를 보내기 위해서 상기 명령어내에 상기 어드레스 오프셋이 표현되는 방식을 사용하는 것이 가능한 것일 수 있다. 상술한 것처럼, 상기 블록 사이즈SB의 배수를 표현하는 즉시 오프셋(122)을 지정하는 명령어의 형태가 제공될 수도 있고, 이 명령어의 형태는, 제2 타입의 명령어들이 사용될 가능성이 높은 상기 상황이기도 한 상기 루프 언롤링에 주로 사용된다. 따라서, 상기 어드레스 오프셋을 규정하는 방식은, 상기 명령어가 제1 폴팅 또는 논폴팅인지도 판정할 수도 있다.

도 10은, 2개의 타입의 명령어를 구별하는 제1 예를 도시한 것이다. 본 예에서, 상기 즉시 오프셋 값이 제로일 경우, 상기 명령어는 상기 제1(제1 폴팅) 타입이고, 상기 즉시 오프셋 값이 논제로일 경우, 상기 명령어는 상기 제2(논폴팅) 타입이다. 종종, 루프 언롤링을 행하는 경우, 상기 언롤 루프의 바로 그 제1 로드는 제로의 오프셋을 갖고, 이후의 로드들은 논제로 오프셋을 가져서, 상기 즉시 오프셋의 제로 여부는, 폴팅 작용의 타입을 식별하는데 사용될 수 있다. 이것에 의해 2개의 형태의 명령어는 상이한 예외 처리 작용을, 상기 인코딩내의 임의의 추가의 비트 공간을 필요로 하지 않고 기동할 수 있다.

도 11은 상기 명령어들을 구별하는 제2 예를 도시한 것이다. 즉시 오프셋을 지정하는 도 4에 도시된 상기 타입의 벡터 로드 명령어와 아울러, 상기 명령어 세트 아키텍처는, 인덱스 레지스터를 사용하여 상기 오프셋을 지정하는 대응한 벡터 로드 명령어도 포함하여도 된다. 이 경우에, 벡터 로드 명령어가 상기 오프셋을 인덱스 레지스터를 사용하여 지정할 때, 이것은 제1 폴팅 타입의 명령어로서 취급되어도 되고, 상기 오프셋이 즉시값에 의해 지정될 때, 이것은 논폴팅 타입의 로드 명령어로서 취급되어도 된다. 즉시 오프셋 값과 상기 논폴팅 타입의 로드 명령어와의 이용이 주로 루프 언롤링을 위해 사용될 가능성이 높으므로, 상기 논폴팅 타입의 로드 명령어를 사용하는 대부분의 인스턴스는 즉시 오프셋 값도 지정하여서, 디폴트에 의해 상기 즉시 지정 로드 명령어를 논폴팅으로 하는 것에 의해, 상기 논폴팅 작용을 식별하기 위한 명령어 인코딩내에 임의의 다른 비트 공간을 다 사용할 필요가 없다.

도 11에 도시된 해결방법이 사용될 때, 언롤 루프의 바로 그 제1 로드는 인덱스 레지스터를 사용하여 지정된 오프셋을 가질 수 있어서, 제1 폴팅 작용을 기동한다. 일부의 경우에, 범용 레지스터는 상기 제1 로드를 위한 인덱스를 기억하도록 할당될 수 있고, 이것이 언롤 루프 반복당 하나의 추가의 스칼라 레지스터를 필요로 하지만, 이후의 로드들이 상기 오프셋을 즉시값을 사용하여 지정할 수 있으므로 매 로드가 별도의 인덱스 레지스터를 가졌을 경우보다 덜 레지스터 압력을 초래한다. 어쨌든, 상기 언롤 루프의 제1 로드가 제로 오프셋을 사용하는 경우가 많을 것이고, 일부의 아키텍처는 (임의의 값으로 설정될 수 있는 상기 범용 레지스터와 아울러) 디폴트에 의해 동일한 제로라고 가정된 소정의 레지스터를 규정한다. 제로를 기억하는 고정배선된 레지스터가 하드웨어로 설치될 수 있거나, 상기 소정의 레지스터가 실제의 레지스터에 해당하지 않아도 되지만, 상기 처리회로는 상기 소정의 레지스터의 상기 레지스터 지정자를, 상기 레지스터 뱅크에 액세스할 필요 없이 제로의 입력값으로 간단히 매핑하여도 된다. 이 때문에, 상기 언롤 루프의 제1 로드에 대해 소정의 레지스터를 참조하여서, 상기 제1 로드가 상기 오프셋을 인덱스 레지스터를 사용하여 지정할 때에도 범용 스칼라 레지스터를 다 사용할 필요가 없다.

따라서, 상기 도시된 언롤 루프의 상기 예는, 도 11에 도시된 해결방법에 근거하여, 상기 제1 폴팅 명령어 ldffld가, 즉시값 #1,#2 등을 참조하는 논폴팅 명령어들과 대조하여, 상기 소정의 레지스터 xzr를 참조하여 그것의 오프셋을 식별하고, 디폴트에 의해 인덱스 레지스터를 사용하여 그것의 오프셋을 식별하기 때문에 제1 폴팅으로서 취급되도록, 변형될 수 있다:

도 12는 주어진 세트의 데이터 요소에 작용하는 명령어들의 시퀀스로부터 생기는 예외 조건들을 상기 FFR(78)을 사용하여 추적하는 일례를 개략적으로 도시한 도이고, 이때 상기 시퀀스의 각 명령어는 이전의 명령어로부터의 결과를 사용한다. 이 명령어들의 어느 하나에 대한 주어진 요소가 폴트를 기동하는 경우, 상기 시퀀스의 이후의 명령어들에 있어서 상기 요소와 임의의 이후의 요소들의 처리를 계속하는 것이 바람직하지 않을 수도 있다. 그러므로, 상기 제1 폴팅 레지스터는, 누적 방식이 규정될 수 있어, 상기 시퀀스의 시작 전에, 모든 비트가 1로 설정되고, 임의의 명령어가 (제1 폴팅 명령어를 위한 상기 제1 액티브 요소 이외의) 주어진 요소에 관한 폴트를 기동하는 경우, 그 주어진 요소와 임의의 이후의 요소들에 대응한 비트들은 상기 제1 폴팅 레지스터(78)에서 클리어되고, 그 명령어들의 시퀀스의 나머지에 대해 클리어되어 있을 것이다. 상기 제1 폴팅 레지스터(78)와 상기 서술어 값 Pg를 AND연산을 사용하여 조합함으로써, 수정된 서술어 Pg'는 결함이 있는 상기 요소가 한층 더 처리되는 것을 방지하기 위해 임의의 이후의 명령어들에 대해 생성될 수 있다. 이후의 명령어(예를 들면, 도 12의 명령어 1)가 조기의 요소에 관해 또 다른 폴트를 생성하는 경우, 상기 FFR(78)의 적어도 하나의 또 다른 비트는 0으로 클리어될 수 있어서, 다음 명령어는 훨씬 보다 적은 요소를 처리할 것이다.

혹은, 도 13에 도시된 것과 같은 상기 FFR과 상기 이전의 마스크 Pg를 AND 연산하지 말고, 대신에 명령어(예를 들면, 상기 예에 도시된 rdffr 명령어)는 상기 FFR을 간단히 판독하여, 그 결과를 상기 시퀀스의 이후의 명령어들에 의해 상기 서술어 레지스터로서 사용되는 대응한 레지스터p4/p5/p6에 기억할 수 있다.

상기 예들에서의 brkn 명령어들은,

BRKN Pdm.B, Pg, Pn.B, Pdm.B의 포맷을 갖고,

상기 처리회로를 제어하여 이하의 연산을 행한다:

Pg에서 최종(즉, 가장왼쪽, 최상위) 트루(true)/액티브/논제로 비트에 해당하는 Pn에서의 상기 서술어 비트도 트루/액티브/논제로일 경우, Pdm이 그대로인 연산과,

Pg에서 최종(즉, 가장왼쪽, 최상위) 트루(true)/액티브/논제로 비트에 해당하는 Pn에서의 상기 서술어 비트도 폴스(false)/비액티브/제로일 경우, Pdm이 모두 폴스/비액티브/제로로 클리어되는 연산을 행한다.

달리 말하면:

Pdm=LastActive(Pg,Pn)?Pdm: 0;

(//LastActive()는 Pg에서 가장왼쪽의 세트 비트를 찾고 Pn에서의 동일한 비트가 트루인지를 회신한다).

달리 말하면, 상기 brkn 명령어들은, FFR에서의 최종의 액티브 요소가 그 로드 후 폴스이다는 것을 의미하는 실패를 상기 제1 로드가 검출하였을 경우, 그 실패는 모두 제로로 설정하여서 상기 제2 로드의 상기 FFR 결과에 전파하는 등 한다. 상기 brkn 명령어들은, "브레이크" 조건을 상기 언롤 루프의 다음 서브반복에 전파한다.

상기 시퀀스의 끝에 도달하였다면, 성공적으로 완료된 임의의 요소들은 유효 결과로서 취급되고, 상기 루프는, 상기 FFR(78)을 검사하고 상기 정지 조건을 해결하여 상기 폴팅 요소들에 대해 생성된 폴트들이 상기 루프 추론으로 인해 생성된 스퓨리어스 폴트들(그래서 그 폴트들이 처리될 필요가 없고 상기 루프가 종료할 수 있다) 또는, 상기 시퀀스를 반복하여서 처리되는 것이 필요한 유효 폴트들인지를 판정하는 일부의 명령어들을 포함하여도 된다. 도 13에 도시된 것처럼, 상기 FFR(78)은 시퀀스 실행의 상기 반복된 시도를 위한 새로운 서술어(마스크) 또는 새로운 어드레스를 판정하는데 사용될 수 있다. 도 13의 좌측은, 결함이 있는 상기 제1 요소(상기 FFR(78)에서 '0'비트를 갖는 제1 요소)가 지금 상기 제1 액티브 요소(상기 갱신된 마스크에서 '1'비트를 갖는 제1 요소)가 되는 상태에서, 새로운 서술어를 생성하는 것을 도시한 것이다. 혹은, 도 13의 우측에 도시된 것처럼, 상기 FFR(78)을 사용하여, 상기 로드 명령어의 기저 어드레스를, 이후의 시도를 위한 상기 기저 어드레스가 상기 폴팅 요소에서 로딩하였던 상기 어드레스에 대응하도록 갱신하는 것도 가능하다. 어느쪽이든, 상기 시퀀스를 반복할 때, 결함이 있는 상기 요소는 제1 액티브 요소이고, 그래서 상기 루프형 시퀀스의 시작에서 상기 제1 폴팅 타입의 명령어는 상기 폴트가 그 요소에 대해 다시 발생하는 경우 응답 액션을 기동시킬 것이다.

도 14는 예외 조건들에 마주칠 수도 있는 벡터 로드 명령어들을 처리하는 방법을 도시한 것이다. 단계 200에서, 상기 프로세서는 현재의 명령어가 벡터 로드 명령어인지를 판정하고, 아닐 경우 그 명령어는 일부의 다른 방식으로 처리된다. 벡터 로드 명령어를 마주칠 경우, 단계 202에서는 벡터의 다수의 데이터 요소들에 대해 로드 연산들을 행한다. 요소마다 상기 어드레스들은, 기저 레지스터와 오프셋을 사용하여, 또는 기저 레지스터와 이덱스 레지스터를 사용하여, 산출된 시작 어드레스에 근거하여 산출되어도 된다. 단계 204에서는, 벡터의 임의의 주어진 데이터 요소에 대해 예외 조건을 검출하였는지를 판정한다. 검출되지 않았을 경우, 상기 방법은 단계 200으로 되돌아가 다음 명령어를 처리하여 성공적으로 상기 로드 연산을 실행할 것이다.

그러나, 예외 조건을 검출하는 경우, 단계 206에서는, 상기 폴트를 기동시킨 상기 주어진 데이터 요소가 상기 벡터의 상기 제1 액티브 데이터 요소인지를 판정한다. 다수의 요소가 폴트를 기동한 경우, 이 요소들 중 제1 요소가 상기 제1 액티브 요소인지를 판정한다. 결함이 있는 상기 주어진 데이터 요소가 상기 제1 액티브 데이터 요소일 경우, 단계 208에서는, 현재의 벡터 로드 명령어의 타입이 제1 폴팅 또는 논폴팅인지를 판정한다. 상기 벡터 로드 명령어가 상기 제1 폴팅 타입의 명령어이었을 경우, 단계 210에서는, 예외 처리루틴을 실행하는 것 또는 상기 폴트가 일어난 것을 가리키는 이룹의 정보를 기록하는 것 등의 상기 응답 액션을 기동시킨다. 한편, 상기 명령어가 명령어의 논폴팅 형태일 경우, 단계 212에서는 상기 응답 액션을 억제하고(즉, 행하지 않고) 단계 214에서는 상기 결함이 있는 상기 주어진 데이터 요소를 식별하기 위해 상기 제1 폴팅 레지스터(78)를 갱신한다. 단계 206에서 상기 주어진 데이터 요소가 상기 제1 액티브 요소가 아닐 경우, 상기 방법은 단계 206으로부터 직접 단계 212로 진행된다(상기 응답 액션이 억제되고, 상기 FFR(78)은 상기 명령어가 제1 폴팅 또는 논폴팅인지의 여부에 상관없이 갱신된다).

도 14에 도시된 기술은, 상술한 타입의 인접한 로드들만이 아닌 모든 타입의 벡터 로드 명령어들에 사용될 수 있다. 따라서, 폴팅 작용이 상이한 제1 및 제2 타입의 로드 명령어는, 타겟 벡터의 요소마다 다수의 불연속 어드레스를 규정하는 어드레스 벡터를 지정하는 게더-로드 명령어들에 대해서도 규정될 수 있고, 이때 상기 로드는 데이터를 각 불연속 어드레스로부터 상기 타겟 벡터에 모은다.

도 15는 소프트웨어(예를 들면, 컴파일러) 또는 하드웨어(예를 들면, 동일한 파이프라인 내에서 생성된 명령어들을 실행하는 회로)로 구현되어도 되는, 루프 언롤러에 의해 행해질 수 있는 처리회로에 의해 처리하기 위한 명령어들을 생성하는 방법을 도시한 것이다. 단계 250에서는 상기 소스 프로그램의 명령어들을 수신한다. 단계 252에서, 상기 루프 언롤러는, 상기 소스 프로그램이 각 반복이 제1 폴틸 벡터 로드 명령어를 포함하면서 소스 루프를 포함하는지를 판정하고, 그러한 루프가 없는 경우, 상기 방법은 종료하고, 일부의 다른 방식으로 명령어들을 생성한다. 그렇지만, 상기 소스 프로그램이 소스 루프를 포함하는 경우, 단계 254에서 상기 루프 언롤러는 상기 소스 루프보다 적은 반복을 하는 언롤 루프를 위한 명령어들을 생성한다. 상기 언롤 루프의 각기 반복은, 제1 폴팅 벡터 로드 명령어와 적어도 하나의 논폴팅 벡터 로드 명령어를 포함한다. 그리고, 단계 256에서, 상기 루프 언롤러는, 상기 소스 루프가 상기 언롤 루프로 대체된 상기 처리회로 에 의해 처리하기 위한 명령어들을 출력한다.

일부의 루프 언롤링 방법들은 도 15에 도시된 상기 제1/제2 타입의 명령어와, 적어도 상기 제2 타입의 명령어들이 상기 즉시값을 사용한 상기 오프셋을 지정하는 선택사항을 사용하기 위해, 도 6 및 도 15의 기술들을 조합하여도 된다는 것을 알 것이다. 그 밖의 루프 언롤링 방법들은, 도 6 및 도 15에 도시된 기술들의 하나 또는 나머지만을 사용하여도 된다.

도 16은 사용할 수도 있는 가상머신 구현을 도시한 것이다. 상술한 실시예들은 관련된 기술들을 지원하는 특정한 처리 하드웨어를 동작시키는 장치 및 방법들의 관점에서 본 발명을 구현하지만, 하드웨어 디바이스들의 소위 가상 머신 구현을 제공하는 것도 가능하다. 이들 가상 머신 구현들은, 가상 머신 프로그램(510)을 지원하는 호스트 운영체계(520)를 동작시키는 호스트 프로세서(530)상에서 동작한다. 전형적으로, 아주 강력한 프로세서들은 합리적 속도로 실행하는 가상 머신 구현을 제공하는데 필요하지만, 이러한 해결방법은, 특정한 상황에서, 이를테면, 호환성 또는 재사용 목적을 위해 또 다른 프로세서 고유의 코드를 실행하기를 바라는 경우에 정당화될 수도 있다. 가상 머신 프로그램(510)은, 이 가상 머신 프로그램(510)에 의해 모형이 만들어지는 상기 디바이스인 실제의 하드웨어에 의해 제공될 애플리케이션 프로그램 인터페이스와 같은 애플리케이션 프로그램(500)에 대한 애플리케이션 프로그램 인터페이스를 제공한다. 따라서, 상술한 메모리액세스들의 제어를 포함하는 상기 프로그램 명령어들은, 상기 가상 머신 프로그램(510)을 사용하여 상기 가상 머신 하드웨어와의 상호작용을 모형으로 만들기 위해 상기 애플리케이션 프로그램(500)내로부터 실행되어도 된다.

요약하면, 제1 및 제2 타입의 벡터 로드 명령어들은, 명령어 세트 아키텍처에서 규정될 수 있다. 상기 제1 타입의 명령어에 대해서, 응답 액션은 상기 타겟 벡터 레지스터의 제1 액티브 데이터 요소에 대해 소정의 시퀀스로 행해진 상기 로드 연산의 예외 조건을 검출할 때 기동되지만, 그 응답 액션은 상기 제1 액티브 요소이외의 액티브 데이터 요소에 대해 행해진 상기 로드 연산을 위한 상기 예외 조건이 일어나는 경우에 억제되고, 그 경우에 상기 예외 조건을 검출한 상기 액티브 데이터 요소를 식별하는 요소 식별 정보가 기억된다. 상기 제2 타입의 명령어에 대해서, 상기 타겟 벡터 레지스터의 임의의 액티브 요소에 대해 행해진 상기 로드 연산을 위한 상기 예외 조건을 검출할 때, 상기 응답 액션은 억제되고 상기 요소 식별 정보는 기억된다.

이러한 해결방법은, 벡터화된 코드의 성능을 향상시키는 2개의 기술, 즉 (루프의 다수의 반복을 언롤 루프의 단일의 반복으로 조합하는 경우의) 루프 언롤링과 (적어도 하나의 액티브 데이터 요소에 대한 상기 로드 연산을, 그 로드 연산이 실제로 행해져야 하는지를 판정하기 위한 관련 조건이 해결되어 있기 전에, 행할 수 있는 경우의) 루프 추론이 함께 사용되게 하는 것을 허가하기 때문에 성능을 향상시키는데 도움이 된다. 그에 반해서, 이전의 명령어의 형태들에 의해, 루프 언롤링과 루프 추론의 양쪽을 이용하는 것은 어려울 것이다. 상기 제1 타입의 벡터 로드 명령어와 아울러 상기 제2 타입의 벡터 로드 명령어를 제공함으로써, 언롤 루프들에서는, 상기 제2 타입의 명령어를 이용하여, 상기 루프 정지(halt) 조건을 해결하기 전에 명령어들에 의해 처리된 요소들이 추론적으로 처리중일 때, 스퓨리어스 예외 처리 응답 액션들이 상기 언롤 루프의 제1 로드 명령어이외의 명령어들에 의해 처리된 요소들에 의해 기동되는 것을 방지할 수 있다.

일반적으로, 상기 벡터 로드 명령어는, 어느 요소들이 액티브 또는 비액티브인지를 가리키는 마스크(또는 서술어)를 가질 수도 있다. 상기 제1 또는 제2 타입의 명령어의 실행 후, 적어도 하나의 또 다른 명령어는, 상기요소 식별 정보에 근거하여, 상기 제1 타입의 벡터 로드 명령어를 실행하려고 하는 이후의 시도를 위한 새로운 마스크와 새로운 어드레스 중 적어도 하나를 생성하는데 실행되어도 된다. 새로운 마스크가 생성되면, 그것은, 상기 예외 조건을 기동한 상기 주어진 데이터 요소가 지금 상기 제1 액티브 요소인 상태에서 생성되어도 되는 한편, 새로운 어드레스가 생성되면, 그 새로운 어드레스는, 상기 예외 조건을 기동한 상기 주어진 데이터 요소에 의해 이전에 로딩된 상기 어드레스에 대응하게 설정되어도 된다. 그 후, 제1 타입의 벡터 로드 명령어를 그 새로운 마스크나 어드레스를 사용하여 반복하는 경우, 상기 폴팅 요소가 지금 제1 액티브 요소이므로, 그 폴트가 그래도 일어나면, 상기 응답 액션을 기동시켜 상기 예외 조건을 해결할 수 있다.

상기 요소 식별 정보는 각종 방식으로 설정될 수 있다. 예를 들면, 상기 요소 식별 정보는, 단지 상기 예외 조건의 원인이 된 상기 주어진 데이터 요소의 식별자일 수 있다.

그렇지만, 유용한 해결방법은, 데이터를 전송중인 상기 적어도 하나의 벡터 레지스터의 각 요소에 다수의 표시가 대응하는 요소 식별 마스크를 설정하는 방법이다. 상기 예외 조건을 검출한 상기 요소와, 상기 소정의 시퀀스에서의 이후의 임의의 요소에 대응한 표시들은 제1 값(예를 들면, 0)으로 설정되어도 되고, (만약에 있다면) 상기 시퀀스에서의 조기의 요소에 대응한 표시들은 제2 값(예를 들면, 1)으로 설정되어도 된다. 이렇게 상기 요소 식별 마스크를 규정하는 것은, 어느 요소들이 액티브인지를 통제하는 상기 서술어(마스크)와 상기 요소 식별 마스크와의 조합을 보다 간단하게 하기 때문에 유용하다.

일반적으로, 어느 요소가 상기 제1 액티브 요소인지를 고려하는지의 판정은 요소들의 임의의 시퀀스에 따라 행해져도 된다. 예를 들면, 상기 소정의 시퀀스는, 상기 벡터의 최하위 요소로부터 최상위 요소로 또는 이와는 반대로 확대될 수 있다. 그렇지만, 실제로, 벡터들은, 상기 최하위 요소에 배치된 최저의 어드레스로부터의 데이터와 상기 최상위 요소에 배치된 최고의 어드레스로부터의 데이터가 채워지게 되고, 대부분의 프로그래머들/컴파일러들은, 상기 최저의 어드레스로부터 최고의 어드레스까지 반복하는 루프들을 기록하게 되는 경우가 많다. 그러므로, 상기 소정의 시퀀스가 최하위 요소로부터 최상위 요소로 확장될 때, 이것은, 종종 벡터화된 코드를 기록하는 방식에 대해 가장 좋게 매핑할 것이다. 이 때문에, 일부의 예들에서, 상기 제1 액티브 요소는 상기 레지스터의 최하위 액티브 데이터 요소일 수 있다.

상술한 것처럼 제1 및 제2 타입의 벡터 로드 명령어는, (로딩되는 각 데이터 요소에 대응한 상기 어드레스들이 인접한 경우의) 인접한 벡터 로드들과, (데이터 요소마다 상기 어드레스들이 비인접하고 어드레스 벡터에 의해 지정되는 경우의) 비인접한(게더) 형태의 벡터 로드와의 양쪽에 이용될 수 있다.

그렇지만, 상기 인접한 타입의 벡터 로드에 대해서는, 적어도 상기 제2 타입의 벡터 로드 명령어들이, 로딩되는 어드레스들의 인접한 블록의 사이즈의 배수로서 표현된 즉시 오프셋 값과 기본 레지스터를 사용하여 로딩되는 어드레스들의 상기 인접한 블록의 시작 어드레스를 지정하는데 유용할 수 있다. 제1 타입의 벡터 로드 명령어도 이렇게 규정될 수 있고, 그럴 경우, 이들은, 그들의 연산부호에 의해, 또는 상기 즉시 오프셋 값이 상기 제1 타입에 대해서는 제로이거나 제2 타입에 대해서는 논제로인지의 여부에 의해 구별되어도 된다.

그 밖의 예들에서, 상기 제2 타입의 벡터 로드 명령어는 자신의 오프셋을 즉시값으로서 지정하여도 되지만, 상기 제1 타입의 벡터 로드 명령어는 액세스되는 어드레스들의 상기 인접한 블록의 시작 어드레스를 형성하기 위해 상기 기저 어드레스에 가산되는 오프셋 값을 기억하는 오프셋(인덱스) 레지스터를 지정하여도 된다. 따라서, 명령어의 어드레싱 모드는, 폴팅 작용의 타입을 구별하는데 사용되어도 된다. 이러한 해결방법은, 디폴트에 의해 제로의 값에 대응하는 소정의 제로 레지스터 지정자를 제공하는 시스템에서 특히 유용한데, 그 이유는, 이에 따라, 상기 제로 오프셋을 기억하기 위한 범용 레지스터를 낭비할 필요 없이 상기 제1 타입의 명령어가 인덱스 레지스터 레퍼런스를 갖는 제로 오프셋을 규정할 수 있기 때문이다.

상기 데이터 요소들에 대해 검출된 예외 조건은, 일부의 종류의 비정상 결과나 일부의 오류의 신호를 보내는 어떠한 조건이어도 된다. 그렇지만, 상기 제1/제2 형태의 명령어는, 상기 예외 조건이 어드레스 변환 폴트나 메모리 허가 폴트를 포함할 때 특히 유용할 수도 있다. 상기 응답 액션은, 달라질 수 있고, 예외 처리 루틴의 실행의 기동, 및/또는 상기 예외 조건이 일어났다는 것을 가리키기 위한 스테이터스 정보의 설정을 포함하여도 된다.

또 다른 구성들의 예가 아래의 조항들에 기재되어 있다:

(1) 복수의 데이터 요소로 이루어진 벡터 오퍼랜드들을 기억하는 복수의 벡터 레지스터; 및

기본 레지스터와 즉시 오프셋 값을 지정하는 벡터 데이터 전송 명령어에 응답하여, 적어도 하나의 벡터 레지스터의 상기 복수의 데이터 요소와, 어드레스들의 인접한 블록에 대응한 데이터 스토어의 기억 장소들과의 사이에서, 데이터를 전송하도록 구성된 처리회로를 구비하고,

상기 벡터 데이터 전송 명령어에 응답하여, 상기 처리회로는, 상기 어드레스들의 인접한 블록의 사이즈에 대응한 승수와 상기 즉시 오프셋 값과의 곱에, 상기 기본 레지스터에 기억된 기저 어드레스를 가산한 결과와 같은 값을 갖는, 상기 어드레스들의 인접한 블록의 시작 어드레스를 결정하도록 구성되는, 장치.

(2) 조항(1)에 있어서, 가변 제어 파라미터를 기억하는 기억소자를 구비하고, 상기 처리회로는, 상기 가변 제어 파라미터에 따라 상기 어드레스들의 인접한 블록의 상기 사이즈를 결정하도록 구성되는, 장치.

(3) 조항(2)에 있어서, 상기 가변 제어 파라미터는 하나의 벡터 레지스터의 사이즈를 식별하는 벡터 사이즈VS를 지정하는, 장치.

(4) 조항(1) 내지 (3) 중 어느 한 항에 있어서, 상기 처리회로는, NR×NE×SS의 곱과 같은 값을 갖는 상기 승수를 결정하도록 구성되고, 여기서,

NR은 상기 벡터 데이터 전송 명령어에 응답하여 데이터를 전송하는 상기 적어도 하나의 벡터 레지스터의 벡터 레지스터들의 수,

NE는 상기 적어도 하나의 벡터 레지스터의 각각에 의해 이루어진 데이터 요소들의 수, 및

SS는 단일의 데이터 요소에 대응한 어드레스들의 유닛의 기억 유닛 사이즈인, 장치.

(5) 조항(4)에 있어서, 하나의 벡터 레지스터의 사이즈를 식별하는 벡터 사이즈 VS를 기억하는 기억소자를 구비하고,

상기 처리회로는, NR×VS/ES×SS와 같은 값을 갖는 상기 승수를 결정하도록 구성되고,

여기서 ES는 하나의 데이터 요소의 데이터 요소 사이즈이고,

상기 처리회로는, 상기 벡터 데이터 전송 명령어의 인코딩에 의거하여 ES, NR 및 SS를 결정하도록 구성되는, 장치.

(6) 조항(1) 내지 (5) 중 어느 한 항에 있어서, 상기 즉시 오프셋 값은 부호없는 정수값을 포함하는, 장치.

(7) 조항(1) 내지 (5) 중 어느 한 항에 있어서, 상기 즉시 오프셋 값은 부호있는 정수값을 포함하는, 장치.

(8) 조항(1) 내지 (7) 중 어느 한 항에 있어서, 상기 기본 레지스터는 스칼라 레지스터를 포함하는, 장치.

(9) 조항(1) 내지 (8) 중 어느 한 항에 있어서, 상기 벡터 데이터 전송 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 데이터 요소마다, 상기 처리회로는 그 데이터 요소와, 상기 어드레스들의 인접한 블록의 각각의 부분에 대응한 기억 장소들과의 사이에서, 데이터를 전송하는 데이터 전송 연산을 행하도록 구성되는, 장치.

(10) 조항(9)에 있어서, 상기 벡터 데이터 전송 명령어가 벡터 로드 명령어이고 상기 적어도 하나의 벡터 레지스터의 주어진 데이터 요소의 상기 데이터 전송 연산을 위한 적어도 하나의 예외 조건이 검출될 때, 상기 처리회로는, 상기 적어도 하나의 예외 조건을 처리하는 적어도 하나의 응답 액션을 억제하고, 상기 적어도 하나의 벡터 레지스터의 데이터 요소가 상기 주어진 데이터 요소인지를 식별하는 요소 식별 정보를 기억하도록 구성되는, 장치.

(11) 조항(1) 내지 (10) 중 어느 한 항에 있어서, 상기 벡터 데이터 전송 명령어가 벡터 로드 명령어를 포함할 때, 상기 처리회로는, 상기 어드레스들의 인접한 블록에 대응한 상기 데이터 스토어의 상기 기억 장소들로부터 상기 적어도 하나의 벡터 레지스터의 상기 복수의 데이터 요소에, 데이터를 로딩하도록 구성되는, 장치.

(12) 조항(1) 내지 (11) 중 어느 한 항에 있어서, 상기 벡터 데이터 전송 명령어가 벡터 스토어 명령어를 포함할 때, 상기 처리회로는, 상기 적어도 하나의 벡터 레지스터의 상기 복수의 데이터 요소로부터 상기 어드레스들의 인접한 블록에 대응한 상기 데이터 스토어의 상기 기억 장소들에, 데이터를 기억하도록 구성되는, 장치.

(13) 기본 레지스터와 즉시 오프셋 값을 지정하는 벡터 데이터 전송 명령어를 수신하는 단계; 및

상기 벡터 데이터 전송 명령어에 응답하여:

어드레스들의 인접한 블록의 사이즈에 대응한 승수와 상기 즉시 오프셋 값과의 곱에, 상기 기본 레지스터에 기억된 기저 어드레스를 가산한 결과와 같은 값을 갖는, 상기 어드레스들의 인접한 블록의 시작 어드레스를 결정하고,

적어도 하나의 벡터 레지스터의 복수의 데이터 요소와, 상기 어드레스들의 인접한 블록에 대응한 데이터 스토어의 기억 장소들과의 사이에서, 데이터를 전송하는 단계를 포함하는, 데이터 처리 방법.

(14) 복수의 데이터 요소로 이루어진 벡터 오퍼랜드들을 기억하는 복수의 수단; 및

기본 레지스터와 즉시 오프셋 값을 지정하는 벡터 데이터 전송 명령어에 응답하여, 벡터 오퍼랜드들을 기억하는 적어도 하나의 수단의 복수의 데이터 요소와, 어드레스들의 인접한 블록에 대응한 데이터 스토어의 기억 장소들과의 사이에서, 데이터를 전송하는 수단을 구비하고,

상기 벡터 데이터 전송 명령어에 응답하여, 상기 전송하는 수단은, 상기 어드레스들의 인접한 블록의 사이즈에 대응한 승수와 상기 즉시 오프셋 값과의 곱에, 상기 기본 레지스터에 기억된 기저 어드레스를 가산한 결과와 같은 값을 갖는, 상기 어드레스들의 인접한 블록의 시작 어드레스를 결정하도록 구성되는, 장치.

(15) 컴퓨터가, 조항(1) 내지 (12) 중 어느 한 항에 따른 상기 장치에 대응한 가상머신 실행 환경을 제공하도록 제어하는 컴퓨터 프로그램.

(16) 소스 프로그램에 근거하여, 처리회로에 의해 처리하기 위한 명령어들을 생성하는 컴퓨터 구현 방법으로서, 이 방법은,

상기 소스 프로그램내에서 복수의 반복으로 이루어진 소스 루프를 검출하는 단계로서, 상기 소스 루프의 각 반복이, 적어도 하나의 벡터 레지스터의 복수의 데이터 요소와, 벡터 데이터 전송 명령어와 주어진 블록 사이즈에 의해 식별된 시작 어드레스를 갖는 어드레스들의 인접한 블록에 대응한 데이터 스토어에서의 기억 장소들과의 사이에서, 데이터를 전송하는 상기 벡터 데이터 전송 명령어를 포함하고, 여기서 상기 소스 루프의 주어진 반복을 위한 상기 어드레스들의 인접한 블록이 이후의 반복을 위한 상기 어드레스들의 인접한 블록과 인접하는, 상기 검출하는 단계; 및

상기 소스 루프를 검출하는 것에 응답하여, 상기 소스 루프보다 적은 반복을 포함하는 언롤 루프를 위한 명령어들을 생성하는 단계로서, 상기 언롤 루프의 각 반복이 상기 소스 루프의 적어도 2개의 반복에 해당하고, 이 각 반복이,

상기 소스 루프의 상기 적어도 2개의 반복 중 선택된 반복의 상기 벡터 데이터 전송 명령어에 의해 식별된 상기 시작 어드레스를 기억하는 기본 레지스터를 지정하는 참조 벡터 데이터 전송 명령어; 및

상기 기본 레지스터에 기억된 상기 시작 어드레스와, 상기 소스 루프의 상기 적어도 2개의 반복 중 나머지 반복의 상기 벡터 데이터 전송 명령어에 의해 식별된 상기 시작 어드레스간의 차이를, 상기 주어진 블록 사이즈의 배수로서 지정하는 즉시 오프셋 값과, 상기 기본 레지스터를 지정하는, 적어도 하나의 또 다른 벡터 데이터 액세스 명령어를 포함하는, 상기 생성하는 단계를 포함하는, 컴퓨터 구현 방법.

(17) 조항(16)의 방법을 행하도록 구성된 데이터 처리장치.

(18) 조항(17)에 있어서, 상기 데이터 처리장치는, 상기 방법에 따라 생성된 상기 명령어들을 실행시키도록 구성된 상기 처리회로를 구비하는, 데이터 처리장치.

(19) 컴퓨터가 조항(16)의 방법을 행하도록 제어하는 명령어들로 이루어진 컴퓨터 프로그램.

(20) 조항(19)의 상기 컴퓨터 프로그램을 기억하는 기억매체.

(21) 소스 프로그램에 근거하여, 처리회로에 의해 처리하기 위한 명령어들을 생성하는 컴퓨터 구현 방법으로서,

상기 소스 루프를 검출하는 것에 응답하여, 상기 소스 루프보다 적은 반복으로 이루어진 언롤 루프를 위한 명령어들을 생성하는 단계로서, 상기 언롤 루프의 각 반복이 상기 소스 루프의 적어도 2개의 반복에 해당하고, 이 각 반복이,

상기 제1 타입의 벡터 로드 명령어; 및

상기 적어도 하나의 벡터 레지스터의 임의의 액티브 데이터 요소에 대해 행해진 상기 로드 연산을 위한 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 처리회로가, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 상기 요소 식별정보를 기억하는 것을 나타내는 인코딩을 갖는 제2 타입의 적어도 하나의 벡터 로드 명령어로 이루어지는, 상기 생성하는 단계를 포함하는, 컴퓨터 구현 방법.

(22) 조항(21)의 방법을 행하도록 구성된 데이터 처리장치.

(23) 조항(22)에 있어서, 상기 데이터 처리장치는, 상기 방법에 따라 생성된 상기 명령어들을 실행시키도록 구성된 상기 처리회로를 구비하는, 데이터 처리장치.

(24) 컴퓨터가 조항(21)의 방법을 행하도록 제어하는 명령어들로 이루어진 컴퓨터 프로그램.

(25) 조항(24)의 상기 컴퓨터 프로그램을 기억하는 기억매체.

본 출원에서, "...하도록 구성된"의 단어는, 장치의 요소가 상기 규정된 연산을 실시할 수 있는 구성을 갖는다는 것을 의미하는데 사용된다. 본 문맥에서, "구성"은, 하드웨어 또는 소프트웨어의 상호연결의 배치 또는 방식을 의미한다. 예를 들면, 상기 장치는 상기 규정된 연산을 제공하는 전용 하드웨어를 가져도 되거나, 프로세서 또는 다른 처리 디바이스는 그 기능을 행하도록 프로그래밍되어도 된다. "하도록 구성된"은, 상기 장치 요소가 임의의 방식으로 상기 규정된 연산을 제공하기 위해서 변경될 필요가 있다는 것을 암시하지는 않는다.

여기서는 본 발명의 실시예들을 첨부도면을 참조하여 상세히 설명하였지만, 본 발명은 구체적인 실시예들에 한정되지 않고, 첨부된 청구항에서 기재된 것과 같은 본 발명의 범위 및 사상으로부터 벗어나지 않고 당업자가 변경 및 변형을 여러 가지로 실시할 수 있다는 것을 알 수 있다.

Claims

벡터 로드 명령어에 응답하여, 데이터 스토어로부터 적어도 하나의 벡터 레지스터의 복수의 요소에 데이터를 로딩하기 위해 로드 연산들을 행하는 처리회로를 구비하고;
제1 타입의 벡터 로드 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 제1 액티브 데이터 요소에 대해 소정의 순서로 행해진 상기 로드 연산을 위해 예외 조건을 검출할 때, 상기 처리회로는 응답 액션을 행하도록 구성되고, 상기 제1 액티브 데이터 요소 이외의 액티브 데이터 요소에 대해 상기 소정의 순서로 행해진 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 처리회로는, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 요소 식별정보를 기억하도록 구성되고;
제2 타입의 벡터 로드 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 임의의 액티브 데이터 요소에 대해 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 처리회로는, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 상기 요소 식별정보를 기억하도록 구성되고;
상기 제1 타입의 벡터 로드 명령어와 상기 제2 타입의 벡터 로드 명령어는 그들의 명령어 인코딩에 의해 구별되는, 장치.
제 1 항에 있어서,
상기 제1 타입 또는 상기 제2 타입의 상기 벡터 로드 명령어에 응답하여, 상기 처리회로는, 상기 적어도 하나의 벡터 레지스터의 적어도 하나의 액티브 데이터 요소에 대한 상기 로드 연산을, 그 로드 연산이 상기 적어도 하나의 액티브 데이터 요소에 대해 행해져야 하는지를 판정하기 위한 관련 조건이 해결되어 있기 전에, 행하도록 구성되는, 장치.
제 1 항 또는 제 2 항에 있어서,
상기 벡터 로드 명령어는, 상기 적어도 하나의 벡터 레지스터의 데이터 요소들이 액티브 데이터 요소들인 것을 가리키는 마스크를 식별하는, 장치.
제 3 항에 있어서,
상기 처리회로는, 적어도 하나의 또 다른 명령어에 응답하여, 상기 요소 식별 정보에 근거하여, 상기 제1 타입의 벡터 로드 명령어를 실행하려고 하는 이후의 시도를 위한 새로운 마스크와 새로운 어드레스 중 적어도 하나를 생성하는 회로인, 장치.
제 1 항 내지 제 4 항 중 어느 한 항에 있어서,
상기 요소 식별 정보는, 상기 적어도 하나의 벡터 레지스터의 상기 데이터 요소들 중 하나에 각각 대응한 복수의 표시로 이루어진 요소 식별 마스크를 포함하고, 상기 예외 조건을 검출한 상기 액티브 데이터 요소와, 상기 소정의 시퀀스에서의 이후의 임의의 액티브 데이터 요소에 대응한 표시들은 제1 값을 갖고, 상기 예외 조건을 검출한 상기 액티브 데이터 요소보다 상기 소정의 시퀀스에서의 조기의 임의의 데이터 요소들에 대응한 표시들은 제2 값을 갖는, 장치.
제 1 항 내지 제 5 항 중 어느 한 항에 있어서,
상기 소정의 시퀀스에서의 제1 액티브 데이터 요소는, 상기 적어도 하나의 벡터 레지스터의 최하위 액티브 데이터 요소를 포함하는, 장치.
제 1 항 내지 제 6 항 중 어느 한 항에 있어서,
상기 벡터 로드 명령어는 어드레스들의 인접한 블록을 식별하고, 상기 적어도 하나의 벡터 레지스터의 데이터 요소마다, 상기 로드 연산은, 상기 어드레스들의 인접한 블록의 각각의 부분에 대응한 상기 데이터 스토어에서의 기억 장소들로부터 그 데이터 요소에 데이터를 로딩하는 것을 포함하는, 장치.
제 7 항에 있어서,
상기 제2 타입의 벡터 로드 명령어는, 기본 레지스터와 즉시 오프셋 값을 지정하고,
상기 제2 타입의 벡터 로드 명령어에 응답하여, 상기 처리회로는, 상기 어드레스들의 인접한 블록의 사이즈에 대응한 승수와 상기 즉시 오프셋 값과의 곱에, 상기 기본 레지스터에 기억된 기저 어드레스를 가산한 결과와 같은 값을 갖는, 상기 어드레스들의 인접한 블록의 시작 어드레스를 결정하도록 구성되는, 장치.
제 7 항 또는 제 8 항에 있어서,
상기 제1 타입의 벡터 로드 명령어는, 기본 레지스터와 오프셋 레지스터를 지정하고,
상기 제1 타입의 벡터 로드 명령어에 응답하여, 상기 처리회로는, 상기 오프셋 레지스터에 기억된 값에 근거하여 결정된 오프셋 값에, 상기 기본 레지스터에 기억된 기저 어드레스를 가산한 결과와 같은 값을 갖는, 상기 어드레스들의 인접한 블록의 시작 어드레스를 결정하도록 구성되는, 장치.
제 9 항에 있어서,
상기 제1 타입의 벡터 로드 명령어가 상기 오프셋 레지스터로서 소정의 레지스터를 지정할 때, 상기 처리회로는 상기 오프셋 값을 제로로서 결정하도록 구성되는, 장치.
제 7 항 또는 제 8 항에 있어서,
상기 제1 및 제2 타입의 벡터 로드 명령어는, 기본 레지스터와 즉시 오프셋 값을 지정하고,
상기 제1 타입 또는 상기 제2 타입의 벡터 로드 명령어에 응답하여, 상기 처리회로는, 상기 어드레스들의 인접한 블록의 사이즈에 대응한 승수와 상기 즉시 오프셋 값과의 곱에, 상기 기본 레지스터에 기억된 기저 어드레스를 가산한 결과와 같은 값을 갖는, 상기 어드레스들의 인접한 블록의 시작 어드레스를 결정하도록 구성되고,
상기 제1 타입의 벡터 로드 명령어에 대해서, 상기 즉시 오프셋 값이 제로이고,
상기 제2 타입의 벡터 로드 명령어에 대해서, 상기 즉시 오프셋 값이 논제로인, 장치.
제 1 항 내지 제 11 항 중 어느 한 항에 있어서,
상기 예외 조건은 어드레스 변환 폴트나 메모리 허가 폴트를 포함하는, 장치.
제 1 항 내지 제 12 항 중 어느 한 항에 있어서,
상기 응답 액션은, 예외 처리 루틴의 실행을 기동하는 것을 포함하는, 장치.
벡터 로드 명령어에 응답하여, 데이터 스토어로부터 적어도 하나의 벡터 레지스터의 복수의 요소에 데이터를 로딩하기 위해 로드 연산들을 행하는 단계;
상기 벡터 로드 명령어가 제1 타입이고, 또 상기 적어도 하나의 벡터 레지스터의 제1 액티브 데이터 요소에 대해 소정의 순서로 행해진 상기 로드 연산을 위해 예외 조건이 검출될 때, 응답 액션을 행하는 단계;
상기 벡터 로드 명령어가 상기 제1 타입이고, 또 상기 제1 액티브 데이터 요소 이외의 액티브 데이터 요소에 대해 상기 소정의 순서로 행해진 상기 로드 연산을 위해 상기 예외 조건이 검출될 때, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 요소 식별정보를 기억하는 단계; 및
상기 벡터 로드 명령어가 제2 타입이고, 또 상기 적어도 하나의 벡터 레지스터의 임의의 액티브 데이터 요소에 대해 상기 로드 연산을 위해 상기 예외 조건이 검출될 때, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 상기 요소 식별정보를 기억하는 단계를 포함하고,
상기 제1 타입의 벡터 로드 명령어와 상기 제2 타입의 벡터 로드 명령어는 그들의 명령어 인코딩에 의해 구별되는, 데이터 처리방법.
벡터 로드 명령어에 응답하여, 데이터 스토어로부터 적어도 하나의 벡터 레지스터의 복수의 요소에 데이터를 로딩하기 위해 로드 연산들을 행하는 수단을 구비하고;
제1 타입의 벡터 로드 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 제1 액티브 데이터 요소에 대해 소정의 순서로 행해진 상기 로드 연산을 위해 예외 조건을 검출할 때, 상기 로드 연산들을 행하는 수단은, 응답 액션을 행하도록 구성되고, 상기 제1 액티브 데이터 요소 이외의 액티브 데이터 요소에 대해 상기 소정의 순서로 행해진 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 로드 연산들을 행하는 수단은, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 요소 식별정보를 기억하도록 구성되고;
제2 타입의 벡터 로드 명령어에 응답하여, 상기 적어도 하나의 벡터 레지스터의 임의의 액티브 데이터 요소에 대해 상기 로드 연산을 위해 상기 예외 조건을 검출할 때, 상기 로드 연산들을 행하는 수단은, 상기 응답 액션을 억제시키고, 상기 예외조건이 검출되는 상기 액티브 데이터 요소를 식별하는 상기 요소 식별정보를 기억하도록 구성되고;
상기 제1 타입의 벡터 로드 명령어와 상기 제2 타입의 벡터 로드 명령어는 그들의 명령어 인코딩에 의해 구별되는, 장치.
청구항 1 내지 13 중 어느 한 항에 따른 상기 장치에 대응한 가상 머신 실행환경을 컴퓨터가 제공하도록 제어하는 컴퓨터 프로그램.