KR102458467B1 - 벡터 생성 명령 - Google Patents

Abstract

벡터 처리 동작을 수행하기 위한 장치 및 방법이 제공된다. 특히, 장치는 벡터 처리 동작을 수행하기 위한 처리 회로 및 벡터 명령을 디코딩해서 벡터 명령에 의해서 특정된 벡터 처리 동작을 수행하기 위해서 처리 회로를 제어하기 위한 명령 디코더를 갖는다. 명령 디코더는, 복수의 엘리먼트를 포함하는 벡터를 생성하기 위해서 처리 회로를 제어하도록 스칼라 시작 값 및 랩핑 제어 정보를 식별하는 벡터 생성 명령에 응답한다. 특히, 처리 회로는 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하도록 배열되고, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 감소하는 시퀀스를 따른다. 벡터 생성 명령은, 다양한 상황에서 유용하게 될 수 있고, 특정 사용 케이스는 메모리 내에 순환 어드레싱 모드를 구현하는 것이고, 여기서 벡터 생성 명령은, 관련된 벡터 메모리 액세스 명령과 결합될 수 있다. 이러한 접근은, 이러한 순환 어드레싱을 지원하기 위해서 메모리 액세스 경로 내에 추가적인 로직을 제공할 필요를 제거할 수 있다.

Description

벡터 생성 명령

본 발명 기술은 데이터 처리의 분야에 관한 것이다. 특히, 본 발명은 벡터 명령의 처리에 관한 것이다.

일부 데이터 처리 시스템은, 명령의 소스 오퍼랜드 또는 결과 값이 다수의 엘리먼트를 포함하는 벡터인 벡터 명령의 처리를 지원한다. 단일 명령에 대한 응답으로 다수의 별개의 엘리먼트의 처리를 지원함으로써, 코드 밀도가 향상되고 명령의 페칭(fetching) 및 디코딩의 오버헤드가 감소될 수 있다. 처리되는 데이터 값의 어레이는, 데이터 값을 벡터 오퍼랜드의 각각의 엘리먼트 내에 로딩하고 단일 벡터 명령을 사용해서 한 번에 데이터 값들을 다수의 엘리먼트에서 처리함으로써, 더 효율적으로 처리될 수 있다.

본 발명은, 벡터 생성 명령을 제공하는 것을 목적으로 한다.

적어도 일부 예는, 벡터 처리 동작을 수행하기 위한 처리 회로, 및 벡터 명령에 의해서 특정된 벡터 처리 동작을 수행하기 위해서 처리 회로를 제어하는 벡터 명령을 디코딩하기 위한 명령 디코더를 포함하고, 상기 명령 디코더는, 스칼라 시작 값 및 랩핑 제어 정보를 식별하는 벡터 생성 명령에 응답해서, 상기 스칼라 시작 값 및 상기 랩핑 제어 정보에 기반하여, 복수의 엘리먼트를 포함하는 벡터를 생성하도록 처리 회로를 제어하고, 상기 처리 회로는, 상기 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하도록 배열되고, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 진행하는 시퀀스를 따르고, 상기 제1엘리먼트 이외의 상기 벡터의 각각의 엘리먼트에 대해, 상기 처리 회로는, 상기 랩핑 제어 정보에 기반해서, 랩핑 조건이 존재하는지를 결정하고, 상기 랩핑 조건이 존재하는지에 기반해서 해당 엘리먼트를 생성하도록 구성된다.

적어도 일부 예는, 벡터 처리 동작을 수행하기 위한 처리 회로를 갖는 장치를 동작시키는 방법 및, 벡터 명령을 디코딩해서 벡터 명령에 의해서 특정된 벡터 처리 동작을 수행하기 위해서 처리 회로를 제어하기 위한 명령 디코더를 제공하고, 방법은: 스칼라 시작 값 및 랩핑 제어 정보를 식별하는 벡터 생성 명령을 디코딩하는 단계와, 상기 디코딩에 응답해서, 상기 스칼라 시작 값 및 상기 랩핑 제어 정보에 기반하여, 복수의 엘리먼트를 포함하는 벡터를 생성하도록 처리 회로를 제어하는 단계로서, 상기 처리 회로는, 상기 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하고, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 진행하는 시퀀스를 따르는, 상기 제어하는 단계를 포함하고, 상기 제1엘리먼트 이외의 상기 벡터의 각각의 엘리먼트에 대해, 상기 처리 회로는, 상기 랩핑 제어 정보에 기반해서, 랩핑 조건이 존재하는지를 결정하고, 상기 랩핑 조건이 존재하는지에 기반해서 해당 엘리먼트를 생성하도록 구성된다.

적어도 일부 예는, 장치를 포함하며: 이 장치는, 벡터 처리 동작을 수행하기 위한 처리 수단, 및 벡터 명령에 의해서 특정된 벡터 처리 동작을 수행하도록 처리 수단을 제어하기 위해서 벡터 명령을 디코딩하기 위한 명령 디코더 수단을 포함하고, 상기 명령 디코더 수단은, 스칼라 시작 값 및 랩핑 제어 정보를 식별하는 벡터 생성 명령에 응답해서, 상기 스칼라 시작 값 및 상기 랩핑 제어 정보에 기반하여, 복수의 엘리먼트를 포함하는 벡터를 생성하도록 처리 수단을 제어하기 위한 것이고, 상기 처리 수단은, 상기 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하기 위한 것이고, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 진행하는 시퀀스를 따르고, 상기 제1엘리먼트 이외의 상기 벡터의 각각의 엘리먼트에 대해, 상기 처리 수단은, 상기 랩핑 제어 정보에 기반해서, 랩핑 조건이 존재하는지를 결정하고, 상기 랩핑 조건이 존재하는지에 기반해서 해당 엘리먼트를 생성하도록 구성된다.

적어도 일부 실시예는, 상기한 장치에 대응하는 명령 실행 환경을 제공하기 위해서 호스트 데이터 처리 장치를 제어하는 프로그램 명령을 포함하는 가상 머신 컴퓨터 프로그램을 제공한다.

또한, 가상 머신 컴퓨터 프로그램을 저장하는 컴퓨터 판독 가능한 저장 매체가 제공될 수 있다. 이 저장 매체는, 비일시적인 저장 매체일 수도 있다.

본 발명 기술은 첨부된 도면에 나타낸 실시예를 참조해서 예로서만 기술될 것이다.

도 1은 일실시예에 따른 장치의 블록도이다.
도 2는 일실시예에 따른 벡터 생성 명령 내에 제공된 필드를 개략적으로 도시한다.
도 3은 일실시예에 따른 벡터 생성 명령의 특정 예들에 대해서 생성될 수 있는 엘리먼트의 벡터를 개략적으로 도시한다.
도 4는 일실시예에 따른 벡터 생성 명령을 실행할 때 수행되는 처리를 도시하는 흐름도이다.
도 5는, 일실시예에 따라서, 어떻게 벡터 생성 명령에 의해서 생성된 벡터가 메모리 어드레스 공간 내의 순환 버퍼를 식별하기 위한 벡터 액세스 명령에 대한 입력으로서 사용되는지를 개략적으로 도시한다.
도 6은 일실시예에 따른 도 1의 벡터 생성 회로의 구성을 더 상세히 도시하는 블록도이다.
도 7a 내지 도 7c는 일실시예에 따른 도 6의 가산기 회로 및 수정 회로의 구성을 개략적으로 도시한다.
도 8은 벡터 명령의 오버랩된 실행의 일례를 도시한다.
도 9는 다른 프로세서 구현들 사이에서 또는 명령의 실행의 다른 인스턴스들 사이의 구동 시간에서, 연속적인 벡터 명령들 사이의 오버랩의 양을 스케일링하는 3개의 예를 도시한다.
도 10은, 일실시예에 따라서, 어떻게 벡터 생성 명령의 랩핑 기능이 선택적으로 디스에이블될 수 있는지를 개략적으로 도시하는 흐름도이다.
도 11은 일실시예에 따른 스칼라 레지스터의 세트와 관련해서 사용될 수 있는 판독 액세스 회로의 구성을 개략적으로 도시한다.
도 12는 또 다른 실시예에 따른 장치의 블록도이다.
도 13a 및 도 13b는 기술된 실시예에 따른 도 12에 나타낸 플래그 정보 스토리지의 2개의 예의 구성을 도시한다.
도 14는, 일실시예에 따라서, 어떻게 벡터 메모리 액세스 동작을 실행할 때 플래그 정보가 사용될 수 있는지를 도시하는 흐름도이다.
도 15a 내지 도 15c는 기술된 실시예에서 사용될 수 있는 플래그 정보의 다른 예의 구성을 도시한다.
도 16a 및 16b는, 일실시예에 따라서, 플래그 정보가 무효화되게 할 수 있는 특정된 이벤트를 표시하는 흐름도이다.
도 17 내지 도 19는 기술된 실시예에 따른 플래그 정보를 파퓰레이트(populate)하기 위해서 사용될 수 있는 다른 메커니즘을 도시하는 흐름도이다.
도 20은 사용될 수 있는 가상 머신 구현을 나타낸다.

첨부된 도면을 참조해서 실시예를 논의하기 전에, 실시예의 다음의 설명이 제공된다.

현재 사용 가능한 대부분의 DSP(Digital Signal Processor)는, 순환(circular), 때때로, 모듈로(modulo)로 불리는, 메모리에 대한 어드레싱 모드의 일부 형태를 지원한다. 이러한 특징은 바운드-체크(bound-check)를 수행하는 알고리즘에 대한 필요를 제거함에 따라서, 유용하다.

일례의 사용 케이스는 FIR 필터이다. 이는, N개의 선행하는 결과의 가중된 합으로부터 새로운 결과를 생성하는 일반적인 DSP 동작이다. 선형 메모리 구성과 함께, 새로운 샘플 블록이 처리될 필요가 있을 때마다, 이전의 결과는 액세스될 필요가 있다. 이는, N 마지막 결과들을 선형 버퍼의 시작에 카피하고 거기서부터 처리함으로써, 수행될 수 있다. 그런데, 처리는 오래된 결과에서 간단히 시작할 수 있음에 따라서, 순환 메모리를 채용할 때, 이러한 카피 단계는 더 이상 필요하지 않고, 엔드에 도달할 때 버퍼의 시작으로 랩 백(wrap back)한다. 따라서, 순환 버퍼는 이러한 동작이 매우 더 효율적인 방식으로 수행될 수 있게 한다.

메모리에 대한 순환 어드레싱 모드를 지원하기 위한 하나의 공지된 접근은, 프로세서와 메모리 사이의 경로 내에 제공된 어드레스 생성 유닛(AGU) 내에 추가적인 로직을 제공하는 것이다. 그런데, 처리 효율이 벡터 오퍼랜드의 각각의 엘리먼트 내에 다수의 데이터 값을 로딩하고 한 번에 데이터 값들을 다수의 엘리먼트에서 처리함으로써, 증가될 수 있는 벡터 처리 시스템에 있어서, 메모리에 대한 액세스 경로는 상당한 타이밍 제약이 될 수 있고, 따라서, 동작의 순환 어드레싱 모드를 지원하기 위해서 그 경로 내에서 가외의 로직을 유지하는 것이 어렵게 될 수 있다. 그러므로, 벡터 처리 시스템 내의 메모리에 대한 순환 어드레싱을 지원하기 위한 개선된 메커니즘을 제공하는 것이 바람직하게 된다.

일실시예에 따르면, 벡터 처리 동작을 수행하기 위한 처리 회로, 및 벡터 명령에 의해서 특정된 벡터 처리 동작을 수행하기 위해서 처리 회로를 제어하도록 벡터 명령을 디코딩하기 위한 명령 디코더를 갖는 장치가 제공된다. 명령 디코더는, 스칼라 시작 값을 식별하는 벡터 생성 명령 및 복수의 엘리먼트를 포함하는 벡터를 생성하도록 처리 회로를 제어하는 제어 정보를 랩핑하는 벡터 생성 명령에 응답한다. 처리 회로는, 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하도록 배열되고, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정되는 것을 보장하도록 요구됨에 따라서 및 요구될 때, 랩핑하도록 제약되는 정기적으로 진행하는 시퀀스를 따른다.

이러한 벡터 생성 명령의 사용은, 이러한 순환 어드레싱을 지원하는 메모리 액세스 경로 내에 추가적인 로직을 제공할 필요없이, 순환 어드레싱을 메모리 내에 직접적으로 구현하기 위해서 후속하는 메모리 액세스 명령의 입력 오퍼랜드로서 사용될 수 있는 엘리먼트의 벡터를 생성하기 위한 매우 효율적인 메커니즘을 제공한다. 분리 명령의 사용을 통해서 순환 어드레싱 모드를 구현함으로써, 이는, 순환 어드레싱의 사용에서 및, 시스템 내에서 사용될 수 있는 순환 버퍼의 수 및 사이즈에서 상당한 유연성을 제공하다.

기술된 실시예의 벡터 생성 명령에 따르면, 벡터 오퍼랜드는 벡터 생성 명령에 대한 입력으로서 요구되지 않고, 대신에, 엘리먼트의 전체 출력 벡터는 스칼라 시작 값으로부터 생성되며, 스칼라 시작 값으로부터 생성된 정기적으로 진행하는 시퀀스가 시퀀스 내의 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 머무는 것을 보장하도록 랩핑되도록 요구되는지 및 요구될 때를 결정하기 위해서 사용되는 랩핑 제어 정보를 참조한다.

스칼라 시작 값이 특정될 수 있는 다수의 방법이 있지만, 일실시예에 있어서, 벡터 생성 명령은, 스칼라 시작 값을 제공하는 제1스칼라 레지스터를 특정한다. 이는, 스칼라 시작 값의 특정과 관련해서 많은 유연성을 제공하다. 더욱이, 명령에 대한 입력 벡터를 특정할 필요를 회피함으로써, 이는, 장치 내에서 벡터 레지스터의 사용에 대한 제약을 완화할 수 있고, 여기서, 이는, 흔히, 벡터 레지스터가 최적으로 사용될 필요가 있는 부족한 자원인 경우이다.

벡터 생성 명령이 벡터 생성 명령에 의해서 생성된 엘리먼트의 벡터를 소비하는 것이 의도되는 명령과 밀접하게 결합될 수 있으므로, 벡터 레지스터의 사용은 기술된 실시예의 벡터 생성 명령을 사용할 때 더 최적화될 수 있고, 그러므로 후속하는 명령이 소스 오퍼랜드로서 엘리먼트의 벡터를 소비할 때까지, 벡터 생성 명령에 의해서 생성된 엘리먼트의 벡터가 시간의 상대적으로 짧은 주기 동안만 유지될 필요가 있는 것을 보장한다.

랩핑 제어 정보가 벡터 생성 명령 내에서 식별될 수 있는 다수의 방법이 있다. 예를 들어, 이는, 하나 이상의 즉시 값(immediate value)을 사용해서 특정할 수 있지만, 일실시예에 있어서, 레지스터의 콘텐츠를 참조해서 특정된다. 랩핑 제어 정보는, 그 경우, 벡터 레지스터 내에서 특정될 수 있지만, 일실시예에 있어서, 또 다른 스칼라 레지스터의 콘텐츠에 의해서 특정된다.

랩핑 제어 정보는, 정기적으로 진행하는 시퀀스를 생성할 때 값이 유지될 필요가 있는 바운드를 결정하기 위해서 사용된다. 랩핑 제어 정보가 제1 및 제2바운드 모두가 결정되게 할 수 있는 충분한 정보를 제공할 수 있는 한편, 일실시예에 있어서, 처리 회로는 제1바운드를 결정하기 위해서 랩핑 제어 정보를 사용하는 한편, 제2바운드가 미리 결정된다. 예를 들어, 일실시예에 있어서, 제2바운드는 제로 값이 될 수 있다. 이러한 실시예에 있어서, 랩핑 제어 정보는, 제1바운드를 결정하기 위해서 사용되는 사이즈 표시를 제공할 수 있다. 사이즈 표시는 다양한 형태를 취할 수 있다. 예를 들어, 이는, 제1 및 제2바운드에 의해서 규정된 버퍼의 사이즈를 식별하기 위해서 사용될 수 있으므로, 처리 회로가, 각각의 값이 그 특정된 버퍼사이즈의 버퍼에 의해서 규정된 바운드 내에서 유지하는 것을 보장하기 위해서 정기적으로 진행하는 시퀀스가 랩핑할 필요가 있게 될 곳 또는 포인트를 결정할 수 있다. 대안적으로, 사이즈 표시는 랩핑 포인트 인디케이터를 식별하기 위해서 사용될 수 있으므로, (정기적으로 증가하는 시퀀스에 대해서) 그 값을 로직 제로 값으로 랩핑하게 하는 정기적으로 진행하는 시퀀스 내의 값을 더 직접적으로 식별하거나 또는 (정기적으로 감소하는 시퀀스에 대해서) 그 값이 제로와 동등할 때 랩핑되는 값을 식별한다.

