KR20210156860A

KR20210156860A - True/false 벡터 인덱스 레지스터

Info

Publication number: KR20210156860A
Application number: KR1020217041187A
Authority: KR
Inventors: 스티븐 제프리 월랙
Original assignee: 마이크론 테크놀로지, 인크.
Priority date: 2019-05-20
Filing date: 2020-04-17
Publication date: 2021-12-27
Also published as: CN113874836A; US11507374B2; WO2020236368A1; EP3973385A4; US20230077404A1; US20200371801A1; EP3973385A1

Abstract

본원에는 벡터 프로세서들의 비교 동작들의 true 및/또는 false 결과들의 인덱스들을 저장 또는 로드하기 위한 벡터 인덱스 레지스터들이 개시되어 있다. 벡터 인덱스 레지스터들 각각은 피연산자 벡터들의 다수의 위치들에 액세스하기 위한 다수의 어드레스들을 저장한다.

Description

TRUE/FALSE 벡터 인덱스 레지스터

관련 출원

본 출원은 2019년 5월 20일자로 출원된 "TRUE/FALSE VECTOR INDEX REGISTERS"이라는 명칭의 미국 특허 출원 일련 번호 제16/417,495호에 대한 우선권을 주장하며, 그 전체 개시 내용은 본원에 참조로서 통합된다.

기술 분야

일반적으로, 본원에 개시된 적어도 일부 실시예들은 벡터 프로세서들에 관한 것이다. 또한, 본원에 개시된 적어도 일부 실시예들은 베터들에 접근하기 위한 어드레스들을 저장하는 벡터 프로세서들의 레지스터들에 관한 것이다.

벡터 프로세서는 일반적으로 벡터라고 하는 데이터 어레이들에서 동작하는 인스트럭션들을 포함하는 인스트럭션 세트를 구현하는 중앙 처리 장치(CPU)이거나 이를 포함할 수 있다. 이는 인스트럭션들이 단일 데이터 항목들에 대해 동작하는, 스칼라 프로세서와 다르다. 벡터 프로세서들은 스칼라 프로세서, 특히 수치 시뮬레이션 및 유사한 태스크들에 비해 특정 워크로드들의 성능을 크게 향상시킬 수 있다. 벡터 프로세서들은 1970년대 초에 등장했으며 1970년대부터 1990년대까지 슈퍼컴퓨팅 설계의 상당 부분을 차지하였다. 스칼라 프로세서 설계와 같은 보다 전통적인 마이크로프로세서 설계의 가격 대 성능 비율의 급격한 하락은 벡터 프로세서들의 개발 및 제조 감소로 이어졌다.

일반적으로, 기존 CPU들(예를 들어, 스칼라 기반 CPU들)은 최대한으로, 한 번에 몇 개의 데이터 조각을 조작할 수 있다. 예를 들어, 이러한 CPU들은 기본적으로 A를 B에 추가하고 결과를 C에 저장하는 인스트럭션을 갖는다. A, B 및 C에 대한 데이터는 일반적으로 데이터를 보유하는 메모리 위치에 어드레스를 전달하여 가리킨다. 이 어드레스를 디코딩하고 메모리에서 데이터를 가져오는 데 시간이 걸리며, 그 동안 CPU는 요청된 데이터가 표시될 때까지 유휴 상태로 대기할 수 있다.

이러한 단계들에 의해 소모되는 시간을 줄이기 위해, 최신 CPU들에서는 인스트럭션이 여러 서브 유닛들을 차례로 통과하는 인스트럭션들 파이프라이닝으로 알려진 기술을 사용한다. 제1 서브 유닛은 어드레스를 판독하여 이를 디코딩하고, 다음 서브 유닛은 해당 어드레스들의 값들을 가져오고, 다음 서브 유닛은 자체적으로 계산을 수행한다. 파이프라이닝을 사용하면, 어셈블리 라인과 유사하게, 제1 인스트럭션이 CPU를 떠나기도 전에 CPU가 다음 인스트럭션의 디코딩을 시작한다. 이렇게 하면, 어드레스 디코더 및 기타 언급된 부분들이 동시에 지속적으로 사용된다. 파이프라이닝으로 인해, 어떤 인스트럭션이든 완료하는 데 동일한 시간이 걸린다.

벡터 프로세서들은 인스트럭션들만 파이프라인하는 대신, 이러한 프로세서들도 데이터 자체를 파이프라인하여 파이프라인을 개선한다. 따라서, 계속해서 인스트럭션들을 디코딩한 다음 인스트럭션들을 완료하는 데 필요한 데이터를 가져오는 대신, 벡터 프로세서는 메모리로부터 단일 인스트럭션을 판독한다. 이를 통해 디코딩 시간을 줄이고 전력 소비를 줄일 수 있다(예를 들어, 다수의 디코드 대신 벡터 프로세서들에 의한 한 번의 디코드).

벡터 프로세서들뿐만 아니라 일반적으로 사용되는 스칼라 프로세서들과 같은 다른 유형의 프로세서들은 프로그램 또는 동작의 실행 동안 피연산자 어드레스들을 수정하기 위한 인덱스 레지스터들을 포함한다. 종종 인덱스들이 사용되며, 벡터 또는 어레이 동작들을 수행하는 데 유용하다. 인덱스 레지스터의 내용은 실제 데이터 또는 피연산자의 유효 어드레스를 형성하기 위해 즉시 어드레스에 더하거나 즉시 어드레스에서 뺄 수 있다. 일반적으로, 인스트럭션들은 인덱스 레지스터를 테스트할 수 있으며, 테스트가 실패하면, 인스트럭션들은 루프의 시작을 리셋할 수 있다. 일부 인스트럭션 세트들은 다수의 인덱스 레지스터들이 사용될 수 있도록 한다.

일반적으로, 인덱싱을 위해 스칼라 레지스터들을 사용하는 것으로 알려져 있다. 즉, 스칼라 인덱스 레지스터들을 사용하는 것으로 알려져 있다. 그러나, 인덱싱을 위해 스칼라 레지스터를 사용하는 것과 관련된 많은 제한 사항들이 있다. 그리고, 이러한 제한 사항들 중 일부는 인덱스 레지스터를 사용하는 프로세서의 성능을 억제할 수 있다. 예를 들어, 피연산자 벡터의 여러 위치들에 액세스하려면, 스칼라 인덱스 레지스터는 증분되어야 하며, 각 증분은 피연산자 벡터에 액세스하는 데 사용될 프로세서에 의해 별도로 로드되어야 한다.

본 개시는 이하의 상세한 설명 및 본 개시의 다양한 실시예들의 첨부 도면들로부터 보다 완전하게 이해될 것이다.
도 1은 본 개시의 일부 실시예들에 따른, 예시적인 컴퓨팅 장치(100)의 예시적인 부분들을 예시한다.
도 2는 본 개시의 일부 실시예들에 따른, 예시적인 컴퓨팅 장치(200)의 예시적인 부분들을 예시한다.
도 3은 본 개시의 일부 실시예들에 따른, 벡터 인덱스 레지스터(302)를 포함하는 예시적인 시스템(300)을 예시한다.
도 4는 본 개시의 일부 실시예들에 따른, 벡터 인덱스 레지스터들(402a, 402b 및 402c)을 포함하는 예시적인 시스템(400)을 예시한다.
도 5는 본 개시의 일부 실시예들에 따른, 벡터 인덱스 레지스터(502) 및 벡터 제1 레지스터(503)를 포함하는 예시적인 시스템(500)을 예시한다.
도 6은 본 개시의 일부 실시예들에 따른, 피연산자 벡터의 요소들에 액세스하는 방법(600)의 예시적인 동작들을 예시한다.
도 7은 본 개시의 일부 실시예들에 따른, 피연산자 벡터의 요소들을 압축하는 방법(700)의 예시적인 동작들을 예시한다.
도 8은 본 개시의 일부 실시예들에 따른, 입력 OVR(804)에 저장된 입력 피연산자 벡터의 요소들을 압축하는데 사용되는 벡터 인덱스 레지스터(802)를 포함하는 예시적인 시스템(800)을 예시한다.
도 9는 본 개시의 일부 실시예들에 따른, 압축된 피연산자 벡터의 요소들과 같은 피연산자 벡터의 요소들을 확장하는 방법(900)의 예시적인 동작들을 예시한다.
도 10은 본 개시의 일부 실시예들에 따른, 다수의 압축된 벡터들에 대한 연산들과 관련된 방법(1000)의 예시적인 동작들을 예시한다.
도 11은 본 개시의 일부 실시예들에 따른, 비교의 TRUE 및 FALSE 결과(예를 들어, "0" 및 "1" 결과)에 대해 벡터 인덱싱 레지스터들(VIR_TRUE 및 VIR_FALSE)에 저장하기 위한 인덱싱 벡터들을 구축하는 방법(1100)의 예시적인 동작을 예시한다.
도 12는 본 개시의 일부 실시예들에 따른, VIR_TRUE(1202a) 및 VIR_FALSE(1202b)에 저장하기 위한 인덱싱 벡터들을 구축하기 위한 예시적인 시스템(1200)을 예시한다.
도 13은 본 개시의 일부 실시예들에 따른, 비교의 TRUE 및 FALSE 결과에 대해 결합된 벡터 인덱싱 레지스터(VIR_combined)에 저장하기 위한 결합된 인덱싱 벡터를 구축하는 방법(1300)의 예시적인 동작들을 예시한다.
도 14는 본 개시의 일부 실시예들에 따른, VIR_combined(1402)에 저장하는 결합된 인덱싱 벡터를 구축하는 예시적인 시스템(1400)을 예시한다.
도 15는 본 개시의 일부 실시예들에 따른, VIR_TRUE(1502a) 및 VIR_FALSE(1502b)를 포함하는 예시적인 시스템(1500)을 예시한다.
도 16은 본 개시의 일부 실시예들에 따른, VIR_TRUE에 따라 피연산자 벡터의 요소들을 압축하는 방법(1600)의 예시적인 동작들을 예시한다.
도 17은 본 개시의 일부 실시예들에 따른, 입력 OVR(1704)에 저장된 입력 피연산자 벡터의 요소들을 압축하는 데 사용되는 VIR_TRUE(1702a)를 포함하는 예시적인 시스템(1700)을 예시한다.

일반적으로, 본원에 개시된 적어도 일부 실시예들은 벡터 프로세서들에 관한 것이다. 또한, 본원에 개시된 적어도 일부 실시예들은 베터들에 접근하기 위한 어드레스들을 저장하는 벡터 프로세서들의 레지스터들에 관한 것이다. 그리고, 본원에 개시된 실시예들의 적어도 일부는 벡터들의 다수의 위치들에 액세스하기 위한 다수의 어드레스들을 각각 저장하는 벡터 프로세서들의 벡터 인덱스 레지스터들이다.

벡터 연산 동안 스칼라 인덱스 레지스터에 저장된 값을 변경함으로써 벡터들의 다수의 위치들을 참조하기 위해 벡터 프로세서에서 스칼라 인덱스 레지스터를 사용하는 것으로 알려져 있다. 그러나, 하나 이상의 피연산자 벡터들의 다수의 위치들을 인덱싱하기 위해 벡터 인덱싱 레지스터를 사용함으로써, 스칼라 인덱스 레지스터가 교체될 수 있으며, 적어도 벡터 연산 동안 스칼라 인덱스 레지스터에서 값들의 연속적인 변경이 방지될 수 있다. 이는 본원에 설명된 기술 문제에 대한 기술 솔루션의 한 예일 뿐이다.

스칼라 또는 단식부기(single-entry) 레지스터는 벡터 레지스터에 대한 연산이 요소 i에서 시작하도록 하는 인덱스 i를 저장할 수 있거나, 연산이 요소 0에서 시작할 수 있다. 연산의 후속 부분들은 각 증분에서 요소 0+1 또는 i+1에 액세스한다. 참고로, 인덱스 i를 저장하는 단식부기 레지스터를 사용하는 것은 벡터 제1 연산 및 인덱싱에 사용될 수 있으며, 이는 어느 정도 본원에도 개시되어 있다.

그러나, 인덱싱을 위해 스칼라 레지스터 또는 단식부기 벡터를 사용하는 것과 관련된 많은 제한 사항들이 있다. 그리고, 이러한 제한 사항들 중 일부는 인덱스 레지스터를 사용하는 벡터 프로세서의 성능을 억제할 수 있다. 예를 들어, 피연산자 벡터의 다수의 위치들에 액세스하려면, 스칼라 또는 단식부기 인덱스 레지스터는 증분되어야 하며, 각 증분은 피연산자 벡터에 액세스하는 데 사용될 벡터 프로세서에 의해 별도로 로드되어야 한다.

하나 이상의 피연산자 벡터들의 다수의 위치들을 인덱싱하기 위해 벡터 인덱싱 레지스터를 사용함으로써, 스칼라 인덱스 레지스터가 교체될 수 있으며, 적어도 벡터 연산 동안 스칼라 인덱스 레지스터의 연속적인 변경이 방지될 수 있다.

일반적으로, 본원에 개시된 실시예들은 적어도 배경 섹션 및 애플리케이션의 다른 부분들에서 언급된 기술적 문제들뿐만 아니라 본원에 설명되지 않았지만 당업자에 의해 인식되는 다른 기술적 문제들에 대한 특정 기술 솔루션들을 제공한다.

일부 실시예들에서, 벡터 인덱스 레지스터(VIR)는 선택적 인덱싱을 사용하는 벡터 연산들을 위한 어드레스 성분들을 저장할 수 있다. 이는 벡터 제1 처리 또는 인덱싱과 다소 유사하다. 예를 들어, 선택적 인텍싱을 사용하여, VIR은 어드레스 부분들(i_1, i_2, ..., i_n)을 저장할 수 있다. 이는 벡터 레지스터에 대한 연산들이 입력 벡터의 요소들(i, i+1, i+2, ..., i+n) 대신, 입력 벡터의 요소들(i_1, i_2, ..., i_n)을 통해 이동하도록 한다. 예를 들어, 선택적 인덱싱을 사용하여, VIR은 비순차적 어드레스 부분들(i_1, i_3, ..., i_8)을 저장할 수 있다. 이를 통해 벡터 레지스터에 대한 연산들이 입력 벡터의 비순차적 요소들을 통해 이동하도록 한다.

VIR의 용도는 다양하다. 예를 들어, VIR은 벡터 압축 또는 확장 기능을 보다 효율적으로 구현하는 데 사용할 수 있다. 예를 들어, 벡터 비교 연산이 선택된 요소들의 인덱스 벡터를 생성할 때, 선택된 성분들은 압축된 벡터의 생성 시 어드레싱에 사용될 수 있는 VIR에 로드될 수 있다. VIR의 요소들(또는 VMX(i)의 요소들)은 벡터 V(i)의 비연속 요소들에 액세스하기 위한 어드레스 성분들이다. 단식부기 인덱스 벡터를 통해 V(i)(여기서, 각 반복에 대해 i = i +1)에 액세스하는 대신, 벡터 프로세서는 순차적으로 V(VMX(i))(여기서, 각 반복에 대해 i = i +1)에 액세스할 수 있다. 또한, 이런 식으로, 성분들은 벡터 프로세서가 사용하기 위해 VIR로부터 한 번만 로드된다. 벡터 제1 레지스터와 같은, 단식부기 인덱스 벡터가 사용되는 경우, 입력 벡터의 요소는 단식부기 인덱스 벡터의 값으로 시작하는 카운터에 의해 어드레스된다. 단식부기 인덱스 레지스터를 사용하기 위해, 각 어드레스는 인덱스 레지스터로부터 순차적으로 로드된다. 다시 말해, VIR의 사용으로, VIR에 저장된 각 어드레스 또는 어드레스 성분이 동시에 한 번만 로드된다. 이는 VIR을 사용하는 벡터 프로세서의 성능을 크게 향상시킨다.

일부 실시예들에서, 카운터(예를 들어, 카운터 레지스터)는 VIR을 구동시킬 수 있다. 또한, N:1 멀티플렉서(즉, 다중 입력 단일 출력 멀티플렉서)와 같은 멀티플렉서는 카운터의 출력들 간에 선택적으로 전환하여, 각 벡터 반복에 대해 피연산자 레지스터의 특정 위치에 액세스하기 위한 출력을 생성하거나, 또는 카운터의 각 반복에 대해 피연산자 레지스터의 특정 위치에 액세스하기 위한 VIR에서 나오는 인덱스를 생성하는 데 사용될 수 있다.

본원에 개시된 전술한 특징들 및 기타 특징들은 조건부 연산에 유용할 수 있다. 예를 들어, 벡터에 대한 조건부 연산을 위한 벡터 마스크 레지스터를 생성하는 대신, 본원에 개시된 회로들 중 하나는 하나 이상의 인덱스 벡터들을 생성할 수 있다. 그런 다음, 인덱스 벡터(들)를 사용하여, 벡터 마스크 레지스터의 분기들이 각각 해당 VIR(들)을 통해 평가될 수 있다. VIR(들)은 벡터 마스크가 생성되거나 반복될 필요가 없고 마스크의 성분들이 반복마다 별도로 로드될 필요가 없기 때문에 벡터 프로세서에 의한 처리 속도를 높인다.