일실시예에 있어서, 정기적으로 진행하는 시퀀스 내의 각각의 값들 사이의 차이는 미리 결정될 수 있다. 그런데, 대안적인 실시예에 있어서, 벡터 생성 명령은, 정기적으로 진행하는 시퀀스에서 인접한 엘리먼트의 값들 사이의 차이를 결정하기 위해서 사용되는 조정 양을 식별한다. 조정 양을 벡터 생성 명령 내에서 특정되게 할 수 있음으로써, 이는, 그러면, 순환 어드레싱을 구현하기 위해서 적합한 벡터의 생성에 관해서 상당히 향상된 유연성을 제공한다. 예를 들어, 조정 양은 메모리 내에서 액세스되는 데이터 값의 사이즈를 고려해서 변경될 수 있으므로, 엘리먼트의 벡터가 액세스되는 데이터 값의 어드레스를 결정하기 위해서 용이하게 사용될 수 있게 할 수 있다.

일실시예에 있어서, 벡터 생성 명령에 의해서 생성된 엘리먼트의 벡터는 액세스되는 메모리 어드레스를 직접적으로 특정하기 위해서 사용될 수 있다. 그런데, 일실시예에 있어서, 엘리먼트의 벡터는 액세스되는 실제 메모리 어드레스를 식별하기 위해서 그 다음 베이스 어드레스와 결합되는 오프셋을 대신 특정한다. 오프셋의 그 벡터를 다른 베이스 어드레스와 단지 결합함으로써, 동일한 벡터가 원칙적으로 메모리 내의 다수의 다른 순환 버퍼를 식별하기 위해서 사용될 수 있으므로, 오프셋의 벡터를 생성함으로써, 이는, 더 향상된 유연성을 제공한다. 순환 버퍼의 수에 대한 유일한 제한은, 이러한 벡터 오프셋을 저장하기 위해서 사용된 사용 가능한 벡터의 수이다. 더욱이, 원칙적으로 버퍼는, 희망하면, 이들이 오버랩하도록 배열될 수 있다.

레지스터로부터의 오프셋을 특정하기 위해서 엘리먼트의 벡터를 사용함으로써 및, 희망하는 바와 같이, 조정 양이 변경되게 허용함으로써, 상기된 접근은, 원칙적으로 소정의 사이즈(일실시예에 있어서, 사이즈는 조정 양의 배수가 되도록 제약된다)가 될 수 있는 순환 버퍼를 메모리 내에 및, 메모리 내의 소정의 위치에 규정하기 위해서 사용될 수 있다. 그러므로, 이는, 순환 버퍼의 사용에 있어서 많은 유연성을 제공하다.

희망하면, 벡터 생성 명령 상에 위치될 수 있는 다양한 제약이 있다. 예를 들어, 조정 양의 배수로 되게 랩핑 제어 정보로부터 결정된 버퍼사이즈를 제한함으로써, 이는, 벡터 생성 명령을 실행할 때 엘리먼트의 벡터를 생성하기 위해서 요구된 회로를 단순화할 수 있다. 일실시예에 있어서, 스칼라 시작 값은, 또한 조정 양의 배수가 되도록 제약될 수 있다. 이러한 제약을 사용함으로써, 이는, 벡터 생성 명령을 실행할 때 엘리먼트의 벡터를 생성하기 위해서 사용되는 회로를 상당히 단순화할 수 있다. 특히, 랩핑 포인트를 검출하기 위해서 요구된 구성 컴포넌트는 조건보다 크거나 또는 작은 것을 검출할 필요가 있는 회로보다 등화 체크 회로(equally checking circuitry)를 사용해서 구현될 수 있다.

더욱이, 희망하면, 버퍼사이즈는 벡터를 생성할 때 마주칠 수 있는 잠재적인 랩핑 포인트의 수를 제한하도록 제약될 수 있다. 예를 들어, 일실시예에 있어서, 버퍼사이즈는 조정 양을 벡터 내의 엘리먼트의 수에 승산함으로써 결정된 사이즈 값을 초과하도록 제약된다. 이러한 제약으로, 최대 하나의 랩만이 벡터 내에서 발생하게 되는 것이 보장될 수 있다.

일실시예에 있어서, 처리 회로는, 상기 벡터를 생성하기 위해서 벡터 생성 명령에 응답해서, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하도록 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 증가하는 시퀀스를 따르도록, 명령 디코더에 의해서 제어된다. 그런데, 대안적으로, 처리 회로는, 상기 벡터를 생성하기 위해서 벡터 생성 명령에 응답해서, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하도록 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 감소하는 시퀀스를 따르도록, 명령 디코더에 의해서 제어될 수 있다. 상부 바운드 또는 하부 바운드가 랩핑 제어 정보에 의해서 규정됨에 따라서 마주칠 때를 체크할 수 있는 회로를 제공함으로써, 그 엘리먼트가 포지티브하게(양으로) 증가하는 시퀀스 또는 네거티브하게(음으로) 증가하는 시퀀스를 따르는 벡터를 생성하는 것이 가능하므로, 이들 벡터는 어느 하나의 방향으로 "워크하는(walk)" 순환 버퍼를 식별하기 위해서 사용될 수 있다. 일실시예에 있어서, 벡터 생성 명령의 2개의 다른 변형이 규정될 수 있는데, 하나는 요구에 따라서 랩핑하도록 제약된 정기적으로 증가하는 시퀀스의 생성으로 귀결되고, 다른 하나는 요구에 따라서 랩핑하도록 제약되는 정기적으로 감소하는 시퀀스를 생성하기 위해서 사용된다.

기술된 실시예의 벡터 생성 명령은, 다양한 상황에서 유용하게 될 수 있다. 그런데, 상기한 바와 같이, 특정 사용 케이스는 메모리 내에 순환 어드레싱 모드를 구현하는 것이 될 수 있고, 여기서 벡터 생성 명령은 관련된 벡터 메모리 액세스 명령과 결합될 수 있다. 특히, 일실시예에 있어서, 명령 디코더는, 복수의 어드레스 엘리먼트를 포함하는 입력 어드레스 벡터 오퍼랜드에 의해서 결정된 어드레스들에서 복수의 데이터 값에, 메모리 내에서, 액세스하도록 처리 회로를 제어하기 위해서 벡터 메모리 액세스 명령에 응답할 수 있다. 이러한 구성에 있어서, 장치는, 상기 벡터 생성 명령 및 관련된 벡터 메모리 액세스 명령 모두를 포함하는 명령의 시퀀스를 실행하도록 배열될 수 있고, 관련된 벡터 메모리 액세스 명령은 벡터 생성 명령에 의해서 생성된 벡터를 상기 입력 어드레스 벡터 오퍼랜드로서 식별한다. 이러한 접근에 의해서, 이는, 복수의 데이터 값이 메모리 내의 순환 버퍼 내에서 액세스되는 것을 보장한다.

하나의 특정 실시예에 있어서, 관련된 벡터 메모리 액세스 명령은 순환 버퍼의 시작 어드레스를 제공하는 베이스 어드레스를 식별하고, 입력 어드레스 벡터 오퍼랜드는 액세스되는 각각의 어드레스를 식별하기 위해서 베이스 어드레스와 결합되는 어드레스 오프셋의 벡터를 복수의 어드레스 엘리먼트로서 특정한다. 상기된 바와 같이, 이러한 접근은, 순환 버퍼의 위치가 베이스 어드레스에 의해서 결정되므로, 메모리 내의 순환 버퍼의 위치에 관해서 상당한 유연성을 제공하고, 그 다음 벡터 생성 명령에 의해서 생성된 엘리먼트의 벡터가, 데이터 값이 베이스 어드레스를 참조해서 식별된 순환 버퍼 내에서 액세스되는 시퀀스를 식별하기 위해서 사용된다.

일실시예에 있어서, 벡터 명령의 실행은 "비이트들(beats)"로 언급되는 부분들로 분할될 수 있고, 각각의 비이트는 미리 결정된 사이즈의 벡터의 부분의 처리에 대응한다. 비이트는, 완전히 실행되거나 또는 전혀 실행되지 않은 및 부분적으로 실행될 수 없는, 벡터 명령의 기본 부분(atomic part)이다. 하나의 비이트로 처리되는 벡터의 부분의 사이즈는 아키텍처에 의해서 규정될 수 있고, 벡터의 임의의 부분이 될 수 있다.

이러한 일실시예에 있어서, 주어진 벡터 명령에 응답해서, 처리 회로는, 벡터 값의 섹션에 각각 대응하는 처리의 복수의 비이트를 수행하도록 구성되고, 처리 회로는, 상기 벡터 생성 명령 및 상기 관련된 벡터 메모리 액세스 명령의 오버랩된 실행을 지원하도록 구성되고, 관련된 벡터 메모리 액세스 명령의 비이트의 제1서브세트는 벡터 생성 명령의 비이트의 제2서브세트와 병렬로 수행된다. 벡터 생성 명령 및 관련된 벡터 메모리 액세스 명령의 오버랩된 실행을 할 수 있게 함으로써, 이는, 상당한 성능 향상을 제공할 수 있다.

벡터 생성 명령이, 엘리먼트의 벡터를 생성할 때, 랩핑 행동이 지원되도록 허용하는 한편, 일실시예에 있어서, 랩핑 행동은 선택적으로 디스에이블될 수 있다. 특히, 일실시예에 있어서, 명령 디코더는, 처리 회로에 의한 랩핑 제어 정보의 사용을 디스에이블하기 위해서, 벡터 생성 명령을 디코딩할 때 검출되는 특정된 조건에 응답해서, 처리 회로가 벡터를 생성하도록 배열되도록 하여, 상기 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 하고, 복수의 엘리먼트의 값은 임의의 랩핑 제약 없이 정기적으로 진행하는 시퀀스를 따른다. 그러므로, 특정된 조건과 마주침에 따라서, 벡터 생성 명령은, 정기적으로 증가하는 시퀀스 또는 정기적으로 감소하는 시퀀스던지, 그 엘리먼트가 정기적으로 진행하는 시퀀스를 따르는 벡터를 생성하기 위해서 사용될 수 있다. 이는, 벡터 생성 명령의 사용에서 추가적인 유연성을 제공하다.

특정된 조건은 다양한 형태를 취할 수 있지만, 일실시예에 있어서, 특정된 조건은 벡터 생성 명령 내의 랩핑 제어 정보를 식별하기 위해서 예약된 값이 사용될 때 검출된다. 그러므로, 이는, 랩핑 제어 정보가 무효인 것을 효과적으로 식별한다. 예약된 값은 다양한 형태를 취할 수 있다. 예를 들어, 일실시예에 있어서, 예약된 값은 허용되지 않은 즉시 값이 될 수 있지만, 다른 실시예에 있어서, 예약된 값은 랩핑 제어 정보에 대해서 식별되는 미리 결정된 레지스터의 형태를 취할 수 있고, 미리 결정된 레지스터는 랩핑 제어 정보를 제공하기 위해서 유효하게 사용될 수 없는 레지스터이다.

일실시예에 있어서, 스칼라 시작 값 및 랩핑 제어 정보 모두는, 장치에 의해서 제공되는 스칼라 레지스터의 세트 내의 스칼라 레지스터를 참조해서 벡터 생성 명령 내에서 식별된다. 하나의 특정 실시예에 있어서, 스칼라 시작 값 및 랩핑 제어 정보를 식별하기 위해서 사용되는 스칼라 레지스터의 선택은, 명령이 실행될 때 요구된 정보에 대한 액세스 시간을 감소하는 목적으로 제약된다. 예를 들어, 일실시예에 있어서, 스칼라 시작 값 및 랩핑 제어 정보를 각각 식별하기 위해서 사용되는 제1 및 제2스칼라 레지스터의 사양은, 제1스칼라 레지스터가, 제2스칼라 레지스터가 선택되는 상기 세트 내의 레지스터의 제2그룹과 오버랩하지 않는 스칼라 레지스터의 세트 내의 스칼라 레지스터의 제1그룹으로부터 선택되도록 제약된다. 이러한 방식으로 제1 및 제2스칼라 레지스터의 선택을 제약함으로써, 스칼라 레지스터의 세트에 액세스하기 위해서 사용되는 액세스 회로는, 제1 및 제2스칼라 레지스터 모두의 콘텐츠가 더 적은 판독 포트와 함께 동시에 액세스될 수 있게 하거나 또는 레지스터 파일이 2개의 독립적인 뱅크로 분할되도록 배열될 수 있어서, 하드웨어 및 잠재적으로 영역의 면에서 더 낮은 비용으로 레지스터 모두에 대한 액세스를 생성한다.

일실시예에 있어서, 처리 회로는, 복수의 엘리먼트 각각을 생성하기 위해서 단계의 시퀀스를 반복적으로 실행함으로써, 벡터 생성 명령에 의해서 요구된 벡터를 생성하도록 제어될 수 있다. 그런데, 대안적인 실시예에 있어서, 프로세서는, 다수의 엘리먼트가 병렬로 생성되도록 할 수 있게 하기 위해서 병렬화될 수 있고, 이에 의해서 성능을 향상한다. 특히, 일실시예에 있어서, 처리 회로는, 스칼라 시작 값으로부터 도출된 입력 값 및 정기적으로 진행하는 조정 값의 시퀀스를 사용해서 상기 벡터에 대한 복수의 후보 엘리먼트를 생성하는 가산기 회로와, 각각의 후보 엘리먼트로부터 상기 벡터 내의 포함을 위한 출력 엘리먼트를 생성하는 수정 회로를 포함한다. 각각의 후보 엘리먼트에 대해서, 수정 회로는, 랩핑 조건이 존재하는지를 결정하고, 상기 랩핑 조건의 존재시, 출력 엘리먼트를 생성하기 위해서 랩핑 제어 정보에 기반해서 후보 엘리먼트를 수정하고, 그렇지 않으면 출력 엘리먼트로서 수정되지 않은 후보 엘리먼트를 사용하도록 산술 동작을 수행한다.

이러한 접근에 의해서, 다수의 계산이 병렬로 수행될 수 있다. 실제로, 희망하면, 가산기 회로 및 수정 회로는, 벡터 내의 모든 엘리먼트가 병렬로 생성되게 할 수 있도록 배열될 수 있다. 대안적으로, 더 작은 사이즈의 가산기 회로 및 수정 회로가 사용될 수 있어서, 다수의 엘리먼트가 병렬로 결정되도록 허용하고, 가산기 회로 및 수정 회로를 통한 추가적인 반복이 벡터에 의해서 요구된 소정의 나머지 엘리먼트를 계산하기 위해서 수행된다.

하나의 특정 실시예에 있어서, 처리 회로는, 상기 벡터를 생성하기 위해서 벡터 생성 명령에 응답해서, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 감소하는 시퀀스를 따르도록, 명령 디코더에 의해서 제어되고, 가산기 회로는, 입력 값으로부터 조정 값 중 관련된 하나를 감산함으로써 각각의 후보 엘리먼트를 생성하는 분리의 가산기 블록을 포함한다. 각각의 가산기 블록으로부터의 캐리 아웃 신호는, 랩핑 조건이 관련된 후보 엘리먼트에 대해서 존재하는지를 결정하도록 사용된다. 그러므로, 이러한 실시예에 있어서, 랩핑 조건의 존재에 관한 결정이 각각의 가산기 블록으로부터의 캐리 아웃 신호로부터 직접적으로 추론될 수 있으므로, 수정 회로가 상당히 단순화될 수 있다. 이는, 랩핑 조건이 존재할 때를 검출하기 위해서 수정 회로 내에 포함되는 더 복잡한 비교 회로에 대한 요건을 회피시킨다.

일실시예에 있어서, 유사한 원칙이, 벡터 생성 명령의 실행이, 정기적으로 증가하는 시퀀스를 따르는 복수의 엘리먼트가, 요구에 따라서, 다시 랩핑되도록 제약된 벡터의 생성을 일으킬 때, 채용될 수 있다. 특히, 일실시예에 있어서, 입력 값은 랩핑 제어 정보로부터 도출된 상부 바운드 값을 스칼라 시작 값으로부터 감산함으로써, 스칼라 시작 값으로부터 도출된다. 가산기 회로는, 조정 값 중 관련된 하나를 입력 값에 가산함으로써 각각의 후보 엘리먼트를 생성하는 분리의 가산기 블록을 포함하고, 각각의 가산기 블록으로부터의 캐리 아웃 신호는 랩핑 조건이 관련된 후보 엘리먼트에 대해서 존재하는지를 결정하도록 사용된다.

그러므로, 이 실시예에 있어서, 입력 값은 스칼라 시작 값으로부터 상부 바운드 값의 초기 감산을 수행함으로써 수정된다. 그 초기 감산을 수행함으로써, 그 다음 가산기 회로가 조정 값 중 관련된 하나를 입력 값에 가산하기 위해서 사용될 때, 각각의 가산기 블록으로부터의 캐리 아웃 신호는 랩핑 조건이 존재하는지를 결정하기 위해서 다시 사용될 수 있다. 랩핑 조건의 존재시, 그 다음, 수정 회로는, 후보 엘리먼트를 수정할 것이다. 그러므로, 입력 값의 적합한 조정에 의해서, 정기적으로 증가하는 시퀀스를 생성할 때에도, 캐리 아웃 신호를 사용함으로써 할 수 있게 되는 수정 회로에 대한 단순화가 유지될 수 있다.

일실시예에 있어서, 수정 회로는, 랩핑 조건의 존재시, 출력 엘리먼트를 생성하기 위해서, 후보 엘리먼트에 대한 랩핑 제어 정보로부터 도출된 상부 바운드 값의 가산을, 상기 산술 연산으로서 수행하도록 배열된다. 그러므로, 처리 회로가 정기적으로 증가하는 시퀀스 또는 정기적으로 감소하는 시퀀스를 생성하는 모든 경우에 있어서, 수정 회로는, 캐리 아운 신호가 설정될 때, 랩핑 제어 정보로부터 도출된 상부 바운드 값을 관련된 후보 엘리먼트에 가산하도록 동일한 방식으로 배열될 수 있다.

특정 실시예가, 이제 도면을 참조해서 기술될 것이다.

도 1은 벡터 명령의 처리를 지원하기 위한 데이터 처리 장치(2)의 일례를 개략적으로 도시한다. 이는, 설명의 용이함을 위해서 간략화된 도면이고, 실제로 장치는 편의를 위해서 도 1에 나타내지 않은 많은 엘리먼트를 가질 수 있는 것으로 이해될 것이다. 장치(2)는 명령 디코더(6)에 의해서 디코딩된 명령에 응답해서, 데이터 처리를 수행하기 위한 처리 회로(4)를 포함한다. 프로그램 명령은 메모리 시스템(8)으로부터 페치되고, 명령 디코더에 의해서 디코딩되어, 아키텍처에 의해서 규정된 방식으로 명령을 처리하도록 처리 회로(4)를 제어하는 제어 신호를 생성한다. 예를 들어, 디코더(6)는, 처리 회로(4)가 산술 연산, 로드/저장 연산 또는 논리 연산과 같은 연산을 수행하기 위해서 적합한 하드웨어 유닛을 활성화하게 하는 제어 신호를 생성하기 위해서 디코딩된 명령의 연산코드(opcode) 및 명령의 소정의 추가적인 제어 필드를 해석할 수 있다. 장치는 스칼라 레지스터(10)의 세트 및 벡터 레지스터(12)의 세트를 갖는다. 또한, 처리 회로의 동작을 구성하기 위해서 사용되는 제어 정보를 저장하기 위한 다른 레지스터(미도시)를 가질 수 있다. 산술 또는 논리 명령에 응답해서, 처리 회로는, 전형적으로 레지스터(10,12)로부터 소스 오퍼랜드를 판독하고 명령의 결과를 레지스터(10,12)에 다시 기입한다. 로드/저장 명령에 응답해서, 데이터 값은 레지스터(10, 12)와 메모리 시스템(8) 사이에서 처리 회로(4) 내의 로드/저장 유닛(18)을 통해서 전송된다. 메모리 시스템(8)은 메인 메모리만 아니라 하나 이상의 레벨의 캐시를 포함할 수 있다.

스칼라 레지스터의 세트(10)는 단일 데이터 엘리먼트를 포함하는 스칼라 값을 저장하기 위한 다수의 스칼라 레지스터를 포함한다. 명령 디코더(6) 및 처리 회로(4)에 의해서 지원되는 일부 명령은 스칼라 레지스터에 다시 기입되는 스칼라 결과를 생성하기 위해서 스칼라 레지스터(10)로부터 판독된 스칼라 오퍼랜드를 처리하는 스칼라 명령이 될 수 있다.

벡터 레지스터(12)의 세트는, 다수의 엘리먼트를 포함하는 벡터 값을 저장하도록 각각 배열된 다수의 벡터 레지스터를 포함한다. 벡터 명령에 응답해서, 명령 디코더(6)는 벡터 레지스터(12) 중 하나로부터 판독된 벡터 오퍼랜드의 각각의 엘리먼트에 대한 다수의 레인의 벡터 처리를 수행하도록 처리 회로(4)를 제어해서, 스칼라 레지스터(10)에 기입되는 스칼라 결과를 생성하거나 또는 벡터 레지스터(12)에 기입되는 또 다른 벡터 결과를 생성할 수 있다. 일부 벡터 명령은, 하나 이상의 스칼라 오퍼랜드로부터 벡터 결과를 생성할 수 있거나 또는, 스칼라 레지스터 내의 스칼라 오퍼랜드에 대한 추가적인 스칼라 동작을 수행할 뿐 아니라 벡터 레지스터 파일(12)로부터 판독된 벡터 오퍼랜드에 대한 레인의 벡터 처리를 수행할 수 있다. 그러므로, 일부 명령은 믹스된 스칼라 벡터 명령이 될 수 있고, 이에 대해서 명령의 하나 이상의 소스 레지스터 및 목적지 레지스터 중 적어도 하나는 벡터 레지스터(12)이고, 하나 이상의 소스 레지스터 및 목적지 레지스터 중 다른 것은 스칼라 레지스터(10)이다.

또한, 벡터 명령은, 데이터 값이 벡터 레지스터(12)와 메모리 시스템(8) 내의 위치 사이에서 전송되도록 하는 벡터 로드/저장 명령을 포함할 수 있다. 로드/저장 명령은, 메모리 내의 위치가 인접한 범위의 어드레스에 대응하는 인접한 로드/저장 명령을 포함하거나 또는, 다수의 분산 어드레스를 특정하고, 각각의 이들 어드레스로부터의 데이터를 벡터 레지스터의 각각의 엘리먼트 내에 로딩하거나 또는 벡터 레지스터의 각각의 엘리먼트로부터의 데이터를 분산 어드레스로에 저장하기 위해서 처리 회로(4)를 제어하는 분산(scatter)/수집(gather) 타입 벡터 로드/저장 명령을 포함할 수 있다.

처리 회로(4)는 다른 데이터 엘리먼트 사이즈의 범위를 갖는 벡터의 처리를 지원할 수 있다. 예를 들어, 128비트 벡터 레지스터(12)는 16개의 8비트 데이터 엘리먼트, 8개의 16비트 데이터 엘리먼트, 4개의 32비트 데이터 엘리먼트 또는 2개의 64비트 데이터 엘리먼트로 분할될 수 있다. 제어 레지스터는 사용되는 현재 데이터 엘리먼트 사이즈를 특정하기 위해서 사용될 수 있거나, 또는 대안적으로, 이는, 실행되는 주어진 벡터 명령의 파라미터가 될 수 있다.

처리 회로(4)는 다른 클래스의 명령을 처리하기 위한 다수의 별개의 하드웨어 블록을 포함할 수 있다. 예를 들어, 메모리 시스템(8)과 상호 작용하는 로드/저장 명령은 전용의 로드/저장 유닛(18)에 의해서 처리될 수 있는 반면, 산술 또는 논리 명령은 산술 논리 유닛(ALU)에 의해서 처리될 수 있다. ALU 자체는 승산을 포함하는 동작을 수행하기 위한 승산 누적 유닛(multiply-accumulate unit, MAC) 및 다른 종류의 ALU 동작을 처리하기 위한 또 다른 유닛으로 더 분할될 수 있다. 부동 소수점 명령(floating-point instruction)을 핸들링하기 위해서 부동 소수점 유닛이 제공될 수도 있다. 소정의 벡터 처리를 포함하지 않는 순수한 스칼라 명령은, 벡터 명령과 비교해서 분리의 하드웨어 블록에 의해서 핸들링하거나 또는 동일한 하드웨어 블록을 재사용할 수 있다.

나머지 도면을 참조해서 더 상세히 설명되는 바와 같이, 일실시예에 따른 벡터 생성 회로(16)는, 장치(2)에 의해서 실행되는 명령의 시퀀스 내에 포함될 수 있는 벡터 생성 명령에 의해서 요구된 동작을 수행되도록 배열된 처리 회로(4) 내에 제공된다. 벡터 생성 회로(16)는 처리 회로(4) 내의 전용의 블록을 포함할 수 있거나 또는, ALU와 같은 다른 회로 블록 중 하나 내에 통합될 수 있다.

여기에 기술된 일부 실시예에 따라서, 스칼라 시작 값 및 랩핑 제어 정보를 식별하는 새로운 타입의 벡터 생성 명령이 규정될 수 있다. 이러한 명령이 명령 디코더(6)에 의해서 디코딩될 때, 제어 신호는 처리 회로(4)로 전송되어 벡터 생성 회로(16)가 복수의 엘리먼트를 포함하는 벡터를 생성하게 하고, 그 생성된 벡터는 그 다음 벡터 레지스터(12) 내에 저장된다. 벡터 생성 회로(16)는, 벡터 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하도록 배열되고, 그 다음, 복수의 엘리먼트의 값들은, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 감소하는 시퀀스를 따른다. 정기적으로 진행하는 시퀀스는 정기적으로 증가하는 시퀀스 또는 정기적으로 감소하는 시퀀스가 될 수 있고, 일실시예에 있어서, 벡터 생성 명령의 다른 변형이 증가 및 감소 시퀀스 모두에 대해서 특정된다.

이러한 엘리먼트의 생성된 벡터는 다양한 상황에서 유용하게 될 수 있다. 그런데, 이러한 벡터가 매우 유용한 하나의 특별한 사용 케이스는, 상기한 벡터 수집/분산 로드/저장 명령에 대한 입력 오퍼랜드이다. 특히, 일실시예에 있어서, 벡터 생성 명령에 의해서 생성된 벡터는 수집/분산 동작이 수행되도록 하는 이러한 벡터 로드/저장 명령에 대한 입력 오퍼랜드로서 제공된 오프셋의 벡터로서 사용될 수 있다. 또한, 이러한 명령은, 전형적으로, 베이스 어드레스를 특정하는 스칼라 입력을 수신하고, 그 다음 오프셋의 벡터는 그 베이스 어드레스를 참조해서 메모리 내에서 액세스되는 각각의 어드레스를 생성하기 위해서 사용된다. 이러한 벡터 로드 또는 저장 명령이 메모리 내의 임의의 어드레스 세트에 액세스하기 위해서 사용될 수 있는 한편, 상기한 벡터 생성 명령에 의해서 생성된 오프셋의 벡터를 사용할 때, 이는, 메모리 내에서 순환 버퍼 내에 상주하는 어드레스의 시퀀스가 식별될 수 있게 한다. 그러므로, 이 메커니즘은 메모리 액세스 경로 내에 추가적인 회로를 추가할 필요없이, 메모리 내에 순환 어드레싱 모드를 채용하기 위한 매우 효율적인 기술을 제공하므로, 이러한 추가적인 회로가 그 경로 내에 도입되는 잠재적인 성능 충격을 회피할 수 있다. 이는, 메모리 액세스 경로가 흔히 시스템 내의 크리티컬한 타이밍 경로인 벡터 처리 시스템에서 상당한 이점을 제공하다.

또한, 도 1에 나타낸 바와 같이, 비이트(beat) 제어 회로(20)는, 희망하면, 명령 디코더(6) 및 처리 회로(4)의 동작을 제어하기 위해서 제공될 수 있다. 특히, 일부 실시예에서, 벡터 명령의 실행은 "비이트(beats)"로서 언급되는 부분들로 분할될 수 있고, 각각의 비이트는 미리 결정된 사이즈의 벡터의 부분의 처리에 대응한다. 도 8 및 도 9를 참조해서 더 상세히 논의되는 바와 같이, 이는, 벡터 명령의 오버랩된 실행을 할 수 있게 하고, 이에 의해서 성능을 향상시킬 수 있다.

도 2는 상기된 타입의 벡터 생성 명령 내에 제공될 수 있는 필드를 개략적으로 도시하는 도면이다. 특히, 명령(50)은 명령의 연산코드를 특정하는 제1필드(52)를 포함할 수 있다. 이는, 명령이 벡터 생성 명령인 것을 식별하기 위해서 사용할 수 있고, 증가하는 또는 감소하는 변형과 같은 명령의 다른 변형을 식별하기 위해서 사용할 수도 있다. 하나의 특정 실시예에 있어서, 벡터 생성 명령의 증가하는 변형은 벡터 증분 및 랩핑 중복(VIWDUP) 명령으로 언급되지만, 감소하는 버전은 벡터 감소분 및 랩핑 중복(VDWDUP) 명령으로 언급된다. "중복(duplicate)" 참조는, 단지 벡터의 각각의 엘리먼트에 대해서 결정된 값이 스칼라 시드 값으로부터 도출되는 것을 식별하는 것을 의도하고, 각각의 엘리먼트에 대한 실제 값은, 이 경우, 이전의 엘리먼트 값의 증가된 또는 감소된 버전이고, 초기 엘리먼트 값은 스칼라 시드 값에서 도출된다.

일실시예에 있어서, 사이즈 정보 필드(53)가 벡터 내의 데이터 값의 사이즈를 식별하기 위해서 명령 내에 제공된다. 특히, 처리 회로가 다른 사이즈의 데이터 값이 벡터 내에서 처리되는 것을 허용하는 곳에서, 이러한 필드는 현재의 명령이 관련된 특정 데이터 값 사이즈를 식별하기 위해서 사용될 수 있다. 대안적인 실시예에 있어서, 데이터 값 사이즈가 미리 결정될 수 있으므로, 이러한 사이즈 정보는 요구되지 않을 수 있다.

목적지 벡터 레지스터 필드(54)는, 명령을 실행함으로써 생성된 엘리먼트의 벡터가 기입되는 벡터 레지스터(예를 들어, 도 2에서 레지스터 Qd로 언급)를 식별한다. 필드(55)는 스칼라 시작 값을 제공하고, 이는, 일실시예에 있어서, 스칼라 레지스터 중 하나(도 2의 예에서는 스칼라 레지스터 Rn으로 언급)를 참조해서 식별된다.

또한, 랩핑 제어 정보 필드(56)는 바운드, 즉 값의 정기적으로 증가하는 시퀀스 또는 정기적으로 감소하는 시퀀스가 랩핑하는 것이 필요할 수 있는 포인트를 식별하기 위해서 사용되는 랩핑 정보를 식별하기 위해서 제공된다. 하나의 특정 실시예에 있어서, 랩핑 제어 정보는, 제1바운드를 결정하기 위해서 사용되고, 제2바운드는 미리 결정된다. 특히, 일실시예에 있어서, 제2바운드는 제로 값인 것으로 가정된다. 이러한 실시예에 있어서, 랩핑 제어 정보는, 예를 들어, 여기에서 버퍼사이즈 또는 "BUFSIZE"로 언급되는 사이즈 정보를 제공할 수 있고, 제2바운드가 미리 결정된 것으로 제공되면, 이는 제1바운드의 값을 식별할 수 있게 한다. 랩핑 제어 정보는, 명령 내의 즉시 값으로서 특정할 수 있고, 또는 대신에 스칼라 레지스터(10) 중 하나 또는 벡터 레지스터(12) 중 하나인 레지스터를 참조해서 식별될 수 있다. 일실시예에 있어서, 랩핑 제어 정보는, 또 다른 스칼라 레지스터에 의해서 특정되고, 도 2의 예에서, 이는 스칼라 레지스터 Rm으로서 언급된다.