이러한 기능은 벡터 확장 연산 및/또는 벡터 연산의 결과를 벡터 레지스터로 병합하는 데에도 유용할 수 있다. 예를 들어, VIR은 B(VMX(i)) = A(i) 연산 시 인덱싱에 사용될 수 있으며, 여기서 "B(VMX(i))"는 압축된 벡터 A의 확장이다. 또한, VIR은 B(VMX(i)) = A(i) +a 연산 시 인덱싱에 사용할 수 있으며, 여기서 "B(VMX(i))"는 압축된 벡터 A의 확장이고, 스칼라 값 "a"가 확장된 벡터 A에 더해진다. 또한, VIR은 B(VMX(i)) = 함수 (A(VMX(i)), C(VMX(i)) 연산 시 인덱싱에 사용될 수 있으며, 여기서 프로세서는 "VMX"라고 표시된 VIR을 통해 선택된 요소들에 대해 벡터 A 및 벡터 C에 대한 연산을 수행한다 이는 조건부 처리의 일 예이며, 중첩된(nested) 조건부 처리에도 사용될 수 있다.

VIR(예를 들어, 피연산자 벡터 레지스터(OVR) 내의 요소들에 액세스하기 위한 [2, 4, 5, 8])에 저장된 인덱스 값들 또는 어드레싱 성분들은 메모리 어드레스들(예를 들어, 기본 어드레스에 각 메모리 유닛에 대한 증분 더함)로 변환될 수 있다. 따라서, 본원에 설명된 멀티플레서드로부터의 출력들과 같은, 본원에 설명된 출력들은 피연산자 벡터 레지스터들(OVR들)에 액세스하는 것과 유사한 방식으로, 메인 메모리의 벡터들에 직접 액세스하기 위한 메모리 어드레스들로 변환될 수 있다.

도 1은 본 개시의 일부 실시예들에 따른, 예시적인 컴퓨팅 장치(100)의 예시적인 부분들을 예시한다. 장치(100)는 도시된 바와 같이, 하나 이상의 네트워크들(112)에 통신 가능하게 결합될 수 있다. 장치(100)는 본 개시의 일부 실시예들에 따른 벡터 프로세서(102)를 포함한다. 장치(100)는 또한 적어도 버스(104), 메인 메모리(106), 데이터 저장 시스템(108), 및 네트워크 인터페이스(110)를 포함한다. 버스(104)는 벡터 프로세서(102), 메인 메모리(106), 데이터 저장 시스템(108), 및 네트워크 인터페이스(110)를 통신 가능하게 결합한다. 장치(100)는 버스(104)(이는 다수의 버스들을 포함할 수 있음)를 통해 서로 통신하는, 적어도 벡터 프로세서(102), 메인 메모리(106)(예를 들어, 읽기 전용 메모리(ROM), 플래시 메모리, 예컨대 동기식 DRAM(SDRAM) 또는 램버스 DRAM(RDRAM)과 같은 동적 랜덤 액세스 메모리(DRAM), 정적 랜덤 액세스 메모리(SRAM) 등), 및 데이터 저장 시스템(108)을 포함하는 컴퓨터 시스템을 포함한다.

달리 말해, 도 1은 본 개시의 실시예들이 동작할 수 있는 컴퓨터 시스템을 갖는 예시적인 장치(100)의 블록도이다. 일부 실시예들에서, 컴퓨터 시스템은 실행 시, 기계가 본원에 논의된 방법론들 중 임의의 하나 이상을 수행하도록 하기 위한 인스트럭션 세트를 포함할 수 있다. 이러한 실시예들에서, 기계는 LAN, 인트라넷, 엑스트라넷 및/또는 인터넷(예를 들어, 네트워크(들)(112))의 다른 기계들에 연결(예를 들어, 네트워크 인터페이스(110)를 통해 네트워킹)될 수 있다. 기계는 클라이언트-서버 네트워크 환경에서 서버 또는 클라이언트 기계의 자격으로, 피어 투 피어(또는 분산형) 네트워크 환경에서의 피어 기계(본원에 설명된 피어 투 피어 네트워크와 같음)로, 또는 클라우드 컴퓨팅 인프라 또는 환경에서의 서버 또는 클라이언트 기계로 동작할 수 있다.

벡터 프로세서(102)는 본 개시의 일부 실시예들에 따른 하나 이상의 벡터 프로세서들을 나타낸다. 벡터 프로세서(102)는 마이크로프로세서, 중앙 처리 장치 등을 포함할 수 있다. 보다 구체적으로, 벡터 프로세서(102)는 CISC(complex instruction set computing) 마이크로프로세서, RISC(reduced instruction set computing) 마이크로프로세서, VLIW(very long instruction word) 마이크로프로세서, 또는 프로세서가 벡터 인스트럭션들, 벡터 레지스터들, 벡터 제1 및 멀티-레인 구성을 사용하는 한, 인스트럭션 세터들의 조합을 구현하는 프로세서를 포함할 수 있다. 벡터 프로세스(102)는 또한 애플리케이션별 집적 회로(ASIC), 필드 프로그램 가능 게이트 어레이(FPGA), 디지털 신호 프로세서(DSP), 그래픽 처리 장치(GPU), 네트워크 프로세서 등과 같은 하나 이상의 특수 목적 처리 장치들일 수 있다. 벡터 프로세서(102)는 본원에 논의된 동작들 및 단계들을 수행하기 위한 인스트럭션들을 실행하도록 구성될 수 있다. 벡터 프로세서(102)는 (네트워크(들)(112)와 같은) 하나 이상의 통신 네트워크를 통해 통신하기 위해 네트워크 인터페이스(110)와 같은 네트워크 인터페이스 장치를 더 포함할 수 있다.

데이터 저장 시스템(108)은 하나 이상의 인스트력션 세트들 또는 소프트웨어가 저장되고 본원에 설명된 방법들 또는 기능들 중 하나 이상 중 적어도 일부 양태들을 구현할 수 있는 기계 판독 가능 저장 매체(컴퓨터 판독 가능 매체라고도 함)를 포함할 수 있다. 데이터 저장 시스템(108)은 비-휘발성 저장 장치를 포함할 수 있다. 인스트럭션들은 또한 기계 판독 가능 저장 매체를 구성할 수도 있는 컴퓨터 시스템, 메인 메모리(106) 및 벡터 프로세서(102)에 의한 실행 동안 메인 메모리(106) 내에 및/또는 벡터 프로세서(102) 내에, 완전히 또는 적어도 부분적으로, 상주할 수 있다. 메모리, 벡터 프로세서 및 데이터 저장 부분들이 예시적인 실시예에서 각각 단일 부분인 것으로 도시되어 있지만, 각 부분은 인스트럭션들을 저장하고 그 각각의 동작들을 수행할 수 있는 단일 부분 또는 다수의 부분들을 포함하는 것으로 간주되어야 한다. "기계 판독 가능 저장 매체"라는 용어는 또한 기계에 의해 실행되는 인스트럭션 세트를 저장 또는 인코딩할 수 있고 기계가 본 개시의 방법들 중 임의의 하나 이상을 수행하게 하는 임의의 매체를 포함하는 것으로 간주되어야 한다. 따라서, "기계 판독 가능 저장 매체"라는 용어는, 이에 제한되는 것은 아니나, 솔리드 스테이트 메모리들, 광학 매체 및 자기 매체를 포함하는 것으로 간주되어야 한다.

도 2는 본 개시의 일부 실시예들에 따른, 예시적인 컴퓨팅 장치(200)의 예시적인 부분들을 예시한다. 도시된 바와 같이, 컴퓨팅 장치(200)는 버스(104) 및 메인 메모리(106)(예를 들어, 도 1 참조) 뿐만 아니라 벡터 프로세서(102)를 포함한다. 컴퓨팅 장치(200)는 또한 컴퓨팅 장치(100)일 수 있거나 이를 포함할 수 있다.

도 2에 도시된 바와 같이, 벡터 프로세서(102)는 벡터 레지스터들(202), 스칼라 레지스터들(204), 버스(206), 산술 로직 유닛들(208)(ALU들(208)), 및 벡터 로드-저장 유닛(210)을 포함한다. 컴퓨팅 장치(200)의 다른 실시예들은 벡터 프로세서(102) 외부에 있거나, 또는 벡터 레지스터들(202)을 갖는 벡터 프로세서의 유닛으로부터 벡터 프로세서의 별도 유닛으로 있는 스칼라 레지스터들(204)을 포함할 수 있다. 버스(206)는 벡터 레지스터들(202), 스칼라 레지스터들(204), 산술 로직 유닛들(ALU들)(208), 및 벡터 로드-저장 유닛(210)을 통신 가능하게 결합하며, 이러한 컴포넌트들은 버스(206)(이는 다수의 버스들을 포함할 수 있음)를 통해 서로 통신할 수 있다. 벡터 레지스터들(202)은 다수의 벡터 레지스터들을 포함한다. 그리고, ALU들(208)은 다수의 ALU들 -- 예를 들어, 산술 로직 장치(ALU) 0, ALU 1 및 ALU N을 포함한다.

벡터 프로세서(102)는 적어도 하나의 벡터 인덱스 레지스터를 포함한다. 벡터 프로세서(102)는 데이터 호출 벡터들의 1차원 어레이들에서 동작하는 인스트럭션들을 구현하는 하나 이상의 중앙 처리 장치들(CPU들)일 수 있거나 이를 포함할 수 있다.

벡터 프로세서(102)의 벡터 레지스터들(202)은 피연산자 벡터 레지스터들(즉, 입력 벡터 레지스터들), 결과 벡터 레지스터들(즉, 출력 벡터 레지스터들), 및 피연산자 벡터 레지스터들 및/또는 결과 벡터 레지스터들의 요소들에 액세스하는 데 사용되는 값들을 저장하는 벡터 인덱스 레지스터들을 포함할 수 있다. 피연산자 벡터 레지스터들 및/또는 결과 벡터 레지스터들의 액세스된 요소들의 값들은 ALU들(208) 중 하나 이상과 같은 ALU들에 대한 입력으로 사용될 수 있다.

일반적으로, 벡터 프로세서(102)는 스칼라 인덱스 레지스터들을 포함할 수 있는 인덱스 레지스터들 및 도 3, 4 및 5에 예시된 벡터 인덱스 레지스터들과 같은 벡터 인덱스 레지스터들을 포함할 수 있다.

벡터 프로세서(102)의 스칼라 레지스터들(204)은 스칼라 인덱스 레지스터들뿐만 아니라 피연산자 스칼라 레지스터들(즉, 입력 스칼라 레지스터들) 및 결과 스칼라 레지스터들(즉, 출력 스칼라 레지스터들)을 포함할 수 있다. 스칼라 레지스터들 중 적어도 일부는 스칼라들 및 벡터들에 대한 다양한 유형의 연산들에 대한 인덱싱 및 제어 값들을 제공할 수 있다. 또한, 스칼라 레지스터들은 벡터 인스트럭션들에 의해 사용되는 숫치 값들도 제공할 수 있다. 예를 들어, 벡터 레지스터에 의해 제공되는 벡터는 스칼라 레지스터에 의해 제공되는 스칼라로 곱해질 수 있다.

스칼라 레지스터들(204) 및 벡터 레지스터들(202) 중 적어도 일부는 ALU들(208)의 각각의 ALU들에 연결될 수 있다. ALU들(208)의 ALU는 정수 이진수에 대해 산술 및 비트 연산들을 수행하는 조합 디지털 전자 회로를 포함할 수 있다. 벡터 프로세서(102)에서, ALU들(208)의 ALU는 입력 벡터 레지스터들에 연결될 수 있으며, 일부 경우에는 출력 벡터 레지스터가 연산 시 피드백을 제공하는 경우 출력 벡터 레지스터들에 연결될 수 있다. 이러한 경우, 출력 벡터 레지스터는 입력 및 출력 벡터이다.

또한, 스칼라 레지스터들(204)은 프로그램 가능 스칼라 레지스터들을 포함할 수 있다. 프로그램 가능 스칼라 레지스터는 벡터 레지스터(예를 들어, 벡터 레지스터들(202) 중 하나)에 의해 제공되는 벡터가 프로그램 가능 스칼라 레지스터들 중 하나에 의해 제공되고 프로그램 가능한 스칼라 레지스터들 중 하나로 프로그래밍되는 스칼라에 의해 연산될 수 있도록 사용될 수 있다. 예를 들어, 연산들 중 하나는 스칼라 값이 곱해진 벡터(예를 들어, 벡터 A(i) X 스칼라 p)를 포함할 수 있다.

도시된 버스(206)는 벡터 로드-저장 유닛(210), 벡터 레지스터들(202), 스칼라 레지스터들(204), 및 산술 로직 유닛들(208)을 통신 가능하게 결합하도록 구성될 수 있다. 버스(206)는 벡터 인덱스 레지스터들로부터 입력들을 수신하고 피연산자 벡터의 액세스를 위한 어드레스 또는 어드레스 성분을 출력하도록 구성된 2:1 멀티플렉서, 3:1 멀티플렉서, 또는 N:1 멀티플렉서를 포함할 수 있다. (예를 들어, 도 3, 4 및 5 참조).

벡터 로드-저장 유닛(210)은 로드 및 저장 인스트럭션들을 실행하고, 로드 및 저장 벡터 연산들의 어드레스들을 생성하고, 메모리로부터 데이터를 로드하거나 이를 벡터 프로세서(102)의 레지스터들로부터 메모리로 다시 저장하기 위한 회로부를 포함한다. 벡터 로드-저장 유닛(210)은 도 6 내지 10의 방법들(600, 700, 900 및 1000)의 많은 동작들을 포함하는 본원에 설명된 많은 동작들을 수행할 수 있다.

본원에 설명된 컴퓨팅 장치들 각각은 해당 기계에 의해 수행될 동작들을 지정하는 인스트럭션 세트(순차적이든 아니든)를 실행할 수 있는 기계일 수 있다. 또한, 도 1 및 2의 예시된 컴퓨팅 장치들 각각에 대해 단일 기계가 예시되어 있지만, "기계"라는 용어는 또한 본원에서 논의된 방법론들 또는 동작들 중 임의의 하나 이상을 수행하기 위해 인스트럭션 세트(또는 복수 세트)를 개별적으로 또는 공통으로 실행하는 임의의 기계 컬렉션을 포함하는 것으로 간주해야 한다. 그리고, 예시된 컴퓨팅 장치들 각각은 적어도 버스 및/또는 마더보드, (하나 이상의 CPU들과 같은) 하나 이상의 컨트롤러들, 임시 데이터 저장 장치를 포함할 수 있는 메인 메모리, 적어도 한 유형의 네트워크 인터페이스, 영구 데이터 저장 장치를 포함할 수 있는 저장 시스템 및/또는 이들의 임의의 조합을 각각 포함할 수 있다.

도 3, 4 및 5에 도시된 시스템들(300, 400 및 500)에 대한 논의 전에, 벡터 레지스터의 요소들은 적어도 벡터 인덱스 레지스터(VIR) 또는 카운터 레지스터와 같은 다른 유형의 레지스터에서 나오는 인덱스를 사용하여 어드레스될 수 있다는 것을 이해하는 것이 중요하다. 일반적으로, 카운터 레지스터가 사용되면, 카운터는 다음 반복 또는 단계에 대한 어드레스를 생성하는 DO 또는 FOR 루프(loop)의 각 반복 또는 단계에 대해 그 자체에 1을 추가한다. VIR은 카운터에 의해 구동될 필요는 없지만, 카운터에 의해 구동되는 VIR을 갖는 것이 유용할 수 있다. 공통 카운터는 VIR 구동을 수행할 수 있을 뿐만 아니라, 벡터 연산 시 피연산자 벡터에 액세스하는 데 사용하기 위해 어드레스 성분을 출력하는 수신 멀티플렉서에 별도의 입력을 제공할 수도 있다.

예를 들어, VIR은 벡터 VMX, 여기서 VMX(i)를 저장할 수 있으며, i= 0, 1, ..., n-1이다. VIR 사용 애플리케이션의 간단한 예는 B(i) = A(VMX(i))와 같은 압축 연산이 있을 것이다. 또한, 다른 벡터 레지스터가 벡터 A를 저장할 때, 해당 요소들은 A(i)이며 여기서 i=0, 1, 2, ...n이다. 일반 모드(예컨대 카운터 출력이 멀티플렉서에 의한 사용을 위해 선택되는 경우)에서, 프로세서는 A +a를 수행할 수 있으며, 여기서 "a"는 멀티플렉서를 통한 카운터의 스케일러이다. 결과는 출력 벡터 레지스터 B에 저장되며, 여기서 B(i) = A(i) +a이고, 여기서 i=0, 1, ..., n-1이다. VIR을 사용하는 모드(예를 들어, 멀티플렉서의 대안적인 선택 제어)에서, 프로세서는 VIR의 출력으로부터 생성된 어드레스를 사용하여 A(VMX) +a를 수행할 수 있다. 따라서, 출력 벡터 레지스터는 B를 가지며, 여기서 B(i) = A(VMX(i)) +a이고, 여기서 i=0, 1, ..., n-1이다. 또한, 예를 들어, 벡터 프로세서는 두 개의 벡터들, 예를 들어 B(i) = 함수 (A(VMX(i)), C(VMX(i))에서 연산하도록 구성될 수 있으며, 여기서 "함수"는 ALU를 통해 구현된다.

도 3은 본 개시의 일부 실시예들에 따른, 벡터 인덱스 레지스터(302)를 포함하는 예시적인 시스템(300)을 예시한다.

시스템(300)은 벡터 프로세서(102)(예를 들어, 도 1 또는 2 참조) 또는 다수의 벡터 프로세서들의 일부일 수 있다. 시스템(300)은 벡터 인덱스 레지스터(302)(VIR(302)), 카운터 레지스터(304), 2:1 멀티플렉서(306), 및 멀티플렉서에 연결된 선택 레지스터(308)를 포함한다. VIR(302)은 도 2에 도시된 벡터 레지스터들(202) 중 하나일 수 있다. 카운터 레지스터(304) 및 선택 레지스터(308)는 스칼라 레지스터들(204)의 레지스터들일 수 있다. 2:1 멀티플렉서(306)는 도 2에 도시된 버스(206) 또는 도 1에 도시된 버스(104)의 일부일 수 있다.

시스템(300)은 복수의 산술 로직 유닛들(ALU들) 중 산술 로직 유닛(ALU)을 포함하는 벡터 프로세서의 일부일 수 있다. 벡터 프로세서는 또한 복수의 피연산자 벡터 레지스터들의 피연산자 벡터 레지스터(OVR)를 포함할 수 있다. OVR은 ALU의 벡터 연산을 위한 입력으로 사용될 피연산자 벡터의 요소들을 저장하도록 구성될 수 있다.

VIR(302)은 OVR의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하도록 구성될 수 있다. 각 어드레스 성분은 OVR의 해당 위치에 액세스하기 위한 유효 어드레스에 추가할 수 있다. OVR의 각 위치는 ALU에 의해 연산될 피연산자 벡터의 요소를 포함할 수 있다.

일부 실시예들에서, 예시적인 OVR은 길이가 64 비트일 수 있다. 피연산자가 64 비트 미만인 경우(예를 들어, 32 비트 정수), 해당 피연산자는 오른쪽 정렬될 수 있다. 이러한 예에서, 본원에 설명된 인덱싱 기술들이 마찬가지로 적용된다. 예를 들어, OVR은 다양한 데이터 유형들을 수용하기 위해 요소들에 패딩을 포함할 수 있다.

도시된 바와 같이, 카운터 레지스터(304)는 시스템(300)의 일부이다. 카운터 레지스터(304)는 또한 시스템(300)을 갖는 벡터 프로세서의 일부일 수 있다. 카운터 레지스터(304)는 카운트(310)를 저장하도록 구성될 수 있다. 카운트(310)는 OVR에 액세스하기 위한 유효 어드레스에 추가될 수 있거나, 카운트는 VIR(302)에 저장된 복수의 어드레스 성분들에서 반복하도록 벡터 프로세서에 의해 사용될 수 있다.

도시된 바와 같이, 2:1 멀티플레서(306)는 시스템(300)의 일부이다. 2:1 멀티플렉서(306)는 또한 시스템(300)을 갖는 벡터 프로세서의 일부일 수 있다. 2:1 멀티플렉서(306)는 카운터 레지스터(304)로부터의 카운트(310) 및 VIR(302)로부터의 출력(312)을, 입력들로서, 수신하도록 구성될 수 있다. VIR(302)로부터의 출력(312)은 카운트(310)에 대응하는 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있다. 2:1 멀티플렉서(306)는 또한, 선택 입력으로서, 모드 값(314)을 수신하도록 구성될 수 있다. 모드 값(314)은 카운트(310)의 선택을 위한 값 또는 VIR(302)로부터의 출력(312)의 선택을 위한 값이거나 이를 포함할 수 있다. 2:1 멀티플렉서(306)는 또한 수신된 모드 값(314)에 따라 VIR(302)로부터 카운트(310) 또는 출력(312)을 선택하도록 구성될 수 있다. 2:1 멀티플렉서(306)는 또한 버스(도 1 또는 2의 버스들 중 하나와 같은)를 통해, VIR로부터의 선택된 카운트 또는 선택된 출력 중 하나인 선택 출력(316)을 출력 및 전달하도록 구성될 수 있다. 선택 출력(316)은 ALU를 위한 OVR에 액세스하는 요청자에게 전달될 수 있다. 요청자는 벡터 프로세서의 벡터 로드-저장 유닛(예를 들어, 도 2에 도시된 벡터 로드-저장 유닛(210) 참조), 또는 다른 벡터 프로세서의 벡터 로드-저장 유닛일 수 있다.

요청자가 벡터 로드 저장 유닛인 경우 벡터 프로세서의 로드 및 저장 동작들의 유효 어드레스들을 생성하도록 구성할 수 있다. 벡터 로드-저장 유닛은 또한, VIR의 각 어드레스 성분에 대해, VIR의 어드레스 성분을 OVR의 해당 위치에 액세스하기 위한 유효 어드레스에 추가하도록 구성될 수 있다.

도 4는 본 개시의 일부 실시예들에 따른, 벡터 인덱스 레지스터들(402a, 402b 및 402c)을 포함하는 예시적인 시스템(400)을 예시한다.

시스템(400)은 벡터 프로세서(102)(예를 들어, 도 1 또는 2 참조) 또는 다수의 벡터 프로세서들의 일부일 수 있다. 시스템(400)은 벡터 인덱스 레지스터들(402a, 402b, 402c)(VIR들(402a, 402b, 402c))을 포함하는 다수의 벡터 인덱스 레지스터들을 포함한다. 시스템(400)은 또한 카운터 레지스터(404), N:1 멀티플렉서(406), 및 멀티플렉서에 연결된 선택 레지스터(408)를 포함한다. VIR들(402a, 402b, 402c)은 도 2에 도시된 벡터 레지스터들(202)의 벡터 레지스터들일 수 있다. 카운터 레지스터(404) 및 선택 레지스터(408)는 스칼라 레지스터들(204)의 레지스터들일 수 있다. N:1 멀티플렉서(406)는 도 2에 도시된 버스(206) 또는 도 1에 도시된 버스(104)의 일부일 수 있다. N:1 멀티플렉서(406)는 도시된 바와 같이 적어도 4개의 입력들을 수신할 수 있는 멀티플렉서이다. 그러나, 일부 실시예들에서, 멀티플레서(406)는 4개 이상의 입력들을 수신할 수 있다. N:1 멀티플렉서(406)는 피연산자 벡터 레지스터(OVR)에 액세스하는 데 사용되는 어드레스 성분일 수 있는 하나의 출력을 출력한다.

시스템(400)은 ALU ALU들을 포함하는 벡터 프로세서의 일부일 수 있다. 벡터 프로세서는 또한 OVR들 중 OVR을 포함할 수 있다. OVR은 ALU의 벡터 연산을 위한 입력으로 사용될 피연산자 벡터의 요소들을 저장하도록 구성될 수 있다.

VIR들(402a, 402b, 402c)은 각각 예를 들어 OVR 또는 3개의 개별 OVR들 내의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하도록 구성될 수 있다. 다수의 OVR들을 갖는 일 예에서, 각 OVR에 대해 별도의 멀티플렉서가 있을 수 있다. 또한, 다수의 OVR들을 갖는 일 예에서, 각 OVR에 대해, 시스템(300)과 같은 별도의 어드레싱 시스템이 있을 수 있다. 다중 VIR들(예를 들어, VIR들(402a, 402b 및 402c))의 각 어드레스 성분은 OVR 또는 다수의 OVR들에서 대응하는 위치에 액세스하기 위한 유효 어드레스에 추가될 수 있다. OVR(들)의 각 위치는 ALU에 의해 연산될 피연산자 벡터의 요소를 포함할 수 있다.

도시된 바와 같이, 카운터 레지스터(404)는 시스템(400)의 일부이다. 카운터 레지스터(404)는 또한 시스템(400)을 갖는 벡터 프로세서의 일부일 수 있다. 카운터 레지스터(404)는 카운트(410)를 저장하도록 구성될 수 있다. 카운트(410)는 하나 이상의 OVR들에 액세스하기 위한 유효 어드레스에 추가될 수 있거나 카운트는 다중 VIR들(예를 들어, VIR들(402a, 402b 및 402c))에 저장된 복수의 어드레스 성분들을 반복하기 위해 벡터 프로세서에 의해 사용될 수 있다.

도시된 바와 같이, N:1 멀티플레서(406)는 시스템(400)의 일부이다. N:1 멀티플렉서(406)는 또한 시스템(400)을 갖는 벡터 프로세서의 일부일 수 있다. N:1 멀티플렉서(406)는 카운터 레지스터(404)로부터 카운트(410)를, 입력들로서, 수신하고 다수의 VIR들(예를 들어, VIR들(402a, 402b 및 402c))로부터 출력들(예를 들어, 출력들(412a, 412b 및 412c))을 수신하도록 구성될 수 있다. VIR들(402a, 402b 및 402c)로부터의 출력들(412a, 412b 및 412c)은 각각 카운트(410)에 대응하는 각 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있다. N:1 멀티플렉서(406)는 또한, 선택 입력으로서, 모드 값(414)을 수신하도록 구성될 수 있다. 모드 값(414)은 예를 들어 VIR들(402a, 402b 및 402c)로부터의 카운트(410)의 선택을 위한 값 또는 출력들(412a, 412b 및 412c)의 선택을 위한 값이거나 이를 포함할 수 있다. N:1 멀티플렉서(406)는 또한 수신된 모드 값(414)에 따라 VIR들(402a, 402b, 402c)로부터 카운트(410) 또는 출력들(412a, 412b 및 412c)을 선택하도록 구성될 수 있다. N:1 멀티플렉서(406)는 또한 버스(도 1 또는 2의 버스들 중 하나와 같은)를 통해, VIR들로부터의 선택된 카운트 또는 선택된 출력 중 하나인 선택 출력(416)을 출력 및 전달하도록 구성될 수 있다. 선택 출력(416)은 ALU 또는 다수의 ALU들을 위한 OVR 또는 다수의 OVR들에 액세스하는 요청자에게 전달될 수 있다. 요청자는 벡터 프로세서의 벡터 로드-저장 유닛(예를 들어, 도 2에 도시된 벡터 로드-저장 유닛(210) 참조), 또는 다른 벡터 프로세서의 벡터 로드-저장 유닛일 수 있다. 요청자가 벡터 로드 저장 유닛인 경우 벡터 프로세서의 로드 및 저장 동작들의 유효 어드레스들을 생성하도록 구성할 수 있다. 벡터 로드-저장 유닛은 또한, VIR들의 각 어드레스 성분에 대해, 어드레스 성분을 OVR(들)의 해당 위치에 액세스하기 위한 유효 어드레스에 추가하도록 구성될 수 있다.

일부 실시예들에서, 다수의 VIR들을 갖는 벡터 프로세서는 카운트를 저장하도록 구성된 카운터를 포함할 수 있으며 카운트는 OVR에 액세스하기 위한 유효 어드레스에 추가 가능하거나 카운트는 VIR들에 저장된 각각의 복수의 어드레스 성분들에 대해 반복하기 위한 것이다. 이러한 예들에서, 프로세서는 또한, 입력들로서, 카운터로부터의 카운트를 수신하고 VIR들로부터의 각각의 출력들을 수신하도록 구성된 N:1 멀티플렉서를 포함할 수 있다. VIR들의 주어진 VIR로부터의 각각의 출력은 카운트에 대응하는 주어진 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있다. 멀티플렉서는 또한, 선택 입력으로서, 모드 값을 수신하도록 구성될 수 있다. 모드 값은 카운트 선택을 위한 값이거나 VIR들로부터의 각각의 출력들 중 하나를 선택하기 위한 값일 수 있다. 멀티플렉서는 수신된 모드 값에 따라 VIR들의 카운트 또는 각각의 출력들 중 하나를 선택하도록 구성할 수도 있다. 멀티플렉서는 또한 ALU를 위한 OVR에 액세스하는 요청자(예를 들어, 벡터 프로세서의 벡터 로드 저장 유닛과 같은)에게 VIR들로부터의 선택된 카운트 또는 각각의 출력들 중 선택된 하나를 전달하도록 구성될 수 있다.

도 5는 본 개시의 일부 실시예들에 따른, 벡터 인덱스 레지스터(502)를 포함하는 예시적인 시스템(500)을 예시한다.

시스템(500)은 벡터 프로세서(102)(예를 들어, 도 1 또는 2 참조) 또는 다수의 벡터 프로세서들의 일부일 수 있다. 시스템(500)은 벡터 인덱스 레지스터(502)(VIR(502)), 카운터 레지스터(504), 3:1 멀티플렉서(506), 및 멀티플렉서에 연결된 선택 레지스터(508)를 포함한다. 시스템(500)은 또한 멀티플레서(506)에 연결된 벡터 제1 레지스터(503)을 포함한다. VIR(502)은 도 2에 도시된 벡터 레지스터들(502) 중 하나일 수 있다. 카운터 레지스터(504), 선택 레지스터(508), 및 벡터 제1 레지스터(503)(VFR(503))는 스칼라 레지스터들(204)의 레지스터들일 수 있다. 3:1 멀티플렉서(506)는 도 2에 도시된 버스(206) 또는 도 1에 도시된 버스(104)의 일부일 수 있다.

시스템(500)은 복수의 산술 로직 유닛들(ALU들) 중 산술 로직 유닛(ALU)을 포함하는 벡터 프로세서의 일부일 수 있다. 벡터 프로세서는 또한 복수의 피연산자 벡터 레지스터들의 피연산자 벡터 레지스터(OVR)를 포함할 수 있다. OVR은 ALU의 벡터 연산을 위한 입력으로 사용될 피연산자 벡터의 요소들을 저장하도록 구성될 수 있다. VIR(502)은 OVR의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하도록 구성될 수 있다. 각 어드레스 성분은 OVR의 해당 위치에 액세스하기 위한 유효 어드레스에 추가할 수 있다. OVR의 각 위치는 ALU에 의해 연산될 피연산자 벡터의 요소를 포함할 수 있다.

VFR(503)은 단일 어드레스 성분(511)을 저장하도록 구성될 수 있다. 단일 어드레스 성분(511)은 단일 어드레스 성분(511)을 기반으로 OVR의 초기 위치에서 OVR의 초기 액세스를 지시하는 어드레스 성분으로서, 액세스된 초기 위치는 OVR의 제1 위치가 아니다. 예를 들어, VFR(503)이 스칼라 "3"을 저장하면, OVR의 벡터 연산 동안 OVR의 제4 위치가 처음에 액세스된다. 이는 OVR의 제1 위치(예를 들어, OVR(0))에서 OVR에 대한 액세스를 시작하는 대신이다.

도시된 바와 같이, 카운터 레지스터(504)는 시스템(500)의 일부이다. 카운터 레지스터(504)는 또한 시스템(500)을 갖는 벡터 프로세서의 일부일 수 있다. 카운터 레지스터(504)는 카운트(510)를 저장하도록 구성될 수 있다. 카운트(510)는 OVR에 액세스하기 위한 유효 어드레스에 추가될 수 있거나, 카운트는 VIR(502)에 저장된 복수의 어드레스 성분들에 대해 반복하도록 벡터 프로세서에 의해 사용될 수 있다. 또한, 카운트(510)는 VFR(503)의 단일 어드레스 성분(511)를 증가시키기 위해 벡터 프로세서에 의해 사용될 수 있거나, 도시된 바와 같이, 이는 단일 어드레스 성분 (511)에 추가될 수 있고 카운트(510)와 단일 어드레스 성분(511)의 합은 벡터 제1 어드레스 성분(513)이다.

도시된 바와 같이, 3:1 멀티플레서(506)는 시스템(500)의 일부이다. 3:1 멀티플렉서(506)는 또한 시스템(500)을 갖는 벡터 프로세서의 일부일 수 있다. 3:1 멀티플렉서(506)는 카운터 레지스터(504)로부터의 카운트(510) 및 VIR(502)로부터의 출력(512) 뿐만 아니라 VFR(503)와 카운터(504)의 출력의 합산의 벡터 제1 어드레스 성분(513)을, 입력들로서, 수신하도록 구성될 수 있다. VIR(502)로부터의 출력(512)은 카운트(510)에 대응하는 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있다. 3:1 멀티플렉서(506)는 또한, 선택 입력으로서, 모드 값(514)을 수신하도록 구성될 수 있다. 모드 값(514)은 카운트(510)의 선택을 위한 값 또는 VIR(502)로부터의 출력(512)의 선택을 위한 값 또는 VFR(503) 또는 카운터(504)의 출력의 합산의 벡터 제1 어드레스 (513)의 선택을 위한 값일 수 있거나 이를 포함할 수 있다. 3:1 멀티플렉서(506)는 또한 수신된 모드 값(514)에 따라 VIR(502)로부터의 카운트(510) 또는 출력(512) 또는 벡터 제1 어드레스 성분(513)을 선택하도록 구성될 수 있다. 3:1 멀티플렉서(506)는 또한 버스(도 1 또는 2의 버스들 중 하나와 같은)를 통해, VIR로부터의 선택된 카운트 또는 선택된 출력 중 하나인 선택 출력(516) 또는 벡터 제1 어드레스 성분(513)을 출력 및 전달하도록 구성될 수 있다. 선택 출력(516)은 ALU를 위한 OVR에 액세스하는 요청자에게 전달될 수 있다. 요청자는 벡터 프로세서의 벡터 로드-저장 유닛(예를 들어, 도 2에 도시된 벡터 로드-저장 유닛(210) 참조), 또는 다른 벡터 프로세서의 벡터 로드-저장 유닛일 수 있다. 요청자가 벡터 로드 저장 유닛인 경우 벡터 프로세서의 로드 및 저장 동작들의 유효 어드레스들을 생성하도록 구성할 수 있다. 벡터 로드-저장 유닛은 또한, VIR의 각 어드레스 성분에 대해, VIR의 어드레스 성분을 OVR의 해당 위치에 액세스하기 위한 유효 어드레스에 추가하도록 구성될 수 있다.

일부 실시예들에서, 적어도 하나의 VIR을 갖는 벡터 프로세서는 또한 적어도 하나의 VFR 뿐만 아니라 VIR 및 VFR에 연결된 적어도 하나의 각각의 카운터를 포함할 수 있다. 카운터는 카운트를 저장하도록 구성될 수 있다. 카운트는 OVR에 액세스하기 위한 유효 어드레스에 추가될 수 있다. 카운트는 벡터 제1 어드레스 성분을 증가시키기 위한 것일 수 있거나, 카운트는 VIR에 저장된 복수의 어드레스 성분들에 대해 반복하기 위한 것일 수 있다. 벡터 프로세서는 또한 카운터로부터의 카운트, VFR로부터의 출력 및 VIR로부터의 출력을, 입력들로서, 수신하도록 구성된 3:1 멀티플렉서를 포함할 수 있다. VIR로부터의 출력은 카운트에 대응하는 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있으며, 벡터 제1 어드레스 성분은 카운트에도 대응할 수 있다. 멀티플렉서는, 선택 입력으로서, 모드 값을 수신하도록 구성될 수 있다. 모드 값은 카운트 선택을 위한 값, VFR로부터의 출력 선택을 위한 값 또는 VIR로부터의 출력 선택을 위한 값일 수 있다. 멀티플렉서는 수신된 모드 값에 따라 카운트, VFR로부터의 출력 또는 VIR로부터의 출력을 선택하고, 선택된 카운트, VFR로부터의 선택된 출력 또는 VIR로부터의 선택된 출력을 ALU를 위한 OVR에 액세스하는 요청자(예를 들어, 벡터 프로세서의 벡터 로드-저장 유닛과 같은)에 전달하도록 구성될 수 있다.

도 3 내지 5에 도시되지 않았지만, 시스템들은 VIR들의 각 VIR에 대한 각각의 벡터 길이 레지스터들을 포함할 수 있다. 각 각자의 벡터 길이 레지스터는 대응하는 VIR에 저장된 벡터의 길이를 저장하도록 구성될 수 있다. 예를 들어, 시스템(300)은 VIR에 저장된 벡터의 길이를 저장하도록 구성된 벡터 길이 레지스터(VLR)를 포함할 수 있다. VLR들은 벡터 연산 시 어드레스 생성을 위한 VIR들의 사용을 활용하는 일부 연산에서 유용할 수 있다.

일부 실시예들에서, 카운터의 출력과 대안적인 어드레스 후보의 출력의 합산 결과는 VIR 및/또는 카운터의 출력과 다중화될 수 있다(예를 들어, 카운터(504)의 출력과 VFR(503)에 저장된 단일 어드레스 성분(511)의 합산인, 도 5의 벡터 제1 어드레스 성분(513) 참조). 대안으로, 대안적인 어드레스 후보(예를 들어, VFR(503)에 저장된 어드레스 성분)는 카운터의 초기 값을 설정하는 데 사용될 수 있다. 대안적인 실시예에서, 대안적인 어드레스 후보에 의해 설정된 카운터는 VIR을 구동하는 카운터와 별개의 카운터이다.

일부 실시예들에서, 시스템들(300, 400 또는 500) 중 하나를 갖는 벡터 프로세서는 로드의 유효 어드레스를 생성하고 벡터 프로세서의 연산을 저장하도록 구성된 벡터 로드-저장 유닛을 더 포함할 수 있다. 벡터 로드-저장 유닛은 또한, VIR의 각 어드레스 성분에 대해, VIR의 어드레스 성분을 OVR의 해당 위치에 액세스하기 위한 유효 어드레스에 추가하도록 구성될 수 있다. VLR의 유효 어드레스와 값들은 일부 벡터 연산에 의해 연산 성능을 향상시키는 데 사용할 수 있다.

일부 실시예들에서, 시스템들(300, 400 또는 500) 중 하나에 연결된 벡터 로드-저장 유닛은 OVR에 저장된 피연산자 벡터를 로드할 뿐만 아니라 스칼라 레지스터에 저장된 스칼라를 로드하도록 구성된다. 이러한 벡터 로드-저장 유닛은 또한 로드된 피연산자 벡터의 요소들을 로드된 스칼라와 비교할 뿐만 아니라, VIR에, 비교에 따라 로드된 피연산자 벡터의 요소들의 위치들을 저장하도록 구성될 수 있다. 예를 들어, 벡터 로드-저장 유닛은 또한 스칼라와 일치하는 요소들의 위치를 저장하거나, 스칼라보다 큰 요소들의 위치를 저장하거나, 스칼라보다 크거나 같은 요소들의 위치를 저장하도록 구성될 수 있다. 또한, 예를 들어, 벡터 로드-저장 유닛은 짝수인 요소들의 위치들을 저장하고, 홀수인 요소들을 저장하지 않도록 구성될 수 있거나, 그 반대도 마찬가지다.

시스템들(300, 400, 또는 500) 중 하나에 연결된 벡터 로드-저장 유닛은 또한, VIR로부터, 로드된 피연산자 벡터의 요소들의 저장된 위치들을 로드하도록 구성될 수 있다. 그리고, 벡터 로드-저장 유닛은 VIR에 저장된 로드된 위치들에 따라 로드된 피연산자 벡터의 요소들에 대한 벡터 연산을 반복하도록 구성될 수 있다.

일부 실시예들에서, 벡터 연산은 로드된 피연산자 벡터의 요소들을 VIR에 저장된 로드된 위치들에 대응하는 출력 OVR에 저장하도록 구성된 압축 연산이다.

일부 실시예들에서, 벡터 로드-저장 유닛은 출력 OVR로부터 저장된 요소들을 로드한 다음, VIR에 저장된 로드된 위치들에 따라 출력 OVR로부터 저장된 요소들에 대한 제2 벡터 연산을 반복하도록 구성될 수 있다. 제2 벡터 연산은 출력 OVR로부터의 요소들을 VIR에 저장된 로드된 위치들에 따라 제2 출력 OVR의 위치들에 있는 제2 출력 OVR에 저장하도록 구성된 확장 연산일 수 있다. 확장 연산은 또한 스칼라를 제2 출력 OVR의 다른 위치들에 있는 제2 출력 OVR에 저장하도록 더 구성될 수 있다.

일부 실시예들에서, 벡터 로드-저장 유닛은 제2 VIR에 저장된 로드된 위치들에 따라 제2 로드된 피연산자 벡터의 요소들에 대한 제2 압축 연산을 반복하도록 구성될 수 있다. 이러한 실시예들에서, 벡터 로드-저장 유닛은 제2 로드된 피연산자 벡터의 요소들을 제2 VIR에 저장된 로드된 위치들에 대응하는 제2 출력 OVR에 저장하도록 구성될 수 있다. 그리고, 벡터 로드-저장 유닛은 제1 출력 OVR 및 제2 출력 OVR로부터의 요소들을 사용하여 하나 이상의 벡터 연산들을 수행하도록 구성될 수 있다.

일부 실시예들에서, 벡터 로드-저장 유닛은 제1 출력 OVR 및/또는 제2 출력 OVR로부터의 요소들 및 순차적으로 액세스되고 VIR의 인덱싱을 통해 생성되지 않은 제3 OVR에 저장된 제3 피연산자 벡터의 요소들을 사용하여 하나 이상의 벡터 연산들을 수행하도록 구성될 수 있다. 연산(들)의 결과들은 제4 OVR에 순차적으로 저장될 수 있다.

언급된 바와 같이, 시스템들(300, 400 및 500)은 하나 이상의 벡터 프로세서들의 일부일 수 있다. 시스템들(300, 400 및 500)은 또한 하나 이상의 벡터 프로세서들의 더 큰 시스템의 서브시스템들일 수 있다.

예를 들어, 시스템들(300, 400 및 500)은 다른 시스템에 포함될 수 있거나 하나 이상의 벡터 프로세서들 중 다른 시스템에 연결될 수 있다. 이러한 시스템은 벡터 프로세서의 일부가 아닐 수도 있다.

복수의 ALU들의 ALU를 포함할 수 있는 시스템이 또한 본원에 개시된다. 시스템은 또한 복수의 피연산자 벡터 레지스터들(OVR들) 중 OVR을 포함할 수 있다. OVR은 ALU의 벡터 연산을 위한 입력으로 사용될 피연산자 벡터의 요소들을 저장하도록 구성될 수 있다. 시스템은 또한 복수의 벡터 인덱스 레지스터들(VIR들) 중 VIR을 포함할 수 있다. VIR은 OVR의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하도록 구성될 수 있다. 각 어드레스 성분은 OVR의 해당 위치에 액세스하기 위한 유효 어드레스에 추가할 수 있다. 그리고, OVR의 각 위치는 ALU에 의해 연산될 피연산자 벡터의 요소를 포함할 수 있다.

시스템은 또한 카운터(또는 카운터 레지스터)를 포함할 수 있다. 카운터는 카운트를 저장하도록 구성될 수 있다. 카운트는 적어도 OVR에 액세스하거나 VIR에 저장된 복수의 어드레스 성분들에 대해 반복하기 위한 유효 어드레스에 추가할 수 있다.

시스템은 또한 N:1 멀티플렉서를 포함할 수 있다. 다시 말해, 시스템은 다수의 입력들과 하나의 출력이 있는 멀티플렉서를 포함할 수 있다. N:1 멀티플렉서는, 입력들로서, 적어도 카운터로부터의 카운트 및 VIR로부터의 출력을 수신하도록 구성될 수 있다. VIR로부터의 출력은 카운트에 대응하는 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있다. N:1 멀티플렉서는 또한, 선택 입력으로서, 모드 값을 수신하도록 구성될 수 있으며, 모드 값은 적어도 카운트 선택을 위한 값 또는 VIR로부터의 출력 선택을 위한 값이다. N:1 멀티플렉서는 또한 수신된 모드 값에 따라 적어도 VIR로부터 카운트 또는 출력을 선택하도록 구성될 수 있다. N:1 멀티플렉서는 또한 ALU용 OVR에 액세스하는 벡터 로드-저장 유닛에 선택을 출력하고 전달하도록 구성할 수 있다.

일부 실시예들에서, 카운트는 OVR에 액세스하기 위한 스칼라 인덱스 레지스터의 어드레스 성분을 증가시키기 위한 것일 수도 있다. 이러한 예들에서, N:1 멀티플렉서는, 입력들로서, 적어도 카운터로부터의 카운트, VIR로부터의 출력 및 스칼라 인덱스 레지스터로부터의 출력을 수신하도록 더 구성될 수 있다. N:1 멀티플렉서는 또한, 선택 입력으로서, 모드 값을 수신하도록 더 구성될 수 있으며, 모드 값은 적어도 카운트 선택을 위한 값, VIR로부터의 출력 선택을 위한 값, 또는 스칼라 인덱스 레지스터로부터의 출력 선택을 위한 값이다. N:1 멀티플렉서는 또한 수신된 모드 값에 따라 적어도 카운트, VIR로부터 출력, 또는 스칼라 인덱스 레지스터로부터의 출력을 선택하도록 더 구성될 수 있다.

일부 실시예들에서, 스칼라 인덱스 레지스터는 벡터 제1 레지스터(VFR)일 수 있다. VFR은 벡터 제1 어드레스 성분을 저장하도록 구성될 수 있다. 벡터 제1 어드레스 성분은 벡터 제1 어드레스 성분을 기반으로 OVR의 초기 위치에서 OVR의 초기 액세스를 지시하는 어드레스 성분일 수 있으며, 액세스된 초기 위치는 OVR의 제1 위치가 아니다. VFR은 VFR에 저장된 값을 기반으로 OVR의 모든 위치에서 초기에 OVR에 액세스하는 데 사용될 수 있다.

일부 실시예들에서, 카운트는 또한 VIR들의 제2 VIR에 저장된 복수의 어드레스 성분들에 대해 반복하기 위한 것일 수 있다. 이러한 예들에서, N:1 멀티플렉서는, 입력들로서, 적어도 카운터로부터의 카운트, VIR로부터의 출력 및 제2 VIR로부터의 출력을 수신하도록 구성될 수 있다. 또한, N:1 멀티플렉서는, 선택 입력으로서, 모드 값을 수신하도록 구성될 수 있으며, 모드 값은 적어도 카운트 선택을 위한 값, VIR로부터의 출력 선택을 위한 값, 또는 제2 VIR로부터의 출력 선택을 위한 값이다. 그리고, N:1 멀티플렉서는 수신된 모드 값에 따라 적어도 카운트, VIR로부터 출력, 또는 제2 VIR로부터의 출력을 선택하도록 더 구성될 수 있다.

도 6 내지 10은 본 개시의 일부 실시에들에 따른, 예시적인 동작들을 예시한다. 일부 실시예들에서, 벡터 로드-저장 유닛(210)과 같은 벡터 로드-저장 유닛은, 단독으로 또는 벡터 프로세서의 다른 부분들과 조합하여, 도 6 내지 10에 예시된 동작들의 다수 또는 전부를 수행하거나 용이하게 할 수 있다. 일부 실시예들에서, 본원에 설명된 값들에 대한 저장, 로딩, 결정, 증분 및 변경은 벡터 로드-저장 유닛에 저장된 인스트럭션들에 따라 벡터 프로세서의 벡터 로드-저장 유닛에 의해 수행될 수 있다. 일부 다른 실시예들에서, 벡터 프로세서의 다른 부분들은 도 6 내지 10에 예시된 동작들뿐만 아니라 본원에 설명된 다른 동작들을 행하거나 용이하게 할 수 있다.

일반적으로, 본원에 설명된 시스템들은 벡터 압축 및 확장 기능들을 포함하는 많은 기능들을 구현할 수 있다. 예를 들어, VMX와 같은 VIR에 저장된 어드레스 성분들의 목록에서, 주어진 벡터 A의 요소들은 벡터 A로부터 요소들 A(VMX(i))를 판독하여 새 벡터로 압축되고 출력 벡터 B(i)에 저장될 수 있다. 따라서, 벡터 A는 i=0, 1, ..., n에 대해, B(i) = A(VMX(i))에 의해 B로 압축된다. 마찬가지로, 확장은 반대로 수행될 수 있다(예를 들어, B(VMX(i)) = A(i)). 또한, 하나 이상의 VIR들은 벡터 프로세서가 압축 및/또는 확장의 유무에 관계없이, 희소 연산들을 직접 수행할 수 있도록 한다. 예를 들어, VIR은 B(i) = 함수 (A(VMX(i)), C(VMX(i))에서 인덱싱을 구현할 수 있으며, 이는 압축을 사용하는 희소 연산일 수 있다. 또한, VIR은 B(VMX(i)) = 함수 (A(VMX(i)), C(VMX(i))에서 인덱싱을 구현할 수 있으며, 이는 압축이 없는 희소 연산일 수 있다. 또한, VIR은 B(VMX(i)) = 함수 (A(i), C(i))에서 인덱싱을 구현할 수 있으며, 이는 확장을 사용하여 압축된 벡터들에 대한 연산일 수 있다.

도 6은 본 개시의 일부 실시예들에 따른, 하나 이상의 벡터 연산을 위해 피연산자 벡터의 요소들에 액세스하는 방법(600)의 예시적인 동작들을 예시한다.

도 6에서, 방법(600)은 단계(602)에서, 벡터 프로세서의 복수의 피연산자 벡터 레지스터들(OVR들)의 피연산자 벡터 레지스터(OVR)에, 벡터 프로세서의 복수의 산술 로직 유닛들(ALU들) 중 산술 로직 유닛(ALU)의 벡터 연산을 위한 입력으로 사용될 피연산자 벡터의 요소들을 저장하는 것으로 시작된다. OVR에 피연산자 벡터의 요소들을 저장하는 것은 ALU의 벡터 연산을 위한 입력으로 사용되기 전에 언제든지 발생할 수 있다. 예를 들어, 단계(602)는 단계(618) 이후 발생할 수 있다.

단계(604)에서, 방법(600)은 벡터 프로세서의 복수의 벡터 인덱스 레지스터들(VIR들) 중 벡터 인덱스 레지스터(VIR)에, OVR의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하는 것을 계속한다.

단계(606)에서, 방법(600)은 출력을 제공하기 위해 카운트(카운터 레지스터에 저장된 카운트와 같은)에 따라 VIR에 저장된 복수의 어드레스 성분들에 대해 반복하는 것을 계속한다. 이후 벡터 로드-저장 유닛은 VIR로부터의 출력을 OVR에 액세스하기 위한 유효 어드레스에 추가한다. VIR로부터의 출력은 카운트에 대응하는 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있다. 카운트에 따라 VIR에 저장된 복수의 어드레스 성분들에 대한 단일 반복은 벡터 로드-저장 유닛이 VIR로부터의 출력을 OVR에 액세스하기 위한 유효 어드레스에 추가하기 위해 VIR로부터의 출력을 요청할 때마다 발생할 수 있다. 이는 VIR이 OVR에 대한 연산에 대해 반복될 때까지 반복적으로 발생할 수 있다.

단계(608)에서, 방법(600)은 벡터 프로세서의 N:1 멀티플렉서에 의해, 적어도 카운터로부터의 카운트 및 VIR로부터의 출력을 수신하는 것을 계속하며, VIR로부터의 출력은 카운트에 대응하는 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있다.

단계(610)에서, 방법(600)은, N:1 멀티플렉서에 의해, 모드 값을 포함하는 선택 입력을 수신하는 것을 계속하며, 모드 값은 적어도 카운트 선택을 위한 값 또는 VIR로부터의 출력 선택을 위한 값이다.

단계(612)에서, 방법(600)은 N:1 멀티플렉서에 의해, 수신된 모드 값에 따라 카운트 또는 VIR로부터의 출력 중 적어도 하나를 선택하는 것을 계속한다.

단계(614)에서, 선택을 ALU를 위한 OVR에 액세스하는 벡터 프로세서의 벡터 로드-저장 유닛에 전달하는 단계를 포함한다.

단계(616)에서, 방법(600)은 카운터에 저장된 카운트를 OVR에 액세스하기 위한 유효 어드레스에 추가하는 것을 계속한다.

단계(618)에서, 방법(600)은 VIR의 어드레스 성분을 OVR의 대응하는 위치에 액세스하기 위한 유효 어드레스에 추가하는 것을 계속한다. OVR의 각 위치는 ALU에 의해 연산될 피연산자 벡터의 요소를 포함할 수 있다.

단계(620)에서, 방법(600)은 단계(616 또는 618)에서 생성된 유효 어드레스에 따라, 벡터 로드-저장 유닛에 의해, ALU를 위한 OVR에 액세스하는 것을 계속한다.

도 7은 본 개시의 일부 실시예들에 따른, 피연산자 벡터의 요소들을 압축하는 방법(700)의 예시적인 동작들을 예시한다. 도 7에서, 방법(700)은, 단계(702)에서, 벡터 로드-저장 유닛에 의해, 입력 OVR에 저장된 입력 피연산자 벡터를 로딩하는 것으로 시작된다.

단계(704)에서, 방법(700)은 벡터 로드-저장 유닛에 의해, 카운터 레지스터에 저장된 카운트를 로드하는 것을 계속한다.

단계(706)에서, 방법(700)은 벡터 로드-저장 유닛에 의해, VIR로부터, 카운트에 따라 로드된 입력 피연산자 벡터의 요소의 저장된 위치를 로드하는 것을 계속한다.

단계(708)에서, 방법(700)은 VIR로부터 로드된 위치에 따라 로드된 입력 피연산자 벡터의 요소들에 대해 벡터 압축 연산을 실행하는 것을 계속한다. 단계(708)는 로드된 입력 피연산자 벡터의 요소를 VIR로부터의 로드된 위치에 대응하는 출력 OVR에 저장하는 것을 계속하는 방법(700)을 포함하는 단계(710)를 포함한다.

단계(712)에서, 방법(700)은 벡터 압축 연산이 VIR에 저장된 위치들 각각에 대한 입력 OVR에 걸쳐 반복될 수 있도록 VIR(즉, VL)의 벡터 길이를 나타내는 값과 카운트를 비교하는 것을 계속한다. 카운트가 VIR의 벡터 길이와 동일할 때, 방법(700)은 종료된다. 카운트가 VIR의 벡터 길이 미만인 경우, 방법(700)은 714에서 카운트를 증가시킨 다음 단계(704)(카운터 레지스터에 저장된 카운트를 로드하는 단계)로 돌아가고, 단계(706)(벡터 로드-저장 유닛에 의해, VIR로부터, 카운트에 따라 로드된 입력 피연산자 벡터의 요소의 저장된 위치를 로드하는 단계) 및 단계(708)(VIR로부터의 로드된 위치에 따라 로드된 입력 피연산자 벡터의 요소들에 대한 벡터 압축 연산을 실행하는 단계)가 이어진다. 이러한 방식으로, 벡터 압축 연산은 VIR에 저장된 위치들 각각에 대해 입력 OVR에 걸쳐 반복된다.

도 8은 본 개시의 일부 실시예들에 따른, 입력 OVR(804)에 저장된 입력 피연산자 벡터의 요소들을 압축하는데 사용되는 벡터 인덱스 레지스터(802)(VIR(802)))를 포함하는 예시적인 시스템(800)을 예시한다. 예시적인 시스템(800)은 적어도 방법(700)을 구현할 수 있는 시스템의 일 예이다.

도 8에서, VIR(802)은 입력 OVR(804)의 위치 목록(예를 들어, 입력 OVR의 제1 요소로서의 "2", 입력 OVR의 제2 요소로서의 "4")을 저장한다. 이 예시된 예에서, 벡터 프로세서는 벡터 압축 연산의 두 사이클 또는 반복 동안 실행되는 것으로 표시된다. 제1 반복에서, 카운터(806)는 제1 사이클에서 카운터에 저장된 값인 "0"의 카운트를 출력한다. 제1 사이클에서, VIR(802)은 "2"를 출력하는 것으로 표시된다. 멀티플렉서(808)는 정상 모드 연산에서 카운터(806)에 의해 지정된 어드레스 성분("0") 또는 VIR 연산 모드(또는 이 특정 예에서의 압축 연산 모드)에서 VIR(802)에 의해 지정된 어드레스 성분("2") 중에서 선택한다. VIR(또는 압축 모드)이 제1 사이클에서 멀티플렉서(808)에 의해 선택되면, VIR(802)로부터의 출력 "2"는 입력 OVR(804)에 액세스하는 데 사용되는 어드레스 성분이다. 결과적으로, 입력 OVR의 위치 "2"에서 요소 "C"의 출력을 위해 입력 OVR(804)이 액세스된다. 출력 OVR(810)은 카운터(806)에 저장된 카운트를 통해 직접 어드레싱된다. 　 카운터(806)의 카운트가 제1 사이클에서 "0"이기 때문에, 출력 ORV(810)는 "C"를 제1 요소로 저장한다. 다음 반복 또는 사이클에서, 출력 ORV(810)는 출력 OVR의 위치 "1"에 제2 요소로서 "E"를 저장한다. 2개의 사이클이 보여지는 이 예에서, {A, B, C, D, E}의 요소들을 갖는 입력 OVR(804)은 {C, E}의 요소들을 갖는 출력 OVR(810)로 압축된다.

또한, 도 8을 참조하여, 입력/출력 벡터들에 대한 어드레스 신호들이 반전되면, {C, E}는 {x, x, C, x, E}의 요소를 갖는 제2 출력 OVR로 확장될 수 있다. 여기서 x는 이전의 기존 값입니다. 압축 연산 또는 스칼라 레지스터로부터 선택된 스칼라 값 전의 기존 값들이다(예를 들어, 스칼라 레지스터로부터의 스칼라 값으로 압축된 벡터를 확장하는 예시적인 방법인 도 9 참조). 　　

또한, VFR로부터의 값이 카운터의 카운트에 추가되면, 입력 OVR에 대한 연산의 제1 반복이 입력 OVR의 제1 위치(예를 들어, 입력 OVR(804)의 제1 위치는 "0"으로 표시됨) 대신 입력 OVR의 다른 위치에서 발생하도록 합산이 사용될 수 있다. 예를 들어, 도 5 참조. 대안으로, VFR은 벡터 연산 시작 시 카운트 레지스터의 초기 값이 VFR에 저장된 값이 되도록 카운트 레지스터에 대한 입력을 제공하는 데 사용될 수 있다. 이러한 옵션들은 벡터 제1 처리를 허용한다.

도 9는 본 개시의 일부 실시예들에 따른, 압축된 피연산자 벡터의 요소들과 같은 피연산자 벡터의 요소들을 확장하는 방법(900)의 예시적인 동작들을 예시한다.

도 9에 도시된 바와 같이, 방법(900)은 방법(700)으로 시작될 수 있으며, 이는 출력 OVR에 저장된 압축된 피연산자 벡터의 출력으로 끝난다. 다음으로, 방법(900)은, 단계(902)에서, 벡터 로드-저장 유닛에 의해, 출력 OVR로부터 저장된 요소들을 로딩하는 것을 계속된다. 저장된 요소들은 압축된 벡터의 요소들이다.

단계(904)에서, 방법(900)은 VIR에 저장된 로드된 위치들에 따라 출력 OVR로부터 저장된 요소들에 대한 제2 벡터 연산을 반복하는 것을 계속한다. 제2 연산은 벡터 팽창 연산이다. 다시 말해, 벡터 확장 연산인 제2 벡터 연산은 출력 OVR에 저장된 압축된 벡터를 확장한다.

단계(906)에서, 방법(900)은, 팽창 연산에 따라, 출력 OVR로부터의 요소들을 VIR에 저장된 로드된 위치들에 따라 제2 출력 OVR의 위치들에 있는 제2 출력 OVR에 저장하는 것을 계속한다.

단계(908)에서, 방법(900)은 확장 연산에 따라, 스칼라를 제2 출력 OVR의 다른 위치들에 있는 제2 출력 OVR에 저장하는 것을 계속한다. 단계(908) 이후의 확장 연산의 최종 출력은 압축된 벡터의 요소들과 확장된 벡터의 다른 위치들에 있는 스칼라 값의 하나 이상의 인스턴스들을 갖는 확장된 벡터이다. 압축된 벡터로부터의 요소들을 확장된 벡터에 위치시키는 것은 VIR에 저장된 로드된 위치들 또는 어드레스 성분들에 대응된다.

도 10은 본 개시의 일부 실시예들에 따른, 다수의 압축된 벡터들에 대한 연산들과 관련된 방법(1000)의 예시적인 동작들을 예시한다.

도 10에 도시된 바와 같이, 방법(1000)은 방법(700)으로 시작될 수 있으며, 이는 출력 OVR에 저장된 압축된 피연산자 벡터의 출력으로 끝난다. 또한, 방법(700)과 유사한 연산들이 제2 피연산자 벡터에 대해 수행된다. 예를 들어, 단계(1002)에서, 방법(1000)은 제2 VIR에 저장된 로드된 위치들에 따라 제2 로드된 피연산자 벡터의 요소들에 대한 제2 압축 연산을 반복하는 것을 계속한다.

단계(1004)에서, 방법(1000)은 제2 로드된 피연산자 벡터의 요소들을 제2 VIR에 저장된 로드된 위치들에 대응하는 제2 출력 OVR에 저장하는 것을 계속한다.

단계(1006)에서, 방법(1000)은 제1 출력 OVR 및 제2 출력 OVR로부터의 요소들을 사용하여 하나 이상의 벡터 연산들을 수행하는 것을 계속한다. 하나 이상의 벡터 연산들은 제1 출력 OVR과 제2 출력 OVR로부터의 요소들인, 두 개의 압축된 벡터들로부터의 요소들을 사용한다.

본원에 언급된 바와 같이, 본원에 개시된 실시예들의 적어도 일부는 벡터들의 다수의 위치들에 액세스하기 위한 다수의 어드레스들을 각각 저장하는 벡터 프로세서들의 벡터 인덱스 레지스터들이다. 또한, 본원에 개시된 실시예들의 적어도 일부는 피연산자 벡터들의 다수의 위치들에 액세스하기 위한 다수의 어드레스들을 각각 저장하는 하나 이상의 비교 결과들(예컨대 수치 비교 결과들)의 TRUE 및/또는 FALSE 결과들을 위한 벡터 인덱스 레지스터들이다.

또한, 본원에 언급된 바와 같이, 벡터 연산 동안 스칼라 인덱스 레지스터에 저장된 값을 변경함으로써 벡터들의 다수의 위치들을 참조하기 위해 벡터 프로세서에서 스칼라 인덱스 레지스터를 사용하는 것으로 알려져 있다. 그러나, 하나 이상의 피연산자 벡터들의 다수의 위치들을 인덱싱하기 위해, TRUE 결과들에 대한 VIR 또는 FALSE 결과들에 대한 VIR과 같은, 벡터 인덱싱 레지스터(VIR)를 사용하여, 스칼라 인덱스 레지스터는 교체될 수 있으며, 적어도 값의 지속적인 변경 TRUE 및/또는 FALSE 결과를 사용하는 벡터 연산 동안 스칼라 인덱스 레지스터의 값들의 지속적인 변경이 방지될 수 있다.

본원에 언급된 바와 같이, 벡터를 인덱싱하기 위해 스칼라 레지스터 또는 단식부기 벡터를 사용하는 것과 관련된 많은 제한 사항들이 있다. 그리고, 이러한 제한 사항들 중 일부는 스칼라 인덱스 레지스터를 사용하는 벡터 프로세서의 성능을 억제할 수 있다. 벡터 비교 연산 또는 다른 유형의 연산에 사용되는 하나 이상의 피연산자 벡터들의 복수 위치들을 인덱싱하기 위해, TRUE 결과들에 대한 VIR 또는 FALSE 결과들에 대한 VIR과 같은 벡터 인덱싱 레지스터를 사용함으로써, 스칼라 인덱스 레지스터는 교체될 수 있으며, 적어도 벡터 연산 동안 스칼라 인덱스 레지스터의 지속적인 변경이 방지될 수 있다.

일부 실시예들에서, TRUE 및 FALSE 요소들의 벡터가 계산될 때(예를 들어, 벡터 마스크의 콘텐트, Vm), 시스템 또는 회로는 벡터를 보완하거나 대체하기 위해 인덱스 벡터를 생성할 수 있다. 인덱스 벡터는 TRUE 결과들 또는 FALSE 결과들 또는 이들의 조합에 대한 것일 수 있으며, 이러한 유형의 인덱스 벡터들은 각각의 벡터 인덱스 레지스터들인, VIR_TRUE, VIR_FALSE 및 VIR_COMBINED에 저장될 수 있다. VIR_COMBINED는 TRUE 섹션과 FALSE 섹션을 포함하는 단일 VIR이다.

VIR_TRUE, VIR_FALSE 및/또는 VIR_COMBINED는 벡터 마스크(Vm) 또는 해당 OVR의 요소들을 포함할 수 있다. Vm은 벡터에 대한 비교 결과(예컨대 벡터에 대한 수치 비교 결과)의 TRUE 및 FALSE 결과들을 저장하는 벡터이다. Vm은 조건부 연산과 압축 및 확장 연산에 사용될 수 있다. Vm에 대한 벡터 레지스터는 VIR_TRUE, VIR_FALSE 및/또는 VIR_COMBINED로 대체될 수 있다. 그리고, VIR_TRUE, VIR_FALSE 및/또는 VIR_COMBINED는 벡터 프로세서가 벡터 연산을 수행할 때 Vm을 대체 시 벡터 프로세서의 성능을 향상시킬 수 있다.

예를 들어, 카운터는 0으로 시작하여, Vm 계산에서 TRUE 요소들의 수를 추적하는 데 사용될 수 있다. 제i TRUE 요소가 Vm의 제j 요소의 결과로 식별되면, 인덱스 j는 벡터 VmxT의 제i 요소에 저장(및 VIR_TRUE에 저장)된다. 마찬가지로, 카운터는 FALSE 결과들을 추적하고 FALSE 결과들의 인덱스들을 벡터 VmxF에 저장(및 VIR_FALSE에 저장)하는 데 사용될 수 있다. VmxT와 VmxF의 벡터 길이의 합은 Vm의 벡터 길이와 같다. 벡터 프로세스는 제i 요소가 VmxT 및 VmxF를 생성하기 위해 값 I을 갖는 벡터로 Vi를 사용할 수 있으며, 여기서 VmxT = 압축 (Vi, Vm) 및 VmxF = 압축 (Vi, ! Vm)이다.

VIR_TRUE 또는 VIR_FALSE에 저장되거나 로드된 압축된 인덱스 또는 어드레스 벡터 VmxT 및/또는 VmxF는 조건부 연산들 및/또는 압축 및 확장 연산들(예컨대 본원에 설명된 압축 및 확장 연산들)에 사용될 수 있다. 압축된 인덱스 또는 어드레스 벡터들이 있는 벡터에 액세스할 수 있는 기능을 사용하여, Vm을 통해 반복하기 위한 레지스터와 같은 중간 벡터 레지스터에서 압축된 벡터를 생성하지 않고도 이러한 연산들이 벡터들에서 직접 실행될 수 있다.

본원에 언급된 바와 같이, VIR_TRUE 또는 VIR_FALSE와 같은 VIR의 용도는 많다. 예를 들어, VIR TRUE 또는 VIR FALSE는 벡터 압축 또는 확장 기능을 보다 효율적으로 구현하는 데 사용될 수 있다.

도 11은 본 개시의 일부 실시예들에 따른, 비교의 TRUE 및 FALSE 결과들(예를 들어, "1" 및 "0" 결과들)에 대해 벡터 인덱싱 레지스터들(VIR_TRUE 및 VIR_FALSE)에 저장하기 위한 인덱싱 벡터들을 구축하는 방법(1100)의 예시적인 동작들을 예시한다.

방법(1100)은 단계(1102)에서, 벡터 프로세서의 벡터 로드-저장 유닛에 의해, 피연산자 벡터 레지스터(OVR)에 저장된 피연산자 벡터를 로딩하는 것으로 시작된다.

단계(1104)에서, 방법(1100)은 벡터 로드-저장 유닛에 의해, 벡터 프로세서의 스칼라 레지스터에 저장된 스칼라를 로드하는 것을 계속한다.

단계(1106)에서, 방법(1100)은 벡터 프로세서에 의해, 카운터에 저장된 카운트에 따라 로드된 피연산자 벡터의 요소를 로드된 스칼라와 비교하는 것을 계속한다. 카운터는 또 다른 스칼라 레지스터 및 벡터 프로세서의 일부일 수 있다. 또한, 일부 실시예들에서, 방법(1100)은 벡터 프로세서에 의해, 카운터에 저장된 카운트에 따라 로드된 피연산자 벡터의 요소를 또 다른 피연산자 벡터와 비교하는 것을 계속할 수 있다. 일부 실시예들에서, 비교를 위해, 로드된 피연산자 벡터의 요소는 제1 카운터의 제1 카운트에 따라 벡터 프로세서에 의해 액세스되고, 다른 로드된 피연산자 벡터의 요소는 제2 카운터의 제2 카운트에 따라 벡터 프로세서에 의해 액세스된다. 비교는 수치 비교일 수 있다.

단계(1108)에서, 방법(1100)은 단계(1106)의 비교 결과가 TRUE인지 FALSE인지(예를 들어, "1"인지 또는 "0"인지)를 식별하는 것을 계속한다. 단계(1106)의 비교 결과가 TRUE이면, 방법(1100)은 단계(1110a)에서, 비교의 TRUE 결과들를 위한 벡터 인덱스 레지스터(VIR_TRUE)에, 카운트에 따라(예컨대 TRUE 카운터- 예를 들어, 도 12에 도시된 TRUE 카운터(1216a) 참조 - 에 저장된 TRUE 카운트를 통한 카운트에 따라) 로드된 피연산자 벡터의 요소의 위치를 저장하는 것을 계속한다. 단계(1106)의 비교 결과가 FALSE인 경우, 방법(1100)은 단계(1110b)에서, 비교의 FALSE 결과들를 위한 벡터 인덱스 레지스터(VIR_FALSE)에, 카운트에 따라(예컨대 FALSE 카운터 - 예를 들어, 도 12에 도시된 FALSE 카운터(1216b) 참조 - 에 저장된 FALSE 카운트를 통한 카운트에 따라) 로드된 피연산자 벡터의 요소들의 위치를 저장하는 것을 계속한다.

단계(1112)에서, 방법(1100)은 카운트가 OVR에 저장된 피연산자 벡터의 벡터 길이(VL)와 동일한지 여부를 식별하는 것을 계속한다. 일부 실시예들에서, 방법(1100)은 OVR의 VL이 VIR_TRUE의 VL 및 VIR_FALSE의 VL을 더한 결과와 동일한지 여부를 계속 식별할 수 있으며, 이는 카운트가 OVR에 저장된 피연산자 벡터의 VL과 동일한지 여부를 식별하는 또 다른 방법일 수 있다. 카운트가 OVR의 VL과 동일한지 여부를 식별하는 이러한 예시적인 대안 방법들은 OVR의 모든 요소들이 비교됨을 보여줄 수 있다. 카운트가 VL 미만이면, 방법은 단계(1114)에서, 카운트를 증가시키는 것을 계속한다. 카운트가 VL과 동일해질 때까지 카운트를 증가시킴으로써, 벡터 프로세서는 로드된 피연산자 벡터의 요소들의 위치들이 VIR_TRUE 또는 VIR_FALSE에 저장될 때까지 카운트에 따라 로드된 피연산자 벡터의 요소들의 위치들을 저장하는 것을 계속할 수 있다. 다시 말해, 방법(1100)은 로드된 피연산자 벡터의 요소들의 위치들이 VIR_TRUE 또는 VIR_FALSE에 저장될 때까지 카운트에 따라 로드된 피연산자 벡터의 요소들의 위치들을 저장하는 것을 계속한다.

단계(1112)에서, 카운트가 VL과 동일한 경우, 방법(1100)은 VIR_TRUE 및 VIR_FALSE에 저장하기 위한 인덱싱 벡터들의 구축을 완료했다. 카운트가 VL과 동일할 때 인덱싱 벡터들을 구축하는 동작이 완료되기 때문에 카운트는 VL보다 클 수 없다. 새로운 인덱싱 벡터들이 구축될 때, 카운트가 리셋되고 VL의 스칼라 값을 저장하는 VL 레지스터도 리셋될 수 있다. 벡터 프로세서는 초기에 OVR의 벡터 길이를 결정한 다음 방법(1100)을 수행하기 전에 VL 레지스터에 길이를 저장할 수 있다.

VIR_TRUE 및 VIR_FALSE에 저장된 인덱싱 벡터들의 구축이 완료되면, 방법(1100)은, 단계(1116에서), 벡터 로드-저장 유닛에 의해, VIR_TRUE 또는 VIR_FALSE 또는 이들의 조합 중 적어도 하나로부터, 로드된 피연산자 벡터의 요소들의 저장된 위치들을 로드하는 것을 계속한다. 그리고, 단계(1118)에서, 방법(1100)은 로드된 위치들에 따라 로드된 피연산자 벡터의 요소들에 대해 하나 이상의 벡터 연산들을 반복하는 것을 계속한다.

도 12는 본 개시의 일부 실시예들에 따른, VIR_TRUE(1202a) 및 VIR_FALSE(1202b)에 저장하기 위한 인덱싱 벡터들을 구축하기 위한 예시적인 시스템(1200)을 예시한다. 시스템(1200)은 방법(1100)의 많은 동작들 및 양태들을 구현할 수 있으며, 시스템(1200)은 하나 이상의 벡터 프로세서들의 일부일 수 있다.

시스템(1200)은 방법(1100)의 설명에서 설명된 VIR_TRUE 및 VIR_FALSE와 같은, VIR_TRUE(1202a) 및 VIR_FALSE(1202b)를 포함한다. 시스템은 또한 방법(1100)의 설명에서 설명된 OVR과 같은 OVR(1204)을 포함한다.

시스템(1200)은 또한 방법(1100)의 설명에서 설명된 스칼라 레지스터와 같은, 스칼라 레지스터(SR)(1206)를 포함한다. 일부 실시예들에서, 스칼라 레지스터는 OVR(1204)과 같은 방식으로 어드레스된 또 다른 OVR로 대체될 수 있다.

시스템은 또한 카운터 레지스터에 의해 부분적으로 구현될 수 있고 방법(1100)의 설명에서 설명된 카운터일 수 있는 카운터(1208)를 포함한다.

시스템(1200)은 또한 SR(1206)에 저장된 값과 OVR(1204)의 요소에 저장된 값의 비교를 수행할 수 있는 비교기(1210)를 포함한다. 비교기(1210)는 OVR(i) < SR, OVR(i) = SR, OVR(i) > SR, OVR(i) ≤ SR, 또는 OVR(i) ≥ SR과 같은 비교들을 수행할 수 있다. 비교기(1210)는 한 번에 또는 주기마다 두 개의 숫자들을 비교한다.　 각 반복 i(어드레스 또는 어드레스 성분 i도 나타냄)에서, 카운터(1208)는 비교기(1210)에 의한 SR(1206)로부터의 스칼라 값과의 비교를 위해 OVR(1204)에 액세스하기 위한 어드레스 i를 제공한다.　 요약하면, 반복 또는 어드레스 i에서의 OVR(1204)의 출력은 스칼라 레지스터(1206)의 값과 비교된다.　 비교기(1210)는 TRUE 또는 FALSE(예를 들어, "1" 또는 "0")인 단일 출력을 생성한다.　　

비교기(1210)는 방법(1100)의 단계(1106)에서 비교를 수행하도록 구성될 수 있다. 다시 말해, 비교기(1210)는 카운터 레지스터에 저장된 카운트에 따라 로드된 피연산자 벡터의 요소를 로드된 스칼라와 비교하도록 구성될 수 있다. 비교기(1210)는 또한 단계(1108)에서 TRUE 또는 FALSE 결과의 식별을 수행하도록 구성될 수 있다. 다시 말해, 비교기(1210)는 단계(1106)의 비교 결과가 TRUE인지 FALSE인지를 식별하도록 구성될 수 있다. 비교기(1210)는 TRUE 결과에 대해 "1" 또는 FALSE 결과에 대해 "0"과 같은, TRUE 또는 FALSE 결과를 출력하도록 구성될 수 있다. 비교기(1210)의 출력은 VIR_TRUE(1202a) 및 VIR_FALSE(1202b) 각각에 대한 각각의 기입 인에이블에 입력된다.

비교기(1210)로부터의 출력은 VIR_TRUE(1202a)에 대한 기입 인에이블(1212a)로 직접 전달될 수 있다. 비교기(1210)로부터의 출력은 인버터(1214)를 통해, VIR_FALSE(1202b)에 대한 기입 인에이블(1212b)에 간접적으로 전달될 수 있다. 인버터(1214)는 VIR_FALSE(1202b)에 대한 기입 인에이블(1212b)에 도달하기 전에 비교기(1210)의 출력을 반전시키도록 구성된다. 예를 들어, 비교기(1210)의 출력이 TRUE(예를 들어, "1")인 경우, 인버터(1214)에 입력될 때 인버터는 값을 FALSE(예를 들어, "0")로 반전하고 FALSE를 출력한다.

시스템(1200)은 또한 VIR_TRUE(1202a)에 대한 별도의 TRUE 카운터(1216a) 및 VIR_FALSE(1202b)에 대한 별도의 FALSE 카운터(1216b)를 포함한다. 비교기(1210)의 출력은 2개의 카운터들인, 카운터들(1216a 및 1216b)을 구동한다. 카운터들(1216a 및 1216b)은 OVR(1204)를 위한 어드레스를 제공하는 카운터(1208)와 별개이다. TRUE 카운터(1216a)의 출력은 VIR_TRUE(1202a)에 액세스하기 위한 어드레스로 사용된다. FALSE 카운터(1216b)의 출력은 VIR_FALSE(1202b)에 액세스하기 위한 어드레스로 사용된다.

예를 들어, 비교기(1210)의 출력이 TRUE일 때, 출력은 OVR(1204)로부터의 현재 위치를 VIR_TRUE(1202a)에 기입하기 위해 기입 인에이블(1212a)을 트리거한다. 비교기(1210)의 출력이 FALSE일 때, 출력은 OVR(1204)로부터의 현재 위치를 VIR_FALSE(1202b)에 기입하기 위해 기입 인에이블(1212b)을 트리거한다. 이 기능은 인버터(1214) 및 2개의 기입 인에이블들(1212a 및 1212b)을 포함하는 회로를 통해 제공된다.

카운터(1208)의 출력은 TRUE 카운터(1216a)에 의해 지정된 어드레스에서 VIR_TRUE(1202a)에 기입될 어드레스 또는 어드레스 성분으로 사용된다. 이는 비교기(1210)의 출력이 TRUE인 경우에 발생한다. 카운터 TRUE(1216a)에 저장된 값은 비교기(1210)로부터 TRUE 출력을 트리거할 때마다 1씩 증가된다. 카운터(1208)의 출력은 FALSE 카운터(1216b)에 의해 지정된 어드레스에서 VIR_FALSE(1202b)에 기입될 어드레스 또는 어드레스 성분으로 사용된다. 이는 비교기(1210)의 출력이 FALSE일 때 발생한다. FALSE 카운터(1216b)에 저장된 값은 비교기(1210)로부터 FALSE 출력을 트리거할 때마다 1씩 증가된다. OVR 성분들의 어드레스들을 저장할 위치를 선택하는 이러한 전체 기능은 비교기(1210), 기입 인에이블들(1212a 및 1212b), 인버터(1214), 및 TRUE 및 FALSE 카운터들(1216a 및 1216b)을 포함하는 회로에 의해 제공된다.

VIR_TRUE(1202a) 및 VIR_FALSE(1202b)는 각각 시스템(1200)의 출력 레지스터이다. VIR_TRUE(1202a)는 세 개의 입력들을 갖는다. 제1 입력은 기입 인에이블(1212a)로부터 나온 것이다. 예를 들어, 이 제1 입력으로부터의 TRUE의 입력은 VIR_TRUE(1202a)에 기입하는 것을 허용하며 FALSE는 레지스터에 기입하는 것을 허용하지 않는다. 제2 입력은 VIR_TRUE(1202a)에 액세스하기 위한 어드레스를 위한 것인, TRUE 카운터(1216a)로부터 나온 것이다. 제3 입력은 카운터(1208)로부터 나온 것이고, 이 입력은 TRUE 카운터(1216a)(또는 제2 입력)에 의해 제공된 레지스터의 어드레스에 있는 VIR_TRUE(1202a)에 기입된 데이터를 포함한다.

시스템(1200)은 벡터 로드-저장 유닛을 포함하는 벡터 프로세서의 일부일 수 있다. 벡터 로드-저장 유닛은 시스템(1200)의 레지스터들에 저장된 데이터를 메인 메모리로 로드할 수 있을 뿐만 아니라 데이터를 메인 메모리에서 시스템의 레지스터들로 저장할 수 있으며, 그 반대(메모리에 저장된 데이터를 시스템(1200)의 레지스터들로 로드할 뿐만 아니라 데이터를 시스템의 레지스터들에서 메모리로 저장함)로도 가능하다.

시스템(1200)은 또한 벡터 길이에 대한 스칼라 레지스터인, 벡터 길이 레지스터(1224)(VLR(1224))를 포함하는 것으로 도시되어 있다. VLR(1224)은 OVR(1204)의 벡터 길이(VL)를 저장하도록 구성된다. 벡터 프로세서는 카운터(1208)로부터의 카운트가 OVR(1204)에 저장된 피연산자 벡터의 VL과 동일한지 여부를 식별하기 위해 VLR(1224)로부터 메모리로 VL을 로드할 수 있다. 이는 예를 들어 도 11의 방법(1100)의 단계(1112)를 구현하는 한 방법이다. 카운트가 VL 미만인 경우, 카운터(1208)의 카운트는 클록 사이클 또는 다른 트리거 또는 반복마다 계속 증가한다(예를 들어, 단계(1114) 참조). 카운트가 VL과 동일해질 때까지 카운트를 증가시킴으로써, 벡터 프로세서는 OVR의 요소들의 위치들이 VIR_TRUE(1202a) 또는 VIR_FALSE(1202b)에 저장될 때까지 카운트에 따라 OVR(1204)의 요소들의 위치들을 저장하는 것을 계속할 수 있다. 다시 말해, 시스템(1200)은 로드된 피연산자 벡터의 요소들의 위치들이 VIR_TRUE(1202a) 또는 VIR_FALSE(1202a)에 저장될 때까지 카운트에 따라 OVR(1204)의 요소들의 위치들을 저장하는 것을 계속할 수 있다. 이는 시스템(1200)이 방법(1100)의 동작들을 구현할 수 있는 방식들 중 하나이다.

카운트가 VL과 같은 경우, 시스템(1200)을 이용한 벡터 프로세서는 VIR_TRUE(1202a) 및 VIR_FALSE(1202b)에 저장하기 위한 인덱싱 벡터들의 구축을 완료했다. 카운트가 VL과 동일할 때 인덱싱 벡터들을 구축하는 동작이 완료되기 때문에 카운트는 VL보다 클 수 없다. 새로운 인덱싱 벡터들이 구축될 때, 카운터(1208)에서 카운트가 리셋되고 VL이 결정되며 VLR(1224)에 저장된다. 벡터 프로세서는 처음에 OVR(예를 들어, OVR(1204))의 벡터 길이를 결정한 다음, 방법(1100)을 수행하기 전에 이를 VLR(1224)에 저장할 수 있다.

VIR_TRUE(1202a) 및 VIR_FALSE(1202b)에 저장된 인덱싱 벡터들의 구축이 완료되면, 벡터 프로세서는, 프로세서의 벡터 로드-저장 유닛에 의해, VIR_TRUE 또는 VIR_FALSE 또는 이들의 조합 중 적어도 하나로부터, OVR(1204)의 요소들의 저장된 위치들을 로드하는 것을 계속한다. 그리고, 벡터 프로세서는 또한 VIR_TRUE(1202a) 및/또는 VIR_FALSE(1202b)의 로드된 위치들에 따라 OVR(1204)의 요소들에 대한 하나 이상의 벡터 연산들을 반복하는 것을 계속할 수 있다.

시스템(1200)에 대한 대안이 VIR_TRUE와 VIR_FALSE 둘 다 기본적으로 하향식으로 저장된 OVR의 TRUE 어드레스 및 레지스터의 상향식으로 저장된 OVR의 FALSE 어드레스를 갖는 하나의 벡터 인덱스 레지스터로 결합되는 도 14에 예시되어 있다.　　 이러한 대안에서, 결합된 VIR의 TRUE 부분을 어드레싱기 위한 카운터는 어드레스 "0"으로 시작되고, 결합된 레지스터에 각 TRUE 입력에 대해 1씩 가산된다. FALSE 카운터는 결합된 VIR에 액세스하기 위한 어드레스에 대해 "N-1"로 시작되고, 카운터는 결합된 레지스터에 대한 각 FALSE 입력에 대해 1씩 증가한다. 도 14에 도시된 바와 같은 멀티플렉서는 TRUE 입력용 카운터 또는 FALSE 입력용 카운터 중 어느 하나로부터 선택하는 데 사용될 수 있다. 각 사이클에서, VIR은 입력이 TRUE 섹션(예를 들어, 어드레스 0, 1, 2, ..., 카운트 + 1, 여기서 카운트는 "0"으로 시작됨) 또는 VIR의 FALSE 섹션(예를 들어, 어드레스 N-1, N-2, N-3, ..., VIR_length - 카운트+1, 여기서 카운트는 "0"으로 시작된)에 대한 입력이기 때문에 기입을 위해 한 번 인에이블되며; 따라서, 인덱스는 하향식 또는 상향식으로 생성된다.

도 13은 본 개시의 일부 실시예들에 따른, 비교의 TRUE 및 FALSE 결과들(예를 들어, "1" 및 "0" 결과들)에 대해 결합된 벡터 인덱싱 레지스터(VIR_combined)에 저장하기 위한 결합된 인덱싱 벡터를 구축하는 방법(1300)의 예시적인 동작들을 예시한다.

방법(1300)은 단계(1302)에서, 벡터 프로세서의 벡터 로드-저장 유닛에 의해, OVR에 저장된 피연산자 벡터를 로딩하는 것으로 시작된다.

단계(1304)에서, 방법(1300)은 벡터 로드-저장 유닛에 의해, 벡터 프로세서의 스칼라 레지스터에 저장된 스칼라를 로드하는 것을 계속한다.

단계(1306)에서, 방법(1300)은 벡터 프로세서에 의해, 카운터에 저장된 카운트에 따라 로드된 피연산자 벡터의 요소를 로드된 스칼라와 비교하는 것을 계속한다. 카운터는 또 다른 스칼라 레지스터 및 벡터 프로세서의 일부일 수 있다. 또한, 일부 실시예들에서, 방법(1300)은 벡터 프로세서에 의해, 카운터에 저장된 카운트에 따라 로드된 피연산자 벡터의 요소를 또 다른 피연산자 벡터와 비교하는 것을 계속할 수 있다. 일부 실시예들에서, 비교를 위해, 로드된 피연산자 벡터의 요소는 제1 카운터의 제1 카운트에 따라 벡터 프로세서에 의해 액세스되고, 다른 로드된 피연산자 벡터의 요소는 제2 카운터의 제2 카운트에 따라 벡터 프로세서에 의해 액세스된다. 비교는 수치 비교일 수 있다.

단계(1308)에서, 방법(1300)은 단계(1306)의 비교 결과가 TRUE인지 FALSE인지(예를 들어, "1"인지 또는 "0"인지)를 식별하는 것을 계속한다. 단계(1306)의 비교 결과가 TRUE이면, 방법(1100)은 단계(1310a)에서 VIR_combined의 최상위 채워지지 않은 위치에, 카운트에 따라(예컨대 TRUE 카운터- 예를 들어, 도 14에 도시된 TRUE 카운터(1416a) 참조 - 에 저장된 TRUE 카운트를 통한 카운트에 따라) 로드된 피연산자 벡터의 요소 위치를 저장하는 것을 계속한다. 단계(1306)의 비교 결과가 FALSE이면, 방법(1300)은 단계(1310b)에서, VIR_combined의 최하위 채워지지 않은 위치에, 카운트에 따라(예컨대 FALSE 카운터- 예를 들어, 도 14에 도시된 FALSE 카운터(1416b) 참조 - 에 저장된 FALSE 카운트를 통한 카운트에 따라) 로드된 피연산자 벡터의 요소 위치를 저장하는 것을 계속한다.

단계(1312)에서, 방법(1300)은 카운트가 OVR에 저장된 피연산자 벡터의 벡터 길이(VL)와 동일한지 여부를 식별하는 것을 계속한다. 일부 실시예들에서, 방법(1300)은 OVR의 VL이 VIR_COMBINED의 TRUE 섹션과 VIR_COMBINED의 FALSE 섹션의 VL을 더한 결과와 동일한지 여부를 식별하는 것을 계속 할 수 있으며, 이는 카운트가 OVR에 저장된 피연산자 벡터의 VL과 동일한지 여부를 식별하는 또 다른 방법일 수 있다. 카운트가 OVR의 VL과 동일한지 여부를 식별하는 이러한 예시적인 대안 방법들은 OVR의 모든 요소들이 비교됨을 보여줄 수 있다. 카운트가 VL 미만이면, 방법은 단계(1314)에서, 카운트를 증가시키는 것을 계속한다. 카운트가 VL과 동일해질 때까지 카운트를 증가시킴으로써, 벡터 프로세서는 로드된 피연산자 벡터의 요소들의 위치들이 VIR_combined에 저장될 때까지 카운트에 따라 로드된 피연산자 벡터의 요소들의 위치들을 저장하는 것을 계속할 수 있다. 다시 말해, 방법(1300)은 로드된 피연산자 벡터의 요소들의 위치들이 VIR_combined에 저장될 때까지 카운트에 따라 로드된 피연산자 벡터의 요소들의 위치들을 저장하는 것을 계속한다.

단계(1312)에서, 카운트가 VL과 동일한 경우, 방법(1300)은 VIR_combined에 저장하기 위한 인덱싱 벡터들의 구축을 완료했다. 카운트가 VL과 동일할 때 인덱싱 벡터들을 구축하는 동작이 완료되기 때문에 카운트는 VL보다 클 수 없다. 새로운 인덱싱 벡터들이 구축될 때, 카운트가 리셋되고 VL의 스칼라 값을 저장하는 VL 레지스터도 리셋될 수 있다. 벡터 프로세서는 초기에 OVR의 벡터 길이를 결정한 다음 방법(1300)을 수행하기 전에 VL 레지스터에 길이를 저장할 수 있다.

VIR_combined에 저장된 인덱싱 벡터의 구축의 완료 시, 방법(1300)은, 단계(1316)에서, 벡터 로드-저장 유닛에 의해, VIR_combined로부터, 로드된 피연산자 벡터의 요소들의 저장된 위치들을 로드하는 것을 계속한다. 그리고, 단계(1318)에서, 방법(1300)은 로드된 위치들에 따라 로드된 피연산자 벡터의 요소들에 대해 하나 이상의 벡터 연산들을 반복하는 것을 계속한다.

도 14는 본 개시의 일부 실시예들에 따른, VIR_combined(1402)에 저장하는 결합된 인덱싱 벡터를 구축하는 예시적인 시스템(1400)을 예시한다.

시스템(1400)은 방법(1300)의 설명에서 설명된 VIR_combined(1402)와 같은 VIR_combined(1402)를 포함한다. 시스템은 또한 방법(1400)의 설명에서 설명된 OVR과 같은 OVR(1404)을 포함한다.

시스템(1400)은 또한 방법(1300)의 설명에서 설명된 스칼라 레지스터와 같은, 스칼라 레지스터(SR)(1406)를 포함한다. 일부 실시예들에서, 스칼라 레지스터는 OVR(1404)과 같은 방식으로 어드레스된 다른 OVR로 대체될 수 있다.

시스템은 또한 카운터 레지스터에 의해 부분적으로 구현될 수 있고 방법(1300)의 설명에서 설명된 카운터일 수 있는 카운터(1408)를 포함한다.

시스템(1400)은 또한 SR(1406)에 저장된 값과 OVR(1404)의 요소에 저장된 값의 비교를 수행할 수 있는 비교기(1410)을 포함한다. 비교기(1410)는 OVR(i) < SR, OVR(i) = SR, OVR(i) > SR, OVR(i) ≤ SR, 또는 OVR(i) ≥ SR와 같은 비교 결과들을 수행할 수 있다. 비교기(1410)는 한번에 또는 사이클마다 두 개의 숫자들을 비교한다. 각 반복 i(이는 또한 어드레스 또는 어드레스 성분 i를 나타냄)에서, 카운터(1408)는 비교기(1410)에 의해 SR(1406)으로부터의 스칼라 값과 비교하기 위해 OVR(1404)에 액세스하기 위한 어드레스 i를 제공한다.　 요약하면, 반복 또는 어드레스 i에서 OVR(1404)의 출력은 스칼라 레지스터(1406)으로부터의 값과 비교된다. 비교기(1410)는 TRUE 또는 FALSE인 단일 출력을 생성한다.　　

비교기(1410)는 방법(1300)의 단계(1306)에서 비교를 수행하도록 구성될 수 있다. 다시 말해, 비교기(1410)는 카운터 레지스터에 저장된 카운트에 따라 로드된 피연산자 벡터의 요소를 로드된 스칼라와 비교하도록 구성될 수 있다. 비교기(1410)는 또한 단계(1308)에서 TRUE 또는 FALSE 결과의 식별을 수행하도록 구성될 수 있다. 다시 말해, 비교기(1410)는 단계(1306)의 비교 결과가 TRUE인지 FALSE인지를 식별하도록 구성될 수 있다. 비교기(1410)는 TRUE 결과에 대해 "1" 또는 FALSE 결과에 대해 "0"과 같은, TRUE 또는 FALSE 결과를 출력하도록 구성될 수 있다. 비교기(1410)의 출력은 VIR_COMBINED(1402)의 TRUE 및 FALSE 섹션들에 대한 각각의 기입 인에이블들 중 하나로 입력된다.

시스템(1400)은 또한 VIR_COMBINED(1402)의 TRUE 섹션의 어드레싱을 위한 별도의 TRUE 카운터(1416a) 및 VIR_COMBINED의 FALSE 섹션의 어드레싱을 위한 별도의 FALSE 카운터(1416b)를 포함한다. 비교기(1410)의 출력은 2개의 카운터들인, 카운터들(1416a 및 1416b)을 구동한다. 카운터들(1416a 및 1416b)은 OVR(1404)를 위한 어드레스를 제공하는 카운터(1408)와 별개이다. 카운터 TRUE(1416a)의 출력은 하향식으로 VIR_COMBINED(1402)에 액세스하기 위한 어드레스로 사용된다. FALSE 카운터(1416b)의 출력은 VIR_COMBINED(1402)에 액세스하기 위한 어드레스로도 사용되지만, 상향식으로도 사용된다. 카운터들이 VIR_COMBINED(1402)를 어드레스하는 방법에 대한 추가 설명은 아래에서 논의된다.

카운터(1408)의 출력은 TRUE 카운터(1416a)에 의해 지정된 어드레스에서 TRUE 섹션에 기입될 어드레스 또는 어드레스 성분으로 사용된다. 이는 비교기(1410)의 출력이 TRUE인 경우에 발생한다. TRUE 카운터(1416a)에 저장된 값은 비교기(1410)로부터 TRUE 출력을 트리거 할 때마다 1씩 증가된다. 카운터(1408)의 출력은 FALSE 카운터(1416b)에 의해 지정된 어드레스에서 FALSE 섹션에 기입될 어드레스 또는 어드레스 성분으로 사용된다. 이는 비교기(1410)의 출력이 FALSE일 때 발생한다. FALSE 카운터(1416b)에 저장된 값은 비교기(1410)로부터 FALSE 출력을 트리거할 때마다 1씩 감소된다. OVR 성분의 어드레스들을 저장할 위치를 선택하는 이 전체 기능은 비교기(1410), TRUE 및 FALSE 카운터들(1416a 및 1416b) 및 멀티플렉서(1420)를 포함하는 회로에 의해 제공된다. 비교기(1410)로부터의 출력은 선택 레지스터(1422)를 통해 멀티플렉서(1420)를 제어한다.

멀티플렉서(1420)는 카운터들(1416a 및 1416b)의 어떤 카운터 출력이 VIR_COMBINED(1402)에 의해 수신되는지를 제어한다. 제어는 카운터(1416a 또는 1416b)의 선택을 통해 이루어지며, 선택은 선택 레지스터(1422)에 저장된 모드 값을 통해 제어된다. 선택 레지스터(1422)는 비교기(1410)의 출력으로부터 모드 값을 수신한다. 각 사이클에서, VIR_COMBINED(1402)는 입력이 VIR의 TRUE 섹션(예를 들어, 어드레스 0, 1, 2, ..., 카운트 + 1, 여기서 카운트는 "0"으로 시작됨) 또는 VIR의 FALSE 섹션(예를 들어, 어드레스 N-1, N-2, N-3, ..., VIR_length - 카운트+1, 여기서 카운트는 "0"으로 시작된)에 대한 입력이기 때문에 기입을 위해 한 번 인에이블되며; 따라서, 인덱스는 하향식 또는 상향식으로 생성된다. 도 14에 도시된 예에서, TRUE 카운터(1416a)는 "0"으로 시작하고 각 사이클마다 "1"씩 증가한다. 이 예에서, FALSE 카운터(1416b)는 VIR_COMBINED(1402)(즉, N-1)의 길이를 나타내는 스칼라 값으로 시작되고 각 사이클마다 "1"씩 감소한다. 예를 들어, 도 14에서, 비교기(1410)에 의한 비교는 SR < OVR(i)이므로, OVR(1404)의 어드레스 "0"에 있는 값 "2"는 TRUE이며, 따라서 OVR의 어드레스 "0"은 VIR_COMBINED(1402)의 어드레스 "0"(또는 VIR의 최상위)에 저장된다. 그리고, OVR(1404)의 어드레스 "1"에 있는 값, "5"는 FALSE이므로, OVR의 어드레스 "1"은 VIR_COMBINED(1402)의 어드레스 "N-1"(또는 VIR의 최하위)에 저장된다. 그리고, OVR(1404)의 어드레스 "2"에 있는 값, "3"은 TURE이므로, OVR의 어드레스 "2"는 VIR_COMBINED(1402)의 어드레스 "1"(또는 채워지지 않은 VIR의 최상위 위치)에 저장된다. 그리고, OVR(1404)의 어드레스 "3"에 있는 값, "6"은 FALSE이므로, OVR의 어드레스 "3"은 VIR_COMBINED(1402)의 어드레스 "N-2"(또는 채워지지 않은 VIR의 최하위 위치)에 저장된다.

TRUE 섹션과 FALSE 섹션은 각각 시스템(1400)의 출력 레지스터의 일부이다. VIR_COMBINED(1402)는 적어도 두 개의 입력들을 갖는다. 제1 입력은 VIR_COMBINED(1402)에 액세스하는 어드레스를 위한 카운터(1416a 또는 1416b)로부터 나온다. 제2 입력은 카운터(1408)로부터 나오며, 이 입력은 카운터(1416a 또는 1416b)에 의해 제공된 레지스터의 어드레스에 있는 VIR_COMBINED(1402)에 기입된 데이터를 포함한다.

시스템(1400)은 벡터 로드-저장 유닛을 포함하는 벡터 프로세서의 일부일 수 있다. 벡터 로드-저장 유닛은 시스템(1400)의 레지스터들에 저장된 데이터를 메인 메모리로 로드할 수 있을 뿐만 아니라 데이터를 메인 메모리에서 시스템의 레지스터들로 저장할 수 있으며, 그 반대(메모리에 저장된 데이터를 시스템(1400)의 레지스터들로 로드할 뿐만 아니라 데이터를 시스템의 레지스터들에서 메모리로 저장함)로도 가능하다.

시스템(1400)은 또한 벡터 길이에 대한 스칼라 레지스터인, 벡터 길이 레지스터(1424)(VLR(1424))를 포함하는 것으로 도시되어 있다. VLR(1424)은 OVR(1404)의 벡터 길이(VL)를 저장하도록 구성된다. 벡터 프로세서는 카운터(1408)로부터의 카운트가 OVR(1404)에 저장된 피연산자 벡터의 VL과 동일한지 여부를 식별하기 위해 VLR(1424)로부터 메모리로 VL을 로드할 수 있다. 이는 예를 들어 도 13의 방법(1300)의 단계(1312)를 구현하는 한 방법이다. 카운트가 VL 미만인 경우, 카운터(1408)의 카운트는 클록 사이클 또는 다른 트리거 또는 반복마다 계속 증가한다(예를 들어, 단계(1314) 참조). 카운트가 VL과 동일해질 때까지 카운트를 증가시킴으로써, 벡터 프로세서는 OVR의 요소들의 위치들이 VIR_COMBINED(1402)의 TURE 섹션 또는 FALSE 섹션에 저장될 때까지 카운트에 따라 OVR(1404)의 요소들의 위치들을 저장하는 것을 계속할 수 있다. 다시 말해, 시스템(1400)은 로드된 피연산자 벡터의 요소들의 위치들이 VIR_COMBINED(1402)의 TRUE 섹션 또는 FALSE 섹션에 저장될 때까지 카운트에 따라 OVR(1404)의 요소들의 위치들을 저장하는 것을 계속할 수 있다. 이는 시스템(1400)이 방법(1300)의 동작들을 구현할 수 있는 방식들 중 하나이다.

카운트가 VL과 같은 경우, 시스템(1400)을 이용한 벡터 프로세서는 VIR_COMBINED(1402)의 TRUE 섹션 또는 FALSE 섹션에 저장하기 위한 인덱싱 벡터들의 구축을 완료했다. 카운트가 VL과 동일할 때 인덱싱 벡터들을 구축하는 동작이 완료되기 때문에 카운트는 VL보다 클 수 없다. 새로운 인덱싱 벡터들이 구축될 때, 카운터(1408)에서 카운트가 리셋되고 VL이 결정되며 VLR(1424)에 저장된다. 벡터 프로세서는 처음에 OVR(예를 들어, OVR(1404))의 벡터 길이를 결정한 다음, 방법(1300)을 수행하기 전에 이를 VLR(1424)에 저장할 수 있다.

VIR_COMBINED(1402)에 저장된 인덱싱 벡터들의 구축의 완료 시, 벡터 프로세서는, 프로세서의 벡터 로드 저장 유닛에 의해, VIR_COMBINED로부터, OVR(1404) 요소들의 저장된 위치들을 로드하는 것을 계속할 수 있다. 그리고, 벡터 프로세서는 또한 VIR_COMBINED(1402)의 로드된 위치들에 따라 OVR(1404)의 요소들에 대한 하나 이상의 벡터 연산들을 반복하는 것을 계속할 수 있다.

도 15는 본 개시의 일부 실시예들에 따른, VIR_TRUE(1502a) 및 VIR_FALSE(1502b)를 포함하는 예시적인 시스템(1500)을 예시한다. 본 개시의 목적을 위해, 시스템(1500)과 유사한 시스템은 다수의 VIR_TRUE들 및 다수의 VIR_FALSE들을 포함할 수 있다는 것을 이해해야 한다. 예를 들어, 2개의 VIR_TRUE들 및 2개의 VIR_FALSE들을 갖는 시스템(1500)과 유사한 실시예는 2개의 VIR_TRUE들 및 2개의 VIR_FALSE드을 수신하기 위한 4개의 입력들 및 카운터(예를 들어, 카운터(1504)와 유사한 카운터)로부터 입력을 수신하기 위한 입력을 갖는 5:1 멀티플렉서를 포함할 수 있다. 일부 실시예들에서, VIR_TRUE의 양은 이러한 시스템들에서 VIR_FALSE의 양과 같습니다.

시스템(1500)은 벡터 프로세서(102)(예를 들어, 도 1 또는 2 참조) 또는 다수의 벡터 프로세서들의 일부일 수 있다. 시스템(1500)은 벡터 인덱스 레지스터들(VIR_TRUE(1502a) 및 VIR_FALSE(1502b)), 카운터 레지스터(1504), 2:1 멀티플렉서(1506), 및 멀티플렉서에 연결된 선택 레지스터(1508)를 포함한다. VIR_TRUE(1502a) 및 VIR_FALSE(1502b)는 도 2에 도시된 벡터 레지스터들(202)의 레지스터들일 수 있다. 카운터 레지스터(1504) 및 선택 레지스터(1508)는 스칼라 레지스터들(204)의 레지스터들일 수 있다. 2:1 멀티플렉서(1506)는 도 2에 도시된 버스(206) 또는 도 1에 도시된 버스(104)의 일부일 수 있다.

VIR_TRUE(1502a)는 비교의 TRUE 결과를 위한 벡터 인덱스 레지스터이며, 비교에 사용될 때 TRUE 결과들을 생성하는 OVR의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하도록 구성된다. 예를 들어, 시스템(1500)의 일부일 수 있는, VIR_TRUE(1202a)를 참조한다.

VIR_FALSE(1502b)는 비교의 FALSE 결과를 위한 벡터 인덱스 레지스터이며, 비교에 사용될 때 FALSE 결과들을 생성하는 OVR의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하도록 구성된다. 예를 들어, 시스템(1500)의 일부일 수 있는, VIR_FALSE(1202b)를 참조한다.

각 어드레스 성분은 OVR의 해당 위치에 액세스하기 위한 유효 어드레스에 추가할 수 있다. OVR의 각 위치는 ALU에 의해 연산될 피연산자 벡터의 요소를 포함할 수 있다. 예를 들어, 시스템(1500)은 복수의 산술 로직 유닛들(ALU들) 중 산술 로직 유닛(ALU)을 포함하는 벡터 프로세서의 일부일 수 있다. 벡터 프로세서는 또한 복수의 피연산자 벡터 레지스터들의 피연산자 벡터 레지스터(OVR)를 포함할 수 있다. OVR은 ALU의 벡터 연산을 위한 입력으로 사용될 피연산자 벡터의 요소들을 저장하도록 구성될 수 있다.

도시된 바와 같이, 카운터 레지스터(1504)는 시스템(1500)의 일부이다. 카운터 레지스터(1504)는 또한 시스템(1500)을 갖는 벡터 프로세서의 일부일 수 있다. 카운터 레지스터(1504)는 카운트(1510)를 저장하도록 구성될 수 있다. 카운트(1510)는 OVR에 액세스하기 위한 유효 어드레스에 추가될 수 있거나, 카운트는 VIR(1502)에 저장된 복수의 어드레스 성분들에 대해 반복하도록 벡터 프로세서에 의해 사용될 수 있다.

도시된 바와 같이, 3:1 멀티플레서(1506)는 시스템(1500)의 일부이다. 3:1 멀티플렉서(1506)는 또한 시스템(1500)을 갖는 벡터 프로세서의 일부일 수 있다. 3:1 멀티플렉서(1506)는, 입력들로서, 카운터 레지스터(1504)로부터의 카운트(1510) 및 VIR들(1502a 및 1502b)로부터의 각각의 출력들(1512a 및 1512b)을 수신하도록 구성될 수 있다. VIR들(1502a 및 1502b)로부터의 출력들(1512a 및 1512b)은 카운트(1510)에 대응하는 VIR의 복수의 어드레스 성분들 중 하나를 포함할 수 있다. 3:1 멀티플렉서(1506)는 또한, 선택 입력으로서, 모드 값(1514)을 수신하도록 구성될 수 있다. 모드 값(1514)은 카운트(1510)의 선택을 위한 값 또는 VIR들(1502a 및 1502b)로부터의 출력들(1512a 또는 1512b) 중 하나의 선택을 위한 값이거나 이를 포함할 수 있다. 3:1 멀티플렉서(1506)는 또한 수신된 모드 값(1514)에 따라 VIR들(1502a 및 1502b)로부터 카운트(1510) 또는 출력들(1512a 또는 1512b) 중 하나를 선택하도록 구성될 수 있다. 3:1 멀티플렉서(1506)는 또한 버스(도 1 또는 2의 버스들 중 하나와 같은)를 통해, VIR들로부터의 선택된 카운트 또는 선택된 출력들 중 하나인 선택 출력(1516)을 출력 및 전달하도록 구성될 수 있다. 선택 출력(1516)은 ALU를 위한 OVR에 액세스하는 요청자에게 전달될 수 있다. 요청자는 벡터 프로세서의 벡터 로드-저장 유닛(예를 들어, 도 2에 도시된 벡터 로드-저장 유닛(210) 참조), 또는 다른 벡터 프로세서의 벡터 로드-저장 유닛일 수 있다.

도 16은 본 개시의 일부 실시예들에 따른, VIR_TRUE(예를 들어, VIR_TRUE(1202a 또는 1502a) 참조)에 따라 피연산자 벡터의 요소들을 압축하는 방법(1600)의 예시적인 동작들을 예시한다. 대안으로, 피연산자 벡터의 요소들을 압축하는 방법(1600)의 예시적인 동작들은 본 개시의 일부 실시예들에 따른, VIR_FALSE(예를 들어, VIR_FALSE(1202b 또는 1502b) 참조)에 따르거나 또는 VIR_COMBINED(예를 들어, VIR_ COMBINED(1402) 참조)의 TRUE 또는 FALSE 섹션에 따를 수 있다.

도 16에서, 방법(1600)은, 단계(1602)에서, 벡터 로드-저장 유닛에 의해, 입력 OVR에 저장된 입력 피연산자 벡터를 로딩하는 것으로 시작된다. 단계(1604)에서, 방법(1600)은 벡터 로드-저장 유닛에 의해, 카운터 레지스터에 저장된 카운트를 로드하는 것을 계속한다. 단계(1606)에서, 방법(1600)은 벡터 로드-저장 유닛에 의해, VIR_TRUE로부터, 카운트에 따라 로드된 입력 피연산자 벡터의 요소의 저장된 위치를 로드하는 것을 계속한다. 단계(1608)에서, 방법(1600)은 VIR_TRUE로부터 로드된 위치에 따라 로드된 입력 피연산자 벡터의 요소들에 대해 벡터 압축 연산을 실행하는 것을 계속한다. 단계(1608)는 로드된 입력 피연산자 벡터의 요소를 VIR_TRUE로부터의 로드된 위치에 대응하는 출력 OVR에 저장하는 것을 계속하는 방법(1600)을 포함하는 단계(1610)를 포함한다. 단계(1612)에서, 방법(1600)은 벡터 압축 연산이 VIR_TRUE에 저장된 위치들 각각에 대한 입력 OVR에 걸쳐 반복될 수 있도록 VIR_TRUE(즉, VL)의 벡터 길이를 나타내는 값과 카운트를 비교하는 것을 계속한다. 카운트가 VIR_TRUE의 벡터 길이와 동일할 때, 방법(1600)은 종료된다. 카운트가 VIR_TRUE의 벡터 길이 미만인 경우, 방법(1600)은 1614에서 카운트를 증가시킨 다음 단계(1604)(카운터 레지스터에 저장된 카운트를 로드하는 단계)로 돌아가고, 단계(1606)(벡터 로드-저장 유닛에 의해, VIR_TRUE로부터, 카운트에 따라 로드된 입력 피연산자 벡터의 요소의 저장된 위치를 로드하는 단계) 및 단계(1608)(VIR_TRUE로부터의 로드된 위치에 따라 로드된 입력 피연산자 벡터의 요소들에 대한 벡터 압축 연산을 실행하는 단계)가 이어진다. 이러한 방식으로, 벡터 압축 연산은 VIR_TRUE에 저장된 위치들 각각에 대해 입력 OVR에 걸쳐 반복된다.

도 17은 본 개시의 일부 실시예들에 따른, 입력 OVR(1704)에 저장된 입력 피연산자 벡터의 요소들을 압축하는 데 사용되는 VIR_TRUE(1702a)(이는 VIR_TRUE(1202a 또는 1502a)와 유사할 수 있음)를 포함하는 예시적인 시스템(1700)을 예시한다. 대안으로, 예시적인 시스템(1700)은 본 개시의 일부 실시예들에 따른 VIR_FALSE(1702b)(이는 VIR_FALSE(1202b 또는 1502b)와 유사할 수 있음)에 따라 피연산자 벡터의 요소들을 압축하는데 사용될 수 있다. 또한, 예시적인 시스템(1700)은 본 개시의 일부 실시예들에 따른, VIR_COMBINED(예를 들어, VIR_ COMBINED(1402) 참조)의 TRUE 또는 FALSE 섹션에 따라 피연산자 벡터의 요소들을 압축하는 데 사용될 수 있다.

예시적인 시스템(1700)은 적어도 방법(1600)을 구현할 수 있는 시스템의 일 예이다.

도 17에서, VIR_TURE(1702a)은 입력 OVR(1704)의 위치 목록(예를 들어, 입력 OVR의 제1 요소로서의 "2", 입력 OVR의 제2 요소로서의 "4")을 저장한다. 이 예시된 예에서, 벡터 프로세서는 벡터 압축 연산의 두 사이클 또는 반복 동안 실행되는 것으로 표시된다. 제1 반복에서, 카운터(1706)는 제1 사이클에서 카운터에 저장된 값인 "0"의 카운트를 출력한다. 제1 사이클에서, VIR_TRUE(1702a)은 "2"를 출력하는 것으로 표시된다. 멀티플렉서(1708)는 정상 모드 연산에서 카운터(1706)에 의해 지정된 어드레스 성분("0") 또는 VIR_TRUE 연산 모드(또는 이 특정 예에서의 VIR_TRUE(1702a)의 내용들에 기반하는 압축 연산 모드)에서 VIR_TRUE(1702a)에 의해 지정된 어드레스 성분("2") 중에서 선택한다. VIR_TRUE(또는 VIR_TRUE 압축 모드)이 제1 사이클에서 멀티플렉서(1708)에 의해 선택되면, VIR_TRUE(1702a)로부터의 출력 "2"는 입력 OVR(1704)에 액세스하는 데 사용되는 어드레스 성분이다. 결과적으로, 입력 OVR의 위치 "2"에서 요소 "C"의 출력을 위해 입력 OVR(1704)이 액세스된다. 출력 OVR(1710)는 카운터(1706)에 저장된 카운트를 통해 직접 어드레싱된다. 　 카운터(1706)의 카운트가 제1 사이클에서 "0"이기 때문에, 출력 ORV(1710)는 "C"를 제1 요소로 저장한다. 다음 반복 또는 사이클에서, 출력 ORV(1710)는 출력 OVR의 위치 "1"에 제2 요소로서 "E"를 저장한다. 2개의 사이클이 보여지는 이 예에서, {A, B, C, D, E}의 요소들을 갖는 입력 OVR(1704)은 {C, E}의 요소들을 갖는 출력 OVR(1710)로 압축된다.

또한, 도 17을 참조하여, 입력/출력 벡터들에 대한 어드레스 신호들이 반전되면, {C, E}는 {x, x, C, x, E}의 요소를 갖는 제2 출력 OVR로 확장될 수 있다. 여기서 x는 이전의 기존 값입니다. 압축 연산 또는 스칼라 레지스터로부터 선택된 스칼라 값 전의 기존 값들이다(예를 들어, 스칼라 레지스터로부터의 스칼라 값으로 압축된 벡터를 확장하는 예시적인 방법인 도 9 참조). 　　

또한, VFR로부터의 값이 카운터의 카운트에 추가되면, 입력 OVR에 대한 연산의 제1 반복이 입력 OVR의 제1 위치(예를 들어, 입력 OVR(1704)의 제1 위치는 "0"으로 표시됨) 대신 입력 OVR의 다른 위치에서 발생하도록 합산이 사용될 수 있다. E.g., see FIG. 5. 대안으로, VIR_TRUE(1702a)는 벡터 연산 시작 시 카운트 레지스터의 초기 값이 VIR_TRUE(1702a)에 저장된 값이 되도록 카운트 레지스터에 대한 입력을 제공하는 데 사용될 수 있다. 이러한 옵션들은 벡터 제1 처리를 허용한다. 상이한 유형의 연산들에 대해, VIR_TRUE(1702a) 대신 VIR_FALSE(1702b)가 사용될 수 있다는 것을 이해해야 한다. 예를 들어, 압축 연산은 VIR_TRUE(1702a) 대신 VIR_FALSE(1702b)의 인덱스를 기반으로 할 수 있다. 또한, VIR_COMBINED는 시스템(1700)에서 VIR_FALSE(1702b) 및 VIR_FALSE(1702b)를 대체할 수 있다.

방법들(600, 700, 900, 1000, 1100, 1300, 및 1600)은 본원에 설명된 벡터 프로세서들 및 시스템들에 의해 구현될 수 있는 많은 연산들 중 일부만을 포함한다.

전술한 상세한 설명의 일부 부분들은 컴퓨터 메모리 내의 데이터 비트들에 대한 연산의 알고리즘 및 상징적 표현들과 관련하여 제시되었다. 이러한 알고리즘적 설명들 및 표현들은 데이터 처리 분야의 당업자가 그들 작업의 실체를 다른 당업자에게 가장 효과적으로 전달하기 위해 사용되는 방식들이다. 여기서, 알고리즘은 일반적으로 원하는 결과를 도출하는 자기 모순 없는(self-consistent) 동작 시퀀스인 것으로 생각된다. 동작들은 이러한 물리적 수량의 물리적 조작을 필요로 한다. 일반적으로, 반드시 그런 것은 아니지만, 이러한 양은 저장되고, 결합되고, 비교되고 아니면 조작될 수 있는 전기 또는 자기 신호들의 형태를 취한다. 이러한 신호들을 비트, 값, 요소, 심볼, 문자, 용어, 숫자 등으로 지칭하는 것이, 주로 일반적인 사용의 이유로, 때때로 편리한 것으로 입증되었다.

그러나, 이러한 및 유사한 용어들 모두는 적절한 물리적 양과 관련이 있으며 이러한 양에 적용되는 편리한 라벨들일 뿐이라는 점을 명심해야 한다. 본 개시는 컴퓨터 시스템의 레지스터들과 메모리들 내에서 물리적(전자적) 양으로 표현되는 데이터를 컴퓨터 시스템 메모리들 또는 레지스터들 또는 다른 이러한 정보 저장 시스템들 내의 물리적 양으로 표현되는 다른 데이터로 조작하고 변환하는 컴퓨터 시스템 또는 이와 유사한 전자 컴퓨팅 장치의 동작 및 프로세스들을 인용할 수 있다.

본 개시는 또한 본원에서 동작들을 수행하기 위한 장치에 관한 것이다. 이 장치는 의도된 목적들을 위해 특별히 구성될 수 있거나, 이는 컴퓨터에 저장된 컴퓨터 프로그램에 의해 선택적으로 활성화되거나 재구성된 컴퓨터를 포함할 수 있다. 이러한 컴퓨터 프로그램은, 이에 제한되는 것은 아니나, 플로피 디스크, 광 디스크, CD-ROM, 및 자기-광학 디스크, 읽기 전용 메모리(ROM), 랜덤 액세스 메모리(RAM), EPROM, EEPROM, 자기 또는 광학 카드, 또는 각각 컴퓨터 시스템 버스에 연결된 전자 인스트럭션들을 저장하기에 적합한 임의의 유형의 매체를 포함하는 임의 유형의 디스크와 같은 컴퓨터 판독 가능 저장 매체에 저장될 수 있다.

본원에 제시된 알고리즘들 및 디스플레이들은 본질적으로 임의의 특정 컴퓨터 또는 다른 장치와 관련되지 않는다. 다양한 시스템들은 본원의 교시에 따른 프로그램들과 함께 사용될 수 있거나, 방법을 수행하기 위해 다 특화된 장치를 구성하는 것이 편리하다는 것을 입증할 수 있다. 다양한 이들 시스템들의 구조는 아래의 설명에서 제시되는 것으로 나타날 것이다. 또한, 본 개시는 임의의 특정 프로그래밍 언어를 참조하여 설명되지 않는다. 다양한 프로그래밍 언어들이 본원에 기술된 바와 같이 본 개시의 교시를 구현하는 데 사용될 수 있음이 이해될 것이다.

본 개시는 본 개시에 따른 프로세스를 수행하기 위해 컴퓨터 시스템(또는 다른 전자 장치)를 프로그래밍하는 데 사용될 수는, 인스트럭션들을 저장한 기계 판독 가능 매체를 포함할 수 있는 컴퓨터 프로그램 제품 또는 소프트웨어로서 부분적으로 제공될 수 있다. 기계 판독 가능 매체는 기계(예를 들어, 컴퓨터)에 의해 판독 가능한 형태로 정보를 저장하기 위한 임의의 메커니즘을 포함한다. 일부 실시예들에서, 기계 판독 가능(예를 들어, 컴퓨터 판독 가능) 매체는 읽기 전용 메모리("ROM"), 랜덤 액세스 메모리("RAM"), 자기 디스크 저장 매체, 광 저장 매체, 플래시 메모리 컴포넌트들 등과 같은 기계(예를 들어, 컴퓨터) 판독 가능 저장 매체를 포함한다.

전술한 명세서에서, 본 개시의 실시예들은 그 특정 예시적인 실시예들을 참조하여 설명되었다. 다음의 청구 범위에 명시된 본 개시의 실시예들의 넓은 사상 및 범위를 벗어나지 않고 다양한 변형들이 이루어질 수 있음이 명백할 것이다. 따라서, 명세서 및 도면들은 제한적인 의미보다는 예시적인 의미로 간주되어야 한다.

Claims

방법에 있어서,
벡터 프로세서의 벡터 로드-저장 유닛에 의해, 피연산자 벡터 레지스터(OVR)에 저장된 피연산자 벡터를 로드하는 단계;
상기 벡터 로드-저장 유닛에 의해, 스칼라 레지스터에 저장된 스칼라를 로드하는 단계;
상기 벡터 프로세서에 의해, 카운터 레지스터에 저장된 카운트에 따라 상기 로드된 피연산자 벡터의 요소와 상기 로드된 스칼라를 비교하는 단계;
상기 비교의 TRUE 결과를 위한 벡터 인덱스 레지스터(VIR_TURE)에, 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소의 위치를 저장하는 단계;
상기 비교의 FALSE 결과를 위한 벡터 인덱스 레지스터(VIR_FALSE)에, 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소의 위치를 저장하는 단계; 및
상기 로드된 피연산자 벡터의 요소들의 위치들이 상기 VIR_TRUE 또는 상기 VIR_FALSE에 저장될 때까지 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소들의 상기 위치들의 저장을 계속하는 단계를 포함하는, 방법.
청구항 1에 있어서,
상기 벡터 로드-저장 유닛에 의해, 상기 VIR_TRUE 또는 상기 VIR_FALSE 또는 이들의 조합 중 적어도 하나로부터, 상기 로드된 피연산자 벡터의 상기 요소들의 저장된 위치들을 로드하는 단계; 및
상기 로드된 위치들에 따라 상기 로드된 피연산자 벡터의 상기 요소들에 대한 하나 이상의 벡터 연산들을 반복하는 단계를 더 포함하는, 방법.
청구항 1에 있어서, 상기 VIR_TRUE 및 상기 VIR_FALSE는 하나의 결합된 벡터 인덱스 레지스터(VIR_combined)의 일부이며, 상기 방법은,
상기 비교의 TRUE 결과를 위한 상기 VIR_combined의 최상위 채워지지 않은 위치에, 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소의 위치를 저장하는 단계;
상기 비교의 FALSE 결과를 위한 상기 VIR_combined의 최하위 채워지지 않은 위치에, 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소의 위치를 저장하는 단계; 및
상기 로드된 피연산자 벡터의 요소들의 위치들이 상기 VIR_combined에 저장될 때까지 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소들의 상기 위치들의 저장을 계속하는 단계를 포함하는, 방법.
청구항 3에 있어서,
상기 벡터 로드-저장 유닛에 의해, 상기 VIR_combined으로부터, 상기 로드된 피연산자 벡터의 상기 요소들의 저장된 위치들을 로드하는 단계; 및
상기 로드된 위치들에 따라 상기 로드된 피연산자 벡터의 상기 요소들에 대한 하나 이상의 벡터 연산들을 반복하는 단계를 더 포함하는, 방법.
청구항 1에 있어서
입력 OVR에 저장된 입력 피연산자 벡터를 로드하는 단계;
제2 카운터 레지스터로부터 카운트를 로드하는 단계;
상기 VIR_TRUE로부터, 상기 제2 카운트에 따라 상기 로드된 입력 피연산자 벡터의 요소의 저장된 위치를 로드하는 단계; 및
벡터 연산의 일부로서, 상기 VIR_TRUE로부터의 상기 로드된 위치에 대응하는 출력 OVR에 상기 로드된 입력 피연산자 벡터의 상기 요소를 저장하는 단계를 더 포함하는, 방법.
청구항 5에 있어서, 상기 벡터 연산은 압축 연산이며, 상기 방법은 상기 VIR_TRUE에 저장된 로드된 위치들에 대응하는 출력 OVR에 상기 로드된 입력 피연산자 벡터의 상기 요소들을 저장하는 단계를 더 포함하는, 방법.
청구항 6에 있어서,
상기 출력 OVR로부터 상기 저장된 요소들을 로드하는 단계;
상기 VIR_TRUE에 저장된 상기 로드된 위치들에 따라 상기 출력 OVR로부터의 상기 저장된 요소들에 대한 제2 벡터 연산을 반복하는 단계로서, 상기 제2 벡터 연산은 확장 연산인, 상기 반복하는 단계; 및
상기 확장 연산에 따라, 상기 VIR_TRUE에 저장된 상기 로드된 위치들에 따라 상기 제2 출력 OVR의 위치들에 있는 제2 출력 OVR에 상기 출력 OVR로부터의 상기 요소들을 저장하는 단계를 더 포함하는, 방법.
청구항 7에 있어서, 상기 확장 연산에 따라, 상기 제2 출력 OVR의 다른 위치들에 있는 상기 제2 출력 OVR에 스칼라를 저장하는 단계를 더 포함하는, 방법.
청구항 8에 있어서,
상기 VIR_FALSE에 저장된 로딩된 위치들에 따라 상기 로드된 피연산자 벡터의 요소들에 대한 제2 압축 연산을 반복하는 단계;
상기 제2 VIR_FALSE에 저장된 상기 로드된 위치들에 대응하는 제2 출력 OVR에 상기 로드된 피연산자 벡터의 상기 요소들을 저장하는 단계; 및
상기 제1 출력 OVR 및 상기 제2 출력 OVR로부터의 상기 요소들을 사용하여 하나 이상의 벡터 연산들을 수행하는 단계를 더 포함하는, 방법.
청구항 8에 있어서,
제2 VIR_TRUE에 저장된 로드된 위치들에 따라 제2 로드된 피연산자 벡터의 요소들에 대한 제2 압축 연산을 반복하는 단계;
상기 제2 VIR_TRUE에 저장된 상기 로드된 위치들에 대응하는 제2 출력 OVR에 상기 제2 로드된 피연산자 벡터의 상기 요소들을 저장하는 단계; 및
상기 제1 출력 OVR 및 상기 제2 출력 OVR로부터의 상기 요소들을 사용하여 하나 이상의 벡터 연산들을 수행하는 단계를 더 포함하는, 방법.
시스템에 있어서,
벡터 프로세서의 카운터 레지스터에 저장된 카운트에 따라 로드된 피연산자 벡터를 로드된 스칼라와 비교하도록 구성된, 상기 벡터 프로세서;
피연산자 벡터를 저장하도록 구성된 상기 벡터 프로세서의 피연산자 벡터 레지스터(OVR);
스칼라를 저장하도록 구성된 상기 벡터 프로세서의 스칼라 레지스터; 및
상기 벡터 프로세서의 벡터 로드-자장 유닛으로서,
상기 OVR에 저장된 피연산자 벡터를 로드하고;
상기 스칼라 레지스터에 저장된 스칼라를 로드하고;
상기 벡터 프로세서에 의해, 비교의 TRUE 결과를 위한 상기 벡터 프로세서의 벡터 인덱스 레지스터(VIR_TRUE)에, 상기 카운트에 따라 로드된 피연산자 벡터의 요소의 위치를 저장하고;
상기 벡터 프로세서에 의해, 비교의 FALSE 결과를 위한 상기 벡터 프로세서의 벡터 인덱스 레지스터(VIR_FALSE)에, 상기 카운트에 따라 상기 로드된 피연산자 벡터의 요소의 위치를 저장하고;
상기 로드된 피연산자 벡터의 요소들의 위치들이 상기 VIR_TRUE 또는 상기 VIR_FALSE에 저장될 때까지 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소들의 상기 위치들의 저장을 계속하도록 구성된, 상기 벡터 로드-자장 유닛을 포함하는, 시스템.
청구항 11에 있어서, 상기 벡터 로드-저장 유닛은 상기 로드된 피연산자 벡터의 상기 요소들의 저장된 위치들에 의해, 상기 VIR_TRUE 또는 VIR_FALSE 또는 이들의 조합 중 적어도 하나로부터 로드되도록 구성되며, 상기 벡터 프로세서는 상기 로드된 위치들에 따라 상기 로드된 피연산자 벡터의 상기 요소들에 대한 하나 이상의 벡터 연산들을 반복하도록 구성되는, 시스템.
청구항 11에 있어서, 상기 VIR_TRUE 및 상기 VIR_FALSE는 하나의 결합된 벡터 인덱스 레지스터(VIR_combined)의 일부이며, 벡터 로드-저장 유닛은,
상기 비교의 TRUE 결과를 위한 상기 VIR_combine의 최상위 채워지지 않은 위치에, 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소의 위치를 저장하고;
상기 비교의 FALSE 결과를 위한 상기 VIR_combine의 최하위 채워지지 않은 위치에, 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소의 위치를 저장하고;
상기 로드된 피연산자 벡터의 요소들의 위치들이 상기 VIR_combined에 저장될 때까지 상기 카운트에 따라 상기 로드된 피연산자 벡터의 상기 요소들의 상기 위치들의 저장을 계속하도록 구성되는, 시스템.
청구항 13에 있어서, 벡터 로드-저장 유닛은, 상기 VIR_combined으로부터, 상기 로드된 피연산자 벡터의 상기 요소들의 저장된 위치들을 로드하도록 구성되며, 상기 벡터 프로세서는 상기 로드된 위치들에 따라 상기 로드된 피연산자 벡터의 상기 요소들에 대한 하나 이상의 벡터 연산들을 반복하도록 구성되는, 시스템.
청구항 11에 있어서, 상기 벡터 로드-저장 유닛은,
상기 벡터 프로세서의 입력 OVR에 저장된 입력 피연산자 벡터를 로드하고;
상기 벡터 프로세서의 제2 카운터 레지스터로부터 카운트를 로드하고;
상기 VIR_TRUE로부터, 상기 제2 카운트에 따라 상기 로드된 입력 피연산자 벡터의 요소의 저장된 위치를 로드하고;
벡터 연산의 일부로서, 상기 VIR_TRUE로부터 상기 로드된 위치에 대응하는 출력 OVR에 상기 로드된 입력 피연산자 벡터의 상기 요소를 저장하도록 구성되는, 시스템.
청구항 15에 있어서, 상기 벡터 연산은 압축 연산이며, 상기 벡터 로드-저장 유닛은 상기 VIR_TRUE에 저장된 로드된 위치들에 대응하는 출력 OVR에 상기 로드된 입력 피연산자 벡터의 상기 요소들을 저장하도록 구성되는, 시스템.
청구항 16에 있어서, 상기 벡터 로드-저장 유닛은 상기 출력 OVR로부터 상기 저장된 요소들을 로드하도록 구성되고, 상기 벡터 프로세서는 상기 VIR_TRUE에 저장된 상기 로드된 위치들에 따라 상기 출력 OVR로부터 상기 저장된 요소들에 대한 제2 벡터 연산을 반복하도록 구성되며, 상기 제2 벡터 연산은 확장 연산이고, 상기 벡터 로드-저장 유닛은, 상기 확장 연산에 따라, 상기 VIR_TRUE에 저장된 상기 로드된 위치들에 따라 상기 제2 출력 OVR의 위치들에 있는 상기 벡터 프로세서의 제2 출력 OVR에 상기 출력 OVR로부터의 상기 요소들을 저장하도록 더 구성되는, 시스템.
청구항 17에 있어서, 상기 벡터 로드-저장 유닛은, 상기 확장 연산에 따라, 상기 제2 출력 OVR의 다른 위치들에 있는 상기 제2 출력 OVR에 스칼라를 저장하도록 구성되는, 시스템.
청구항 18에 있어서, 상기 벡터 프로세서는 상기 VIR_FALSE에 저장된 로드된 위치들에 따라 상기 로드된 피연산자 벡터의 요소들에 대한 제2 압축 연산을 반복하도록 구성되고, 상기 벡터 로드-저장 유닛은 상기 제2 VIR_FALSE에 저장된 상기 로드된 위치들에 대응하는 제2 출력 OVR에 상기 로드된 피연산자 벡터의 상기 요소들을 저장하도록 구성되며,
상기 벡터 프로세서는 상기 제1 출력 OVR 및 상기 제2 출력 OVR로부터의 상기 요소들을 사용하여 하나 이상의 벡터 연산들을 수행하도록 더 구성되는, 시스템.
벡터 프로세서에 있어서,
복수의 산술 로직 유닛들의 산술 로직 유닛(ALU);
상기 ALU의 벡터 연산을 위한 입력으로서 사용될 피연산자 벡터의 요소들을 저장하도록 구성된, 복수의 피연산자 벡터 레지스터들의 피연산자 벡터 레지스터(OVR);
비교에 사용될 시 TRUE 결과를 생성하는 상기 OVR의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하도록 구성된, 비교의 TRUE 결과를 위한 벡터 인덱스 레지스터(VIR_TRUE); 및
비교에 사용될 시 FALSE 결과를 생성하는 상기 OVR의 복수의 위치들에 대응하는 복수의 어드레스 성분들을 저장하도록 구성된, 비교의 FALSE 결과를 위한 벡터 인덱스 레지스터(VIR_ FALSE)로서,
각 어드레스 성분은 상기 OVR의 해당 위치에 액세스하기 위한 유효 어드레스에 추가 가능하고;
상기 OVR의 각 위치는 상기 ALU에 의해 연산될 상기 피연산자 벡터의 요소를 포함하는, 상기 VIR_ FALSE을 포함하는, 벡터 프로세서.