일실시예에 있어서, 벡터 처리에 종속되는 데이터 값은 미리 결정된 사이즈가 될 수 있지만, 다른 실시예에서는 데이터 값 사이즈가 변경될 수 있어서, 일부 명령을 실행할 때 데이터 값이 제1사이즈로 되는 것으로 가정되도록 하는 한편, 다른 명령을 실행할 때 이들이 다른 사이즈로 되는 것으로 가정된다. 다른 데이터 값 사이즈를 지원하는 실시예에 있어서, 벡터 생성 명령(50)은, 일실시예에 있어서 즉시 값으로서 특정될 수 있지만 대안적으로 레지스터의 콘텐츠에 의해서 특정될 수 있는 조정 양 필드(57)를 포함할 수 있다. 명령이 실행될 때, 조정 양은 각각의 엘리먼트가 정기적으로 진행하는 시퀀스 내에서 증가 또는 감소하는 양을 결정할 것이다. 상기된 바와 같이, 일실시예에 있어서, 벡터 생성 명령에 의해서 생성된 벡터는 후속하는 벡터 로드 또는 저장 명령에 대한 어드레스 오프셋의 벡터로서 사용될 것이므로, 조정 값은 그 후속하는 벡터 로드 또는 저장 명령에 의해서 액세스될 데이터 값의 사이즈를 고려해서 설정될 수 있다. 예를 들어, 일실시예에 있어서, 후속해서 액세스되는 데이터 값이 바이트 사이즈 데이터 값이면, 조정 양은 1로 설정될 것이고, 데이터 값이 16비트 엔티티이면, 2로 설정될 것이며, 데이터 값이 32비트 엔티티이면, 4로 설정될 것이다.

벡터 생성 명령을 실행할 때 엘리먼트의 벡터가 생성되는 방식은 도 3의 특정 예를 참조해서 더 상세히 설명된다. 이 예에 있어서, 벡터 생성 명령은, VIWDUP 명령, 즉 증가하는 변동인 것으로 가정된다. 도 3에 나타낸 바와 같이, 논리적 버퍼(70)는 제로 값을 갖는 것으로 가정된 제2바운드 및 버퍼사이즈(80)를 참조해서 식별된 제1바운드를 갖는 것으로 식별된다. 스칼라 시작 값(75)은 시작 값으로서 사용되는 그 논리 버퍼 내에서 특정 포인트를 식별한다. 도 3에 나타낸 예에 있어서, 버퍼사이즈는 16, 즉 16 바이트(byte)인 것으로 가정되고, 벡터 길이는 128비트인 것으로 가정된다. 이는 도 3에 나타낸 3개의 예 각각에 대한 동작의 랩핑 행동을 설명하기 위해서 도움이 되므로, 버퍼사이즈는 순수하게 설명을 위해서 상대적으로 작게 선택된다. 실제로, 버퍼사이즈는 상당히 크게 될 수 있으므로, 벡터의 소정의 특정 인스턴스를 생성할 때 발생하는 랩핑(wrapping)의 발생이 감소될 것이다.

예 1에 예시된 바와 같이, 조정 양은, 관련 데이터 값 사이즈가 8비트인 것을 표시하는, 1로 설정되는 것으로 가정되고, 스칼라 시작 값은 9로 설정되며, 이는, 예 1에 있어서, 8비트 사이즈의 데이터 값 각각에 대해서 하나인, 16개의 엔트리를 포함하는 것을 나타내는 벡터의 생성으로 귀결된다. 알 수 있는 바와 같이, 벡터 내의 엘리먼트는 정기적으로 증가하는 시퀀스를 따르지만, 값이 제1바운드 값으로 증가하게 되는 포인트에서 랩핑하고, 그 포인트에서 시퀀스는 제로로 복귀한 다음, 그 후 증가한다.

예 2는, 조정 양이, 관련된 데이터 값이 16비트 사이즈인 것을 식별하는, 2로 설정되는 상황을 나타낸다. 이는, 이 예에 있어서, 스칼라 시작 값은 10인 것으로 가정되고, 이는, 128비트 벡터 내의 16비트 사이즈 데이터 값 각각에 대해서 하나인, 8개의 엘리먼트를 갖는 도 3에 나타낸 벡터의 생성으로 귀결된다. 다시, 랩핑 포인트는, 값이 제1바운드 값으로 증가한 곳에서 발생하는 것으로 보이지만, 그 대신, 그 다음, 논리 제로 값으로 다시 랩핑된다.

예 3은, 조정 양이, 데이터 값 사이즈가 32비트인 것을 표시하는 4로 설정되는 예를 나타낸다. 이 예에 있어서, 초기 스칼라 시작 값은 8이고, 이는, 도 3에 나타낸 엘리먼트의 벡터 벡터의 생성으로 귀결되며, 여기에 128비트 벡터 내의 32비트 데이터 값 각각에 대해서 하나인, 벡터 내에 4개의 엘리먼트가 있게 된다. 다시, 랩핑이 적합한 포인트에서 발생하는 것을 알 수 있다.

이 타입의 벡터를 생성하기 위한 특정 명령의 사용은, 메모리 내의 순환 버퍼의 사양과 관련해서 많은 유연성을 제공하다. 원칙적으로, 이러한 순환 버퍼는 소정의 사이즈가 될 수 있고, 메모리 내의 소정의 위치에 있을 수 있으며, 실제로, 희망하면, 메모리 어드레스 공간 내에서 오버랩하는 다수의 버퍼가 규정될 수 있다.

일실시예에 있어서, 벡터 생성 동작을 구현하기 위해서 요구되는 회로를 단순화하기 위해서, 버퍼사이즈 및 스칼라 시작 값의 사양에 대해서 다수의 제약이 가해질 수 있다. 예를 들어, 일실시예에 있어서, 버퍼사이즈는 조정 양의 배수가 되도록 제약될 수 있다. 더욱이, 희망하면, 스칼라 시작 값은 조정 양의 배수가 되도록 제한될 수 있다. 이들 2개의 제약은, 도 3에 도시된 3개의 예에 대해서 가해지는 것을 수 있다. 이러한 제약을 사용함으로써, 랩핑 포인트를 검출하기 위해서 요구되는 회로는, 적어도 일부 실시예에 있어서, 조건보다 크거나 또는 작은 것을 검출하는 것이 필요한 회로보다 등화 체크 회로를 사용해서 구현될 수 있다.

VIWDUP 또는 VDWDUP 명령을 실행할 때 구현된 기능은, 다음과 같이 도시될 수 있다:

상기 기능은 도 4의 흐름도를 참조해서 더 상세히 논의된다. 단계 100에서, 랩 기능을 갖는 벡터 생성 명령이 실행되고, 그 후 단계 105에서 스칼라 레지스터 Rn이 판독되어 초기 오프셋, 즉 스칼라 시작 값이 획득된다. 더욱이, 단계 110에서, 스칼라 레지스터 Rm이 판독되어 버퍼사이즈 정보를 획득한다. 그 후, 단계 115에서, 변수 "e"는 0과 동일하게 설정되고, 그 다음 단계 120에서 결과의 벡터 레지스터 내의 e번째 엘리먼트는 현재 오프셋 값과 동일하게 설정된다. 그 다음, 수행된 후속하는 단계는 실행된 벡터 생성 명령이 증가하는 버전인지 감소하는 버전인지에 의존한다.

단계 125에서, 이것이 증가하는 버전인 것으로 결정되면, 단계 130에서 오프셋은 즉시 값, 즉 조정 양에 의해서 증가되고, 그 후 단계 135에서, 이제, 오프셋이 버퍼사이즈와 동일한지가 결정된다. 동일하면, 오프셋은 단계 145로 진행하기 전에 단계 140에서 제로로 리셋되고, 그렇지 않으면, 단계 145로 직접 진행한다. 단계 145에서, e의 값이 최대 값에 도달했는지가 결정되는데, 이는, (데이터 값 사이즈로부터 결정됨에 따라서) 미리 결정된 길이의 벡터 내의 데이터 값의 수에 의존한다. e가 아직 최대 값에 있지 않으면, 프로세스가 단계 120으로 복귀하기 전에, e는 단계 150에서 증가한다.

단계 125에서, 실행되는 명령이 감소하는 버전인 것으로 결정되면, 단계 155에서 현재 오프셋이 제로인지가 결정된다. 결정했으면, 오프셋은 단계 160에서, 버퍼사이즈로부터 즉시 값을 감산하는 것과 동일한 값으로 조정된다. 그런데, 단계 155에서 제로와 동일하게 되는 것으로 결정되지 않으면, 오프셋은 단계 165에서 그 즉시 값에 의해서 감소된다. 단계 160 또는 165에 이어서, 프로세스는 단계 145로 진행한다.

e가 그 최대 값에 도달한 것이 단계 145에서 결정되면, 벡터 내의 모든 엘리먼트가 생성될 것이고, 따라서 결과의 벡터 Qd는 희망하는 복수의 엘리먼트를 포함할 것이다. 그 다음, 프로세스는 단계 170으로 진행하고, 여기서, 일실시예에 있어서, 레지스터 Rn 내의 오프셋 값이 갱신된다. 단계 170은 옵션이지만, 벡터 생성 명령이, 예를 들어, 루프의 바디 내에서, 반복적으로 실행되면, 유용하게 될 수 있는데, 다음 반복에서 레지스터 Rn은, 그러면 그 다음 반복에 대한 적합한 시작 값을 이미 포함할 것이다.

도 4에 나타낸 접근에 대한 대안으로서, 일부 실시예에 있어서, 스칼라 레지스터 Rn은 각각의 반복 동안 갱신될 수 있다. 그러므로, 이 실시예에 있어서, 박스(170)는 단계 145로부터의 "노(no)" 경로 내에 상주하는 것으로 고려될 수 있다. e가 최대 값과 동일한 것으로 결정되는 최종 반복 후에, 프로세스는 "예스(yes)" 경로를 따를 것이고, 도 4에 나타낸 절차에 따라서, 레지스터 Rn의 콘텐츠를 다시 갱신할 것이다.

일실시예에 있어서, 소스 레지스터 Rm은 버퍼사이즈를 특정하지만, 다른 실시예에 있어서, 소스 레지스터 Rm은 버퍼의 사이즈로부터의 즉시 값의 감산과 동일한 값을 제공함으로써, 랩핑 포인트 값을 직접적으로 특정할 수 있다. 이러한 구성에 있어서, VIWDUP 명령에 대한 상기된 기능은 다음과 같다:

이 접근은 잠재적으로 하드웨어 요건을 감소시킬 수 있고, 오프셋의 증가와 병렬로 수행되도록 랩핑할지에 관한 결정을 할 수 있다.

VDWDUP 명령에 대한 대응하는 기능은 다음과 같다:

도 5는, 어떻게 상기된 방식으로 생성된 엘리먼트의 벡터가 벡터 메모리 액세스 명령에 대한 입력 오퍼랜드로서 사용될 수 있는지를 도시한다. 특히, 도 5의 예에 있어서, 벡터 메모리 액세스 명령은, 어드레스 오프셋 Qm의 벡터에 의해서 특정된 메모리 내의 위치들로부터 데이터 값의 수집을 수행하도록 배열된 벡터 로드 명령인 것으로 가정된다. 그 다음, 결과의 데이터 값은 결과의 벡터 Qd 내의 엘리먼트로서 저장된다. 스칼라 레지스터 Rn은 메모리 내의 베이스 어드레스를 포함하고, 액세스되는 개별 어드레스를 식별하기 위해서 오프셋의 벡터와 결합된다. 벡터 생성 명령과 마찬가지로, 벡터 액세스 명령은 처리되는 데이터 값의 사이즈를 식별하기 위해서 사이즈 필드를 포함할 수 있다.

이러한 벡터 로드 명령이 메모리 내의 임의의 어드레스로부터 데이터 값을 수집하기 위해서 사용될 수 있지만, 벡터 소스 레지스터 Qm이 VIWDUP 또는 VDWDUP 명령의 실행에 의해서 생성된 벡터로 설정될 때, 액세스된 어드레스는 실제로 메모리 내의 순환 버퍼에 대응하는 것으로 이해될 것이다. 따라서, 예를 들어, 초기 VIWDUP 명령에 의해서 생성된 엘리먼트의 벡터가 도 5의 엘리먼트(200)에 의해서 나타낸 바와 같은, 즉 벡터는 길이가 128비트이고 데이터 값이 32비트 데이터 값인 상기된 도 3의 예 3에서의 결과와 동일한 상황을 고려하면, 도 5에 나타낸 바와 같이, 순환 버퍼가 메모리 어드레스 공간 내에서 액세스될 것이고, 그 순환 버퍼의 시작 위치는 레지스터 Rn 내에 제공된 스칼라 값에 의존한다. 따라서, 스칼라 값이 제1값(205)을 가지면, 순환 버퍼는 엘리먼트(210)에 의해서 나타낸 형태를 취하고, 반면에 다른 예에서 스칼라 값이 값 215를 가지면, 순환 버퍼는 엘리먼트(220)에 의해서 나타낸다. 따라서, 이 접근은, 순환 버퍼가 메모리 어드레스 공간 내에서 규정되는 곳에 관해서 많은 유연성을 제공한다. 오프셋(200)의 벡터를 사용할 때, 데이터는 관련 순환 버퍼로부터 검색되고 결과의 벡터 레지스터 Qd 내에 저장되어 도 5에 나타낸 형태(225)를 취한다.

도 4를 참조해서 상기한 바와 같이, VIWDUP 또는 VDWDUP 명령을 실행할 때 수행되는 기능은 반복적인 시퀀스로서 구현될 수 있고, 여기서 벡터의 하나의 엘리먼트가 각각의 반복에서 생성되며, 일부 실시예에 있어서, 벡터 생성 회로는 다수의 엘리먼트가 병렬로 생성될 수 있게 하도록 배열될 수 있다.

도 6은 벡터 생성 회로의 하나의 이러한 구성을 도시하는 블록도이다. 이 예에 있어서, 가산기 회로(250)가 제공되고, 이는, 일실시예에 있어서, 복수의 분리의 가산기 블록을 포함할 수 있으며, 각각의 가산기 블록은 출력 벡터에 대한 후보 엘리먼트를 생성하도록 배열된다. 그 다음, 각각의 가산기 블록에 대응하는 분리의 수정 블록을 갖는 수정 회로(260)가 제공되고, 각각의 수정 블록은 랩핑 조건이 그 후보 엘리먼트의 값에 대해서 검출되는지에 의존해서 대응하는 가산기 블록에 의한 후보 엘리먼트 출력을 선택적으로 수정한다. 가산기 회로는, 스칼라 시작 값(250) 및 즉시 값의 다양한 배수를 수신한다. 수정 회로(260)는 랩핑 제어 정보를 수신한다.

일실시예에 있어서, 가산기 회로(250) 및 관련된 수정 회로(260) 모두는 벡터의 모든 엘리먼트에 대한 값을 병렬로 계산할 수 있도록 충분한 블록을 포함할 수 있다. 대안적으로, 적어도 일부 데이터 값 사이즈에 대해서, 가산기 회로 및 수정 회로는 모든 엘리먼트의 값을 병렬로 계산하기 위해서 충분한 블록을 갖지 않을 수 있지만, 모든 엘리먼트에 대한 값은 가산기 회로 및 수정 회로를 통과하는 2 이상의 패스의 결과로서 계산될 수 있다.

도 6에 나타낸 예에 있어서, 벡터는 M개의 엘리먼트를 갖고, 가산기 회로(250) 및 수정 회로(250)는 벡터 내의 모든 엘리먼트를 병렬로 생성할 수 있는 것으로 가정된다.

도 7a는 VIWDUP 명령, 즉 명령의 증가하는 버전을 처리할 때 사용되는 도 6의 벡터 생성 회로(16)의 일례의 형태를 도시한다. 이 경우의 가산기 회로는, 즉시 값의 관련된 배수 및 현재 오프셋, 즉 스칼라 시작 값이 각각 제공되는 가산기 블록(300, 302, 304, 306)의 시퀀스를 포함한다. (벡터 내의 모든 엘리먼트가 병렬로 생성되는 것으로 가정하면) 요구되는 가산기 블록의 수는 데이터 값 사이즈에 의존하는 것으로 이해될 것이다. 도 3을 참조해서 앞서 논의된 3개의 예에 대해서, 생성되는 벡터는 데이터 값 사이즈(및 128비트의 벡터 길이를 가정하면)에 의존해서, 4개의 엘리먼트, 8개의 엘리먼트 또는 16개의 엘리먼트를 가질 것이고, 그러므로 시퀀스 내의 최종 가산기(306)는 즉시 값의 3배, 즉시 값의 7배 또는 즉시 값의 15배에 대응하는 제2입력을 수신할 것을 알 수 있을 것이다.

일실시예에 있어서, 16개의 가산기 블록 및 16개의 수정 블록을 갖는 단일 벡터 생성 회로가 제공될 수 있고, 모든 블록이 요구되지 않는 예들에서, 소정의 블록은 턴 오프될 수 있다. 그러므로, 4개의 엘리먼트를 갖는 벡터를 생성할 때는 블록의 4분의 1만이 활성화되는 것이 필요하게 될 것이고, 8개의 엘리먼트를 갖는 벡터를 생성할 때는 블록의 2분의 1이 활성화되는 것이 필요하게 될 것이며, 16개의 엘리먼트를 갖는 벡터를 생성할 때는 모든 블록이 활성화될 것이다.

각각의 가산기 블록(300)은, 수정 회로(260) 내의 관련 비교 블록(310, 312, 314, 316)에 대한 하나의 입력으로 포워딩되는 후보 엘리먼트를 생성하기 위해서 현재 오프셋에 즉시 값의 특정된 배수를 가산한다. 각각의 비교 블록에 대한 다른 입력은, 본 예시적인 실시예에 있어서, 버퍼사이즈 값이다. 그 다음, 각각의 비교 블록은 관련된 가산기 블록으로부터의 출력이 버퍼사이즈보다 크거나 또는 동일한지를 결정한다. 더욱이, 이는, 관련된 가산기 블록으로부터 수신된 입력으로부터 버퍼사이즈를 감산하는 것과 동일한 값(도 7a에서 "a-b"로 표시)을 계산한다. 그 다음, 각각의 멀티플렉서 회로(320, 322, 324, 326)는 관련된 가산기 블록으로부터의 출력 및 관련된 수정 블록으로부터의 "a-b" 출력을 수신하고, 비교 블록에 의해서 수행된 비교의 출력에 의존해서 제어된다. 그러므로, 가산기의 출력이 버퍼사이즈보다 크거나 동일하지 않은 것으로 결정되면, 가산기로부터의 출력은 관련된 멀티플렉서로부터 출력되는 반면, 가산기로부터의 출력이 버퍼사이즈보다 크거나 동일하면, 수정 블록으로부터의 출력이 멀티플렉서로부터 출력되는데, 즉 관련된 가산기 블록에 의해서 출력된 값으로부터의 버퍼사이즈의 감산에 대응하는 출력이 출력된다.

일실시예에 있어서, VDWDUP 명령에 의해서 요구되는 동작을 수행하기 위해서 사용될 수 있는 회로의 일례를 도 7b에 나타낸다. 다시, 일련의 가산기 블록(330, 332, 334, 336)이 제공되고, 다시 이들은 하나의 입력으로서 현재 오프셋을 수신하고, 다른 입력으로서 즉시 값의 배수를 수신한다. 그런데, 이 예에 있어서, 수신된 배수는 즉시 값의 네거티브의(음의) 배수이고, 가산기가 현재 오프셋 값으로부터 즉시 값의 그 배수의 감산을 수행하게 한다. 가산기 블록으로부터의 출력은 수정 회로로 포워딩되고, 더욱이, 캐리 아웃 신호가 수정 회로로 전파된다. 이 예에 있어서, 수정 회로는 비교 블록을 포함할 필요는 없지만, 대신에 관련된 가산기 블록(330, 332, 334, 336)으로부터의 출력을 하나의 입력으로서 수신하고 버퍼사이즈 정보를 제2입력으로서 수신하는 또 다른 가산기 블록(340, 342, 344, 346)을 포함할 수 있다. 그 다음, 각각의 또 다른 가산기 블록은 가산기 블록으로부터의 출력에 버퍼사이즈 값을 가산하고, 그 값을 관련된 멀티플렉서(350, 352, 354, 356)에 제2입력으로서 제공하고, 각각의 멀티플렉서의 제1입력은 가산기 회로(250)의 가산기 블록(330, 332, 334, 336)으로부터의 출력이다. 소정의 가산기 블록(330, 332, 334, 336)으로부터의 출력이 네거티브의 값이면, 캐리 비트는 이를 표시할 것이고, 이에 따라서, 이는 멀티플렉스를 제어하기 위해서 사용될 수 있어서, 캐리 비트가 네거티브의 값을 표시하면, 멀티플렉서는 가산기 블록(330, 332, 334, 336)으로부터의 오리지널 출력 대신에 관련된 수정 회로 블록(340, 342, 344, 346)으로부터의 출력을 선택하도록 한다.

도 7a 및 도 7b의 상기 비교로부터 알 수 있는 바와 같이, VDWDUP 명령을 구현할 때 사용되는 회로는, 가산기로부터의 캐리 신호의 사용에 의해서, 상당히 단순화될 수 있고, 따라서 비교 회로에 대한 필요를 회피할 수 있다. 도 7c는 VIWDUP 명령을 구현할 때 사용될 수 있는 회로의 대안적인 구성을 도시하는데, 이는, 또한 캐리 신호가 비교 회로를 회피하기 위해서 사용될 수 있게 한다. 도 7c에 나타낸 바와 같이, 각각의 가산기 블록(360, 362, 364, 366)은 도 7a의 예시적인 회로 마다에서와 같이, 현재 오프셋 및 즉시 값의 배수를 수신하지만, 추가적으로 "-BufSize"의 제3입력을 수신한다. 결과적으로, 이는, 효과적으로 가산기가 시작에서 현재 오프셋으로부터 버퍼사이즈를 감산하게 하고, 결과적으로 가산기로부터의 출력 중 일부가 네거티브가 되게 하는 것이 가능한데, 이는, 캐리 비트 신호를 통해서 표시될 것이다. 컴포넌트(370, 372, 374, 376)는 도 7b의 컴포넌트(340, 342, 344, 346)에 대응한다. 네거티브인 소정의 출력에 대해서, 관련된 멀티플렉서(380, 382, 384, 386)는 가산기 블록(360, 362, 364, 366)으로부터의 오리지널 출력 대신에 컴포넌트(370, 372, 374, 376)로부터의 조정된 출력을 선택할 것이다.

그러므로, 도 7c의 회로를 채용할 때, VIWDUP 명령의 실행은, 벡터의 엘리먼트를 병렬로 및 비교 회로에 대한 요건 없이 생성하기 위해서, 매우 효율적으로 수행될 수 있다. 2개 대신에 3개의 수를 가산하는 것은, 전체 가산기의 열(row)을 사용함으로써, 가산기(360, 362, 364, 366) 내에 용이하게 수용되어, 3개의 입력을 2개의 가수(addend)로 "감소"시켜서 캐리-전파 가산기에 입력한다.

더욱이, 동일한 회로가, 단지 "-BufSize" 입력을 제로로 설정되게 및 가산되는 대신에 감산되도록 즉시 값의 배수에 대해서 배열되게, VDWDUP 동작을 수행하기 위해서 사용될 수 있는 것에 유의해야 한다.

디지털 신호 처리(DSP)와 같은 일부 애플리케이션에 있어서, 대략 동일한 수의 ALU 및 로드/저장 명령이 있을 수 있고, 그러므로 MAC과 같은 일부 대형 블록은 상당한 시간 동안 아이들 상태로 남게 될 수 있다. 실행 자원이 더 높은 성능을 얻기 위해서 벡터 레인의 수로 스케일됨에 따라서, 이 비효율은 벡터 아키텍처에서 악화될 수 있다. 더 작은 프로세서(예를 들어, 단일 발행, 인-오더 코어(single issue, in-order core)) 상에서, 스케일 아웃된 벡터 파이프라인의 영역 오버헤드는 금지될 수 있다. 사용 가능한 실행 자원을 보다 양호하게 사용하면서 영역 충격을 최소화하는 하나의 접근은, 도 8에 나타낸 바와 같이, 명령의 실행을 오버랩하는 것이다. 이 예에 있어서, 3개의 벡터 명령은 로드 명령 VLDR, 승산 명령 VMUL 및 시프트 명령 VSHR을 포함하고, 이들 모든 명령은 이들 사이에 데이터 종속성이 있더라도 동시에 실행할 수 있다. 이는, VMUL의 엘리먼트 1이 Ql의 엘리먼트 1에만 의존하고, Ql 레지스터의 전체 엘리먼트에 의존하지 않으므로, VMUL의 실행이 VLDR의 실행이 종료되기 전에 시작할 수 있기 때문이다. 오버랩하는 명령을 허용함으로써, 승산기와 같은 값 비싼 블록을 더 오래 활성화할 수 있다.

그러므로, 마이크로아키텍처 구현이 벡터 명령의 실행을 오버랩할 수 있게 하는 것이 바람직할 수 있다. 그런데, 고정된 양의 명령 오버랩이 있는 것으로 아키텍처가 가정하면, 마이크로아키텍처 구현이 아키텍처에 의해서 가정된 명령 오버랩의 양과 실제로 매칭하면, 높은 효율을 제공할 수 있지만, 이는, 다른 오버랩을 사용하거나 또는 전혀 오버랩하지 않는 다른 마이크로아키텍처로 스케일되면, 문제가 발생할 수 있다.

대신에, 아키텍처는, 도 9의 예들에 나타낸 바와 같이, 다른 오버랩의 범위를 지원할 수 있다. 벡터 명령의 실행은 "비이트(beat)"로서 언급되는 부분들로 분할되고, 각각의 비이트는 미리 결정된 사이즈의 벡터의 부분의 처리에 대응한다. 비이트는 완전히 실행되거나 또는 전혀 실행되지 않는 벡터 명령의 기본 부분이고, 부분적으로 실행될 수 없다. 하나의 비이트로 처리되는 벡터의 부분의 사이즈는 아키텍처에 의해서 규정되고, 벡터의 임의의 부분이 될 수 있다. 도 9의 예에 있어서, 비이트는 벡터 폭의 1/4에 대응하는 처리로서 규정되므로, 벡터 명령 당 4개의 비이트가 있다. 명확히, 이는, 단지 하나의 예이고, 다른 아키텍처는, 예를 들어 2 또는 8의 다른 수의 비이트를 사용할 수 있다. 하나의 비이트에 대응하는 벡터의 부분은 처리되는 벡터 내의 엘리먼트 사이즈와 동일한, 보다 크거나 또는 작은 사이즈가 될 수 있다. 그러므로, 엘리먼트 사이즈가 구현마다 또는 다른 명령들 사이의 구동 시간에서 변경되더라도, 비이트는 벡터 처리의 소정의 고정된 폭이다. 하나의 비이트에서 처리되는 벡터의 부분이 다수의 엘리먼트를 포함하면, 캐리 신호는, 각각의 엘리먼트가 독립적으로 처리되는 것을 보장하기 위해서 각각의 엘리먼트 사이의 바운더리에서 디스에이블될 수 있다. 하나의 비이트에서 처리된 벡터의 부분이 엘리먼트의 부분에만 대응하고 하드웨어가 병렬로 다수의 비이트를 계산하기에 불충분하면, 하나의 비이트의 처리 동안 생성된 캐리 출력은 캐리 입력으로서 처리 중인 다음의 비이트에 입력되므로, 2개의 비이트의 결과가 함께 엘리먼트를 형성한다.

도 9에 나타낸 바와 같이, 처리 회로(4)의 다른 마이크로아키텍처 구현은 추상적인 아키텍처 클럭의 하나의 "틱(tick)"에서 다른 수의 비이트를 실행할 수 있다. 여기서 "틱(tick)"은 아키텍처 상태 진전의 단위에 대응한다(예를 들어, 간단한 아키텍처 상에서, 각각의 틱은 다음 명령을 포인팅하기 위해서 프로그램 카운터를 갱신하는 것을 포함해서, 명령을 실행하는 것과 관련된 모든 아키텍처 상태를 갱신하는 인스턴스에 대응할 수 있다). 파이프라이닝(pipelining)과 같은 공지된 마이크로아키텍처 기술은, 단일 틱(tick)이 하드웨어 레벨에서 수행하도록 다수의 클럭 사이클을 요구할 수 있고, 하드웨어 레벨에서 단일 클럭 사이클이 다수의 명령의 다수의 부분을 처리할 수 있는 것을 의미할 수 있는 것을, 당업자는 이해할 것이다. 그런데, 이러한 마이크로아키텍처 기술은, 틱이 아키텍처 레벨에서 기본(atomic)임에 따라서, 소프트웨어에 보이지 않는다. 간결성을 위해서, 이러한 마이크로아키텍처는 본 개시의 또 다른 설명 동안 무시된다.

도 9의 하부 예에 나타낸 바와 같이, 일부 구현은 하나의 틱 내에서 병렬로 모든 비이트를 처리하기 위한 충분한 하드웨어 자원을 제공함으로써, 동일한 틱에서 벡터 명령의 모두 4개의 비이트를 스케줄링할 수 있다. 이는, 더 높은 성능 구현에 적합할 수 있다. 이 경우, 전체 명령을 하나의 틱에서 완료할 수 있으므로, 아키텍처 레벨에서 명령들 사이의 소정의 오버랩에 대한 필요는 없다.

한편, 더 영역 효율적인 구현은 틱 당 2개의 비이트만을 처리할 수 있는 더 좁은 처리 유닛을 제공할 수 있고, 도 9의 중간 예에 나타낸 바와 같이, 명령 실행은 제1명령의 제3 또는 제4비이트와 병렬로 수행되는 제2벡터 명령의 제1 및 제2비이트와 오버랩될 수 있는데, 여기서 이들 명령은 처리 회로 내에서 다른 실행 유닛 상에서 실행된다(예를 들어, 도 9에 있어서, 제1명령은 백터 생성 회로를 제공하는 유닛 내에서 실행된 벡터 증분 및 랩핑 명령이고, 제2명령은 로드/저장 유닛을 사용해서 실행된 로드 명령이다).

더욱 더 에너지/영역 효율적인 구현은 더 좁고 한 번에 단일 비이트만을 처리할 수 있는 하드웨어 유닛을 제공할 수 있고, 이 경우 하나의 비이트는 틱 당 처리될 수 있고, 명령 실행은, 도 9의 상단 예에 나타낸 바와 같이, 예를 들어 2개의 비이트에 의해서 오버랩 및 스태거(staggered)된다.

도 9에 나타낸 오버랩은 단지 일부 예인 것으로 이해될 것이고, 다른 구현도 가능하다. 예를 들어, 처리 회로(4)의 일부 구현 예들은 동일한 틱에서 병렬로 다수의 명령의 듀얼 발행을 지원할 수 있으므로, 명령의 더 큰 처리량이 있게 된다. 이 경우, 하나의 사이클에서 함께 시작하는 2 이상의 벡터 명령은 다음 사이클에서 시작하는 2 이상의 벡터 명령과 오버랩되는 일부 비이트를 가질 수 있다.

다른 성능 포인트로 스케일하기 위해서 구현에 걸쳐서 오버랩 양을 변화시킬뿐 아니라, 벡터 명령들 사이의 오버랩의 양도 프로그램 내에서 벡터 명령의 실행의 다른 인스턴스들 사이의 구동 시간에서 변경할 수 있다. 그러므로, 처리 회로(4) 및 명령 디코더(6)는, 주어진 명령이 이전의 명령에 대해서 실행되는 타이밍을 제어하기 위해서 사용되는 도 1에 나타낸 바와 같은 비이트 제어 회로(20)를 참조할 수 있다. 이는, 구현하기 더 어려운 또는 명령에 대해서 사용 가능한 자원에 의존하는 소정의 코너 케이스에서 명령을 오버랩하지 않기 위해서 선택하는 자유도를 마이크로아키텍처에 제공한다. 예를 들어, 동일한 자원을 요구하고 모든 사용 가능한 MAC 또는 ALU 자원이 이미 다른 명령에 의해서 사용되는 주어진 타입의 백 투 백(back to back) 명령(예를 들어, 승산 누적)이 있으면, 다음 명령을 실행하는 것을 시작하기 위해서 자유 자원이 충분하지 않을 수 있고, 그러므로 오버랩핑보다, 제2명령의 발행이, 제1명령이 완료될 때까지, 대기할 수 있다.

따라서, 도 9의 상기 설명으로부터, 어떻게 벡터 생성 명령 및 관련된 메모리 액세스 명령이 실행되는지에 관한 많은 유연성이 있지만, 이들은 밀접하게 결합되어 벡터 메모리 액세스 명령이 비교적 신속하게 벡터 생성 명령에 의해서 생성된 벡터를 소비하게 할 수 있다. 이는, 벡터 레지스터의 수가, 전형적으로 부족한 자원임에 따라서, 및 따라서 장기적인 주기 동안 벡터 레지스터 내에서 유지되는 벡터 생성 명령에 의해서 생성된 벡터를 요구하지 않음으로써, 유용하게 될 수 있고, 이는 벡터 레지스터 자원를 확보(free up)할 수 있게 한다. 벡터 생성 명령 자체의 형태는, 또한 벡터 오퍼랜드가 벡터 생성 명령에 대한 소스 오퍼랜드로서 요구되지 않고, 그 대신에 벡터 생성 명령이 즉시 값 또는 스칼라 레지스터로부터 자체의 입력을 취함에 따라서, 이 이득을 달성하는 것을 돕는다.

일부 실시예에 있어서, 벡터 생성 명령에 의해서 제공되는 랩핑 기능이 선택적으로 디스에이블되는 것이 가능하고, 이는 도 10의 흐름도를 참조해서 예로서 도시된다. 특히, 단계 400에서 벡터 생성 명령이 실행되고, 단계 405에서 스칼라 레지스터 Rm(즉, 랩핑 제어 정보를 특정하는 레지스터)이 예약된 값으로 설정되는지가 결정된다. 예를 들어, 하나 이상의 스칼라 레지스터가 이러한 랩핑 제어 정보에 대해서 특정하는 유효한 스칼라 레지스터가 아니고, 따라서, 레지스터 Rm을 이들 레지스터 중 하나에 설정함으로써, 이것이, 랩핑 기능이 디스에이블되는 것을 식별하는 것이 될 수 있다. 하나의 특정 예에 있어서, 이는, 프로그램 카운터 레지스터를 레지스터 Rm으로서 특정함으로써, 달성될 수 있다. 레지스터 Rm이 예약된 값을 특정하지 않으면, 단계 410에 의해서 표시한 바와 같이, 프로세스는, 통상적으로, 예를 들어 상기된 도 4의 프로세스를 구현하는 것을 계속한다. 그런데, 레지스터 Rm이 예약된 값이면, 랩핑은 단계 415에서 디스에이블되고, 벡터 생성 회로는 단계 420에서 오프셋 및 즉시(즉, 조정 양) 값을 사용하지만 소정의 랩핑 제약이 없는 값의 증가하는 또는 감소하는 시퀀스를 생성한다. 이는, VIWDUP 및 VDWDUP 명령(랩핑에 있어서, 디스에이블된 변형이 VIDUP 및 VDDUP 명령으로도 언급될 수 있는)의 사용에서 추가적인 유연성을 제공할 수 있다.

스칼라 레지스터 Rm 및 Rn의 사양을 제약함으로써, 또 다른 성능 및 효율 이득을 실현할 수 있다. 특히, 하나의 스칼라 레지스터가 다른 스칼라 레지스터가 선택되는 스칼라 레지스터의 그룹과 오버랩하지 않는 스칼라 레지스터의 제1그룹 내에 있도록 제약되면, 스칼라 레지스터 파일(10)의 판독 액세스 회로를 사용해서 동일한 시간에서 양쪽 레지스터의 콘텐츠에 액세스되는 것이 가능할 수 있고, 레지스터가 이러한 방식으로 제약되지 않았다면 더 적은 판독 포트가 요구되었을 것이고 또는 레지스터 파일은 2개의 독립적인 뱅크로 분리된다. 이는, 2개의 그룹이 짝수 및 홀수 레지스터인 도 11에 개략적으로 도시된다. 그러므로, 모든 짝수 레지스터 R0(455), R2(465) 등은 하나의 그룹 내에 있고, 모든 홀수 레지스터 R1(460), R3(470) 등은 또 다른 그룹 내에 있다. 랩핑 제어 정보가 다른 그룹 내의 레지스터에 의해서 특정되는 동안, 스칼라 시작 값이 이들 그룹 중 하나 내에서 레지스터에 의해서 특정되도록 제약되면, 도 11 내의 판독 액세스 회로(450)에 의해서 나타낸 바와 같이, 멀티플렉서(475 및 480)로부터의 출력을 사용해서, 단일 판독 포트를 통해서 홀수 레지스터 및 짝수 레지스터의 콘텐츠 모두에 액세스되는 것이 가능하다. 이는, 이들이 최종 멀티플렉서(485)에 입력되기 전에 이들 값을 탭핑오프(tapping off)함으로써 달성되고, 이 최종 멀티플렉서(485)는, 희망하면, 단일 레지스터 출력이 판독되도록 여전히 허용한다.

도 11에서 예가 짝수 레지스터의 그룹 및 홀수 레지스터의 그룹과 관련해서 도시되지만, 보다 일반적으로, 동일한 이득이, 스칼라 레지스터 세트의 비-오버랩핑 부분으로부터의 것이 되게 오프셋을 특정하는 레지스터 및 버퍼사이즈를 특정하는 레지스터를 제약함으로써, 달성될 수 있다.

다음은, 어떻게 논의된 제안된 명령이 순환 메모리의 사용을 효율적으로 허용하기 위해서 사용될 수 있는지를 도시하는 일례의 코드 시퀀스이다.

처음 3개의 이동 명령은 스칼라 레지스터 r8, r9 및 r10의 콘텐츠를 논리 제로 값으로 초기화하기 위해서 사용되고, WLSTP 명령은 루프를 설정해서 루프의 수를 링크 레지스터에 저장하다. 그 다음, VLDRW 명령은, 스칼라 레지스터("srcCoeff"로 표시) 내의 특정된 어드레스로부터의 데이터의 연속적인 로드를 수행하고, 그 결과의 데이터 값을 벡터 레지스터 qO 내에 저장하고, 그 다음, 명령은, 또한 스칼라 레지스터의 어드레스를 증분한다. 그 다음, VIWDUP 명령은 벡터 레지스터 q7 내에 저장된 오프셋의 벡터를 생성하기 위해서 상기한 바와 같이 동작한다. 데이터 값 사이즈가 32비트이므로, 즉시 값은 4이다. 그 다음, 후속하는 VLDRW 명령은 벡터 레지스터 q7의 콘텐츠를 사용하고, 소스 레지스터("srcSamplesCircular"로 언급)에서 특정된 베이스 어드레스를 사용해서, 메모리 내에서, 벡터 레지스터 q1 내에 저장되는 데이터 값에 액세스하다. 그 다음, 벡터 승산 누적 동작이 수행되고, 여기서 q0 내의 각각의 엘리먼트가 q1 내의 대응하는 엘리먼트와 승산된 다음, 레지스터 r8 및 r9 내에 유지된 스칼라 값 내에 누적된다. 이 프로세스는 요구된 수의 루프가 수행될 때까지 루프의 다수의 반복을 통해서 계속된다.

상기된 바와 같이, 수행될 수 있는 벡터 메모리 액세스 동작의 하나의 타입은, 복수의 어드레스 엘리먼트를 포함하는 어드레스 벡터 오퍼랜드로부터 결정된 어드레스에서 메모리 내의 복수의 데이터 값에 액세스한다. 어드레스 벡터 오퍼랜드는 액세스되는 개별 어드레스를 직접적으로 특정할 수 있지만, 흔히 어드레스 벡터 오퍼랜드는, 액세스되는 어드레스를 식별하기 위해서 베이스 어드레스와 결합되는, 오프셋의 벡터를 특정한다. 이러한 동작은, 데이터가 임의의 메모리 위치에서 액세스되도록 허용하며, 흔히 메모리 내의 어드레스로부터 벡터의 개별 엘리먼트 내로 데이터를 로딩할 때 수집 동작으로서 언급되거나 또는, 벡터로부터 식별된 어드레스 위치로 개별 엘리먼트를 저장할 때 분산 동작으로서 언급된다.

이러한 분산 또는 수집 동작에 포함된 어드레스는 임의적이 될 수 있는 사실에 기인해서, 이러한 동작의 처리는, 전형적으로, 일련의 다양한 액세스 요청을 요구하여, 일련의 독립적인 로드 또는 저장 연산이 수행되도록 한다. 액세스가 실제로 임의적인 경우에 있어서, 이는 합리적이고 필요하다. 그런데, 이는, 이러한 분산 또는 수집 타입 메모리 액세스 동작이 사용되지만 액세스되는 적어로 일부 어드레스가 실제로 연속적이고, 따라서 다수의 데이터 값이, 단일 액세스를 통해서, 메모리 내의 인접한 어드레스에 액세스될 수 있는, 증가하는 수의 경우가 있는 것으로 실현된다. 이것의 하나의 특정 예는, 어드레스가 랩핑 포인트가 도달하는 어드레스가 아닌 연속적이 될 것이므로, 상기된 벡터 증분 및 랩 또는 벡터 감소분 및 랩핑 명령을 사용해서 수집 또는 분산 동작을 수행될 때 사용되는 오프셋의 벡터를 생성할 때이다.

그런데, 벡터 처리 시스템에 있어서, 메모리에 대한 액세스 경로는, 흔히 크리티컬한 타이밍 경로이고, 따라서, 전형적으로, 벡터 메모리 액세스 동작이 처리되는 시간에서 어드레스를 분석하기 위해서 메모리 액세스 경로 내에 회로를 제공하는 것은 통상적으로 실용적이지 않다.

나머지 도면을 참조해서 설명되는 바와 같이, 소정의 실시예는 이 문제점을 완화시키기 위한 메커니즘을 제공할 수 있다. 도 12는 어드레스의 소정의 시퀀스가 인접하게 될 때를 식별하는 것을 목적으로 하는 컴포넌트를 통합하는 일례의 실시예를 개략적으로 도시하고, 그러므로, 이러한 상황에서 요구되는 액세스의 수를 감소시키는데 있어서 로드/저장 유닛을 돕는다. 도 12와 도 1을 비교로부터 알 수 있는 바와 같이, 도 12는 본질적으로 도 1의 장치(2)이지만 일부 추가적인 컴포넌트를 갖는 장치(2')를 도시한다. 특히, 처리 회로(4')는 도 1의 처리 회로(4) 내에 제공된 모든 컴포넌트를 포함하지만, 추가적으로 벡터 레지스터(12) 중 하나 내의 저장을 위해서 생성된 벡터가 특정된 인접 기준을 충족하는 복수의 엘리먼트를 포함하는 결정에 대한 플래그 정보를 설정하도록 배열될 수 있는 플래그 설정 회로(500)를 갖는다. 플래그 설정 회로에 의해서 생성된 플래그 정보는 다양한 위치 내에 저장될 수 있다. 예를 들어, 플래그 정보 스토리지(505)는 플래그 정보를 저장하기 위한 플래그 설정 회로와 관련되어 제공될 수 있다. 대안적으로, 플래그 정보 스토리지(510)는 필요한 플래그 정보를 캡처하기 위해서 각각의 벡터 레지스터와 관련해서 다수의 추가적인 비트를 제공함으로써, 벡터 레지스터 파일(12) 내에서 효과적으로 통합될 수 있다.

특정 벡터 레지스터에 대해서, 플래그 설정 회로(500)가 그 벡터 레지스터의 적어도 부분이 특정된 인접 기준을 만족하는 엘리먼트를 갖는 것을 식별하기 위해서 플래그 정보를 설정하면, 로드/저장 유닛이 그 레지스터를 참조해서 특정된 오프셋의 벡터를 사용해서 수집 또는 분산 동작을 후속해서 수행할 때, 어느 어드레스 엘리먼트가 인접한지를 결정하기 위해서 플래그 정보를 사용될 수 있고, 그러므로, 수집 또는 분산 동작을 수행하기 위해서 요구되는 메모리 시스템(8)에 대한 액세스의 수를 잠재적으로 감소시킬 수 있다. 설정되는 플래그 정보의 부재시, 그러면, 로드/저장 유닛은 표준 방식으로 수집 또는 분산 동작을 핸들링할 것이다. 이는, 비인접한 어드레스를 식별하는 것으로서 각각의 어드레스 엘리먼트를 처리하는 것을 로드/저장 유닛(18)에 요구하는 것을 포함할 수 있고, 그러므로 각각의 어드레스 엘리먼트에 대해서 분리의 액세스를 수행하는 것을 포함할 수 있다. 대안적으로, 일부 다른 컴포넌트는 액세스를 적어도 부분적으로 최적화하도록 찾는 메모리 액세스 경로 내에 제공될 수 있다. 이러한 추가적인 회로가 제공되는 한, 이는, 본 명세서에 설명된 플래그 정보 메커니즘에 추가해서 사용될 수 있다.

플래그 설정 회로(500)가 그 존재 또는 부재를 결정하기 위해서 찾는 특정된 인접 기준은 다양한 형태를 취할 수 있지만, 일실시예에 있어서, 정기적으로 진행하는 시퀀스를 따르는 값을 갖기 위해서 벡터 내의 엘리먼트의 적어도 서브세트를 요구한다. 그 다음, 플래그 정보는, 처리 회로가, 정기적으로 진행하는 시퀀스를 따르는 값을 갖는 벡터 내의 어느 엘리먼트를 결정할 수 있도록 설정된다.

도 13a는 일실시예에 따라서 플래그 정보 스토리지(505) 내에서 제공될 수 있는 엔트리를 도시한다. 이 예에 있어서는, 다수의 엔트리가 제공되고, 각각의 엔트리는 엔트리가 관련된 레지스터를 식별하는 레지스터 ID 필드(515) 및 하나 이상의 유효한 플래그를 포함하는 유효한 플래그 필드(517)를 갖는다. 일실시예에 있어서, 단일의 유효한 플래그는 전체 벡터와 관련해서 사용될 수 있고, 벡터 내의 모든 엘리먼트가 정기적으로 진행하는 시퀀스를 따르면, 설정될 것이다. 대안적으로, 다수의 유효한 플래그가 유효한 플래그 필드(517) 내에 제공될 수 있고, 각각의 플래그는 벡터의 다른 부분과 관련되고 관련된 부분이 정기적으로 진행하는 시퀀스를 따르는 엘리먼트를 포함하는지에 의존해서 설정된다. 희망하면, 추가적인 정보는, 또한 정기적으로 진행하는 시퀀스가 다수의 부분들 사이에서 연장되는지를 식별하기 위해서 캡처될 수 있다. 그러므로, 예를 들어, 벡터 내의 4개의 부분에 관한 4개의 유효한 플래그가 있고, 유효한 플래그가 부분 2 및 3 모두가 정기적으로 진행하는 시퀀스를 따르는 엘리먼트를 포함하는 것을 표시하면, 플래그 정보는, 희망하면, 부분 3 내의 정기적으로 진행하는 시퀀스가 부분 2 내의 정기적으로 진행하는 시퀀스의 인터럽트되지 않은 연속성인지를 추가적으로 캡처할 수 있다.

탐색되는 정기적으로 진행하는 시퀀스는 다양한 형태를 취할 수 있지만, 일실시예에서는, 연속적인 메모리 어드레스가, 이들 값이 메모리 액세스 동작을 위한 어드레스 엘리먼트로서 사용되면 정기적으로 진행하는 시퀀스를 따르는 값으로부터 발생하게 되도록 한다. 상기한 바와 같이, 단일 데이터 값 사이즈만이 지원되므로, 정기적으로 진행하는 시퀀스는 그 데이터 값 사이즈를 고려한 연속적인 어드레스를 식별하는 값과 관련될 것이다. 그런데, 다른 실시예에 있어서, 다수의 다른 데이터 값 사이즈가 지원될 수 있고, 그 경우 사이즈 필드(519)는, 플래그 정보가 관련되는 데이터 값의 사이즈를 식별하기 위해서 각각의 엔트리 내에 제공될 수 있다. 특히, 값들의 시퀀스가, 그 데이터 값이 하나의 사이즈일 때 인접한 어드레스를 나타내기 위해서 사용될 수 있지만, 데이터 값이 다른 사이즈를 가지면, 값들의 동일한 시퀀스가 인접한 어드레스를 나타낼 필요가 없게 될 것으로 이해될 것이다.

다른 예로서, 시스템이 다수의 데이터 값 사이즈를 지원하지만, 기술된 실시예의 플래그 설정 메커니즘은 특정 사이즈의 데이터 값에 대해서만 구현된다. 예를 들어, 처리되는 데이터 값이 바이트 사이즈의 데이터 값일 때 플래그 설정 기술을 구현하도록 결정될 수 있지만, 데이터 값이 소정의 더 큰 사이즈로 될 때 플래그 설정 기술을 구현하지 않도록 결정될 수 있다. 이러한 경우에 있어서, 사이즈 정보 필드(519)는 요구되지 않을 수 있다.

유사하게, 플래그 설정 기술의 사용은 하나 이상의 특정 벡터 레지스터에 제한되고, 플래그 정보 스토리지 내의 각각의 엔트리는 특정 레지스터와 직접적으로 관련될 수 있다. 그 경우, 레지스터 식별자 필드(515)를 제공할 필요가 없을 수도있다.

또 다른 대안적인 실시예에 있어서, 플래그 정보는 단일 레지스터에 대해만 유지될 수 있는데, 특히 마지막 사용된 벡터에 대한 플래그 정보를 제공하기 위해서 유지될 수 있다. 이러한 실시예에 있어서, 메모리 액세스 명령에 바로 선행하는 명령이 연속적인 오프셋을 나타낼 수 있는 엘리먼트의 벡터를 생성하는 방식으로 코드가 구성되면, 구현은, 간단히 동일한 벡터가 메모리 액세스 명령에 대한 오프셋 레지스터로서 사용되는 것을 체크한 다음, 이에 따라서 플래그 정보를 판독한다. 다시, 이는, 레지스터 식별자가 플래그 정보 내에서 캡처되도록 하는 소정의 특정 필요를 회피시킨다.

도 13b는 벡터 레지스터 파일(12)의 벡터 레지스터와 조합해서 제공되는 대안적인 플래그 정보 스토리지(510)의 일례의 구성을 도시한다. 각각의 벡터 레지스터(520)에 대해서, 대응하는 유효한 플래그 필드(522)가 제공되어, 그 레지스터와 관련된 하나 이상의 유효한 플래그를 저장할 수 있다. 또한, 요구되면, 사이즈 정보 필드(524)가 제공될 수 있다. 이러한 접근으로, 유효한 플래그 정보는 잠재적으로 벡터 레지스터 파일(12) 내의 각각의 벡터 레지스터에 대해서 동시에 유지될 수 있다.

도 14는, 어떻게 벡터 메모리 액세스 동작을 실행할 때 플래그 정보가 사용되는지를 나타내는 흐름도이다. 단계 550에서, 벡터 메모리 액세스 동작이 수행되는 것으로 결정된다. 특히, 일실시예에 있어서, 이 포인트에서 로드/저장 유닛(18)은 이것이 수행할 벡터 메모리 수집 또는 분산 동작을 갖는 것으로 결정한다. 메모리 내의 인접한 어드레스를 고유하게 식별하는 다른 타입의 벡터 로드 또는 저장 명령에 대해서, 플래그 정보에 대한 필요는 없고, 이들 액세스는 어드레스의 공지된 연속적인 본성의 장점을 취하는 표준 방식으로 핸들링될 수 있다. 그런데, 상기한 바와 같이, 분산 또는 수집 타입 동작에 대해서, 이들은 잠재적으로 메모리 내의 임의의 어드레스에 대해서 될 수 있지만, 어드레스 오프셋 정보를 제공하기 위해서 사용되는 벡터 레지스터와 관련된 플래그 정보의 존재는, 로드/저장 유닛이, 소정의 어드레스 엘리먼트가, 실재로, 인접한 어드레스와 관련되는지를 결정할 수 있게 하고, 그 정보를 요구된 액세스의 수를 잠재적으로 감소하기 위해서 사용할 수 있게 할 수 있다.

따라서, 단계 555에서, 플래그 정보가 어드레스 벡터 오퍼랜드를 제공하는 벡터 레지스터와 관련되는지가 결정되는데, 일실시예에 있어서, 이는 어드레스 오프셋의 벡터가 될 수 있고, 어드레스 오프셋은 그 다음 액세스하는 어드레스를 식별하기 위해서 베이스 어드레스와 결합된다. 플래그 정보가 그 벡터 레지스터와 관련되면, 단계 560에서, 플래그 정보는, 데이터 값에 액세스하기 위해서 요구된 메모리에 대한 액세스의 수를 결정할 때, 로드/저장 유닛(18)에 의해서 사용된다. 그런데, 그렇지 않으면, 프로세스는, 수집 또는 분산 동작이 데이터 값에 액세스하기 위해서 표준 방식으로 수행되는 단계 565로 진행한다.

도 15a 내지 도 15c는 벡터 수집 동작을 특정하는 벡터 로드 명령에 대한 입력으로서 제공된 오프셋 값에 대한 다양한 예를 도시한다. 이 예에 있어서, 벡터 로드 명령은 4개의 32비트 데이터 값을 128비트 목적지 레지스터 Qd에 로딩하는 것으로 가정하고, 오프셋 정보는 소스 벡터 레지스터 Qm 내에 제공되고, 베이스 어드레스는 스칼라 레지스터 Rn 내에 특정된다. 도 15a에 나타낸 예에 있어서, 오프셋의 벡터(570)는 4개의 32비트 데이터 값에 대한 인접한 어드레스를 생성하기 위해서 사용될 수 있는 값의 정기적으로 증가하는 시퀀스를 제공하는 것으로 가정된다. 또한, 이 예에 있어서, 플래그 정보(572)는, 정기적으로 진행하는 시퀀스가 전체 벡터 폭과 관련되는 것을 식별하도록 설정된 단일의 유효한 플래그를 갖는 것으로 가정한다. 또한, 사이즈 정보 필드는, 가정된 데이터 사이즈가 32비트인 것을 식별하도록 설정되고, 레지스터 ID 필드는 플래그 정보가 레지스터 Qm과 관련되는 것을 식별하도록 설정된다. 벡터 로드 명령이 32비트의 양으로 동작하므로, 그 다음, 플래그 정보가 참조될 때, 사이즈 정보가 매칭하고, 레지스터 ID가 소스 레지스터 Qm과 매칭하는 것으로 결정된다. 유효한 플래그가 설정되므로, 로드/저장 유닛은, 모든 어드레스 엘리먼트가 메모리 내의 인접한 어드레스가 베이스 어드레스와 결합할 때 식별되게 하는 정기적으로 진행하는 시퀀스를 따르는 것을 안다.

어떻게 로드/저장 유닛(18)이 정보를 사용하는지는, 사용 가능한 메모리 액세스 대역폭을 포함하는 다수의 팩터에 의존할 것이다. 예를 들어, 64비트 메모리 액세스 대역폭이 지원되면, 도 15a에 나타낸 정보에 기반해서, 로드/저장 유닛은 각각이 2개의 인접한 어드레스로 향하는 2개의 64비트 액세스를 수행할 수 있으므로, 2개의 데이터 값은 각각의 액세스에 의해서 검색될 수 있다. 대신에, 128비트 메모리 액세스 대역폭이 지원되면, 로드/저장 유닛(18)은 단일 액세스를 통해서 모두 4개의 데이터 값을 검색하기 위해서 4개의 인접한 어드레스로 향하는 하나의 128비트 액세스를 수행될 수 있다.

도 15b는, 플래그 정보가 유효한 플래그 필드 내에 2개의 유효한 플래그를 갖고, 따라서 플래그 정보가 엘리먼트(574)의 특정한 예시적인 벡터에 대한 형태(576)를 취하는 제2예를 도시한다. 그러므로, 이 예에 있어서, 적어도 64비트 메모리 액세스가 지원되면, 로드/저장 유닛은 제1의 2개의 데이터 값을 검색하기 위해서 단일 액세스를 발행할 수 있다. 그 다음, 분리의 액세스가, 전형적으로, 제3데이터 값 및 제4데이터 값을 획득하기 위해서 필요하게 될 것이다.

양쪽의 유효한 플래그가 설정되는 경우에 있어서, 요구된 진행하는 시퀀스를 따르는 엘리먼트를 포함하는 소스 벡터 레지스터 Qm의 하부 2분의 1 및 상부 2분의 1 모두에 기인해서, 옵션으로, 일부 추가적인 정보는 2개의 2분의 1 사이의 연속성이 있는지를 식별하기 위해서 캡처될 수 있다. 예를 들어, Qm이 엘리먼트 20, 16, 4, 0을 유지하면, 양쪽 유효한 플래그가 설정되지만 이 추가적인 정보는 설정되지 않는 반면, Qm이 값 12, 8, 4, 0을 유지하면 양쪽 유효한 플래그가 설정되고, 추가적으로, 이는 또 다른 플래그가 2개의 2분의 1 사이의 연속성을 식별하도록 설정된다. 이는, 소정의 상황에서 유용하게 될 수 있다. 예를 들어, 메모리 액세스 경로가 128비트의 대역폭을 가지면, 이 추가적인 정보는 2개의 64비트의 인접한 액세스가 발행될 필요가 있는지를, 또는 단일의 128비트의 인접한 액세스가 발행될 수 있는지를 결정하도록 사용될 수 있다.

도 15c는, 오프셋의 소스 벡터가 형태(580)를 취하고, 플래그 정보는 형태(582)를 취하는 또 다른 예를 도시한다. 이 예에 있어서, 플래그 정보 필드는 간단히 일련의 플래그를 포함하지 않지만, 대신에 인접한 어드레스를 나타내는 어느 엘리먼트를 식별하기 위해서 충분한 정보를 제공한다. 이 예에 있어서, 벡터 내의 처음 3개의 엘리먼트는 요구된 패턴을 갖고, 그 정보는 플래그 필드 내에서 캡처될 수 있다. 이것이 다양한 방식으로 캡처될 수 있는 것으로 이해될 것이다. 예를 들어, 인접하게 되는 엘리먼트의 수와 함께, 인접성의 시작 엘리먼트 및 엔드 엘리먼트가 식별될 수 있거나 또는, 인접한 시퀀스에 대한 시작 엘리먼트가 식별될 수 있다.

일실시예에 있어서, 플래그 설정 회로(500)는 하나 이상의 특정된 이벤트의 발생에 대한 플래그 정보를 무효화하도록 배열될 수 있다. 특히, 도 16a에 나타낸 바와 같은 일실시예에 있어서, 예외가 단계 600에서 발생하는 것으로 결정되면, 플래그 정보는 단계 605에서 무효화된다. 그러므로, 예외는 플래그 정보가 무효화되게 하는 특정된 이벤트 중 하나를 형성한다.

도 16b는 다른 예의 특정된 이벤트를 도시하는데, 이 경우, 특정된 이벤트는, 처리 회로가 이것과 관련된 플래그 정보를 갖는 벡터 레지스터에 기입할 때이다. 기입 동작이 발생한 것으로 제공되면, 플래그 정보는 더 이상 정확하다고 가정될 수 없고, 따라서 무효화된다. 단계 610에서, 현재 명령이 벡터 레지스터에 기입하는지가 결정되고, 그러면, 단계 615에서 유효한 플래그 정보가 그 벡터 레지스터에 대해서 저장되는지가 결정된다. 그러면, 그 벡터 레지스터에 대한 플래그 정보는 단계 620에서 무효화된다. 그 후, 단계 625에서 명령이 실행된다. 단계 610 또는 단계 615로부터 따르는 경로가 없으면, 프로세스는 단계 625로 직접적으로 진행해서 명령을 실행하고, 소정의 플래그 정보가 유지된다.

이러한 이벤트의 발생에 따라서 플래그 정보가 무효화되게 구성하는 것은, 플래그 정보가 아키텍처하게 보이지 않게 되고, 그러므로 예외 상황에서 세이브 및 복원될 필요가 없게 되는 것을 의미한다. 이는, 플래그 설정 메커니즘의 구현을 단순화한다.

플래그 설정 회로(500)를 트리거해서 엘리먼트의 벡터에 대한 플래그 정보를 생성하기 위해서 사용될 수 있는 다수의 메커니즘이 있다. 도 17은, 플래그 설정 회로가 상기된 VIWDUP 또는 VDWDUP 명령 중 하나의 실행에 따라서 트리거되는 하나의 예시적인 구성을 도시한다. 특히, 단계 650에서 이들 명령 중 하나가 실행되는 것으로 결정되면, 단계 655에서, 벡터 생성 회로(16)가 그 명령을 실행하는 한편, 이는 플래그 설정 회로(500)에 정보를 제공해서, 랩(wrap)이 생성된 벡터 내에서 발생하는지를 식별하고, 그러면, 벡터 내에서 그 랩이 발생한 곳을 식별한다.

단계 660에서, 그 다음, 플래그 설정 회로는, 그 정보를 분석하고, 이에 따라서 관련 레지스터에 대해서 플래그 정보를 설정한다. 특히, 랩이 발생하지 않으면, 그 VIWDUP 또는 VDWDUP 명령에 대해서 식별된 데이터 값 사이즈에 대해서, 엘리먼트의 벡터가, 그 벡터가 동일한 데이터 값 사이즈와 관련되는 후속하는 수집 또는 분산 동작에 대한 입력으로서 사용되는지를 인접한 어드레스에 나타낼 것이고, 이에 따라서 유효한 플래그 또는 유효한 플래그들이 설정되는 것이, 공지된다. 유사하게, 랩핑 포인트가 있으면, 벡터 내의 어느 엘리먼트가 인접한 어드레스를 나타내는지가 여전히 결정될 수 있고, 이에 따라서 플래그 정보가 설정될 수 있다. 이러한 경우에 있어서, 이는, 플래그 정보의 본성 및 세분성에 의존하게 될 것인데, 이들은, 소정의 유효한 플래그가 인접한 어드레스와 관련되는 엘리먼트를 포함하는 벡터의 적어도 부분을 식별하도록 설정될 수 있는지에 관해서, 생성된다.

도 18은 도 17의 접근 대신에 또는 도 17의 접근을 사용하는 것에 추가해서 플래그 설정 회로(500)를 인보트(invoke)하기 위해서 사용될 수 있는 다른 메커니즘을 도시한다. 단계 665에서, 새로운 명령이 디코딩되는지가 결정되고, 그러면 디코딩 회로는, 단계 670에서, 그 명령의 실행이 그 엘리먼트가 정기적으로 진행하는 시퀀스를 따르는 값을 갖는 벡터를 생성할 것인지를 결정한다. 예를 들어, 이들이 실행될 때, 특정 데이터 값 사이즈에 대해서 인접한 어드레스에 대한 어드레스 오프셋을 나타내기 위해서 사용될 수 있는, 정기적으로 진행하는 시퀀스를 생성할 것으로 공지된 소정의 명령이 있을 수 있다. 이러한 결정이 단계 670에서 이루어지면, 단계 675에서, 명령 디코더는, 제어 신호를 플래그 설정 회로에 전송해서, 플래그 설정 회로가, 그 명령이 처리 회로(4') 내에서 후속해서 실행될 때, 관련 벡터 레지스터에 대한 플래그 정보를 설정하게 한다. 더욱이, 단계 680에서, 제어 신호는, 처리 회로가, 프로세스가 단계 665로 복귀하기 전에, 명령에 의해서 요구되는 동작을 수행하게 하도록 생성된다. 단계 670에서, 명령의 실행이, 그 엘리먼트가 정기적으로 진행하는 시퀀스를 따르는 값을 갖는 벡터를 생성하는 것을 보장하지 않게 될 것으로 결정되면, 프로세스는 단계 675를 바이패싱해서 단계 680으로 직접적 진행한다.

도 19는 도 17 및 도 18에서 논의된 메커니즘 대신에, 또는 이에 추가해서 플래그 설정 회로를 인보크하기 위해서 사용될 수 있는 또 다른 메커니즘을 도시한다. 이 예에 있어서, 단계 685에서, 벡터가 메모리로부터 로딩되었는지를 결정한다. 벡터가 메모리로부터 벡터 레지스터 중 하나로 로딩된 것으로 결정될 때, 플래그 설정 회로 내의 비교 회로가, 단계 690에서, 벡터의 엘리먼트를 분석해서, 엘리먼트의 적어도 서브세트가 정기적으로 진행하는 시퀀스를 따르는 값을 갖는지를 식별한다(이는, 다양한 가능한 다른 데이터 값 사이즈에 대해서 분석될 수 있다). 그 다음, 플래그 정보는, 이에 따라서, 플래그 설정 회로에 의해서 수행된 분석의 결과로서 설정될 수 있다. 도 19에서 식별된 비교 동작은 메모리에 대한 크리티컬한 액세스 경로 상에 있지 않은 회로에 의해서 및, 처리 회로의 성능에 충격을 주지 않을 시스템 동작에서의 편리한 포인트에서 수행될 수 있는 것으로 이해될 것이다. 플래그 정보가 생성될 때, 그 벡터가 수집 또는 분산 동작에 대한 어드레스 오프셋의 입력 벡터로서 후속해서 사용되면, 플래그 정보는 수집 또는 분산 동작을 처리하기 위해서 요구되는 메모리에 대한 액세스의 수를 잠재적으로 감소하기 위해서 참조될 수 있다.

다음 코드 시퀀스는, 어떻게 플래그 설정 메커니즘이 성능을 개선할 수 있는지의 일례를 도시한다:

VIWDUP 명령의 실행은, 이것이 랩핑하는 드문 경우에만, 단조롭게(monotonically) 증가하는 벡터 값을 생성한다. 하나의 예시적인 구현에 있어서, 플래그 설정 회로는, 그 워드 내의 모든 엘리먼트를 단조롭게 증가하는 것을 명시하는, 워더 당 플래그(예를 들어, 32비트)를 설정할 수 있다. 그 다음, 벡터 로드 명령이 후속해서 실행될 때, 이들 플래그가 판독될 수 있고, 정상적으로 수집 로드를 처리하는 대신에, 이들 플래그가 연속적인 엘리먼트를 표시하는 어디에서나 발행될 수 있다.

도 20은 사용될 수 있는 가상 머신 구현을 도시한다. 상기된 실시예가 관련 기술을 지원하는 특정 처리 하드웨어를 동작하기 위한 장치 및 방법의 면에서 본 발명 기술을 구현하지만, 하드웨어 장치의 소위 가상 머신 구현을 제공하는 것도 가능하다. 이들 가상 머신 구현은 가상 머신 프로그램(730)을 지원하는 호스트 오퍼레이팅 시스템(740)을 구동하는 호스트 프로세서(750) 상에서 구동한다. 전형적으로, 큰 파워풀한 프로세서가, 합리적인 속도로 실행하는 가상 머신 구현을 제공하기 위해서 요구되지만, 이러한 접근은, 호환성 또는 재사용 이유를 위해서 다른 프로세서에 고유한 코드를 구동하려는 희망이 있을 때와 같은 소정의 환경에서 정당화될 수 있다. 가상 머신 프로그램(730)은, 가상 머신 프로그램(730)에 의해서 모델링되는 장치인 실제 하드웨어에 의해서 제공되는 하드웨어 인터페이스와 동일한 게스트 프로그램(720)에 가상 하드웨어 인터페이스를 제공한다. 따라서, 상기된 메모리 액세스를 제어하기 위해서 사용되는 것들을 포함하는, 프로그램 명령은, 가상 머신 하드웨어와의 그들의 상호 작용을 모델링하기 위해서 가상 머신 프로그램(730)을 사용해서 게스트 프로그램(720) 내에서부터 실행될 수 있다. 게스트 프로그램(720)은 베어 메탈(bare metal) 프로그램이 될 수 있거나 또는, 대안적으로, 이는, 어떻게 Host OS(740)가 가상 머신 애플리케이션(730)을 구동하는지와 유사한 방식으로 애플리케이션을 구동하는 게스트 오퍼레이팅 시스템이 될 수 있다. 또한, 다른 타입의 가상 머신이 있을 수 있고, 일부 타입에 있어서, 가상 머신은 호스트 OS(740)에 대한 필요 없이, 호스트 하드웨어(750) 상에서 직접 구동되는 것으로 이해할 수 있다.

본원에 있어서, 문맥 "... 하도록 구성되는"은 장치의 엘리먼트가 규정된 동작을 수행할 수 있는 구성(configuration)을 갖는 것을 의미하는 것으로 사용된다. 이 문맥에서 "구성(configuration)"은 하드웨어 또는 소프트웨어의 상호 연결의 구성 또는 방식을 의미하다. 예를 들어, 장치는 규정된 동작을 제공하는 전용의 하드웨어를 가질 수 있거나 또는 프로세서 또는 다른 처리 장치가 기능을 수행하도록 프로그램될 수 있다. "구성되는(configured)"은, 장치 엘리먼트가 규정된 동작을 제공하기 위해서 소정의 방식으로 변경될 필요가 있는 것을 의미하지 않는다.

본 발명의 예시적인 실시예들이 첨부된 도면을 참조해서 본원에 상세하게 설명되었지만, 본 발명은 이들 실시예에 정확히 한정되지 않으며, 다양한 변경, 추가 및 수정이, 첨부된 청구 범위에 의해서 규정된 바와 같은 본 발명의 범위 및 사상으로부터 벗어남이 없이 당업자에 의해서 이루어질 수 있는 것으로 이해된다. 예를 들어, 종속항의 특징의 다양한 조합이 본 발명의 범위를 벗어나지 않고 독립항의 특징으로 만들어질 수 있다.

2 - 장치,
4 - 처리 회로,
6 - 명령 디코더.

Claims (23)

1. 장치로서,
   벡터 처리 동작을 수행하기 위한 처리 회로와,
   벡터 명령에 의해서 특정된 벡터 처리 동작을 수행하기 위해서 처리 회로를 제어하는 벡터 명령을 디코딩하기 위한 명령 디코더를 포함하고,
   상기 명령 디코더는, 스칼라 시작 값 및 랩핑 제어 정보를 식별하는 벡터 생성 명령에 응답해서, 상기 스칼라 시작 값 및 상기 랩핑 제어 정보에 기반하여, 복수의 엘리먼트를 포함하는 벡터를 생성하도록 처리 회로를 제어하고, 상기 처리 회로는, 상기 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하도록 배열되고, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 진행하는 시퀀스를 따르고,
   상기 제1엘리먼트 이외의 상기 벡터의 각각의 엘리먼트에 대해, 상기 처리 회로는, 상기 랩핑 제어 정보에 기반해서, 랩핑 조건이 존재하는지를 결정하고, 상기 랩핑 조건이 존재하는지에 기반해서 해당 엘리먼트를 생성하도록 구성되는, 장치.
2. 제1항에 있어서,
   상기 벡터 생성 명령은, 상기 스칼라 시작 값을 제공하는 제1스칼라 레지스터를 특정하는, 장치.
3. 제1항 또는 제2항에 있어서,
   상기 랩핑 제어 정보는, 즉시 값 및 레지스터 중 하나를 참조해서 벡터 생성 명령 내에서 식별되는, 장치.
4. 제1항 또는 제2항에 있어서,
   상기 처리 회로는, 제1바운드를 결정하기 위해서 랩핑 제어 정보를 사용하도록 배열되고, 제2바운드는 미리 결정되는, 장치.
5. 제4항에 있어서,
   상기 랩핑 제어 정보는, 제1바운드를 결정하기 위해서 사용된 사이즈 표시를 제공하고, 제2바운드는 제로 값인, 장치.
6. 제1항 또는 제2항에 있어서,
   상기 벡터 생성 명령은, 정기적으로 진행하는 시퀀스 내의 인접한 엘리먼트의 값들 사이의 차이를 결정하기 위해서 사용된 조정 양을 식별하는, 장치.
7. 제6항에 있어서,
   상기 벡터 생성 명령은, 적어도 하나의 다음 조건을 충족하도록 제약되고, 다음 조건은,
   - 랩핑 제어 정보로부터 결정된 버퍼사이즈가 조정 양의 배수이고,
   - 스칼라 시작 값이 조정 양의 배수이며,
   - 버퍼사이즈가 조정 양을 벡터 내의 엘리먼트의 수에 승산함으로써 결정된 사이즈 값을 초과하는, 장치.
8. 제1항 또는 제2항에 있어서,
   상기 처리 회로는, 상기 벡터를 생성하기 위해서 벡터 생성 명령에 응답해서, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하도록 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 증가하는 시퀀스를 따르도록, 상기 명령 디코더에 의해서 제어되는, 장치.
9. 제1항 또는 제2항에 있어서,
   상기 처리 회로는, 상기 벡터를 생성하기 위해서 벡터 생성 명령에 응답해서, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하도록 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 감소하는 시퀀스를 따르도록, 상기 명령 디코더에 의해서 제어되는, 장치.
10. 제1항 또는 제2항에 있어서,
    상기 명령 디코더는, 복수의 어드레스 엘리먼트를 포함하는 입력 어드레스 벡터 오퍼랜드에 의해서 결정된 어드레스에서 복수의 데이터 값에, 메모리 내에서, 액세스하도록 처리 회로를 제어하기 위해서 벡터 메모리 액세스 명령에 응답하고,
    상기 장치는 상기 벡터 생성 명령 및 관련된 벡터 메모리 액세스 명령을 포함하는 명령의 시퀀스를 실행하도록 배열되고, 관련된 벡터 메모리 액세스 명령은 벡터 생성 명령에 의해서 생성된 벡터를 상기 입력 어드레스 벡터 오퍼랜드로서 식별해서, 복수의 데이터 값이 메모리 내의 순환 버퍼 내에서 액세스되도록 하는, 장치.
11. 제10항에 있어서,
    상기 관련된 벡터 메모리 액세스 명령은 순환 버퍼의 시작 어드레스를 제공하는 베이스 어드레스를 식별하고, 입력 어드레스 벡터 오퍼랜드는 액세스되는 각각의 어드레스를 식별하기 위해서 베이스 어드레스와 결합되는 어드레스 오프셋의 벡터를 복수의 어드레스 엘리먼트로서 특정하는, 장치.
12. 제10항에 있어서,
    주어진 벡터 명령에 응답해서, 상기 처리 회로는 벡터 값의 섹션에 각각 대응하는 처리의 복수의 비이트(beat)를 수행하도록 구성되고,
    상기 처리 회로는, 상기 벡터 생성 명령 및 상기 관련된 벡터 메모리 액세스 명령의 오버랩된 실행을 지원하도록 구성되고, 상기 관련된 벡터 메모리 액세스 명령의 비이트의 제1서브세트는 벡터 생성 명령의 비이트의 제2서브세트와 병렬로 수행되는, 장치.
13. 제1항 또는 제2항에 있어서,
    상기 명령 디코더는, 상기 처리 회로에 의한 랩핑 제어 정보의 사용을 디스에이블하기 위해서, 상기 벡터 생성 명령을 디코딩할 때 검출되는 특정된 조건에 응답해서, 상기 처리 회로가 벡터를 생성하도록 배열되도록 하여, 상기 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 하고, 상기 복수의 엘리먼트의 값은 임의의 랩핑 제약 없이 정기적으로 진행하는 시퀀스를 따르는, 장치.
14. 제13항에 있어서,
    상기 특정된 조건은 랩핑 제어 정보를 식별하기 위해서 사용되는 예약된 값을 포함하는, 장치.
15. 제1항 또는 제2항에 있어서,
    스칼라 레지스터의 세트를 더 포함하고,
    상기 벡터 생성 명령은, 상기 스칼라 시작 값을 제공하는 제1스칼라 레지스터 및 랩핑 제어 정보를 식별하는 제2스칼라 레지스터를 특정하고, 제1 및 제2스칼라 레지스터의 사양은, 제1스칼라 레지스터가 제2스칼라 레지스터가 선택되는 상기 세트 내의 레지스터의 제2그룹과 오버랩되지 않는 상기 세트 내의 스칼라 레지스터의 제1그룹으로부터 선택되도록 하는, 장치.
16. 제1항 또는 제2항에 있어서,
    상기 처리 회로는, 스칼라 시작 값으로부터 도출된 입력 값 및 정기적으로 진행하는 조정 값의 시퀀스를 사용해서 상기 벡터에 대한 복수의 후보 엘리먼트를 생성하는 가산기 회로와,
    각각의 후보 엘리먼트로부터, 상기 벡터 내의 포함을 위한 출력 엘리먼트를 생성하는 수정 회로를 포함하고, 각각의 후보 엘리먼트에 대해서, 상기 수정 회로는, 상기 랩핑 조건의 존재시, 출력 엘리먼트를 생성하기 위해서 상기 랩핑 제어 정보에 기반해서 후보 엘리먼트를 수정하고, 그렇지 않으면 상기 출력 엘리먼트로서 수정되지 않은 상기 후보 엘리먼트를 사용하기 위하여 산술 동작을 수행하도록 배열되는, 장치.
17. 제16항에 있어서,
    상기 처리 회로는, 상기 벡터를 생성하기 위해서 벡터 생성 명령에 응답해서, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 감소하는 시퀀스를 따르도록, 상기 명령 디코더에 의해서 제어되고,
    상기 가산기 회로는, 입력 값으로부터 조정 값 중 관련된 하나를 감산함으로써 각각의 후보 엘리먼트를 생성하는 분리의 가산기 블록을 포함하고, 각각의 가산기 블록으로부터의 캐리 아웃 신호는 랩핑 조건이 관련된 후보 엘리먼트에 대해서 존재하는지를 결정하도록 사용되는, 장치.
18. 제16항에 있어서,
    상기 처리 회로는, 상기 벡터를 생성하기 위해서 벡터 생성 명령에 응답해서, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 증가하는 시퀀스를 따르도록, 상기 명령 디코더에 의해서 제어되고,
    상기 입력 값은 랩핑 제어 정보로부터 도출된 상부 바운드 값을 스칼라 시작 값으로부터 감산함으로써 시작 어드레스로부터 도출되고,
    상기 가산기 회로는, 조정 값 중 관련된 하나를 입력 값에 가산함으로써 각각의 후보 엘리먼트를 생성하기 위한 분리의 가산기 블록을 포함하고, 각각의 가산기 블록으로부터의 캐리 아웃 신호는 랩핑 조건이 관련된 후보 엘리먼트에 대해서 존재하는지를 결정하도록 사용되는, 장치.
19. 제16항에 있어서,
    상기 수정 회로는, 상기 랩핑 조건의 존재시, 상기 산술 동작으로서, 출력 엘리먼트를 생성하기 위해서 후보 엘리먼트에 대한 랩핑 제어 정보로부터 도출된 상부 바운드 값의 가산을 수행하도록 배열되는, 장치.
20. 벡터 처리 동작을 수행하기 위한 처리 회로 및 벡터 명령에 의해서 특정된 벡터 처리 동작을 수행하기 위해서 처리 회로를 제어하는 벡터 명령을 디코딩하기 위한 명령 디코더를 갖는 장치를 동작하는 방법으로서,
    스칼라 시작 값 및 랩핑 제어 정보를 식별하는 벡터 생성 명령을 디코딩하는 단계와,
    상기 디코딩에 응답해서, 상기 스칼라 시작 값 및 상기 랩핑 제어 정보에 기반하여, 복수의 엘리먼트를 포함하는 벡터를 생성하도록 처리 회로를 제어하는 단계로서, 상기 처리 회로는, 상기 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하고, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 진행하는 시퀀스를 따르는, 상기 제어하는 단계를 포함하고,
    상기 제1엘리먼트 이외의 상기 벡터의 각각의 엘리먼트에 대해, 상기 처리 회로는, 상기 랩핑 제어 정보에 기반해서, 랩핑 조건이 존재하는지를 결정하고, 상기 랩핑 조건이 존재하는지에 기반해서 해당 엘리먼트를 생성하도록 구성되는, 방법.
21. 장치로서,
    벡터 처리 동작을 수행하기 위한 처리 수단과,
    벡터 명령에 의해서 특정된 벡터 처리 동작을 수행하기 위해서 처리 수단을 제어하는 벡터 명령을 디코딩하기 위한 명령 디코더 수단을 포함하고,
    상기 명령 디코더 수단은, 스칼라 시작 값 및 랩핑 제어 정보를 식별하는 벡터 생성 명령에 응답해서, 상기 스칼라 시작 값 및 상기 랩핑 제어 정보에 기반하여, 복수의 엘리먼트를 포함하는 벡터를 생성하도록 처리 수단을 제어하기 위한 것이고, 상기 처리 수단은, 상기 복수 내의 제1엘리먼트가 스칼라 시작 값에 의존하도록 벡터를 생성하기 위한 것이고, 복수의 엘리먼트의 값이, 각각의 값이 랩핑 제어 정보로부터 결정된 바운드 내에 있는 것을 보장하기 위해서 요구됨에 따라서 랩핑하도록 제약되는 정기적으로 진행하는 시퀀스를 따르고,
    상기 제1엘리먼트 이외의 상기 벡터의 각각의 엘리먼트에 대해, 상기 처리 수단은, 상기 랩핑 제어 정보에 기반해서, 랩핑 조건이 존재하는지를 결정하고, 상기 랩핑 조건이 존재하는지에 기반해서 해당 엘리먼트를 생성하도록 구성되는, 장치.
22. 제1항 또는 제2항에 따른 장치에 대응하는 명령 실행 환경을 제공하기 위해서 호스트 데이터 처리 장치를 제어하는 프로그램 명령을 포함하는, 컴퓨터 판독 가능한 저장 매체에 저장된, 가상 머신 컴퓨터 프로그램.
23. 제22항에 따른 가상 머신 컴퓨터 프로그램을 저장하는, 컴퓨터 판독 가능한 저장 매체.

Images