KR101031158B1 - Ｓｉｍｄ 연산을 구현하는 데이터 프로세싱 시스템 및 그방법 - Google Patents

Abstract

메모리 구성요소(12)와 레지스터 파일(구성요소(34)) 내의 레지스터들 사이에 다중 벡터 요소를 전송하는 데 여러가지 로드 및 저장 명령어가 사용될 수 있다. 메모리로 또는 그로부터 전송될 요소의 총 개수를 나타내는 데 cnt 파라미터가 사용될 수 있으며, 레지스터 파일 내의 단일의 레지스터로 또는 그로부터 전송될 수 있는 벡터 요소의 최대 개수를 나타내는 데 rcnt 파라미터가 사용될 수 있다. 또한, 명령어들은 각종의 서로 다른 어드레싱 모드를 사용할 수 있다. 소스 및 목적지 크기가 명령어 내에서 서로 다를 수 있도록 레지스터 요소 크기와 독립적으로 메모리 요소 크기가 지정될 수 있다. 어떤 명령어의 경우, 벡터 스트림이 개시되고 조건부로 인큐 및 디큐될 수 있다. 소스 데이터 요소가 전송될 때 절단 또는 반올림될 수 있도록 절단 또는 반올림 필드가 제공될 수 있다. 또한, 소스 데이터 요소는 전송될 때 부호 또는 무부호 확장(signed- or unsigned-extended)될 수 있다.

데이터 프로세싱 시스템, 어드레싱 모드, 제로-확장, 부호-확장, 레지스터

Description

ＳＩＭＤ 연산을 구현하는 데이터 프로세싱 시스템 및 그 방법{DATA PROCESSING SYSTEM FOR IMPLEMENTING SIMD OPERATIONS AND METHOD THEREOF}

본 발명은 일반적으로 데이터 프로세싱 시스템에 관한 것으로서, 보다 구체적으로는 데이터 프로세싱 시스템 내에서 사용하기 위한 명령어에 관한 것이다.

벡터의 다중 요소에 대한 연산의 병렬 실행을 가능하게 해줌으로써 데이터 프로세싱 시스템에서의 향상된 성능이 달성될 수 있다. 오늘날 이용가능한 한 유형의 프로세서가 벡터 연산을 수행하기 위해 벡터 레지스터를 이용하는 벡터 프로세서이다. 그렇지만, 벡터 프로세서는 높은 성능을 가능하게 해주는 반면 스칼라 범용 레지스터를 사용하는 프로세서보다 복잡도 및 비용의 증가도 역시 가져온다. 즉, 벡터 프로세서 내의 벡터 레지스터 파일은 일반적으로 N개의 벡터 레지스터를 포함하며, 각각의 벡터 레지스터는 M개의 요소를 보유하는 M개의 레지스터의 뱅크를 포함한다. 예를 들어, 기술 분야에 공지된 한가지 이러한 벡터 프로세서에서, 레지스터 파일은 32개의 벡터 레지스터를 포함하며, 각각의 벡터 레지스터는 32개의 64-비트 레지스터의 뱅크를 포함하고, 따라서 1024개의 64-비트 레지스터에 상당하는 것을 필요로 한다.

오늘날 이용가능한 다른 유형의 프로세서는 임의의 기존의 스칼라 범용 레지 스터(GPR)를 사용하면서 제한된 벡터 프로세싱을 가능하게 해주는 단일 명령어 다중 데이터(single-instruction multiple-data, SIMD) 스칼라 프로세서("짧은 벡터 머신(short-vector machine)"이라고도 함)이다. 예를 들어, 32개의 스칼라 64-비트 GPR을 갖는 데이터 프로세싱 시스템에서, 각각의 스칼라 레지스터는 2개의 32-비트 요소, 4개의 16-비트 요소, 또는 8개의 8-비트 요소를 보유할 수 있으며, 따라서 2개의 32-비트 요소 연산, 4개의 16-비트 요소 연산, 또는 8개의 8-비트 요소 연산을 수행할 수 있다. 따라서, 연산당 요소의 개수가 벡터 프로세서(상기한 예에 따르면, 레지스터 뱅크 내의 32개의 64-비트 요소에 대한 연산을 한번에 행할 수 있음)에 비해 제한되어 있지만, 감소된 하드웨어가 요구된다. 그렇지만, 현재의 SIMD 스칼라 프로세서에서는, 실행을 위해 벡터 요소를 스칼라 레지스터로 전송하는 것 및 다중 벡터 요소를 다시 메모리로 전송하는 것과 연관된 많은 오버헤드가 있다. 이 오버헤드는 연산의 유효 처리능력을 제한하며, 따라서 메모리와 레지스터 간에 다중 벡터 요소를 로드 및 저장하는 개선된 방법이 필요하다.

도 1은 본 발명의 일 실시예에 따른 데이터 프로세싱 시스템의 블록도.

도 2 내지 도 11은 본 발명의 여러가지 실시예들에 따라 도 1의 데이터 프로세싱 시스템에 의해 실행될 수 있는 벡터 로드 및 저장 명령어를 나타낸 도면.

도 12는 본 발명의 일 실시예에 따른 예시적인 메모리 부분을 나타낸 도면.

도 13 내지 도 17은 본 발명의 여러가지 실시예들에 따라 일련의 스칼라 GPR 내의 엔트리들의 예를 나타낸 도면.

도 18은 본 발명의 일 실시예에 따라 시간에 따른 메모리 부분의 예를 나타낸 도면.

도 19 내지 도 26은 본 발명의 여러가지 실시예들에 따라 일련의 스칼라 GPR 내의 엔트리들의 예를 나타낸 도면.

도 27 내지 도 33은 본 발명의 여러가지 대체 실시예들에 따라 도 1의 데이터 프로세싱 시스템에 의해 실행될 수 있는 벡터 로드 및 저장 명령어를 나타낸 도면.

도 34는 본 발명의 일 실시예에 따라 메모리 부분의 예를 나타낸 도면.

도 35는 본 발명의 일 실시예에 따라 일련의 스칼라 GPR 내의 엔트리들의 예를 나타낸 도면.

본 발명은 예로서 도시된 것이며 유사한 참조 번호가 유사한 구성요소를 나타내고 있는 첨부 도면에 의해 제한되지 않는다.

당업자라면 도면들 내의 구성요소가 간단함 및 명백함을 위해 도시되어 있으며 꼭 축척대로 도시되어 있지 않아도 됨을 잘 알 것이다. 예를 들어, 본 발명의 실시예들에 대한 이해를 증진시키는 데 도움이 되도록 도면들 내의 어떤 구성요소의 치수는 다른 구성요소에 대해 과장되어 있을 수 있다.

본 명세서에서 사용되는 바와 같이, 용어 "버스"는 데이터, 어드레스, 제어 또는 상태 등의 하나 이상의 여러가지 유형의 정보를 전송하는 데 사용될 수 있는 복수의 신호 또는 도체를 지칭하는 데 사용된다. 본 명세서에서 논의되는 바와 같은 도체는 단일의 도체, 복수의 도체, 단방향 도체 또는 양방향 도체인 것에 관하여 예시되거나 설명될 수 있다. 그렇지만, 여러가지 실시예들은 도체의 구현을 다르게 할 수 있다. 예를 들어, 양방향 도체보다는 오히려 별도의 단방향 도체가 사용될 수 있으며, 그 역도 마찬가지이다. 또한, 복수의 도체가 다중 신호를 직렬로 또는 시간-멀티플렉스된(time-multiplexed) 방식으로 전송하는 단일의 도체로 대체될 수 있다. 이와 마찬가지로, 다중 신호를 전달하는 단일의 도체는 이들 신호의 서브셋을 전달하는 여러가지 서로 다른 도체로 분할될 수 있다. 따라서, 신호를 전송하는 데 많은 옵션이 존재한다.

신호, 상태 비트 또는 유사한 장치를 그의 논리적 참 상태 또는 논리적 거짓 상태로 각각 렌더링하는 것을 지칭할 때 용어 "어써트(assert)" 또는 "설정(set)" 및 "부정(negate)"(또는 "디어써트(deassert)" 또는 "클리어(clear)")이 사용된다. 논리적 참 상태가 논리 레벨 1인 경우, 논리적 거짓 상태는 논리 레벨 0이다. 그리고, 논리적 참 상태가 논리 레벨 0인 경우, 논리적 거짓 상태는 논리 레벨 1이다. 또한, 숫자에 선행하는 "0x"는 그 숫자가 그의 16진수 형태, 즉 밑수(base) 16인 형태로 표현되어 있음을 나타낸다는 것에 유의해야 한다. 숫자에 선행하는 심볼 "%"은 그 숫자가 그의 이진 형태, 또는 밑수 2인 형태(base two form)로 표현되어 있음을 가리킨다.

전술한 바와 같이, 메모리로부터 레지스터로 및 레지스터로부터 메모리로 다중 벡터 요소를 전송하는 것과 연관된 오버헤드를 감소시킬 필요가 있다. 따라서, 개선된 방식으로 메모리로 및 그로부터 벡터 요소를 전송할 수 있게 해주는 다양한 서로 다른 벡터 로드 및 저장 명령어가 본 명세서에서 설명된다. 게다가, 본 명세서에 기술된 명령어들의 사용은 최소한의 부가의 하드웨어 복잡도가 기존의 설계에 부가되는 상황에서 감소된 오버헤드를 가능하게 해줄 수 있다. 예를 들어, 많은 유형의 데이터 프로세싱 시스템 내에서 사용되는 것과 같은 스칼라 레지스터 파일이 이들 명령어와 함께 사용될 수 있으며, 따라서 보다 고비용의 별도의 벡터 레지스터 파일을 필요로 하지 않는다. 또한, 이들 명령어는 실행 효율성을 여전히 향상시키면서 감소된 소프트웨어 복잡도를 가능하게 해줄 수 있다. 또한, 본 명세서에서의 명령어들은 메모리에서의 벡터 요소의 정렬, 향상된 정밀도를 위해 메모리 요소의 크기를 레지스터 요소로 확장할 필요성, 임의적인 벡터 길이 대 레지스터의 고정된 길이, 또는 데이터의 벡터를 검색/저장하는 데 요구되는 로드/저장 명령어의 개수와 연관된 오버헤드(예를 들어, 명령어 발행 및 실행에서의) 등의 여러가지 문제를 해소하는 데 사용될 수 있다. 본 명세서에서의 명령어들은 또한 이들 문제의 임의의 조합 또는 부가의 문제 또는 문제들의 조합을 해소하는 데도 사용될 수 있으며, 이는 도 1 내지 도 35를 참조하여 이하에 제공되는 설명으로 이해될 것이다.

도 1은 본 발명의 일 실시예에 따른 데이터 프로세싱 시스템(10)을 블록도 형태로 나타낸 것이다. 데이터 프로세싱 시스템(10)은 프로세서(14), 메모리(12), 입력/출력(I/O)(16), 기타 주변 장치(18) 및 시스템 버스(20)를 포함한다. 메모리(12)는 도체(22)를 거쳐 시스템 버스(20)에 양방향으로 연결되어 있고, I/O(16)는 도체(24)를 거쳐 시스템 버스(20)에 양방향 연결되어 있으며, 기타 주변 장치(18)는 도체(26)를 거쳐 시스템 버스(20)에 양방향 연결되어 있고, 프로세서(14)는 도체(58)를 거쳐 시스템 버스(20)에 양방향 연결되어 있다. 일 실시예에서, 기타 주변 장치(18)는 하나 이상의 주변 장치를 포함할 수 있으며, 각각은 UART(universal asynchronous receiver transmitter, 범용 비동기 수신기 송신기), RTC(real time clock, 실시간 클럭), 키보드 콘트롤러, 다른 메모리, 기타 등등의 임의의 유형의 주변 장치일 수 있다. 기타 주변 장치(18) 중 어떤 것 또는 그 모두는 도체(62)를 거쳐 데이터 프로세싱 시스템(10) 외부의 정보를 전달할 수 있다. I/O 회로(16)는 예를 들어 도체(60)를 거쳐 데이터 프로세싱 시스템(10) 외부와 정보를 수신 또는 제공하는 임의의 유형의 I/O 회로를 포함할 수 있다. 메모리(12)는 예를 들어, 판독 전용 메모리(ROM), 랜덤 액세스 메모리(RAM), 비휘발성 메모리(예를 들어, 플래쉬), 기타 등등의 임의의 유형의 메모리일 수 있다. 데이터 프로세싱 시스템(10)은 예시된 것 이외의 다른 요소를 포함할 수 있거나 예시된 것보다 더 많은 또는 더 적은 요소를 포함할 수 있다. 예를 들어, 데이터 프로세싱 시스템(10)은 임의의 수의 메모리 또는 프로세서를 포함할 수 있다.

프로세서(14)는 예를 들어 마이크로프로세서, 마이크로콘트롤러, 디지털 신호 프로세서, 기타 등등의 임의의 유형의 프로세서일 수 있다. 일 실시예에서, 프로세서(14)는 프로세서 코어라고 말할 수 있다. 다른 실시예에서, 프로세서(14)는 멀티-프로세서 데이터 프로세싱 시스템에서의 많은 프로세서 중 하나일 수 있다. 게다가, 도시되어 있지는 않지만, 그 자체로서 프로세서(14)는 파이프라인 방식 프로세서(pipelined processor)일 수 있다. 도 1에 예시된 실시예에서, 프로세서(14)는 제어 유닛(28), 명령어 유닛(instruction unit, 30), 실행 유닛(32), 스칼라 레지스터 파일(34), 버스 인터페이스 유닛(bus interface unit, BIU)(36), 및 로드/저장 유닛(38)을 포함한다. 제어 유닛(28)은 도체(40)를 거쳐 명령어 유닛(30)에, 도체(42)를 거쳐 실행 유닛(32)에, 도체(46)를 거쳐 스칼라 레지스터 파일(34)에, 및 도체(48)를 거쳐 로드/저장 유닛(38)에 양방향 연결되어 있다. 실행 유닛(32)은 도체(44)를 거쳐 스칼라 레지스터 파일(34)에 양방향 연결되어 있고, 스칼라 레지스터 파일(34)은 도체(50)를 거쳐 로드/저장 유닛(38)에 양방향 연결되어 있다. BIU(36)는 도체(54)를 거쳐 명령어 유닛(30)에, 및 도체(52)를 거쳐 로드/저장 유닛(38)에 양방향 연결되어 있다. 프로세서(14)는 도체(58)에 연결된 도체(56)를 거쳐 시스템 버스(20)와 양방향 통신할 수 있다. 유의할 점은 프로세서(14)가 예시된 것보다 많은 회로를 포함할 수 있으며, 이 경우 부가의 회로도 역시 도체(58)에 연결될 수 있다는 것이다. 즉, 도체(56)는 도체(58)의 전부 또는 그의 일부분을 거쳐 시스템 버스(20)와 통신할 수 있다. 또한, 유의할 점은 프로세서(14)의 전부 또는 그의 일부분이 프로세싱 회로로서 지칭될 수 있다는 것이다.

동작을 설명하면, 명령어 유닛(30)은 BIU(36) 및 시스템 버스(20)를 거쳐 메모리(12) 등의 메모리로부터 명령어를 페치하고, 제어 유닛(28)으로 및 그로부터 제어 명령어를 수신 및 제공한다. 명령어 유닛(30)은 기술 분야에 공지된 것과 같은 임의의 유형의 명령어 유닛일 수 있으며, 기술 분야에 공지된 바와 같이 동작하고, 따라서 본 명세서에서 보다 상세히 기술하지 않는다. 명령어 유닛(30)은 따라서 예를 들어 실행 유닛(32) 및 로드/저장 유닛(38)(이들 양자는 필요에 따라 직접 또는 제어 유닛(28)을 거쳐 스칼라 레지스터 파일(34)과 통신할 수 있음)을 통하여 이들 수신된 명령어의 실행을 제어하는 제어 유닛(28)에 명령어를 제공한다. 예를 들어, 제어 유닛(28)은 명령어를 실행하기 위해 필요에 따라, 로드/저장 유닛(38) 및 BIU(36)를 통해, 메모리(메모리(12) 등)로부터 스칼라 레지스터 파일(34) 내의 레지스터로 데이터를 로드할 수 있으며, 명령어를 실행하기 위해 필요에 따라 스칼라 레지스터 파일(34) 내의 레지스터로부터 메모리(메모리(12) 등)로 데이터를 저장할 수 있다. 예를 들어, 일 실시예에서, 로드/저장 유닛(38)은 도체(48)를 거쳐 제어 유닛(28)으로부터 제공된 제어 정보에 기초하여 도체(50)를 통해 (데이터를 판독 및 기록하기 위해) 스칼라 레지스터 파일(34)과 직접 통신할 수 있다. 실행 유닛(32)은 제어 유닛(28)을 통해 명령어 유닛(30)으로부터 수신된 명령어를 실행하기 위해 필요에 따라, 스칼라 레지스터 파일(34) 내에 저장된 데이터를 사용하여 산술, 논리, 시프트 또는 기타 연산을 수행하고 결과를 스칼라 레지스터 파일(34) 내의 레지스터에 저장할 수 있다. 실행 유닛(32)은 예를 들어 산술 논리 유닛(ALU), 부동 포인트 유닛, 기타 등등을 포함할 수 있다.

스칼라 레지스터 파일(34)은 N개의 범용 레지스터(GPR)를 포함하며, 여기서 N은 0 보다 크거나 같은 임의의 정수일 수 있다. 일 실시예에서, 스칼라 레지스터 파일(34)은 32개의 64-비트 레지스터를 포함한다. 본 명세서에서 사용되는 바와 같이, 스칼라 레지스터는 1차원 맵을 가지며 따라서 1 행의 데이터만을 보유하는 레지스터(예를 들어, 1 x M-비트 레지스터)를 가리키며, 여기서 M은 1보다 크거나 같은 임의의 정수일 수 있다. 일 실시예에서, M은 64이고, 각각의 레지스터는 따라서 64-비트 분량을 저장할 수 있다. 스칼라 레지스터 파일(34)은 도체(46)를 거쳐 제어 유닛(28)으로 또는 그로부터 제어 정보 또는 데이터를 제공 또는 수신할 수 있다.

프로세서(14)의 동작은 당업자라면 일반적으로 잘 알고 있다. 따라서, 도 2 내지 도 36을 참조하여 기술되는 여러가지 실시예들을 이해하는 데 필요한 부분을 제외하고는 본 명세서에서 프로세서(14)에 대해 보다 상세히 기술하지 않는다. 또한, 유의할 점은 피연산자를 스칼라 범용 레지스터 파일에 저장하는 데이터 프로세싱 시스템에 대한 기존의 설계가 본 명세서에 기술된 명령어 로드 및 저장을 실행하기 위해 필요에 따라 수정될 수 있다는 것이다. 게다가, 유의할 점은 스칼라 레지스터 파일이 사용될 수 있기 때문에, 현재 존재하는 설계가 본 명세서에서 기술될 명령어를 가능하게 해주도록 개조될 수 있다는 것이다. (그렇지만, 유의할 점은 본 명세서에 기술된 실시예들이 임의의 유형의 레지스터 파일과 함께 사용될 수 있으며 스칼라 레지스터 파일에만 한정되지 않는다는 것이다.)

도 2 내지 도 11은 프로세싱 회로에 의해, 예를 들어 도 1의 프로세서(14) 등에 의해 실행될 수 있는 여러가지 서로 다른 벡터 요소 로드 및 저장 명령어를 나타낸 것이다. 예를 들어, 각각의 명령어는 명령어 유닛(30)에 의해 페치될 수 있으며, 이 명령어 유닛(30)은 적절한 경우 이들을 제어 유닛(28)에 제공한다. 제어 유닛(28)은 따라서 이하에 보다 상세히 기술되는 바와 같이 데이터를 저장하기 위해 필요에 따라 스칼라 레지스터 파일(34)을 사용하여, 필요에 따라 수신된 명령어를 실행하도록 로드/저장 유닛(38) 및 실행 유닛(32)에 지시할 수 있다. 유의할 점은 도 2 내지 도 11에 예시된 명령어를 사용하는 예가 차후의 도면을 참조하여 제공된다는 것이다. 또한, 유의할 점은 본 명세서에서 사용되는 바와 같이, 벡터 요소(또는 레지스터 요소)가 기껏해야 스칼라 GPR의 크기일 수 있지만 GPR의 크기보다 작을 수도 있는 요소를 지칭한다는 것이다. 예를 들어, 스칼라 레지스터 파일(34)이 64-비트 레지스터(M=64)를 포함하는 경우, 벡터 요소는 64 비트 이하의 크기일 수 있다. 예를 들어, 벡터 요소는 하나의 64-비트 GPR이 8개의 벡터 요소를 보유할 수 있도록 1 바이트(8 비트)일 수 있다. 또한, 벡터 요소는 하나의 64-비트 GPR이 4개의 벡터 요소를 보유할 수 있도록 하프워드(halfword)(16비트)일 수 있다. 이와 유사하게, 벡터 요소는 하나의 64-비트 GPR이 2개의 요소를 보유할 수 있도록 워드(word)(32비트)일 수 있다. 또한, 유의할 점은 본 명세서에서 사용되는 바와 같이, 바이트는 "b"로 나타내고, 하프워드는 "h"로 나타내며, 워드는 "w"로 나타내어져 있다는 것이다. (유의할 점은 대체 실시예에서 1 워드 또는 하프워드가 서로 다르게 정의될 수 있다는 것이다. 예를 들어, 1 워드는 32 비트가 아니라 16 비트를 말할 수 있다. 그렇지만, 본 명세서에서 사용되는 바와 같이, 워드는 설명의 편의상 32 비트를 말한다.)

도 2는 메모리로부터의 요소로 레지스터 파일(예를 들어, 스칼라 레지스터 파일(34) 등) 내의 하나의 목적지 레지스터(destination register)를 로드하는 벡터 요소 로드(load vector elements, lvex) 명령어를 나타낸 것이다. 일 실시예에서, 도 2에서 각각이 마침표로 분리되어 연산자 "lvex" 다음에 오는 것으로 도시되어 있는 s/u 필드, ms 필드 및 ds 필드 등의 부가의 제어 필드가 연산을 추가로 정의하기 위해 사용될 수 있다. 일 실시예에서, 이들 제어 필드 각각이 존재하지만, 대체 실시예에서 이들 제어 필드 중 어떤 것이 존재하거나 그 중 아무것도 존재하지 않을 수 있다. 일 실시예에서, ms 필드는 메모리 요소 크기 필드에 대응하며, ds 필드는 목적지 요소 크기에 대응한다. 예를 들어, 일 실시예에서, 메모리 요소 크기(ms) 필드는 로드되는 메모리 요소가 바이트, 하프워드 또는 워드인지를 나타내기 위해 각각 mb, mh 또는 mw 중 하나로 설정될 수 있다. 이와 유사하게, 목적지 요소 크기(ds) 필드는 각각의 로드된 요소가 목적지 레지스터 내에서 갖게 되는 크기를 나타내는 데 사용된다.

도 2의 lvex 명령어는 또한 3개의 피연산자(operand), rD, rA 및 rB를 포함한다. 명령어 lvex는 목적지 레지스터 rD에 메모리로부터의 벡터 요소를 로드한다. 메모리에서의 첫번째 요소는 레지스터 rA가 가리키고 있고, 도 2의 실시예에서, 부가의 파라미터가 레지스터 rB에 지정되어 있다. 따라서, rD, rA 및 rB 각각은 스칼라 레지스터 파일(34) 내의 GPR 중 하나를 나타낼 수 있다. 레지스터 rB에 저장된 부가의 파라미터는 카운트(cnt) 값 및 스트라이드(stride) 값을 포함하며, 따라서 lvex 명령어는 메모리로부터 "cnt"개의 요소들을(그 중 첫 번째 요소는 rA가 가리키고 있음) 레지스터 rD에 로드하여 크기 ds를 갖는 rD의 필드들에 넣으며 그에 따라 rD에서의 각각의 목적지 요소는 크기 ds를 갖는다.

메모리에서의 요소들이 얼마나 떨어져 있는지를 가리키는 스트라이드 값도 역시 지정될 수 있다. 즉, 메모리에서의 요소들은 "stride"개의 크기 ms인 단위만큼 떨어져 있다. 예를 들어, 메모리에서의 요소들이 연속적인 경우, "cnt"개의 크기 "ms"인 연속적인 요소를 가져오기 위해 1의 스트라이드가 사용될 수 있다. 예를 들어, 요소들이 3개의 요소만큼 떨어져 있는 경우, "cnt"개의 요소들(각각은 3개의 크기 "ms"인 단위만큼 서로 떨어져 있음)을 가져오기 위해 3의 스트라이드가 사용될 수 있다. 예를 들어, ms가 워드(예를 들어, mw)를 나타내는 경우, 3의 스트라이드는 rA가 가리키는 메모리 위치에서 시작하여 메모리에서의 매 3번째 워드를 가져오게 된다. 또한, 유의할 점은 스트라이드 값이 부호있는 값(signed value)일 수 있으며 여기서 음의 값은 점차적으로 더 높은 어드레스 위치에서가 아니라 점차적으로 더 낮은 어드레스 위치에서 요소들을 가져온다는 것이다.

일 실시예에서, 목적지 크기(ds)는 메모리 요소 크기(ms)보다 크거나 같아야만 한다. 목적지 크기(ds)가 메모리 요소 크기(ms)보다 큰 경우, s/u 필드는 각각의 메모리 요소를 적절히 확장하는 데 사용될 수 있다. "s"는 요소들이 부호를 가지며(signed) 따라서 부호-확장(sign-extended)되어야만 함을 나타내기 위해 사용될 수 있는 반면, "u"는 요소들이 부호를 갖지 않으며(unsigned) 따라서 제로-확장(zero-extended)되어야만 함을 나타내기 위해 사용될 수 있다. 예를 들어, "lvex.u.mh.dw rD, rA, rB"의 경우, 이하에 보다 상세히 기술하는 바와 같이, rD 내의 각각의 목적지 위치의 상위 하프워드(크기 워드의)가 영으로 되어 있다. 또한, 유의할 점은 일 실시예에서 "cnt*ds"가 목적지 레지스터 rD의 크기보다 작은 경우, rD의 나머지 하위 부분이 영으로 되어 있다는 것이다. 다른 대안으로서, 예를 들어 rD의 나머지 하위 부분 등의 rD의 임의의 나머지 부분은 임의의 미리 정해진 값(영 또는 임의의 다른 미리 정해진 값 등)으로 채워질 수 있다. 또한, 일 실시예에서, ds가 ms보다 작은 경우, 요소들 각각은 rD에 로드될 때 반올림 또는 절단될 수 있다(여기서, lvex 명령어는 또한 저장 명령어와 관련하여 이하에 기술되는 바와 같이, 절단 또는 반올림 제어 필드를 가질 수 있다).

예시된 실시예에서, s/u 필드, ms 필드 및 ds 필드는 연산 코드(opcode) 또는 서브 연산 코드(subopcode)의 일부로서 인코딩될 수 있다. 따라서, 예시된 실시예에서, lvex 명령어는 연산 코드를 나타내기 위한 필드, rD를 나타내기 위한 필드, rA를 나타내기 위한 필드, rB를 나타내기 위한 필드, 및 서브연산 코드를 나타내기 위한 필드를 포함한다. 그렇지만, 대체 실시예에서, s/u, ms, 및 ds 필드도 역시 cnt 및 stride와 함께 rB에 표시될 수 있음에 유의한다.

도 3은 도 2의 lvex 명령어의 대체 실시예를 나타낸 것이며, 여기서 rB를 피연산자로 나타내기 보다는 오히려 rB는 부가의 파라미터들을 포함하며, 이들 파라미터 모두는 명령어 연산 코드 또는 서브 연산 코드의 전부 또는 그 일부로서 제공될 수 있다. 예를 들어, cnt, stride 및 제어 필드(s/u, ms 및 ds) 모두는 명령어의 서브 연산 코드 부분 내에 표시될 수 있다.

유의할 점은 제어 필드 s/u, ms 및 ds와 관련하여 앞서 제공된 설명이 본 명세서에 기술된 모든 로드 명령어에 적용된다는 것이다. 명령어 lvex에서와 같이, 이들 제어 필드의 전부, 일부, 또는 본 명세서에 기술된 다른 로드 명령어에 존재하거나 또는 그 어느 것도 존재하지 않을 수 있다. 또한, 유의할 점은 본 명세서에서의 설명의 경우, rD는 일반적으로 목적지 레지스터를 말하고, rA는 메모리에서의 첫번째 메모리 요소를 가리키며, rB는 명령어에 존재하는 경우 그 명령어에 대한 어떤 또는 모든 부가의 파라미터를 저장한다는 것이다. 유의할 점은 rB도 역시 제어 레지스터라고 말할 수 있으며 GPR 중 하나일 필요가 없다는 것이다. 이와 유사하게, rA는 제어 레지스터 또는 다른 메모리 위치일 수 있으며 GPR 중 하나일 필요는 없다. 또한, 유의할 점은 본 명세서에 기술된 모든 명령어(로드 및 저장)들에서, 제어 필드는 명령어의 연산 코드 또는 서브 연산 코드의 일부로서 인코딩되거나 또는 레지스터 rB에 위치할 수 있다는 것이다. 이들이 레지스터 rB 내에 위치하는 경우, 제어 필드는 일반적으로 마침표로 분리되어 연산자 다음에 나타나지 않고 레지스터 rB에만 나타난다. 또한, 유의할 점은 더 많은 파라미터 또는 제어 필드가 필요한 경우, 본 명세서에서의 명령어들 중 어느 것이라도 필요한 경우 명령어 파라미터 및 제어 필드를 나타내기 위해 하나 이상의 레지스터를 나타낼 수 있거나 부가의 정보가 공통의(common) 또는 디스조인트(disjoint) 저장 위치에 포함될 수 있다는 것이다.

도 4는 다중 목적지 레지스터에 메모리로부터의 요소들을 로드하는 다중 벡터 요소 로드(load multiple vector elements, lmvex) 명령어를 나타낸 것이다. lvex 명령어에서와 같이, lmvex 명령어도 역시 s/u 필드, ms 필드 및 ds 필드를 포함할 수 있으며, 이들 각각은 도 4에서 마침표로 분리되어 연산자 "lmvex" 다음에 오는 것으로 예시되어 있다. 도 4의 lmvex 명령어는 또한 3개의 피연산자, 즉 rD, rA 및 rB를 포함한다. 명령어 lmvex는 첫번째 목적지 레지스터 rD 및 rD 다음에 오는 필요한 수만큼의 레지스터에 메모리로부터의 "cnt"개의 벡터 요소를 로드하여(여기서 메모리에서의 첫번째 요소는 레지스터 rA가 가리키고 있음), 임의의 목적지 레지스터에서의 각각의 목적지 요소는 크기 ds를 갖는다. 예를 들어, 하프워드(16 비트) 크기의 9개의 요소가 rD에 로드되는 경우(여기서 GPR 각각은 64 비트임), 3개의 GPR이 필요하다. 일 실시예에서, rD는 첫번째 레지스터를 나타내며, 더 필요한 경우, 부가의 연속적인 레지스터가 사용된다. 예를 들어, rD가 9개의 요소에 대한 레지스터 R4를 나타내는 경우, 레지스터 R4, R5 및 R6가 사용된다.

레지스터 rB에 저장된 부가의 파라미터는 cnt, stride, skip 및 skip_cnt를 포함한다. 파라미터 cnt 및 stride는 도 1을 참조하여 전술한 바와 동일하다. 즉, 로드될 메모리 내의 요소들은 "stride"개의 크기 ms인 단위만큼 떨어져 있을 수 있다. lmvex 명령어는 "skip_cnt"개의 요소가 페치될 때까지 "stride"개의 단위(크기는 ms임)만큼 떨어져 있는 메모리로부터의 요소들을 로드한다. 이 때, 그 다음 요소는 "skip"개의 크기 ms인 단위만큼 떨어져 있으며, skip_cnt를 추적하는 메카니즘(예를 들어, 카운터 등)이 리셋된다. 따라서, (명령어의 시작 이래로 또는 마지막으로 skip_cnt 카운터가 리셋된 이래로) skip_cnt개의 요소가 페치될 때마다, 그 다음 요소는 ("stride"보다는 오히려) "skip"개의 크기 ms인 단위만큼 떨어져 있다. 일 실시예에서, 프로세서(14) 내의 카운터(제어 유닛(28) 등의 내부에 있음)는 "skip_cnt-1"로 설정되고, 카운터가 만료될 때까지(0에 도달) 각각의 페치 이후에 감소되며, "cnt"개의 요소들이 페치될 때까지 "skip"개의 단위만큼 떨어져 있는 요소를 계속하여 페치하기 위해 "skip_cnt-1"로 다시 리셋된다. (다른 대안으로서, 카운터는 영으로 설정되고 카운터가 skip_cnt-1에 도달할 때까지 매번 증가될 수 있다. 대체 실시예들은 skip_cnt를 추적하기 위해 다른 방법들을 사용할 수 있다.) 유의할 점은 stride 및 skip 둘다가 부호를 갖는 양(signed quantity)일 수 있다는 것이다. 또한, 일 실시예에서, 메모리로부터 "cnt"개의 요소를 로드한 후에, 사용된 마지막 목적지 레지스터 내의 임의의 나머지 채워지지 않은 바이트는 미리 정해진 값(예를 들어, 영(zero) 등)으로 채워진다.

일 실시예에서, 목적지 크기(ds)는 메모리 요소 크기(ms)보다 크거나 같아야만 한다. 목적지 크기(ds)가 메모리 요소 크기(ms)보다 큰 경우, lvex와 관련하여 전술한 바와 같이, s/u 필드는 각각의 메모리 요소를 적절히 확장시키는 데 사용될 수 있다. 그렇지만, 일 실시예에서, ds가 ms보다 작은 경우, 저장(store) 명령어와 관련하여 이하에 기술하는 바와 같이, 요소들 각각은 rD에 로드될 때 반올림 또는 절단될 수 있다.

도 5는 도 4의 lmvex 명령어의 대체 실시예를 나타낸 것이며, 여기서 rB를 피연산자로서 나타내기보다는 오히려 rB는 부가의 파라미터들을 포함하고, 이들 파라미터 모두는 명령어 서브 연산 코드의 전부 또는 그 일부로서 제공될 수 있다. 예를 들어, cnt, stride, skip, skip_cnt 및 제어 필드(s/u, ms 및 ds) 모두는 명령어의 서브 연산 코드 또는 연산 코드 부분 내에 나타내어질 수 있다. 또다른 대체 실시예(도시 생략)에서, 개개의 명령어 파라미터는 명령어 필드 또는 rB 내의 필드에 할당될 수 있다. rB 내의 필드에의 할당은 예를 들어 파라미터가 계산 결과에 기초하여 또는 시스템 상태에 기초하여 동적으로 수정될 수 있는 것이 요망되는 경우에 사용될 수 있다. 다른 파라미터들은 정적 특성을 가질 수 있으며, 따라서 명령어 내의 필드에 인코딩될 수 있다.

유의할 점은 본 명세서에 기술된 나머지 명령어들에 있어서, 임의의 부가적인 파라미터들은 rB 내에 위치하게 되며 이 경우 rB는 명령어에 대한 피연산자로서 제공된다는 것이다. 그렇지만, 대체 실시예에서, 전술한 바와 같이 명령어들이 다른 포맷을 가질 수 있다는 것을 잘 알 것이다.

도 6은 다중 목적지 레지스터에 메모리로부터의 요소들을 로드시키는 다른 다중 벡터 요소 로드(load multiple vector elements, lmvex2) 명령어를 나타낸 것이다. 전술한 명령어들에서와 같이, lmvex2 명령어도 역시 s/u 필드, ms 필드 및 ds 필드를 포함할 수 있으며, 이들 각각은 도 6에서 마침표로서 분리되어 연산자 "lmvex2" 다음에 오는 것으로 도시되어 있다. 도 6의 lmvex2 명령어도 역시 3개의 피연산자, 즉 rD, rA 및 rB를 포함한다. 명령어 lmvex2는 목적지 레지스터 rD에 메모리로부터의 "cnt"개의 벡터 요소(여기서 메모리에서의 첫번째 요소는 레지스터 rA가 가리키고 있음)를 로드시키며, 따라서 임의의 목적지 레지스터 내의 각각의 목적지 요소는 크기 ds를 갖는다. 예를 들어, 하프워드(16 비트) 크기의 9개의 요소가 rD에 로드되는 경우(각각의 GPR은 64 비트임), 적어도 3개의 GPR이 필요하며, 이후에 기술하는 바와 같이 3개를 넘는 부가의 GPR이 필요할 수도 있다. 일 실시예에서, rD는 첫번째 레지스터를 나타내며, 더 필요한 경우, 부가의 연속적인 레지스터가 사용된다. 예를 들어, rD가 9개의 요소에 대한 레지스터 R4를 나타내는 경우, 적어도 레지스터 R4, R5 및 R6가 사용된다.

레지스터 rB에 저장된 lmvex2에 대한 부가적인 파라미터들은 cnt, rcnt, stride 및 skip을 포함한다. 파라미터 cnt 및 stride는 lmvex와 관련하여 전술한 바와 동일하다. 즉, 로드될 메모리 내의 요소들은 "stride"개의 크기 ms인 단위만큼 떨어져 있을 수 있으며, cnt는 로드될 요소들의 총 개수를 정의한다. rcnt 파라미터는 각각의 레지스터로 로드될 목적지 요소들의 최대 개수를 정의한다. (따라서, 필요한 레지스터의 총 개수는 cnt 및 rcnt 둘다에 의존한다.) lmvex2 명령어는 메모리로부터의 총 "cnt"개의 요소들을 하나 이상의 (필요한 수만큼의) 목적지 레지스터로 로드하며, 이 경우 단지 "rcnt"개의 요소들만이 각각의 목적지 레지스터로 로드된다. (따라서, 일 실시예에서, rcnt는 단일의 GPR 내에 들어갈 수 있는 크기 ds의 목적지 요소들의 총 개수보다 작거나 같고, rcnt는 또한 cnt보다 작거나 같다.)

예를 들어, lmvex2 명령어는 "rcnt"개의 요소가 단일의 레지스터 내로 페치될 때까지 "stride"개의 단위(크기가 ms 임)만큼 서로 떨어져 있는 메모리로부터의 요소들을 목적지 레지스터(rD) 내로 로드한다. 이 때, 총 "cnt"개의 요소들이 아직도 페치되지 않은 경우, 그 다음 요소는 "skip"개의 크기 ms인 단위만큼 떨어져 위치하고 있다. 이어서, "rcnt"개의 요소들이 또하나의 목적지 레지스터로 페치될 때까지(또는 "cnt"개의 요소가 페치될 때까지, 단 둘 중 먼저 일어나는 경우를 따름) "stride"개의 (크기 ds인) 단위만큼 떨어져 있는 메모리 위치로부터의 요소가 그 목적지 레지스터(예를 들어, rD + 1 등)로 로드된다. "rcnt"개의 요소들이 페치된 후에, "cnt"개의 요소들이 아직도 페치되지 않은 경우, 계속하여 "skip"개의 단위만큼 떨어져 위치하고 있는 그 다음 요소가 예를 들어 rD + 2 내로 로드된다. "cnt"개의 요소에 도달된 경우, 로드가 종료된다. 따라서, 유의할 점은 주어진 목적지 레지스터에 대한 메모리 내의 요소들이 "stride"개의 ms 단위만큼 떨어져 있으며, 연속적인 레지스터들에 대한 요소들이 "skip"개의 크기 ms인 단위를 이전의 목적지 레지스터의 마지막 요소의 어드레스에 가산한 후에 페치된다는 것이다. 또한, 유의할 점은 stride 및 skip 둘다가 부호를 갖는 양일 수 있으며 마이너스 stride 및 skip을 허용한다는 것이다.

유의할 점은 대체 실시예에서, skip_cnt 파라미터가 사용될 수 있으며, 따라서 skip_cnt개의 요소가 페치된 후에 그 다음 요소가 "skip"개의 크기 ms인 단위만큼 떨어져 있다는 것이다. 이와 같이, "rcnt"개의 요소가 목적지 레지스터 내로 로드된 후에, 연속적인 레지스터의 그 다음 요소는, skip_cnt개의 요소가 로드된 경우에는 skip에 기초하여, 또는 명령어의 시작 이래로 또는 skip_cnt가 최후에 리셋된 이래로 skip_cnt개의 요소가 아직 로드되지 않은 경우에는 stride에 기초하여 페치된다.

lvex와 관련하여 전술한 바와 같이, 프로세서(14) 내의(제어 유닛(28) 등 내의) 카운터는 벡터 요소의 로드 동안에 "cnt"를 추적하는 데 사용될 수 있다. 이와 유사하게, 프로세서(14) 내의 카운터는 또한 각각의 목적지 레지스터의 로드 동안에 "rcnt"를 추적하는 데도 사용될 수 있다. 대체 실시예는 cnt 및 rcnt를 추적하기 위해 다른 방법을 사용할 수 있다. 또한, 일 실시예에서, "rcnt"개의 요소가 로드된 후에 각각의 목적지 레지스터에서의 임의의 나머지 바이트는 예를 들어 영(zero) 등의 미리 정해진 값으로 채워진다. 또한, 일 실시예에서, 사용된 마지막 목적지 레지스터에서의 나머지 바이트는 메모리로부터 "cnt"개의 요소를 로드한 후에 미리 정해진 값(예를 들어, 영(zero) 등)으로 채워진다.

일 실시예에서, 목적지 크기(ds)는 메모리 요소 크기(ms)보다 크거나 같아야만 한다. 목적지 크기(ds)가 메모리 요소 크기(ms)보다 큰 경우, 상기 명령어들을 참조하여 전술한 바와 같이, s/u 필드는 각각의 메모리 요소를 적절히 확장시키는 데 사용될 수 있다. 그렇지만, 일 실시예에서, ds가 ms보다 작은 경우, 저장 명령어와 관련하여 이하에 기술되는 바와 같이, 각각의 요소는 rD에 로드될 때 반올림 또는 절단될 수 있다.

도 7은 메모리로부터의 벡터 요소의 스트림을 목적지 레지스터와 연관되어 있는 지명된 스트림으로 로드하는 것을 개시하는 벡터 요소의 스트림 로드(load stream of vector elements, lstrmvex) 명령어를 나타낸 것이다. 전술한 명령어들에서와 같이, lstrmvex 명령어도 역시 s/u 필드, ms 필드 및 ds 필드를 포함할 수 있으며, 이 각각은 도 7에서 마침표로 분리되어 연산자 "lstrmvex" 다음에 오는 것으로 도시되어 있다. 도 7의 lstrmvex 명령어도 역시 3개의 피연산자, rD, rA 및 rB를 포함한다. lstrmvex 명령어에 대한 부가의 파라미터는 cnt, rcnt, stride, skip 및 skip_cnt를 포함한다. 파라미터 cnt, rcnt, stride, skip 및 skip_cnt는 일반적으로 lvex, lmvex 및 lmvex2와 관련하여 전술한 바와 동일하다.

lstrmvex 명령어는 rD의 다수의 인스턴스에 메모리로부터의 총 "cnt"개의 요소들(이 경우 메모리에서의 첫번째 요소는 레지스터 rA가 가리키고 있음)을 로드하며, 따라서 목적지 레지스터에서의 각각의 목적지 요소는 크기 ds를 갖는다. cnt 및 rcnt의 값은 타겟으로 된 rD의 인스턴스의 개수를 결정한다. lstrmvex 명령어는 "skip_cnt"개의 요소들이 페치될 때까지 "stride"개의 크기 ms인 단위만큼 떨어져 있는 메모리로부터의 벡터 요소들을 로드한다. 이 때, 로드될 그 다음 요소의 어드레스를 획득하기 위해 페치된 마지막 요소의 어드레스에 ("stride * ms" 대신에) "skip * ms"가 가산된다. 또한, 이 때, skip_cnt를 추적하는 메카니즘(예를 들어, 카운터 등)이 리셋된다. 따라서, (명령어의 시작 이래로 또는 최후로 skip_cnt 카운터가 리셋된 이래로) "skip_cnt"개의 요소가 페치될 때마다, 그 다음 요소의 위치는 "stride"보다는 "skip" 파라미터에 의해 표시된다.

"rcnt" 파라미터는 레지스터 인스턴스별 목적지 요소들의 개수를 정의한다. (따라서, 일 실시예에서, rcnt는 단일의 GPR 내의 크기 ds의 목적지 요소들의 총 개수보다 작거나 같고, rcnt는 cnt보다 작거나 같다.) 예를 들어, lstrmvex 명령어는 "rcnt"개의 요소가 페치될 때까지 (상기한 바와 같이, 파라미터들 stride, skip 및 skip_cnt에 따라) 메모리로부터의 요소들을 rD(즉, rD의 첫번째 인스턴스) 내로 로드한다. 이 때, "cnt"개의 요소가 아직도 페치되지 않은 경우, 그 다음 요소는 "stride"개의 크기 ms인 단위만큼 떨어져 위치하고 있다(또는, skip_cnt개의 요소가 페치된 경우, 그 다음 요소는 "stride"보다는 오히려 "skip"개의 크기 ms인 단위만큼 떨어져 위치하고 있다). lstrmvex 명령어는 이어서 "rcnt"개의 요소들이 페치될 때까지(또는 "cnt"개의 요소들이 페치될 때까지, 단 둘 중 먼저 일어나는 경우를 따름) (파라미터들 stride, skip 및 skip_cnt에 따라) 계속하여 메모리로부터의 요소들을 rD의 다른 인스턴스(즉, rD의 이전의 값을 오버라이트하는 rD의 제2의 인스턴스) 내로 로드한다. "rcnt"개의 요소들이 페치된 후에 "cnt"개의 요소들이 아직도 페치되지 않은 경우, 계속하여 그 다음 요소를 rD(rD의 다른 인스턴스) 내로 로드한다. "cnt"개의 요소들이 페치된 경우, 로드가 종료된다. rD의 각각의 인스턴스는 메모리로부터 페치된 rcnt 요소들의 고유 세트에 대응한다. rD의 각각의 인스턴스가 디큐될 때, 그 다음 인스턴스에는 스트림의 총 cnt개의 요소들이 로드될 때까지 이 스트림에서의 rcnt 요소들의 그 다음 세트가 로드된다.

일 실시예에서, rD의 인스턴스들은 후속 명령어에서의 rD의 사용 또는 위치에 기초하여 디큐된다. 예를 들어, 일 실시예에서, rD가 후속 명령어에서 특정의 소스 레지스터로서 사용되는 경우에 rD의 인스턴스는 디큐된다. 따라서, 그 후속 명령어(이 특정의 소스 레지스터로서 rD를 가짐)가 실행된 후에, 그 다음 "rcnt"개의 요소들이 rD 내로 로드되어진다("cnt"개의 요소들에 아직도 도달하지 않은 것으로 가정함). 그렇지만, rD가 이 특정의 소스 레지스터로서 사용되지 않는 경우(예를 들어, 그것이 다른 소스 레지스터이거나 목적지 레지스터인 경우), rD는 디큐되지 않으며 그 다음 "rcnt"개의 요소들이 아직도 rD 내로 로드되어 있지 않다. 대체 실시예에서, 디큐잉 여부의 옵션은 다른 방식들로, 예를 들어 명령어 내의 플래그에 의해 또는 다른 연산 코드(예를 들어 디큐잉을 요구하는 특수한 명령어들의 서브셋 등에 대응하는 것 등)를 사용하는 등에 의해 나타내어진다. 선택적인 디큐잉의 예들에 대해서는 도 23 내지 도 26을 참조하여 이하에 기술된다.

상기한 명령어들을 참조하여 전술한 바와 같이, 프로세서(14) 내의(제어 유닛(28) 등 내의) 카운터는 벡터 요소들의 로드 동안에 "cnt"를 추적하는 데 사용될 수 있다. 이와 유사하게, 프로세서(14) 내의 카운터는 또한 각각의 목적지 레지스터의 로드 동안에 "rcnt"를 추적하는 데도 사용될 수 있다. 카운터는 또한 skip_cnt를 추적하는 데도 사용될 수 있다. 대체 실시예는 cnt, rcnt 및 skip_cnt를 추적하기 위해 다른 방법들을 사용할 수 있다. 또한, 일 실시예에서, 각각의 목적지 레지스터 또는 레지스터 인스턴스에서의 임의의 나머지 바이트들은 "rcnt"개의 요소들이 로드된 후에 예를 들어 영(zero) 등의 미리 정해진 값으로 채워진다. 또는, 일 실시예에서, 메모리로부터의 "cnt"개의 요소들을 로드한 후에, 사용된 마지막 목적지 레지스터 또는 레지스터 인스턴스에서의 나머지 바이트들은 미리 정해진 값(예를 들어, 영(zero) 등)으로 채워진다. 또한, 유의할 점은 stride 및 skip 둘다가 부호를 갖는 양일 수 있으며 음의 stride 및 skip을 허용한다는 것이다.

일 실시예에서, 목적지 크기(ds)는 메모리 요소 크기(ms)보다 크거나 같아야만 한다. 목적지 크기(ds)가 메모리 요소 크기(ms)보다 큰 경우, 상기한 명령어들을 참조하여 전술한 바와 같이, 각각의 메모리 요소를 적절히 확장시키기 위해 s/u 필드가 사용될 수 있다. 그렇지만, 일 실시예에서, ds가 ms보다 작은 경우, 그 요소들 각각은 rD 내에 로드될 때 반올림 또는 절단될 수 있다.

유의할 점은 대체 실시예들에서 lstrmvex 명령어의 개개의 파라미터들 각각이 선택적일 수 있다는 것이며, 이것은 lvex, lmvex 및 lmvex2 명령어 등의 본 명세서에 기술된 다른 명령어들의 대체 실시예에서도 마찬가지일 수 있다.

도 8은 소스 레지스터로부터 메모리로 요소들을 저장하는 벡터 요소 저장(store vector elements, stvex) 명령어를 나타낸 것이다. stvex 명령어는 lvex 명령어에 카운터파트 저장 명령어로 볼 수 있다. 일 실시예에서, stvex 명령어는 s/u 필드, ms 필드, ss 필드 및 h/l 필드 등의 부가의 제어 필드를 사용하며, 이 각각은 도 8에서 마침표로 분리되어 연산자 "stvex" 다음에 오는 것으로 도시되어 있다. 일 실시예에서, 이들 제어 필드 각각이 존재하지만, 대체 실시예들에서, 이들 제어 필드 중 단지 어떤 것만이 존재하거나 아무것도 존재하지 않을 수 있다. 일 실시예에서, s/u 필드(부호 또는 무부호 확장(signed or unsigned extend)) 및 ms 필드(메모리 크기)는 로드 명령어와 관련하여 전술한 것과 동일하다. 일 실시예에서, ss 필드는 소스 레지스터에서의 각각의 소스 요소의 크기를 나타내는 소스 요소 크기 필드에 대응한다. 예를 들어, 일 실시예에서, ss 필드는 메모리에 저장될 소스 요소가 바이트, 하프워드, 또는 워드인지를 각각 나타내기 위해 sb, sh 또는 sw 중 하나로 설정될 수 있다.

도 8의 stvex 명령어는 또한 3개의 피연산자, rS, rA 및 rB를 포함한다. 도 8의 실시예에서, 부가의 파라미터들은 레지스터 rB에 지정되어 있으며, 여기서 이들 부가의 파라미터들은 cnt 및 stride를 포함한다. (따라서, 상기한 로드 명령어에서와 같이, rS, rA 및 rB 각각은 스칼라 레지스터 파일(34) 내의 GPR 중 하나를 가리킬 수 있다.) stvex 명령어는 소스 레지스터 rS로부터의 "cnt"개의 크기 ss인 요소들을 메모리에 저장하며, 첫번째 요소는 레지스터 rA가 가리키는 메모리 위치에 저장되어지고, 따라서 메모리에서의 각각의 목적지 요소는 크기 ms를 갖는다(또 s/u 및 h/l 필드가 나타내는 바와 같이, 선택적으로 절단되거나 확장된다).

메모리에서의 요소들이 어떻게 떨어져 있는지를 나타내는 stride 값도 역시 지정될 수 있다. 즉, 메모리에서의 요소들은 저장될 때 "stride"개의 크기 ms인 단위만큼 서로 떨어져야 한다. 예를 들어, 1의 stride는 "cnt"개의 크기 "ms"인 연속적인 요소들을 저장하는 데 사용될 수 있다. 이와 유사하게, 3의 stride는 "cnt"개의 크기 "ms"인 요소들을 메모리에 저장하는 데 사용될 수 있으며, 이 각각은 3개의 크기 "ms"인 단위만큼 서로로부터 떨어져 있다. 또한, 유의할 점은 stride 값이 부호있는 값일 수 있다는 것이다.

일 실시예에서, h/l 필드는 절단 제어 필드(truncation control field)이다. 예를 들어, ss가 ms보다 큰 경우(즉, 소스 크기가 메모리 크기보다 큰 경우), h/l 필드는 소스 요소들이 어떻게 절단되는지를 나타내는 데 사용될 수 있다. 예를 들어, h/l 필드가 "h"인 경우, 소스 요소의 하위 부분이 절단된다. 그렇지만, h/l 필드가 "l"인 경우, 소스 요소의 상위 부분이 절단된다. 유의할 점은 대체 실시예들에서, stvex 명령어도 역시 반올림 제어 필드(절단 제어 필드 이외에 또는 그 대신에)를 포함할 수 있으며 따라서 예를 들어 ss가 ms보다 큰 경우 값이 절단되기 보다는 오히려 반올림될 수 있다는 것이다. 예를 들어, 일 실시예에서, 소스 요소의 상위 부분은 소스 요소의 하위 부분의 값에 기초하여 반올림될 수 있다.

일 실시예에서, 소스 요소 크기(ss)가 메모리 요소 크기(ms)보다 작은 경우, s/u 필드는 각각의 소스 요소가 메모리에 저장될 때 이를 적절히 확장하는 데 사용될 수 있다. "s"는 이 요소들이 부호를 가지며 따라서 부호-확장되어야 함을 나타내는 데 사용될 수 있는 반면, "u"는 이 요소들이 부호를 갖지 않으며 따라서 제로-확장되어야만 함을 나타내는 데 사용될 수 있다.

예시된 실시예에서, 본 명세서에 기술된 저장 명령어들 중 임의의 것의 s/u 필드, ms 필드, ss 필드 및 h/l 필드는 연산 코드 또는 서브 연산 코드의 일부로서 인코딩될 수 있다. 따라서, 예시된 실시예에서, stvex 명령어는 연산 코드를 나타내기 위한 필드, rS를 나타내기 위한 필드, rA를 나타내기 위한 필드, rB를 나타내기 위한 필드, 및 서브 연산 코드를 나타내기 위한 필드를 포함한다. 그렇지만, 대체 실시예에서, 유의할 점은 s/u, h/l, ms 및 ss 필드는 또한 cnt 및 stride와 함께 rB에 나타내어질 수 있다는 것이다. 또한, 로드 명령어에서와 같이, 부가의 파라미터들 각각도 역시 rB 등의 레지스터를 지정할 필요없이 연산 코드 또는 서브 연산 코드의 일부로서 인코딩될 수 있다. 따라서, 유의할 점은 대체 실시예들에서 본 명세서에 기술된 저장 명령어들 중 어느 것이라도 다양한 서로 다른 포맷을 가질 수 있다는 것이다. 또한, 유의할 점은 임의의 부가의 파라미터들이 레지스터 rB에 저장되어 있는 것을 참조하여 저장 명령어에 대해 기술되어진다는 것이다. (전술한 바와 같이, 부가의 파라미터 및 제어 필드가 필요한 경우 다중 레지스터 또는 저장 위치가 명령어에 표시될 수 있다.)

유의할 점은 제어 필드 s/u, ms, ss 및 h/l에 관하여 앞서 제공된 설명이 본 명세서에 기술된 저장 명령어들 모두에 적용된다는 것이다. 명령어 stvex에서와 같이, 이들 제어 필드 모두 또는 그 중 어떤 것이 본 명세서에 기술된 다른 저장 명령어들에 존재하거나 그 아무 것도 존재하지 않을 수 있다. 또한, 유의할 점은 본 명세서에서의 설명에서, rS는 일반적으로 소스 레지스터를 말하며, rA는 첫번째 요소가 저장되어 있는 메모리에서의 위치를 가리키며, rB는 명령어에 존재하는 경우 명령어에 대한 부가의 파라미터들 모두 또는 그 중 어떤 것을 보유한다는 것이다.

도 9는 다중 소스 레지스터로부터 메모리로 요소들을 저장하는 다중 벡터 요소 저장(store multiple vector elements, stmvex) 명령어를 나타낸 것이다. stmvex 명령어는 lmvex 명령어의 카운터파트 저장 명령어인 것으로 간주될 수 있다. 일 실시예에서, stmvex 명령어는 s/u 필드, ss 필드, ds 필드 및 h/l 필드 등의 부가의 제어 필드를 사용하며, 이 각각은 도 9에서 마침표로 분리되어 연산자 "stmvex" 다음에 오는 것으로 도시되어 있다. stvex 명령어와 관련하여 이들 필드에 대한 앞서 제공된 설명은 여기서 stmvex 명령어에도 적용된다.

도 9의 stmvex 명령어는 또한 3개의 피연산자, 즉 rS, rA 및 rB를 포함한다. 도 9의 실시예에서, 부가의 파라미터들이 레지스터 rB에 지정되어 있으며, 여기서 이들 부가의 파라미터들은 cnt, stride, skip 및 skip_cnt를 포함한다. stmvex 명령어는 다중 소스 레지스터 rS(및 필요에 따라 rS+1, rS+2 등의 rS에 후속하는 레지스터)로부터의 "cnt"개의 크기 ss인 요소들을 메모리에 저장하며, 여기서 저장될 첫번째 요소의 어드레스는 레지스터 rA가 가리키고 있고, 따라서 메모리에서의 각각의 요소는 크기 ms를 갖는다(s/u 및 h/l 필드로 나타낸 바와 같이 선택적으로 절단 또는 확장된다).

stvex에서와 같이, stride 값은 메모리에서의 요소들이 어떻게 떨어져 있는지를 나타낼 수 있다. 따라서, rS로부터의 소스 요소들이 메모리에 저장되어 그들은 "skip_cnt"개의 요소들이 저장될 때까지 "stride"개의 단위(크기 ms임)만큼 떨어져 위치된다. 이 때, 저장된 그 다음 요소의 어드레스를 획득하기 위해 ("stride*ms" 대신에) 저장된 마지막 요소의 어드레스에 "skip*ms"가 가산된다. 또한, 이 때, skip_cnt를 추적하는 -*데 사용되는 메카니즘(예를 들어, 카운터 등)이 리셋된다. 따라서, (명령어의 시작 이래로 또는 최후로 skip_cnt 카운터가 리셋된 이래로) "skip_cnt"개의 요소들이 저장될 때마다, 저장될 그 다음 요소의 위치는 stride 파라미터보다 오히려 skip 파라미터에 의해 나타내어진다. rS로부터 소스 요소들이 메모리에 저장된 후에, "cnt"개의 요소들이 저장될 때까지 그 다음 소스 레지스터(예를 들어, rS+1 등)로부터의 소스 요소들은 stride, skip 및 skip_cnt 파라미터에 기초하여 메모리에 저장된다.

로드 명령어와 관련하여 전술한 바와 같이, 프로세서(14) 내의(예를 들면, 제어 유닛(28) 내의) 카운터는 cnt 및 skip_cnt를 적절히 추적하기 위해 사용될 수 있다. 예를 들어, 카운터는 skip_cnt개의 요소들을 나타내기 위해 사용될 수 있으며, 여기서 skip_cnt개의 요소들이 저장된 후에, 카운터가 리셋되고 그 다음 skip_cnt개의 요소들은 시작이 skip으로 표시되어 있는 위치에 저장된다. 이것은 예를 들어 cnt개의 요소들(이는 예를 들어 또하나의 카운터에 의해 나타내어질 수 있음)이 저장될 때까지 계속될 수 있다. 대체 실시예는 cnt 및 skip_cnt를 추적하는 다른 방법을 사용할 수 있다.

유의할 점은 일 실시예에서, ss가 ms보다 작은 경우, 메모리 목적지 요소를 생성하기 위해 s/u 필드(stvex와 관련하여 기술함)에 의해 나타내어진 바와 같이 각각의 소스 요소가 적절히 확장된다는 것이다. 또한, 일 실시예에서, ss가 ms보다 큰 경우, 각각의 소스 요소는 메모리 목적지 요소를 생성하기 위해 h/l 필드(stvex와 관련하여 기술함)로 나타낸 바와 같이 적절히 절단된다.

도 10은 다중 목적지 레지스터로부터 메모리로 요소들을 저장하는 또하나의 다중 벡터 요소 저장(store multiple vector elements, stmvex2) 명령어를 나타낸 것이다. stmvex2 명령어는 lmvex2 명령어의 카운터파트 저장 명령어인 것으로 간주될 수 있다. 일 실시예에서, stmvex2 명령어는 s/u 필드, ss 필드, ds 필드, 및 h/l 필드 등의 부가의 제어 필드를 사용하며, 이 각각은 도 10에서 마침표로 분리되어 연산자 "stmvex2" 다음에 오는 것으로 도시되어 있다. stvex 및 stmvex 명령어와 관련하여 이들 필드에 대한 앞서 제공된 설명은 또한 여기에서 stmvex2 명령어에도 적용된다.

도 10의 stmvex2 명령어는 또한 3개의 피연산자, 즉 rS, rA 및 rB를 포함한다. 도 10의 실시예에서, 부가의 파라미터들이 레지스터 rB에 지정되고, 여기서 이들 부가의 파라미터는 cnt, rcnt, stride 및 skip을 포함한다. stmvex2 명령어는 다중 소스 레지스터 rS(및 필요에 따라 rS+1, rS+2 등의 rS에 후속하는 레지스터들)로부터의 "cnt"개의 크기 ss인 요소들을 메모리에 저장하며, 여기서 저장될 첫번째 요소의 어드레스는 레지스터 rA가 가리키고 있으며 따라서 메모리에서의 각각의 요소는 크기 ms를 갖는다(선택적으로 s/u 및 h/l 필드에 의해 나타낸 바와 같이 절단되거나 확장된다). rcnt 파라미터는 저장될 소스 레지스터당 소스 요소의 개수를 정의하고, cnt 파라미터는 저장될 요소들의 총 개수를 정의한다.

stmvex에서와 같이, stride 값은 메모리에서의 요소들이 어떻게 떨어져 있는지를 나타낼 수 있다. 따라서, rS로부터의 소스 요소들은 이들이 "stride"개의 단위(크기 ms임)만큼 떨어져 위치하도록 메모리에 저장된다. 일 실시예에서, 주어진 소스 레지스터(rS)로부터의 "rcnt"개의 요소들을 저장한 후에, 나머지 요소들이 저장되는 경우, 그 다음 요소의 어드레스를 획득하기 위해 저장된 마지막 요소의 어드레스에 "skip*ms"가 가산된다. 이어서, 표시된 "stride" 값을 사용하여, 그 다음 소스 레지스터(예를 들어, rS+1 등)로부터의 "rcnt"개의 소스 요소가 메모리에 저장된다. 이것은 "cnt"개의 요소들이 저장될 때까지 계속된다. 유의할 점은 일 실시예에서 "rcnt*ss"가 소스 레지스터의 크기보다 작은 경우, 각각의 소스 레지스터의 나머지 하위 부분이 무시된다. 또한 유의할 점은 "stride" 및 "skip"이 부호를 갖는 양일 수 있으며 따라서 음의 stride 및 skip이 허용된다.

유의할 점은 대체 실시예에서, skip_cnt개의 요소들이 저장된 후에 그 다음 요소가 ("stride"개의 크기 ms인 단위만큼 떨어지는 것보다는) "skip"개의 크기 ms인 단위만큼 떨어져 위치하도록 skip_cnt 파라미터도 또한 사용될 수 있다는 것이다. 이와 같이, "rcnt"개의 요소들이 메모리에 저장된 후에, 연속한 레지스터로부터의 그 다음 요소는 skip_cnt개의 요소가 저장된 경우는 skip에 기초하여 또는 명령어의 시작 이래로 또는 skip_cnt가 최후에 리셋된 이래로 skip_cnt개의 요소가 아직도 저장되지 않은 경우는 stride에 기초하여 메모리 내의 위치에 저장된다.

로드 명령어와 관련하여 전술한 바와 같이, 프로세서(14) 내의(예를 들면, 제어 유닛(28) 내의) 카운터는 cnt 및 rcnt를 적절히 추적하는 데 사용될 수 있다. 대체 실시예들은 cnt 및 rcnt를 추적하는 다른 방법을 사용할 수 있다.

유의할 점은 일 실시예에서, ss가 ms보다 작은 경우, 메모리 목적지 요소를 생성하기 위해 s/u 필드(stvex와 관련하여 설명됨)에 의해 나타낸 바와 같이 각각의 소스 요소가 적절히 확장된다는 것이다. 또한, 일 실시예에서, ss가 ms보다 큰 경우, 메모리 목적지 요소를 생성하기 위해 각각의 소스 요소는 h/l 필드(stvex 및 stmvex와 관련하여 설명됨)에 의해 나타낸 바와 같이 적절히 절단된다. stvex 명령어와 관련하여 앞서 설명한 바와 같이, 반올림도 역시 선택적으로 지정될 수 있다.

도 11은 지명된 스트림으로부터 메모리로 벡터 요소들의 스트림을 저장하는 것을 개시하는 벡터 요소의 스트림 저장(store stream of vector element, ststrmvex) 명령어를 나타낸 것이다. ststrmvex 명령어는 lstrmvex 명령어의 카운터파트 저장 명령어인 것으로 간주될 수 있다. 일 실시예에서, ststrmvex 명령어는 s/u 필드, ss 필드, ds 필드, 및 h/l 필드 등의 부가의 제어 필드를 사용하며, 이 각각은 도 11에서 마침표로 분리되어 연산자 "ststrmvex" 다음에 오는 것으로 도시되어 있다. stvex, stmvex 및 stmvex2와 관련하여 이들 필드에 대한 앞서 제공된 설명은 또한 여기에서 ststrmvex 명령어에도 적용된다.

도 11의 ststrmvex 명령어는 또한 3개의 피연산자, 즉 rS, rA 및 rB를 포함한다. 도 11의 실시예에서, 부가의 파라미터가 레지스터 rB에 지정되어 있으며, 여기서 이들 부가의 파라미터는 cnt, rcnt, stride, skip 및 skip_cnt를 포함한다. ststrmvex 명령어는 총 "cnt"개 요소를 갖는 소스 레지스터 rS의 다중 인스턴스를 메모리에 저장하며, 여기서 저장될 첫번째 요소의 어드레스는 rA가 가리키고 있다. 따라서, "cnt" 파라미터는 저장될 요소들의 총 개수를 정의하며, "rcnt" 파라미터는 소스 레지스터 rS의 인스턴스당 소스 요소들의 개수를 정의한다. ststrmvex 명령어는 "skip_cnt"개의 요소들이 저장될 때까지 rS(즉, 첫번째 rS 인스턴스)로부터의 요소들이 "stride"개의 단위(크기 ms임)만큼 떨어져 있도록 이들을 메모리에 저장한다. 이 때, 그 다음 요소의 어드레스를 획득하기 위해 ("stride*ms" 대신에) 저장된 마지막 요소의 어드레스에 "skip*ms"이 가산된다. 또한, 이 때, skip_cnt를 추적하는 메카니즘(예를 들어, 카운터 등)이 리셋된다. 따라서, (명령어의 시작 이래로 또는 최후에 skip_cnt 카운터가 리셋된 이래로) "skip_cnt"개의 요소들이 저장될 때마다, 그 다음 요소의 위치는 stride 파라미터보다는 오히려 skip 파라미터에 의해 표시된다.

또한, rS의 주어진 인스턴스로부터의 "rcnt"개의 요소들을 저장한 후에, 저장될 요소들이 남아 있는 경우(즉, "cnt"개의 요소들이 아직 저장되지 않은 경우), rS의 그 다음 인스턴스로부터 저장될 첫번째 요소의 어드레스를 획득하기 위해 저장된(예를 들어, rS가 목적지 레지스터로서 사용되는 명령어의 실행 후에 저장된) 마지막 요소의 어드레스에 "stride*ms"가 부가된다("skip_cnt"개의 요소들이 저장되지 않았다면, 이 경우 저장된 마지막 요소의 어드레스에 "stride*ms"보다는 오히려 "skip*ms"가 부가된다). 예를 들어, 일 실시예에서, rS가 명령어에 대한 목적지 레지스터로서 사용될 때 인스턴스들은 인큐된다. 예를 들어, rS가 후속 명령어에 대한 목적지 레지스터로서 사용되고 "cnt"개의 요소들이 아직도 저장되지 않은 경우, 후속 명령어의 목적지 레지스터인 rS로부터의 "rcnt"개의 요소들(예를 들어, 후속 명령어의 결과들 모두 또는 그의 일부분을 포함함)이 stride, skip 및 skip_cnt 파라미터에 따라 메모리에 저장된다. 이 실시예에서, rS가 명령어의 목적지 레지스터로서 사용되지 않는 경우, 이는 그 명령어의 실행 시에 인큐되지 않는다(따라서 벡터 스트림의 일부로서 저장되지 않는다). 대체 실시예에서, 명령어 내의 플래그 또는 연산 코드(예를 들어, 인큐잉을 요구하는 특수한 명령어들의 서브셋에 대응하는 것 등) 등의 다른 메카니즘이 rS의 인스턴스가 인큐되어야 하는지 여부를 나타내는 데 사용될 수 있다.

유의할 점은 일 실시예에서, "rcnt*ss"가 소스 레지스터의 크기보다 작은 경우, 소스 레지스터의 나머지 하위 부분은 무시된다. 또한, 유의할 점은 "stride" 및 "skip"이 부호를 갖는 양일 수 있으며, 따라서 음의 stride 및 skip를 허용한다는 것이다.

로드 명령어와 관련하여 전술한 바와 같이, 프로세서(14) 내의(예를 들면, 제어 유닛(28) 내의) 카운터가 cnt, rcnt, skip 및 skip_cnt를 적절히 추적하는 데 사용될 수 있다. 대체 실시예들은 이들 파라미터를 추적하는 다른 방법을 사용할 수 있다.

유의할 점은 일 실시예에서, ss가 ms보다 작은 경우, 메모리 목적지 요소를 생성하기 위해, s/u 필드(stvex와 관련하여 설명함)로 나타낸 바와 같이 각각의 소스 요소가 적절히 확장된다는 것이다. 또한, 일 실시예에서, ss가 ms보다 큰 경우, 메모리 목적지 요소(memory destination element)를 생성하기 위해, h/l 필드(stvex 및 stmvex와 관련하여 설명됨)로 나타낸 바와 같이 각각의 소스 요소가 적절히 절단된다. 다른 대안으로서, 메모리 목적지 요소를 생성하기 위해 반올림이 사용될 수 있다.

전술한 여러가지 서로 다른 로드 명령어의 예가 도 12 내지 도 16을 참조하여 기술된다. 도 12는 예를 들어 도 1의 메모리(12)의 전부 또는 그 일부분에 대응할 수 있는 메모리의 일부분(100)을 나타낸 것이다. 메모리 부분(100)은 설명의 편의상 128-비트 와이드 메모리로서 나타내어져 있지만, 주어진 실시예에서의 실제 구성은 다를 수 있다. 예를 들어, 메모리 부분(100)은 위치 0x12-0x16에 저장된 첫번째 행(하프워드 A, B 및 C에 대응함), 위치 0x22-0x26에 저장된 두번째 행(하프워드 D, E 및 F에 대응함), 및 위치 Ox32-0x36에 저장된 세번째 행(하프워드 G, H 및 I에 대응함)를 갖는 행렬(102)을 포함한다. 메모리 부분(100)은 위치 0x54-0x58에 저장된 첫번째 행(하프워드 K, L 및 M에 대응함), 위치 0x64-0x68에 저장된 두번째 행(하프워드 N, O 및 P에 대응함), 및 위치 Ox74-0x78에 저장된 세번째 행(하프워드 Q, R 및 S에 대응함)를 갖는 행렬(106)을 포함한다. 메모리 부분(100)은 위치 0x8A-0x8E에 저장된 첫번째 행(하프워드 aa, bb 및 cc에 대응함), 위치 0x9A-0x9E에 저장된 두번째 행(하프워드 dd, ee 및 ff에 대응함), 및 위치 OxAA-0xAE에 저장된 세번째 행(하프워드 gg, hh및 ii에 대응함)를 갖는 행렬(108)을 포함한다. 메모리 부분(100)은 위치 0x46-0x4E에 저장된 벡터(104)(하프워드 pp, qq, rr, ss 및 tt에 대응함)를 포함한다. 메모리 일부분(100)은 또한 위치 0xA2, 0xA3, 0xA4 및 0xA5에 각각 저장된 바이트-크기 요소 T, U, V 및 W도 포함한다.

유의할 점은 대체 실시예에서, 메모리 부분(100)이 서로 다르게 어드레스될 수 있다는 것이다. 또한, 메모리 부분(100)이 임의의 크기를 가질 수 있으며 임의의 유형의 정보를 가질 수 있고, 또 데이터 프로세싱 시스템 내의 어느 곳에라도 위치할 수 있다.

행렬이 도 12의 행렬(102, 106)에 저장되어 있을 때, 전술한 로드 및 저장 명령어는 예를 들어 행렬 연산을 수행하는 데 사용될 수 있다. 즉, 유의할 점은 행렬(102, 106) 각각이 3x3 2차원 어레이로서 저장된다는 것이다. 또한, 일 실시예에서, 행렬 연산의 결과도 역시 동일한 포맷으로, 즉 행렬(108)과 같이, 3x3 2차원 행렬로서 저장될 수 있다. 따라서, 유의할 점은 이하의 의사 코드가 행렬(102) 및 행렬(106)의 첫번째 행의 가산을 수행하여 그 결과적인 첫번째 행 행렬(108)을 획득하는 데 사용될 수 있다는 것이다.

/* R7은 0x12를 저장하고 R8은 3의 cnt 값 및 1의 stride 값을 저장함 */

lvex.u.mh.dh RO, R7, R8

/* R9는 Ox54를 저장하고 R10은 3의 cnt 값 및 1의 stride 값을 저장함 */

lvex.u.mh,dh R1, R9, R10

add.h R2, R0, R1 /* R0 및 R1의 4개의 독립적인 하프워드 요소를 합산하고 결과를 R2에 저장함 */

/* R11은 0x8A를 저장하고 R12는 3의 cnt 값 및 1의 stride 값을 저장함 */

stvex.u.mh.sh R2, R11, R12

유의할 점은 이 예에서 R7이 행렬(102)의 첫번째 행의 시작 어드레스(0x12)를 저장하고, R8이 도 2 및 도 3과 관련하여 전술한 cnt 및 stride 파라미터를 저장하기 위한 rB로서 사용된다는 것이다. 이와 유사하게, R9는 행렬(106)의 첫번째 행의 시작 어드레스(0x54)를 저장하고 r10은 cnt 및 stride 파라미터를 저장하기 위한 rB로서 사용된다. R11은 R2의 첫번째 요소가 저장되어지는 위치(0x8A)를 저장하는 데 사용되고 R12는 cnt 및 stride 파라미터를 저장하는 데 사용된다.

도 13은 상기 의사 코드(pseudo-code)의 실행 후의 레지스터 파일(예를 들어, 도 1의 스칼라 레지스터 파일(34) 등)을 나타낸 것이다. 유의할 점은 행렬(102)의 A, B 및 C가 첫번째 lvex 명령어의 실행으로 R0에 로드되고, R0의 마지막 필드는 미리 정해진 값(예를 들어, 이 실시예에서는 영)으로 채워진다는 것이다. 이와 유사하게, 행렬(106)의 K, L 및 M은 두번째 lvex 명령어의 실행으로 R1에 로드된다. 따라서, 유의할 점은 행렬의 첫번째 행들 각각이 cnt 및 stride가 지정될 수 있게 해주는 단일의 명령어만으로 용이하게 로드될 수 있다는 것이다. add.h 명령어는 R0 및 R1 내의 4개의 독립적인 하프워드 요소들을 가산하고 그 결과적인 4개의 하프워드 요소들을 R2에 배치한다. 유의할 점은 lvex 명령어가 R0 및 R1의 마지막 미사용 필드를 영으로 채울 수 있게 해주기 때문에(왜냐하면 cnt*ds가 R0 및 R1의 폭인 64 비트보다 작기 때문임), 2개의 레지스터를 가산하면 R2의 원하지 않는 필드에 제로가 오게 된다. 이와 같이, R2의 원하지 않는 필드에 미지의 값을 갖는 것(또는 미지의 값의 가산으로 인해 원하지 않는 예외적인 상황이 일어나게 하는 것)보다는, 미리 정해진 값(예를 들어, 영)으로 되는 것이 공지되어 있다. 이어서, aa = A + K, bb = B + L 및 cc = C + H가 되도록, R2의 처음 3 필드가 stvex 명령어를 사용하여 메모리에 저장된다.

이어서, 행렬(102, 106)의 가산이 이하의 의사 코드에 의해 완료될 수 있다.

add R7, 0x10 /* R7은 이제 0x22를 저장하고 있음 */

add R9, 0x10 /* R9는 이제 0x64를 저장하고 있음 */

add R11, 0x10 /* R11은 이제 0x9A를 저장하고 있음 */

lvex.u.mh.dh R0, R7, R8

lvex.u.mh.dh R1, R9, R10

add.h R2, R0, R1

stvex.u.mh.sh R2, R11, R12

add R7, 0x10 /* R7은 이제 0x32를 저장하고 있음 */

add R9, 0x10 /* R9는 이제 0x74를 저장하고 있음 */

add R11, 0x10 /* R11은 이제 0xAA를 저장하고 있음 */

lvex.u.mh.dh R3, R7, R8

lvex.u.mh.dh R4, R9, R10

add.h R5, R0, R1

stvex.u.mh.sh R5, R11, R12

처음 3개의 add 명령어는 R7, R9 및 R11의 값들을 증가시켜, 각각은 행렬(102, 106, 108) 각각의 두번째 행의 첫번째 요소를 각각 가리키도록 한다. 도 14는 상기 코드의 실행 이후의 도 13의 레지스터 파일을 나타낸 것이다. 처음 2개의 lvex 명령어 이후에, D, E 및 F는 R0 내에 로드되고, N, O 및 P는 R1에 로드된다. add.h 명령어는 R0 및 R1 내의 4개의 독립적인 하프워드 요소를 가산하고, 4개의 결과 하프워드 요소를 R2 내에 배치한다. 이어서, 이 결과는 stvex 명령어에 의해 메모리에 행렬(108)로 저장되어 dd = D + N, ee = E + O 및 ff = F + P가 된다. 5번째 내지 7번째 add 명령어는 또다시 R7, R9 및 R11의 값을 증가시켜, 그들 각각이 행렬(102, 106, 108) 각각의 세번째 행의 첫번째 요소를 각각 가리키도록 한다. 유의할 점은 행렬(102, 106)의 세번째 행을 로드하기 위한 lvex 명령어가 이들을 R0 및 R1이 아니라 R3 및 R4에 각각 로드한다는 것이다. 대체 실시예들이 필요에 따라 연산을 수행하기 위해 임의의 레지스터를 사용할 수 있음을 잘 알 것이다. 예를 들어, 동일 레지스터(R0 및 R1 등)가 연속적으로 오버라이트되거나 다른 레지스터(R3 및 R4 등)가 사용될 수 있다. 마지막 저장 명령어는 이 결과를 행렬(108)에 저장하여 gg = G + Q, hh = H + R 및 ii = I + S가 된다.

유의할 점은 대체 실시예에서, 행렬(102, 106)을 가산하여 그 결과를 행렬(108)에 저장하기 위해 다른 코드 및 명령어가 사용될 수 있다는 것이다. 예를 들어, 상기 의사 코드는 행렬의 각각의 행에 대해 2개의 lvex 및 하나의 stvex 명령어가 루프 보디에 있도록 루프 형태로 작성될 수 있으며, 이 경우 루프는 각 행에 대해 한번씩 3번 수행된다. 다른 대안으로서, 행렬(102) 또는 행렬(106) 모두를 한꺼번에 레지스터 파일로 가져오기 위해 다른 벡터 로드 및 저장 명령어가 사용될 수 있다. 이것은 예를 들어 lmvex 또는 lmvex2 명령어를 사용하여 달성될 수 있다. 예를 들어, 도 15 및 도 16은 행렬(102)을 레지스터(R0, R1, R2)로 로드하는 2가지 예를 나타낸 것이다.

도 15는 예를 들어 lmvex 명령어를 사용하여 행렬(102)을 로드한 이후의 레지스터 파일을 나타낸 것이다. 이하의 lmvex 명령어에서, R7이 행렬(102)의 시작을 가리키는 것으로(R7이 0x12를 저장하고 있는 것으로) 가정하고 R8이 9의 cnt 값, 1의 stride 값, 6의 skip 값, 및 3의 skip_cnt 값을 저장하는 rB에 대응하는 것으로 가정한다. 따라서, 이하의 명령어가 사용될 수 있다.

lmvex.u.mh.dh R0, R7, R8 /* cnt = 9, stride = 1, skip = 6 및 skip_cnt = 3 */

따라서, 도 15에 도시한 바와 같이, 요소 A, B 및 C는 R0에 로드되고, 각각이 메모리에서는 연속적인데 그 이유는 이 요소들이 "stride*ms" 또는 1 하프워드 떨어져 위치하고 있기 때문이다. 이어서, skip_cnt개(즉, 3개)의 요소들이 로드되기 때문에, "stride*ms"(즉, 1 하프워드) 떨어져 있기 보다는 "skip*ms"(즉, 6개 하프워드) 떨어져 위치하고 있는 그 다음 요소 D는 R0의 4번째 요소로서 로드된다. 이어서, 다시 skip_cnt개의 요소가 로드될 때까지, 요소 E 및 F가, R0에 후속하는 레지스터인 R1에 로드되어, 6 하프워드 떨어져 위치하는 그 다음 요소 G로의 "건너뜀(skip)"을 필요로 한다. 이것은 "cnt"개의 요소가 로드될 때까지 계속된다. 따라서, 마지막 요소 I는 R2의 첫번째 필드에 로드된다. 유의할 점은 R2의 나머지 필드가 미리 정해진 값(이 예에서는, 영)으로 채워진다는 것이다.

도 16은 예를 들어 cnt, rcnt, skip 및 skip_cnt가 지정될 수 있는 lmvex2 명령어를 사용하여 행렬(102)을 로드한 후의 레지스터 파일을 나타낸 것이다. 이하의 lmvex 명령어에서, R7이 행렬(102)의 시작을 가리키는 것으로(R7이 0x12를 저장하고 있는 것으로) 가정하고 또 R8이 9의 cnt 값, 3의 rcnt 값, 1의 stride 값 및 6의 skip 값을 저장하고 있는 rB에 대응하는 것으로 가정한다. 따라서, 이하의 명령어가 사용될 수 있다.

lmvex2.u.mh.dh R0, R7, R8 /* cnt = 9, rcnt = 3, stride = 1, skip = 6 */

따라서, 도 16에 도시한 바와 같이, 요소 A, B 및 C는 R0에 로드되고, 이 각각은 메모리에서는 연속적인데 그 이유는 스트라이드가 "stride*ms" 또는 1 하프워드이기 때문이다. 이 때, rcnt개(즉, 3개)의 요소가 R0에 로드되고, 따라서 그 다음 요소 D는 "skip*ms"(즉, 6개 하프워드) 떨어져 있는 위치로부터 로드된다. 게다가, 그 다음 요소 D는 lmvex 명령어를 사용하는 이전의 도 15의 예에서 행해진 것과 같이 R0의 네번째 요소로서 로드되지 않고, 그 대신에 R1(R0에 후속하는 레지스터임)의 첫번째 요소로서 로드되는데, 그 이유는 R0가 이미 "rcnt"개의 요소를 가지고 있기 때문이다. 요소 E 및 F도 역시 R1으로 로드되고 R1에 대한 3의 rcnt를 완료한다. rcnt개의 요소가 R1에 로드되었기(또 cnt개(즉, 9개)의 요소가 아직 로드되지 않았기) 때문에, 그 다음 요소 G는 skip에 의해 결정된 위치로부터, 즉 6개 하프워드 떨어진 위치로부터 R2로 페치된다. 또한, 요소 H 및 I도 역시 R2로 로드된다. 이 때, cnt개의 요소가 로드된다. 또한, 유의할 점은 R0, R1 및 R2의 미사용 필드 각각이 미리 정해진 값(이 예에서는, 영)으로 채워진다는 것이다.

대체 실시예에서, 전술한 바와 같이, lmvex2 명령어는 또한 skip_cnt 필드가 지정될 수 있게 해준다. 예를 들어, 행렬(102)은 또한 도 16에서 보는 바와 같이 상기와 같이 3의 skip_cnt를 갖는 lmvex2 명령어를 사용하여 로드될 수 있다. 이 예(여전히 도 16을 참조하며 상기 lmvex2 명령어는 동일 파라미터 모두 및 skip_cnt = 3의 가산을 가짐)에서, 요소 A, B 및 C는 R0에 로드되고, 이 각각은 메모리에서는 연속적인데 그 이유는 이 요소들이 "stride*ms", 즉 1개 하프워드 떨어져 위치하고 있기 때문이다. 이어서, skip_cnt개(즉, 3개)의 요소가 로드되기 때문에, "stride*ms"(즉, 1개 하프워드) 떨어져 위치하기 보다는 "skip*ms"(즉, 6개 하프워드) 떨어져 위치하고 있는 그 다음 요소 D가 로드된다. 또한, 유의할 점은 rcnt개(즉, 3개)의 요소만이 각각의 레지스터에 로드된다는 것이다. 따라서, 그 다음 요소 D는 lmvex 명령어를 이용하는 이전의 도 15의 예에서 행해진 것과 같이 R0의 네번째 요소로서 로드되지 않고 그 대신에 R1(R0에 후속하는 레지스터임)의 첫번째 요소로서 로드된다. 이어서, 요소 E 및 F도 역시 R1에 로드된다. skip_cnt개의 요소가 또다시 로드되었기(또 cnt개, 즉 9개의 요소가 아직 로드되지 않았기) 때문에, 그 다음 요소 G는 6개 하프워드 떨어져 위치하고 있다. 또한, rcnt개의 요소가 이미 R1에 로드되어 있기 때문에, 그 다음 요소 G는 H 및 I와 함께 R2에 로드된다. 이 때, cnt개의 요소가 로드된다. 또한, 유의할 점은 R0, R1 및 R2의 미사용 필드 각각이 미리 정해진 값(이 예에서는, 영)으로 채워진다는 것이다.

따라서, 유의할 점은 행렬(102) 등의 행렬이 상기한 로드 명령어의 여러가지 실시예를 사용하여 다양한 서로 다른 방식으로 용이하게 메모리로부터 레지스터 파일로 이동될 수 있다는 것이다. 또한, 유의할 점은 rcnt 파라미터의 사용이 메모리로부터 벡터 요소를 로드하기 위해 종래의 프로그래밍 방법을 사용할 때 요구되는 마스킹 동작의 수를 감소시킬 수 있다는 것이다.

대체 실시예에서, 상기 명령어들은 본 명세서에 기술된 것보다 더 많은, 더 적은 또는 그와 다른 파라미터를 포함할 수 있다. 예를 들어, 다른 실시예들에서, lmvex2 명령어는 skip_cnt 파라미터를 고려하거나 고려하지 않을 수 있다. 또한, 유의할 점은 상기 제공된 예시적인 명령어가 필요한 경우 요소들이 레지스터에 저장될 때 제로 확장되도록 s/u 필드를 u로 설정한다는 것이다. 일 실시예에서, s/u 필드는 "s"로 설정되거나 생략될 수 있다. 예를 들어, 일 실시예에서, ms = ds인 경우, s/u 필드는 생략되거나 무시될 수 있다.

도 16도 또한 T, U 및 V를 메모리 일부분(100)에서의 위치 0xA2, 0xA3 및 0xA4로부터 R4로 로드하는 로드 명령어의 예를 나타낸 것이다. 예를 들어, 이하의 lvex 명령어가 사용될 수 있으며, 이 경우 R10이 시작 값 0xA2를 저장하고 R11이 3의 cnt 값 및 1의 stride 값을 저장하는 것으로 가정한다.

lvex.u.mb.dh R4, R10, R11

유의할 점은 메모리 크기(mb) 및 목적지 크기(dh)가 서로 다르다는 것이다. 즉, 본 명세서에 기술된 모든 명령어들에서, 메모리 크기 및 목적지 크기(또는 저장 명령어의 경우에, 소스 크기) 각각은 이들이 동일하거나 서로 다를 수 있도록 독립적으로 설정될 수 있다. 상기 예에서, 유의할 점은 메모리 크기가 메모리에서의 각각의 요소(T, U 및 V)의 크기가 바이트임을 가리키는 mb로 설정된다는 것이다. 그렇지만, 목적지 크기는 R4에서의 목적지 크기가 바이트보다 큰 하프워드임을 나타내기 위해 dh로 설정된다. 따라서, cnt개의 요소(3개의 요소)가 R4로 로드되고, 여기서 각각의 요소 T, U 및 V는 하프워드 목적지 크기를 채우기 위해 적절히 확장된다. 이 예에서, 이들은 ".u"로 나타낸 바와 같이 제로 확장된다(즉, 무부호 확장된다). 그렇지만, 요소들 각각을 부호 확장하기 위해 ".s"가 사용될 수 있다. 또한, 유의할 점은 "cnt*ds"가 3 하프워드(즉, 46 비트)이고 따라서 R4의 크기보다 작기 때문에, R4의 나머지 미사용 부분은 미리 정해진 값(이 예에서는, 영)으로 채워진다는 것이다.

도 17은 레지스터 파일의 예를 나타낸 것이며, 여기서 메모리 부분(100)의 벡터(104)는 1의 stride 및 2의 stride로 로드되어 있다. 일 예에서, R7은 0x46을 저장함으로써 벡터(104)의 시작인 pp를 가리키고 R10은 5의 cnt 값, 1의 stride 값 및 5의 skip_cnt 값을 저장하고 있는 것으로 가정한다. 유의할 점은 cnt = skip_cnt이기(즉, "건너뛸(skip)" 필요없이 메모리로부터의 단일의 벡터가 로드되기) 때문에 skip의 값이 이 예에서는 중요하지 않다는 것이다. 따라서, 이하의 명령어는 벡터(104)를 레지스터 파일에 로드하는 데 사용될 수 있다.

lmvex.u.mh.dh R1, R7, R10 /* cnt = 5, stride = 1, skip_cnt = 5 */

상기 예에서, cnt개의 요소(5개의 요소)가 R1에서 시작하여 R2로 계속되는 레지스터 파일에 로드된다. stride = 1이고 후속하는 요소들이 "stride"개의 크기 ms인 단위만큼 떨어져 위치하기 때문에, 로드될 요소들은 서로로부터 1개 하프워드만큼 떨어져 위치하고 있다. 따라서, 5개의 연속한 하프워드(pp, qq, rr, ss, tt)가 레지스터 R1 및 R2에 로드된다. 또한 유의할 점은 R2의 나머지 미사용 부분들은 미리 정해진 값(본 예에서는 0)으로 채워지는 것이다. 또한, 유의할 점은 그 대신에 s/u 필드에 대해 ".s"가 사용될 수 있다는 것이다. 또는, 다른 대안으로서, s/u 필드가 존재하지 않을 수 있다.

다른 예에서, R7이 pp를 가리키고(0x46을 저장하고 있고) R10이 3의 cnt 값 및 2의 stride 값을 저장하고 있는 것으로 가정한다. 따라서, 벡터(104)의 요소를 하나 걸러 레지스터 파일에 로드하는 데 이하의 명령어가 사용될 수 있다.

lvex.u.mh.dh R4, R7, R10 /* cnt = 3, stride = 2 */

이 예에서, lvex 명령어가 사용될 수 있는데, 그 이유는 cnt*ms(3개 하프워드)가 단일의 레지스터(예시된 실시예에서, 64-비트 레지스터)에 들어가기 때문이다. 이 lvex 명령어로, cnt개의 요소(3개의 요소)가 R4에 로드되고, 여기서 후속 요소들은 "stride"개의 크기 ms인 단위만큼 떨어져 위치하고 있다. 따라서, 이 예에서, 후속 요소들은 2개 하프워드("stride*ms") 떨어져 위치하고 있으며, 따라서 각각의 요소가 로드된 후에, 그 다음 요소는 2개 하프워드 떨어진 곳으로부터 페치된다. 예를 들어, pp는 0x46으로부터 페치되고, 이어서 rr은 0x4A(0x46 + 0x2)로부터 페치된다. 이것은 3개의 요소가 로드될 때까지 계속된다. 또한, 유의할 점은 R4의 미사용 부분이 미리 정해진 값(이 예에서는, 영)으로 채워진다는 것이다.

도 18은 예를 들어 도 1의 메모리(12)(또는 데이터 프로세싱 시스템 내의 어느 곳에라도 위치할 수 있음)의 전부 또는 그 일부분에 대응할 수 있는 4개의 서로 다른 때(시각 = 0, 시각 = 1, 시각 = 2 및 시각 = 3)의 메모리의 부분(200)을 나타낸 것이다. 예시된 실시예에서, 메모리 일부분(200)은 64-비트 폭 메모리로서 도시되어 있다. 유의할 점은 대체 실시예들에서, 메모리 부분(200)이 서로 다른 폭을 갖는 다양한 서로 다른 방식으로 포맷될 수 있다는 것이다. 메모리 부분(200)은 요소 C₄, C₃, C₂, C₁ 및 C₀를 각각 메모리 위치 0x80, 0x0A, 0x0C, 0x0E 및 0x10에 저장하고 있다. 요소 t, u 및 v는 각각 0x12, 0x14 및 0x16에 저장되어 있다. 시각 t=0에서의 메모리 부분(200)은 또한 X_-4, X_-3, X_-2, X_-1 및 X₀를 각각 위치 0x20, 0x22, 0x24, 0x26 및 0x28에 저장하고 있다. 일 실시예에서, 이들 값 각각은 특정의 샘플 레이트로 샘플링된 디지털적으로 샘플링된 신호의 여러가지 시간 샘플을 지칭할 수 있다. 예를 들어, 시각 = 0에서, 현재 샘플은 X₀로 표시되고, 1 시각 지연(즉, 1/샘플 레이트) 이전의 샘플은 X_-1로 표시되며, 2 시각 지연(즉, 2* 1/샘플 레이트) 이전의 샘플은 X_-2로 표시되어 있고, 이하 마찬가지이다.

그 다음에, 시각 = 1에서, 현재 샘플은 현재 샘플은 X₁로 표시되고, 1 시각 지연(즉, 1/샘플 레이트) 이전의 샘플은 X₀로 표시되며, 2 시각 지연(즉, 2* 1/샘플 레이트) 이전의 샘플은 X_-1로 표시되어 있고, 이하 마찬가지이다. 유의할 점은 가장 새로운 샘플이 가장 오래된 시간 샘플(시각 = 1에서 예시된 실시예에서는 X_-4임)을 오버라이트한다는 것이다. 따라서, 시각 = 2에서, 현재 샘플 X₂는 X_-3을 오버라이트하고, 시각 = 3에서, 현재 샘플 X₃은 X_-2를 오버라이트한다. 따라서, 저장 위치 0x20, 0x22, 0x24, 0x26 및 0x28은 디지털적으로 샘플링된 신호의 들어오는 시간 샘플을 연속하여 저장하는 원형 버퍼를 구현할 수 있다. 대체 실시예에서, 원형 버퍼는 다른 이유로 또는 다른 응용을 위해 구현될 수 있다.

일 실시예에서, 원형 버퍼의 값들이 예를 들어 필터링 펑션을 구현하는 등에 있어서 계산을 위해 정확한 원하는 순서로 있도록 이들 값을 레지스터 파일의 레지스터들로 정확히 가져오기 위해 수정된 lmvex 로드 명령이 사용될 수 있다(이에 대해서는 도 19 내지 도 22를 참조하여 기술됨). 예를 들어, 이하의 식은 필터링 펑션에 대응할 수 있으며, 여기서 Y₀, Y₁, Y₂ 및 Y₃은 각각 시각 = 0, 시각 = 1, 시각 = 2 및 시각 = 3에서의 결과에 대응한다.

식 1 Y₀ = C₀*X₀+C₁*X_-1+C₂*X_-2+C₃*X_-3+C₄*X_-4

식 2 Y₁ = C₀*X₁+C₁*X₀+C₂*X_-1+C₃*X_-2+C₄*X_-3

식 3 Y₂ = C₀*X₂+C₁*X₁+C₂*X₀+C₃*X_-1+C₄*X_-2

식 4 Y₃ = C₀*X₃+C₁*X₂+C₂*X₁+C₃*X₀+C₄*X_-1

일 실시예에서, 수정된 lmvex 명령어는 도 27에 나타낸 바와 같이 다중 벡터 요소 1회 건너뜀 로드(skip once load multiple vector elements, lmvex_skip_once) 명령어라고 한다. 도 27의 lmvex_skip_once 명령어는 lmvex 명령어와 관련하여 상기한 바와 똑같이 동작하는 s/u 필드, ms 필드 및 ds 필드를 포함한다. lmvex_skip_once 명령어는 또한 3개의 피연산자, 즉 rD, rA 및 rB를 취한다. lmvex_skip_once는 부가의 파라미터, 즉 cnt, stride, skip 및 skip_cnt를 사용하며, 여기서 이들은 rB로 표시된 레지스터 또는 레지스터들에 저장되어 있거나 명령어의 서브 연산 코드에 의해 지정될 수 있다. 피연산자 및 부가의 파라미터 모두는 skip_cnt 부가의 파라미터를 제외하고는 lmvex 명령어와 관련하여 상기한 것과 동일하게 동작한다. 상기한 바와 같이, lmvex 명령어는 skip_cnt개의 요소를 페치하고 이어서 그 다음 요소를 페치하기 위해 "skip" 파라미터를 사용한다. 이 때, skip_cnt 카운터는 또다시 건너뛰기 이전에 그 다음의 skip_cnt개의 요소가 페치될 수 있도록 리셋되어야만 한다. 이것은 cnt개의 요소가 로드될 때까지 계속된다. lmvex_skip_once 명령어는 lmvex 명령어와 달리 skip_cnt개의 요소가 페치된 후에 skip_cnt 카운터를 리셋하지 않는다. 따라서, skip_cnt개의 요소가 페치된 후에, 그 다음 요소는 skip개의 크기 ms인 단위만큼 떨어져 위치하고 있다. 그렇지만, 이 때부터 계속하여 skip_cnt 카운터는 "cnt"개의 요소가 페치될 때까지 계속하여 감소된다(즉, 리셋되지 않는다).

예를 들어, 도 19 내지 도 22를 참조하여 기술하는 바와 같이, 이하의 의사 코드 섹션은 상기 식 1, 2, 3 및 4의 필터 결과 Y₀, Y₁, Y₂ 및 Y₃를 계산하는 데 사용될 수 있다.

/* 5의 cnt 값 및 1의 stride 값을 저장하도록 R12를 초기화함 */

/* 5의 cnt 값, 1의 stride 값, 5의 skip_cnt 값 및 -4의 skip 값을 저장하도록 R13을 초기화함 */

/* 0x08을 저장하도록 R1을 초기화함 */

/* 0x20을 저장하도록 R2를 초기화함 */

lmvex.u.mh.dh R6, R1, R12 /* C₄-C₁을 R6에 로드하고 C₀를 R7에 로드함 */

loop:

lmvex_skip_once.u.mh.dh R8, R2, R13 /* 첫번째 반복에서, X_-4-X_-1을 R8에 로드하고 X₀를 R9에 로드함 */

vmac.h R10, R6, R8 /* 첫번째 반복에서, C₄+X_-4 + C₃*X_-3 +C₂*X_-2 + C₁*X_-1을 R10에 저장함 */

vmac.h R11, R7, R9 /* 첫번째 반복에서, C0*X0를 R11에 저장함 */

add R10, R10, R11 /* 첫번째 반복에서, Y₀를 R10에 저장함 */

/* R10 내의 값이 메모리로 저장될 수 있음 */

add R2, R2, 2 /* R2에서의 시작 포인터를 2만큼 앞으로 이동시킴 */

/* "skip_cnt = skip_cnt - 1"이 되도록 R13에서의 값을 수정함 */

branch loop

상기 코드 섹션에서 라벨 "loop:"로 표시된 루프에 들어가기에 앞서, R12는 5의 cnt 값 및 1의 stride 값으로 초기화되고, R13은 5의 cnt 값, 1의 stride 값, 5의 skip_cnt 값 및 -4의 skip 값으로 초기화된다. 따라서, 레지스터 R12 및 R13은 후속 벡터 로드 명령어에서 "rB" 피연산자로서 사용될 수 있다. R1은 상수 벡터의 시작(0x08에 있는 C₄)을 가리키도록 초기화된다. R2는 원형 버퍼의 시작(도 18에 도시된 바와 같이, 시각 = 0에서 0x20임)을 가리키도록 초기화된다. 따라서, 유의할 점은 루프의 첫번째 반복이 시각 = 0에 대응하는 레지스터 파일(도 19에 도시되어 있음)로 로드되는 값들에 대응한다는 것이다.

첫번째 lmvex 명령어는 이전에 초기화된 R12에 저장된 파라미터 및 도 4 및 도 5를 참조하여 전술한 바와 같은 제어 필드에 따라 C₄-C₁을 R6에 로드하고 C₀를 R7에 로드한다(도 19에서 R6 및 R7로 예시되어 있음). 이어서, 루프를 통한 첫번째 반복은 lmvex_skip_once 명령어부터 시작된다. 시각 = 0에 대응하는 첫번째 반복에서, lmvex_skip_once 명령어는 R12에 저장된 파라미터 및 도 19에서 R8 및 R9로 나타낸 바와 같이 이전에 초기화된 제어 필드에 따라 X_-4-X_-1을 R8에 로드하고 X₀를 R9에 로드한다. 유의할 점은 이 첫번째 반복에서 skip_cnt = cnt이므로, skip 값이 필요하지 않기 때문에 skip 값이 "don't care"로서 취급될 수 있다는 것이다. 즉, skip_cnt 카운터가 만료될 때, cnt 카운터도 만료되고 따라서 명령어는 "건너뜀(skipping)" 없이 완료된다.

첫번째 벡터 곱셈-누적(vector multiply-accumulate) 명령어(vmac.h)는 레지스터 R6 및 R8의 하프워드 요소에 대해 벡터 곱셈-누적 연산을 하고 결과를 R10에 저장한다. 따라서, 도 19에서 R10으로 나타낸 바와 같이, R10은 이제 C₄*X_-4+C₃*X_-3+C₂*X_-2+C₁*X_-1을 저장하고 있다. 두번째 벡터 곱셈-누적 명령어는 레지스터 R7 및 R9의 하프워드에 대해 벡터 곱셈-누적 연산을 하고 결과를 R11에 저장한다. 따라서, R11은 이제 C₀*X₀+0*0+0*0+0*0(간단히 C₀*X₀와 같음)을 저장하고 있다. 유의할 점은 이 예에서 벡터 로드 명령어(lmvex 및 lmvex_skip_once) 각각에 있어서, 레지스터(R7 및 R9 등)의 나머지 채워지지 않은 부분이 영으로 되고, 따라서 그 결과 R11에 정확한 결과가 얻어진다. 그렇지 않고, 예를 들어 t, u 및 v의 값이 그 대신에 메모리(200)로부터 로드된 경우, R11은 부정확한 값일 수 있다.

이어서, 첫번째 add 명령어는 R10 및 R11의 값을 가산하고 결과를 R10에 저장한다(이 동작은 도 19에 나타내지 않음). 상기 식 1의 Y₀에 대응하는 이 값은 이어서 필요에 따라 메모리(200) 등에 다시 저장될 수 있다. 두번째 add 명령어는, 도 18 및 도 20에 나타낸 바와 같이, 시각 = 1에 대한 시작 포인터가 이제 어드레스 0x22에 있는 X_-3을 가리키도록 원형 버퍼의 시작 포인터를 그 다음 하프워드로 전진시킨다. 그 다음에, R13은 skip_cnt = skip_cnt - 1이 되도록 수정된다. 따라서, 상기 코드 세그먼트의 첫번째 반복 이후에, skip_cnt는 이제 4이다. 루프 카운터 또는 부가의 명령어(상기 코드 세그먼트에 포함되지 않음)는 루프가 종료되어야만 하는지 여부를 나타내는 데 사용될 수 있다. 루프가 종료되지 않은 경우, 코드는 다시 "loop"로 분기하고 그 다음 반복이 시작한다.

값 C₄-C₀는 R6 및 R7에 남아 있다(도 20에서 R6 및 R7로 나타냄). 루프를 통한 두번째 반복은 lmvex_skip_once 명령어로 시작한다. 시각 = 1에 대응하는 두번째 반복에서, lmvex_skip_once 명령어는, 도 20에서 R8 및 R9로 나타낸 바와 같이, 제어 필드 및 R12에 저장된 파라미터에 따라 X_-3-X₀를 R8에 로드하고 X₁을 R9에 로드한다. 이 반복에서, skip_cnt가 4이고 rA가 로드될 첫번째 요소로서 X_-3을 가리키고 있기 때문에, 4개의 요소, 즉 X_-3-X₀가 로드된다. 이 때, skip_cnt(4)개의 요소가 로드되었고 cnt(5)개의 요소가 아직 로드되지 않았기 때문에, 그 다음 요소는 "skip"개의 크기 ms(하프워드)인 단위만큼 떨어진 위치로부터 로드된다. 따라서, 이 예에서의 -4의 skip은 0x28 - 4*2 = 0x20이기 때문에 요소 X₁이 로드될 수 있게 해준다. (유의할 점은 메모리(200)이 하프워드 어드레싱가능(halfword addressable)이며, 따라서 크기 ms인 skip 단위만큼 떨어져 있다는 것은 -4개 하프워드 떨어져 있음을 나타낸다는 것이다.) 유의할 점은 전술한 바와 같이 시각 = 1에서 메모리(200)에서 가장 최근의 요소가 이전에 가장 오래된 시간 샘플의 위치인 0x20에 저장된다는 것이다. 따라서, lmvex_skip_once 명령어는 Y₁을 계산하는 데 필요한 5개 요소를, 가장 오래된 것부터 가장 새로운 시간 샘플의 순서로 메모리 위치 0x20-0x28로부터 R8 및 R9로 정확하게 로드한다.

첫번째 벡터 곱셈-누적 명령어(vmac.h)는 레지스터 R6 및 R8의 하프워드 요소에 대해 벡터 곱셈-누적 연산을 하고 결과를 R10에 저장한다. 따라서, 도 20에서 R10으로 나타낸 바와 같이, R10은 이제 C₄*X_-3+C₃*X_-2+C₂*X_-1+C₁*X₀을 저장하고 있다. 두번째 벡터 곱셈-누적 명령어는 레지스터 R7 및 R9의 하프워드에 대해 벡터 곱셈-누적 연산을 하고 결과를 R11에 저장한다. 따라서, R11은 이제 C₀*X₁+0*0+0*0+0*0(간단히 C₀*X₁와 같음)을 저장하고 있다. 유의할 점은 이 예에서 벡터 로드 명령어(lmvex 및 lmvex_skip_once) 각각에 있어서, 레지스터(R7 및 R9 등)의 나머지 채워지지 않은 부분이 영으로 되고, 따라서 그 결과 R11에 정확한 결과가 얻어진다. 그렇지 않고, 예를 들어 a, b 또는 c(또는 t, u 또는 v)의 값이 그 대신에 메모리(200)로부터 로드된 경우, R11은 부정확한 값일 수 있다.

이어서, 첫번째 add 명령어는 R10 및 R11의 값을 가산하고 결과를 R10에 저장한다(이 동작은 도 20에 나타내지 않음). 상기 식 2의 Y₁에 대응하는 이 값은 이어서 필요에 따라 메모리(200) 등에 다시 저장될 수 있다. 두번째 add 명령어는, 도 18 및 도 21에 나타낸 바와 같이, 시각 = 2에 대한 시작 포인터가 이제 어드레스 0x24에 있는 X_-2을 가리키도록 원형 버퍼의 시작 포인터를 그 다음 하프워드로 전진시킨다. 그 다음에, R13은 skip_cnt = skip_cnt - 1이 되도록 수정된다. 따라서, 상기 코드 세그먼트의 두번째 반복 이후에, skip_cnt는 이제 3이다. 루프 카운터 또는 부가의 명령어(상기 코드 세그먼트에 포함되지 않음)는 루프가 종료되어야만 하는지 여부를 나타내는 데 사용될 수 있다. 루프가 종료되지 않은 경우, 코드는 다시 "loop"로 분기하고 그 다음 반복이 시작한다.

세번째 반복은 첫번째 및 두번째 반복과 유사하게 동작한다. 시각 = 2에 대응하는 세번째 반복에서, lmvex_skip_once 명령어는, 도 21에 나타낸 바와 같이, X_-2, X_-1, X₀, X₁ 및 X₂를 레지스터 R8 및 R9에 로드한다. 따라서, 요소 X_-2, X_-1 및 X₀가 로드되었으면(0x24부터 시작함), skip_cnt개의 요소가 로드되었고 skip은 X₁ 및 X₂를 로드하는 데 사용된다. 후속하는 벡터 곱셈-누적 명령어들의 결과 C₄*X_-2+C₃*X_-1+C₂*X₀+C₁*X_-1가 R10에 저장되고 C₀*X₂가 R11에 저장된다. 첫번째 add 명령어는 Y₂에 대응하는 결과를 R10에 저장하고, 여기서 Y₂는 이어서 원하는 경우 메모리에 저장될 수 있다. 이어서, 두번째 add 명령어는, 도 22에 나타낸 바와 같이, 포인터를 시작 위치 0x26으로 전진시킨다. 또한, R13은 skip_cnt = skip_cnt - 1이 되도록 수정된다. 따라서, 상기 코드 세그먼트의 세번째 반복 이후에, skip_cnt는 이제 2이다. 루프 카운터 또는 부가의 명령어(상기 코드 세그먼트에 포함되지 않음)는 루프가 종료되어야만 하는지 여부를 나타내는 데 사용될 수 있다. 루프가 종료되지 않은 경우, 코드는 다시 "loop"로 분기하고 그 다음 반복이 시작한다.

도 4 및 도 5를 참조하여 상기한 lmvex 명령어에 있어서, skip_cnt를 추적하는 메카니즘(예를 들어, 카운터)는 그 다음 skip_cnt 개의 요소들이 로드될 때(또 cnt개의 요소들이 아직 로드되지 않은 것으로 가정할 때) 그 다음 요소가 skip*ms개 단위만큼 떨어진 곳으로부터 로드되도록 리셋된다. 그렇지만, 이 예에서, lmvex_skip_once 명령어는 skip_cnt개의 요소가 로드될 때 skip_cnt를 추적하는 메카니즘이 리셋되지 않도록 사용되고 있다. 이와 같이, skip은 전체 cnt개의 요소가 로드되기 이전에는 다시 사용되지 않는다. 이것은 예를 들어 네번째 반복(시각 = 3에 대응함)에서 기술되는 바와 같이 모든 요소들이 후속 반복에서 정확하게 로드될 수 있게 해준다.

네번째 반복은 이전의 반복들과 유사하게 동작한다. 시각 = 3에 대응하는 네번째 반복에 있어서, lmvex_skip_once 명령어는 도 22에 나타낸 바와 같이, X_-1, X₀, X₁, X₂ 및 X₃을 레지스터 R8 및 R9에 로드한다. 이 반복에서, 유의할 점은 로드된 첫번째 요소가 위치 0x26(시각 = 3에 대해 도 18에 도시한 것과 같음)으로부터의 X_-1이라는 것이다. X_-1 및 X₀를 로드한 후에, skip_cnt(이제 2임)개의 요소들이 로드되었고, 따라서 cnt(5)개의 요소가 아직 로드되지 않았기 때문에 포인터를 다시 위치 0x20으로 넘어가도록 위해 skip이 사용된다. 또한, 유의할 점은 skip_cnt 메카니즘이 리셋되지 않는다는 것이다. 이와 같이, 그 다음 skip_cnt(2)개의 요소가 로드된 후에도, 건너뜀이 수행되지 않는다. 그 다음 skip_cnt개의 요소 후에 이 반복을 위해 건너뜀이 수행된 경우, 요소 X₁ 및 X₂만이 건너뛰기 이전에 페치되고 따라서 요소 X₃를 놓친다. 따라서, skip_cnt가 첫번째 건너뜀 이후에 리셋되었는지 여부가 이전의 반복에서는 중요하지 않을 수 있지만, 이번과 같은 어떤 반복에서는, 이것이 정확한 요소가 페치되는지 여부를 결정할 수 있다. 따라서, lmvex_skip_once 명령어가 예를 들어 필터 응용 등을 위한 원형 버퍼를 정확하게 구현하기 위해 어떻게 사용될 수 있는지를 잘 알 수 있다. 또한, 유의할 점은 상기 코드 세그먼트가 다양한 서로 다른 방식으로 작성될 수 있다는 것이다. 예를 들어, 루프는 루프로서 작성되기보다는 롤 아웃(roll out)될 수 있다. 이 예에서, lmvex 명령어는 시각 = 0, 1 및 2에 대해 사용될 수 있으며, lmvex_skip_once 명령어는 시각 = 3 및 4에 대해 사용될 수 있다.

도 22에서 알 수 있는 바와 같이, 요소 X_-1, X₀, X₁, X₂ 및 X₃이 로드되면, 후속하는 벡터 곱셈-누적 명령어 결과 C₄*X_-1+C₃*X₀+C₂*X_-1+C₁*X_-2가 R10에 저장되고 C₀*X₃가 R11에 저장된다. 첫번째 add 명령어는 Y₃에 대응하는 결과를 R10에 저장하고, 여기서 Y₃는 이어서 원하는 경우 메모리에 저장될 수 있다. 이 때, 이전의 반복에서 상기한 바와 같이 흐름이 계속된다. 일 실시예에서, R12가 skip_cnt가 0이도록 수정된 후에, skip_cnt가 다시 5로 리셋될 수 있도록 루프가 종료될 수 있고, 전체 프로세스가 반복된다.

따라서, skip, skip_cnt, stride 및 cnt와 함께 벡터 로드 명령어가 원형 버퍼를 구현하는 데 어떻게 사용될 수 있는지를 잘 알 수 있다. 일 실시예에서, 도 28에 나타낸 바와 같이, 원형 버퍼 다중 벡터 요소 로드(circular buffer load multiple vector elements, lmvex_cb) 명령어가 사용될 수 있다. 이 명령어는 rB에 저장된 부가의 파라미터가 buffer_size 및 offset인 것을 제외하고는 도 4 및 도 5와 관련하여 전술한 lmvex 명령어와 유사하다. (lmvex 명령어에서와 같이, 유의할 점은 대체 실시예에서 부가의 파라미터가 연산 코드 또는 서브 연산 코드의 일부로서 포함될 수 있다는 것이다.) 도 29는 원형 버퍼를 정의하기 위해 부가의 파라미터들이 어떻게 사용될 수 있는지를 나타낸 것이다. 예를 들어, 상기한 로드 명령어에서와 같이 rA는 도 29에 나타낸 바와 같이 원형 버퍼를 메모리에 저장하는 메모리 위치의 시작을 나타낸다. Buffer_size는 "버퍼 요소의 총 개수 * ms"를 나타내고, offset은 로드될 첫번째 요소가 원형 버퍼에서 어디에 있는지를 정의한다. 또한, 유의할 점은 예시되어 있지는 않지만 원형 버퍼 다중 벡터 요소 저장(circular buffer store multiple vector elements, stmvex_cb) 명령어도 역시 lmvex_cb에 상응하는 저장 명령어로서 사용될 수 있다는 것이다. lmvex_cb 및 stmvex_cb 명령어 둘다의 경우, 어떤 실시예에서, "offset"으로 표현된 현재 시작 값은 원형 버퍼를 통한 각각의 통과 이후에, 즉 cnt개의 요소가 처리된 후에 lmvex_cb 또는 stmvex_cb 명령어의 실행의 일부로서 미리 정해진 수의 요소만큼 자동적으로 증가 또는 감소된다.

도 30은 부가의 파라미터가 cnt, skip 및 skip_cnt보다는 오히려 buffer_size 및 offset을 포함하는 것(도 29와 관련하여 전술하였음)을 제외하고는 상기 lstrmvex 명령어와 유사하게 동작하는 lstrmvex_cb(circular buffer load stream of elements) 명령어를 나타낸 것이다. 상기 lstrmvex 명령어와 같이, lstrmvex_cb 명령어는 메모리로부터의 벡터 요소들의 스트림을 개시하고, 여기서 이 요소들은 예를 들어 rD가 후속 명령어의 특정의 소스 피연산자로서 사용되는 때에 의존하여 디큐될 수 있다. 따라서, 어드레싱 모드에 관한 것을 제외하고는, lstrmvex에 대한 상기 동일 설명이 lstrmvex_cb에 적용된다. 또한, 유의할 점은 예시되어 있지는 않지만 ststrmvex_cb(circular buffer store vector stream of elements) 명령어도 역시 lstrmvex_cb의 카운터 파트 저장으로서 사용될 수 있다는 것이다. lstrmvex_cb 및 ststrmvex_cb 둘다에 있어서, 어떤 실시예에서, "offset"으로 표현된 현재의 시작 값은 원형 버퍼를 통한 각각의 통과 후에 미리 정해진 수의 요소만큼 자동적으로 증가된다.

lmvex_cb, stmvex_cb, lstrmvex_cb 및 ststrmvex_cb 명령어에 대한 선택적인 지정자는 앞서 lmvex, lmvex2, stmvex, stmvex2, lstrmvex 및 ststrmvex 명령어와 관련하여 기술한 바와 같이 동작하는 rcnt 및 stride를 포함한다(도 29 및 도 30에 도시하지 않음). 이것은 레지스터 rD의 각각의 인스턴스로 로드되거나 소스 레지스터 rS의 각각의 인스턴스로부터 저장되는 원형 버퍼 요소들의 개수에 대한 제어는 물론 원형 버퍼를 통한 액세스의 스트라이딩(striding)을 제어하는 것을 가능하게 해준다. 스트라이딩은 예를 들어 분수 레이트 필터링 동작(fractional rate filtering operation) 또는 데시메이팅 필터(decimating filter)를 구현하는 데 사용될 수 있다.

도 23 내지 도 26은 lstrmvex 명령어(도 7을 참조하여 전술하였음)가 예를 들어 행렬 곱셈을 수행하는 데 어떻게 사용될 수 있는지의 일례를 나타낸 것이다. 이 예에서, 도 12의 메모리 부분(100) 및 행렬(102, 106 및 108)이 사용된다. 도 23 내지 도 26은 예를 들어 도 1의 스칼라 레지스터 파일(34) 등의 레지스터 파일의 내용을, 행렬 곱셈 동안에 여러 시점에서 나타낸 것이다.

현재 예에서, 행렬(102)은 행렬(106)과 곱해지고 그 결과는 행렬(108)에 대응한다. 예를 들어, 행렬 곱셈을 수행함에 있어서, 이하의 식이 결과 행렬(108)의 처음 2개의 열에 대해 사용된다.

식 5 aa = A*K + B*N + C*Q

식 6 dd = D*K + E*N + F*Q

식 7 gg= G*K + H*N + I*Q

식 8 bb = A*L + B*O + C*R

식 9 ee = D*L + E*O + C*R

식 10 hh = G*L + H*O + I*R

상기 식에서, 유의할 점은 aa, dd 및 gg를 획득함에 있어서 행렬(102)로부터 요소들을 디큐하는 것은 바람직하지만(왜냐하면 A, B, C가 aa를 획득하기 위해 사용되고, D, E, F가 dd를 획득하는 데 사용되며, G, H, I는 gg를 획득하는 데 사용되기 때문임) 행렬(106)로부터 디큐하는 것은 바람직하지 않다(왜냐하면 K, N, Q가 aa, dd 및 gg 각각을 획득하는 데 필요하기 때문임)는 것이다. 따라서, 이하의 의사 코드는 lstrmvex 명령어 등의 명령어가 결과 행렬(108)을 획득하기 위해 어떻게 사용될 수 있는지의 예를 제공한다. 유의할 점은 이하의 의사 코드 예에서 디큐잉은 rD가 명령어의 첫번째 소스(소스1)로서 나타내는 때(예를 들어, 명령어 목적지, 소스1, 소스2)에만 수행된다는 것이다.

/* 9의 cnt, 3의 rcnt, 1의 stride, 6의 skip 및 3의 skip_cnt를 저장하도록 R6을 초기화함 */

/* 0x12, 즉 행렬(102)의 첫번째 행의 시작을 저장하도록 R4를 초기화함 */

/* 9의 cnt, 3의 rcnt, 8의 stride, -15의 skip 및 3의 skip_cnt를 저장하도록 R7을 초기화함 */

/* 0x54, 즉 행렬(106)의 첫번째 열의 시작을 저장하도록 R5를 초기화함 */

lstrmvex.u.mh.dh R1, R4, R6 /* 행렬(102)의 첫번째 행, A, B, C를 로드함 */

lstrmvex.u.mh.dh R2, R5, R7 /* 행렬(106)의 첫번째 열, K, N, Q를 로드함 */

vmac.h R10, R1, R2 /* R10에 aa를 저장하고 행렬(102)의 R1을 디큐함 */

vmac.h R11, R1, R2 /* R11에 dd를 저장하고 행렬(102)의 R1을 디큐함 */

vmac.h R12, R2, R1 /* R12에 gg를 저장하고 행렬(104)의 R2를 디큐함 */

lstrmvex.u.mh.dh R1, R4, R6 /* 행렬(102)의 첫번째 행, A, B, C를 로드함 */

vmac.h R13, R1, R2 /* R13에 bb를 저장하고 행렬(102)의 R1을 디큐함 */

vmac.h R14, R1, R2 /* R14에 ee를 저장하고 행렬(102)의 R1을 디큐함 */

vmac.h R15, R2, R1 /* R15에 hh를 저장하고 행렬(104)의 R2를 디큐함 */

상기 의사 코드는 상기 식 5 내지 식 8에 기술된 바와 같이, aa, dd, gg, bb, ee 및 hh를 획득하는 데 사용될 수 있다. 이 예에서 사용되는 바와 같이, 모든 값들은 부호를 갖지 않는 하프워드인 것으로 가정된다. 먼저, R6는 9의 cnt, 3의 rcnt, 1의 stride, 6의 skip 및 3의 skip_cnt를 저장하도록 초기화되며, 여기서 R6는 lstrmvex 명령어에 대한 rB 레지스터로서 사용될 수 있다. 도 23에 도시한 바와 같이, R4는 0x12에 있는 요소 A, 즉 도 12의 행렬(102)의 첫번째 행의 첫번째 요소를 가리키도록 초기화된다. R7는 9의 cnt, 3의 rcnt, 8의 stride, -15의 skip 및 3의 skip_cnt를 저장하도록 초기화되며, 여기서 R7은 lstrmvex 명령어에 대한 rB 레지스터로서 사용될 수 있다. 도 23에 도시한 바와 같이, R5는 0x54에 있는 요소 K, 즉 행렬(106)의 첫번째 열의 첫번째 요소를 가리키도록 초기화된다.

첫번째 lstrmvex 명령어는 행렬(102)의 각 행을 차례로 로드하는 벡터 요소들의 스트림을 개시한다. 먼저, 이 명령어는 행렬(102)의 첫번째 행을 R1에 로드한다(도 23에 나타냄). 예를 들어, 요소 A, B 및 C는 각각 1개 하프워드만큼 떨어져 있다(따라서, 1의 stride가 필요함). 3의 rcnt는 한번에 단지 3개의 요소만을 R1에 로드하고(나머지 부분을 영으로 됨), skip_cnt개(이 예에서는, 3개)의 요소가 로드된 후에, 위치 0x22(0x16 + 0x08)에 있는 그 다음 요소 D의 어드레스를 획득하기 위해 8*ms(8개 하프워드)의 skip이 C의 위치(0x16)에 가산된다. R1이 후속 명령어의 소스1로서 사용되는 경우, 이하에 기술하는 바와 같이, 이는 (rcnt, stride 및 skip_cnt로 정의된 바와 같이) 행렬(102)의 그 다음 행이 R1으로 로드되도록 디큐된다.

두번째 lstrmvex 명령어는 행렬(106)의 각 열을 차례로 R2에 로드하는 벡터 요소들의 스트림을 개시한다. 먼저, 이 명령어는 행렬(106)의 첫번째 열을 R2에 로드한다(도 23에 나타냄). 예를 들어, 요소 K, N 및 Q는 각각 메모리에서 8개 하프워드만큼 떨어져 있다(따라서, 8의 stride가 필요함). 3의 rcnt는 한번에 단지 3개의 요소만을 R2에 로드하고(나머지 부분을 영으로 됨), skip_cnt개(이 예에서는, 3개)의 요소가 로드된 후에, 위치 0x56(0x74 - 0x0F*2)에 있는 그 다음 요소 L의 어드레스를 획득하기 위해 -15*ms(-15 또는 -0x0F개 하프워드)의 skip이 Q의 위치(0x74)에 가산되며, 여기서 L은 행렬(106)의 두번째 열의 첫번째 요소이다. R2가 후속 명령어의 소스1로서 사용되는 경우, 이하에 기술하는 바와 같이, 이는 (rcnt, stride 및 skip_cnt로 정의된 바와 같이) 행렬(106)의 그 다음 열이 R2로 로드되도록 디큐된다.

첫번째 곱셉 누적(vmac) 명령어는 도 24에 나타낸 바와 같이 A*K + B*N + C*Q(이는 aa와 같음)를 R10에 저장한다. R1이 소스1로서 사용되기 때문에, 행렬(102)의 그 다음 행(D, E 및 F)이 R1에 저장되고 나머지 부분은 영으로 되도록, 이는 첫번째 lstrmvex 명령어(및 R6 내의 파라미터)에 따라 디큐된다. 이 때, 유의할 점은 R2가 소스1로서 사용되지 않기 때문에 이는 디큐잉되지 않으며 따라서 K, N 및 Q는 R2에 그대로 있고 행렬(106)의 그 다음 열도 아직 R2에 저장되지 않는다.

두번째 곱셉 누적(vmac) 명령어는 도 25에 나타낸 바와 같이 D*K + E*N + F*Q(이는 dd와 같음)를 R11에 저장한다. R1이 소스1로서 사용되기 때문에, 행렬(102)의 그 다음 행(G, H 및 I)이 R1에 저장되고 나머지 부분은 영으로 되도록, 이는 첫번째 lstrmvex 명령어(및 R6 내의 파라미터)에 따라 또다시 디큐된다. 이 때, 첫번째 lstrmvex 명령어에 대응하는 9개 요소가 로드되어 있으며, 따라서 "cnt"개의 요소가 로드되어 있고 이 명령어의 스트리밍이 종료된다. R2가 소스1로서 사용되지 않기 때문에, 이는 디큐잉되지 않으며 따라서 K, N 및 Q는 R2에 그대로 있고 행렬(106)의 그 다음 열도 아직 R2에 저장되지 않는다. 이 때, 두번째 lstrmvex 명령어에 대응하는 3개의 요소만이 로드되어 있고, 따라서 이 명령어에 대해 cnt개의 요소가 로드되어 있지 않다.

세번째 곱셉 누적(vmac) 명령어는 도 26에 나타낸 바와 같이 G*K + H*N + I*Q(이는 gg와 같음)를 R11에 저장한다. 이제 R2가 소스1로서 사용되기 때문에, 행렬(106)의 그 다음 열(L, O 및 R)이 R2에 저장되고 나머지 부분은 영으로 되도록, 이는 두번째 lstrmvex 명령어(및 R7 내의 파라미터)에 따라 후속하여 디큐된다. 이 때, 행렬(106)의 9개 요소 중 6개가 로드되어 있다. 또한, "cnt"개의 요소(행렬(102)의 경우)가 첫번째 lstrmvex 명령어에 의해 이미 로드되어 있기 때문에, R1은 변화되지 않고 여전히 G, H 및 I를 보유한다. (게다가, "cnt"개의 요소가 첫번째 lstrmvex 명령어에 의해 아직 로드되지 않았을지라도, R1은 여전히 변화되지 않는데, 그 이유는 R1이 소스2로서 사용되므로 디큐되지 않기 때문이다.)

세번째 lstrmvex 명령어는 첫번째 lstrmvex 명령어와 동일한 벡터 요소들의 새 스트림을 개시한다. 즉, 세번째 lstrmvex 명령어는 전술한 바와 같이 행렬(102)의 각 행을 차례로 R1에 로드한다. 후속하는 3개의 vmac 명령어는 bb, ee 및 hh의 값을 R13, R14 및 R15에 각각 저장한다. 유의할 점은 처음 3개의 vmac 명령어에서와 같이, 첫번째 lstrmvex 명령어는 세번째 lstrmvex 명령어 다음에 오는 처음 2개의 vmac 명령어로 디큐되고, 두번째 lstrmvex 명령어는 세번째 lstrmvex 명령어 다음에 오는 세번째 vmac 명령어로 디큐된다. 이 때, 행렬(106)의 마지막 열(M, P, S)은 R2로 로드되고(도시 생략), 이 때 "cnt"개의 요소(예를 들어, 9개 요소)가 로드될 것이기 때문에 두번째 lstrmvex 명령어에 대한 로드는 중단된다. 이어서, cc, ff 및 ii를 획득하기 위해 유사한 명령어들이 사용될 수 있다. 이어서, aa, dd, gg, bb, ee, hh, cc, ff 및 ii의 값은 다시 행렬(108)의 메모리 위치 0x8A, 0x9A, 0xAA, 0x8C, 0x9C, 0xAC, 0x8E, 0x9E 및 0xAE에 각각 저장될 수 있다. 본 명세서에 기술되어 있는 바와 같이, 벡터 저장 명령어가 이들 저장을 수행하는 데 사용될 수 있다.

유의할 점은 상기 의사 코드 예에서, 요소들이 후속 명령어에서의 rD의 위치에(즉, rD가 소스1로서 또는 소스2로서 사용되는지에) 의존하여 디큐된다는 것이다. 그렇지만, 유의할 점은 대체 실시예에서, 요소들이 디큐되어야 하는지 여부를 나타내기 위해 다른 인자들이 사용될 수 있다는 것이다. 예를 들어, 디큐잉을 나타내기 위해 다른 연산 코드가 사용될 수 있거나, 예를 들어 플래그 등의 다른 표시자가 사용될 수 있다. 또한, 일 실시예에서, rD는 소스1일 때만이 아니라 후속 명령어에서 소스로서 나타나는 경우에는 항상 디큐된다. 또다른 실시예에서, 디큐잉은 동일 레지스터 rD를 소스 피연산자로서 사용하는 명령어가 프로세싱 장치(14)에 의해 구현되는 모든 명령어들의 적절한 서브셋 내의 하나 이상의 미리 정해진 명령어일 때에만 수행된다. 즉, 이 실시예에서, 명령어 또는 명령어 펑션의 서브셋만이 실제로 그의 실행의 일부로서 디큐잉을 수행하고, 프로세싱 유닛(14)에 의해 구현되는 나머지 명령어는 rD를 소스 피연산자로서 사용하는 것에 상관없이 디큐잉을 수행하지 않는다. 디큐잉(dequeueing)을 수행하는 서브셋은 구현된 전체 명령어의 미리 정해진 서브셋일 수 있으며, 데이터 프로세싱 시스템(10)의 필요에 기초하여 결정될 수 있다. 또다른 실시예에서, 디큐잉은 디큐잉 동작을 제어하기 위한 명령어 내의 제어 필드 값에 의해 결정될 수 있다.

도 23 내지 도 26에 대해 기술하는 이전의 문단에서 디큐잉에 대해 기술되어 있지만, 인큐잉(enqueueing)이라는 유사한 동작도 똑같이 본 발명의 실시예들에 적용가능하며, 거의 유사한 방식으로 동작한다. 인큐잉은 후속 명령어의 목적지로서의 인큐잉 소스 레지스터 rS의 위치에 기초하거나 프로세싱 유닛(14)에 의해 구현된 모든 명령어의 적절한 서브셋 내의 하나 이상의 미리 정해진 명령어에서 목적지 피연산자인 것에 기초하여 수행될 수 있다. 즉, 일 실시예에서, 명령어 또는 명령어 펑션의 서브셋만이 실제로 그의 실행의 일부로서 인큐잉을 수행하고, 프로세싱 유닛(14)에 의해 구현되는 나머지 명령어는 rS를 목적지 피연산자로서 사용하는 것에 상관없이 인큐잉을 수행하지 않는다. 인큐잉을 수행하는 서브셋은 구현된 전체 명령어의 미리 정해진 서브셋일 수 있으며, 데이터 프로세싱 시스템(10)의 필요에 기초하여 결정될 수 있다. 또다른 실시예에서, 인큐잉은 인큐잉 동작을 제어하기 위한 명령어 내의 제어 필드 값에 의해 결정될 수 있다.

도 31은 고속 푸리에 변환(FFT)에서 사용될 수 있는 명령어를 나타낸 것이다. 도 31은 제어 필드 s/u, ms 및 ds와 피연산자 rD, rA 및 rB를 갖는 다중 벡터 요소 로드(load multiple vector elements) FFT(lmvex_fft) 명령어를 나타낸 것이다. 이들 제어 필드 및 피연산자 각각은 다른 로드 명령어들과 관련하여 전술한 바와 같이 동작한다. lmvex_fft 명령어도 역시 rB에 저장된 부가의 파라미터 "radix"를 사용하며, 다른 벡터 요소 로드 명령어와 관련하여 전술한 바와 같이 선택적으로 rB에 저장된 rcnt 제어 필드를 구현할 수 있다. 상기 명령어들에서와 같이, 대체 실시예에서, "radix"(및 존재하는 경우, "rcnt")는 연산 코드 또는 서브 연산 코드의 일부일 수 있으며, 따라서 rB는 필요없을 수 있다. lmvex_fft 명령어는 또한 전술한 바와 같이 절단 또는 반올림 필드를 사용할 수 있다.

도 32는 제어 필드 s/u, ms 및 ss와 피연산자 rS, rA 및 rB를 갖는 다중 벡터 요소 저장(store multiple vector elements) FFT(stmvex_fft) 명령어를 나타낸 것이다. 이들 제어 필드 및 피연산자 각각은 다른 저장 명령어들과 관련하여 전술한 바와 같이 동작한다. stmvex_fft 명령어도 역시 전술한 바와 같이 절단 또는 반올림 필드를 사용할 수 있으며, 다른 벡터 요소 저장 명령어와 관련하여 전술한 바와 같이 선택적으로 rcnt 제어 필드를 구현할 수 있다. stmvex_fft 명령어도 역시 rB에 저장된 부가의 파라미터 "radix"를 사용한다. 상기 명령어들에서와 같이, 대체 실시예에서, "radix"는 연산 코드 또는 서브 연산 코드의 일부일 수 있으며, 따라서 rB는 필요없을 수 있다. stmvex_fft 명령어는 lmvex_fft 명령어에 상응하는 저장 명령어인 것으로 간주될 수 있다.

다시 lmvex_fft 명령어를 참조하면, 기술 분야에 공지된 바와 같이, "radix" 파라미터는 FFT 어드레싱 알고리즘에 따라 일련의 데이터를 레지스터 또는 일련의 레지스터에 로드하는 데 사용될 수 있다. 예를 들어, FFT의 경우, 어떤 FFT 계산을 위해 X₀, X₁, X₂, X₃, X₄, X₅, X₆ 및 X₇ 순서의 데이터가 X₀, X₄, X₆, X₂, X₁, X₅, X₃, X₇의 순서로 "비트 반전(bit reversed)"되는 것은 공지되어 있다. lmvex_fft 명령어에서, "radix"는 요소의 개수 및 요소들의 특정의 저장 순서를 정의한다. 예를 들어, 도 34는 예를 들어 도 1의 메모리(12)의 일부분일 수 있는 메모리 부분(300)을 나타낸 것이다. 메모리 부분(300)은 0x16-0x24에 각각 저장되어 있는 요소 X₀, X₁, X₂, X₃, X₄, X₅, X₆ 및 X₇를 포함한다. 메모리 부분(300)은 또한 0x44-0x52에 저장되어 있는 요소 Y₀, Y₄, Y₆, Y₂, Y₁, Y₅, Y₃ 및 Y₇를 포함한다.

도 35는 도 1의 스칼라 레지스터 파일(34) 등의 레지스터 파일의 일부분을 나타낸 것이다. 예를 들어, 8의 radix를 갖는 lmvex_fft 명령어는 X 요소들을 비트 반전된 순서로 레지스터 R1 및 R2로 가져오는 데 사용될 수 있으며(도 35에 도시됨), 여기서 R1은 rD에 의해 지정되며 로드될 첫번째 메모리 위치(0x16)는 rA에 의해 지정된다. 이와 유사하게, 8의 radix를 갖는 lmvex_fft는 비트 반전된 Y 요소들을 순차적 순서로 레지스터 R4 및 R5로 가져오는 데 사용될 수 있으며(도 35에 도시되어 있음), 여기서 R4는 rD에 의해 지정되고 로드될 첫번째 메모리 위치(0x44)는 rA에 의해 지정된다. 따라서, lmvex_fft 명령어는 비트 반전된 방식으로 요소들을 로드할 수 있으며, 여기서 요소들은 처음에 비트 반전되어 있거나 그렇지 않다.

이와 유사하게, stmvex_fft 명령어는 요소들을 비트 반전된 방식으로 메모리에 저장하는 데 사용될 수 있다. 예를 들어, 8의 radix를 갖는 stmvex_fft 명령어는 비트 반전된 X 요소들을 R1 및 R2로부터 위치 0x16-0x24에 있는 메모리로 저장하는 데 사용될 수 있으며, 따라서 메모리 내의 요소들은 R1 및 R2 내의 것들과 비교하여 비트 반전되어 있지 않다. 이와 유사하게, stmvex_fft 명령어는 순차적인 Y 요소들을 R4 및 R5로부터 위치 0x44-0x52에 있는 메모리로 저장하는 데 사용될 수 있으며, 따라서 메모리 내의 요소들은 R4 및 R5에서의 것과 비교하여 비트 반전되어 있다.

도 33은 제어 필드 s/u, ms 및 ds와 피연산자 rD, rA 및 rB를 갖는 벡터 요소들의 스트림 로드(load stream of vector elements) FFT(lmstrmvex_fft) 명령어를 나타낸 것이다. 이들 제어 필드 및 피연산자 각각은 lmstrmvex 명령어를 참조하여 전술한 바와 같이 동작한다. lmstrmvex_fft 명령어도 rB에 저장된 부가의 파라미터 "radix"를 사용하며, 다른 벡터 요소 로드 명령어들을 참조하여 전술한 바와 같이 선택적으로 rB에 저장된 rcnt 제어 필드를 구현할 수 있다. 상기 명령어들에서와 같이, 대체 실시예에서, "radix"(및 존재하는 경우, "rcnt")는 연산 코드 또는 서브 연산 코드의 일부일 수 있으며, 따라서 rB는 필요없을 수 있다. "radix"는 로드될 요소들의 총 개수를 정의한다. lmstrmvex 명령어에서와 같이, lmstrmvex_fft는 메모리로부터의 벡터 요소들의 스트림을 개시하며, 여기서 요소들은 비트 반전된 방식으로 또는 비트 반전된 순서로부터 순차적 순서로 로드되며, 예를 들어 후속 명령어에서의 rD의 위치에 의존하여 디큐될 수 있다. 유의할 점은 도시되어 있지는 않지만, FFT 응용에서와 같이, 상응하는 저장 명령어가 요소들의 스트림을 비트 반전된 방식으로 메모리에 저장하는 것을 개시하는 데 사용될 수 있다는 것이다.

따라서, 다양한 서로 다른 유형의 벡터 로드 및 저장 명령어가 예를 들어 스칼라 레지스터 파일 등의 일련의 레지스터를 갖는 시스템에서 어떻게 사용될 수 있는지를 잘 알 것이다. 즉, 상기 명령어들은 기존의 설계에서 사용될 수 있거나 기존의 설계의 실행 유닛(실행 유닛(32) 등) 및 제어 유닛(제어 유닛(28) 등)에 최소한의 수정만을 필요로 할 수 있다. 유의할 점은 본 명세서에 기술된 명령어들 각각이 서로 다른 포맷을 가질 수 있고 또 다중 명령어로 분할될 수조차 있다는 것이다. 또한, 벡터 요소들을 레지스터로 및 그로부터 전송함에 있어서, 어느 레지스터 요소를 메모리로 전송할지(벡터 저장 명령어 등의 경우) 또는 레지스터 내의 어느 레지스터 요소에 메모리로부터 로드된 벡터 요소를 저장할지(벡터 로드 명령어 등의 경우)를 나타내기 위해 부가의 파라미터가 사용될 수 있다. 게다가, 벡터 요소를 레지스터에 어떻게 배치할지 또는 메모리의 어디로부터 벡터 요소를 판독할지를 정의하기 위해 부가의 파라미터가 사용될 수 있다. 예를 들어, 레지스터 내의 어디로 또는 어디로부터 전송을 시작할지를 나타내는 시작 위치 표시자가 제공될 수 있다. 또한, 파라미터가 레지스터 내에서 비연속적인 방식으로 레지스터로 또는 레지스터로부터 전송될 수 있도록 레지스터에 대한 스트라이드(stride)가 제공될 수 있다. 또한, 본 명세서에 기술된 모든 파라미터 및 제어 필드가 임의의 명령어들과 임의의 조합으로 나타날 수 있다.

또한, 유의할 점은 stride, skip, skip_cnt, 기타 등등을 사용하는 것 또는 buffer_size 및 offset을 사용하는 것, 또는 radix를 사용하는 것 등의 서로 다른 어드레싱 모드가 전술되어 있다는 것이다. 그렇지만, 대체 실시예에서, 다른 어드레싱 모드들이 사용될 수 있다. 예를 들어, 어레이(예를 들어, 2차원 4x4 어레이, 3차원 5x5 어레이, 기타 등등)의 차원 등의 어레이 차원이 그 대신에 지정될 수 있다. 따라서, 상기 실시예들에서 본 명세서에 기술된 어드레싱 모드는 상기한 바와 같이 데이터 또는 예를 들어 지그-재그 패턴 및 다른 규칙적인 패턴을 비롯한 여러가지 패턴의 데이터의 어레이를 로드 또는 저장하는 데 사용될 수 있다. 본 명세서에 기술된 명령어들은 또한 현재의 SIMD 프로세서에서 요구되는 오버헤드와 비교하여 메모리 요소들을 메모리로 및 메모리로부터 전송하는 데 필요한 오버헤드를 감소시킬 수 있다. 예를 들어, SIMD 연산을 할 수 있는 현재의 프로세서에서, 벡터 요소들(벡터 또는 데이터의 어레이 또는 다른 규칙적인 패턴의 데이터 등)을 메모리로 및 그로부터 전송하는 데 많은 수의 명령어가 필요하다. 그렇지만, 요소들의 동일 전송은 상기한 벡터 로드 및 저장 명령어로 달성될 수 있으며, 이 경우 감소된 수의 명령어(또는 단지 하나의 명령어)가 이 전송을 달성하는 데 사용될 수 있다.

이하의 문단에서는 본 발명의 여러가지 측면, 형태 및 실시예에 대한 설명을 제공한다. 이들 설명 각각은 여러가지 실시예들의 일례를 제공할 뿐이며 상기한 임의의 설명 또는 실시예를 제한하려는 것이 아니다.

본 발명의 한 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 적어도 하나의 범용 레지스터를 갖는다. 처리 회로는 하나 이상의 명령어를 실행하며, 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송한다. 적어도 하나 이상의 명령어는 적어도 하나의 범용 레지스터에서의 데이터 요소의 크기를 지정하는 것과 별도로 또 이와 독립적으로 메모리에서의 데이터 요소의 크기를 지정한다. 한 형태에서, 하나 이상의 명령어는 메모리에 대한 제1 데이터 크기 지정자 및 적어도 하나의 범용 레지스터에 대한 제2 데이터 크기 지정자를 개별적으로 저장하는 독립적인 필드를 포함한다. 다른 형태에서, 하나 이상의 명령어는 메모리에 대한 제1 데이터 크기 지정자 및 적어도 하나의 범용 레지스터에 대한 제2 데이터 크기 지정자를 정의하는 저장 위치를 지정한다. 한 형태에서, 저장 위치는 메모리 내의 위치 및 메모리 외부의 프로세서 레지스터 위치 중 어느 하나이다. 다른 형태에서, 저장 위치는 데이터 프로세싱 시스템의 제어 레지스터이다. 한 형태에서, 저장 위치는 데이터 프로세싱 시스템에 의해 수행되는 산술, 논리 및 시프트 연산이 이용하는 데이터 프로세싱 시스템 내의 레지스터이다. 메모리는 메모리와 적어도 하나의 범용 레지스터 간에 전송되는 복수의 다중 데이터 요소를 더 포함할 수 있다. 한 형태에서, 다중 데이터 요소는 메모리에서 연속적이다. 다른 형태에서, 다중 데이터 요소는 메모리에서 비연속적이다. 한 형태에서, 적어도 하나의 범용 레지스터 각각은 다중 데이터 요소를 보유한다. 다른 형태에서, 적어도 하나의 범용 레지스터 각각은 1차원 메모리 맵을 갖는 스칼라 레지스터를 포함한다.

적어도 하나 이상의 명령어가 메모리에서의 소스 데이터 요소의 크기를 적어도 하나의 범용 레지스터에서의 목적지 데이터 요소의 크기보다 크도록 지정하는 경우, 프로세서 회로는 메모리에서의 소스 데이터 요소의 일부분을 절단(truncate)할 수 있다. 절단되는 메모리에서의 소스 데이터 요소의 일부분은 메모리에서의 소스 데이터 요소의 상위 부분(high order portion)일 수 있다. 절단되는 메모리에서의 소스 데이터 요소의 일부분은 메모리에서의 소스 데이터 요소의 하위 부분(lower order portion)일 수 있다. 적어도 하나 이상의 명령어가 메모리에서의 소스 데이터 요소의 크기를 적어도 하나의 범용 레지스터에서의 목적지 데이터 요소의 크기보다 크도록 지정하는 경우, 프로세서 회로는 메모리에서의 소스 데이터 요소의 하위 부분의 값에 기초하여 메모리에서의 소스 데이터 요소의 상위 부분을 반올림(round)할 수 있다. 적어도 하나 이상의 명령어가 메모리에서의 소스 데이터 요소의 크기를 적어도 하나의 범용 레지스터에서의 목적지 데이터 요소보다 더 작은 크기를 갖도록 지정하는 경우, 프로세서 회로는 메모리로부터의 소스 데이터 요소에 의해 채워지지 않은 적어도 하나의 범용 레지스터의 목적지 데이터 요소의 일부분에 미리 정해진 값을 넣을 수 있다. 한 형태에서, 프로세서 회로는 제로 확장(zero extension)을 사용하여 적어도 하나의 범용 레지스터의 목적지 데이터 요소의 일부분에 미리 정해진 데이터 값을 넣는다. 다른 형태에서, 프로세서 회로는 부호 확장(sign extension)을 사용하여 적어도 하나의 범용 레지스터의 목적지 데이터 요소의 일부분에 미리 정해진 데이터 값을 넣는다. 또다른 형태에서, 프로세서 회로는 적어도 하나의 범용 레지스터의 목적지 데이터 요소의 하위 데이터 부분에 미리 정해진 비트 값을 채움으로써 적어도 하나의 범용 레지스터의 목적지 데이터 요소의 일부분에 미리 정해진 데이터 값을 넣으며, 이 미리 정해진 비트 값은 제로 값이다.

적어도 하나 이상의 명령어가 메모리에서의 목적지 데이터 요소의 크기를 적어도 하나의 범용 레지스터에서의 소스 데이터 요소의 크기보다 작도록 지정하는 경우, 프로세서 회로는 적어도 하나의 범용 레지스터에서의 소스 데이터 요소의 일부분을 절단할 수 있다. 한 형태에서, 프로세서 회로는 적어도 하나의 범용 레지스터에서의 소스 데이터 요소의 상위 부분을 절단한다. 다른 형태에서, 프로세서 회로는 적어도 하나의 범용 레지스터에서의 소스 데이터 요소의 하위 부분을 절단한다. 적어도 하나 이상의 명령어가 메모리에서의 목적지 데이터 요소의 크기를 적어도 하나의 범용 레지스터에서의 소스 데이터 요소의 크기보다 작도록 지정하는 경우, 프로세서 회로는 소스 데이터 요소의 하위 부분의 값에 기초하여 적어도 하나의 범용 레지스터에서의 소스 데이터 요소의 상위 부분을 반올림할 수 있다. 적어도 하나 이상의 명령어가 메모리에서의 목적지 데이터 요소의 크기를 적어도 하나의 범용 레지스터에서의 소스 데이터 요소의 크기보다 크도록 지정하는 경우, 프로세서 회로는 적어도 하나의 범용 레지스터에서의 소스 데이터 요소에 의해 채워지지 않는 메모리에서의 목적지 데이터 요소의 일부분에 미리 정해진 데이터 값을 넣을 수 있다. 다른 형태에서, 프로세서 회로는 제로 확장을 사용하여 채워지지 않은 메모리에서의 목적지 데이터 요소의 일부분에 미리 정해진 데이터 값을 넣거나 또는 부호 확장을 사용하여 채워지지 않은 메모리에서의 목적지 데이터 요소의 일부분에 미리 정해진 데이터 값을 넣는다. 다른 형태에서, 목적지 데이터 요소의 하위 데이터 부분에 미리 정해진 비트 값을 넣음으로써 채워지지 않은 메모리에서의 목적지 데이터 요소의 일부분에 미리 정해진 값이 넣어진다.

다른 측면에 따르면, 데이터 프로세싱 시스템에서 데이터 요소를 로드(load) 및 저장(store)하는 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 하나 이상의 명령어가 실행되고, 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소의 전송이 일어나게 한다. 적어도 하나 이상의 명령어는 적어도 하나의 범용 레지스터에서의 데이터 요소의 크기를 지정하는 것과는 별도로 또 그와 독립적으로 메모리에서의 데이터 요소의 크기를 지정한다. 데이터 요소의 크기는 적어도 하나 이상의 명령어 내에 독립적인 필드들을 구현함으로써 지정되고, 제1 필드는 메모리에 대한 제1 데이터 크기 지정자를 나타내고 제2 필드는 적어도 하나의 범용 레지스터에 대한 제2 데이터 크기 지정자를 나타낸다. 데이터 요소의 크기는 적어도 하나 이상의 명령어 내에 미리 정해진 필드를 구현함으로써 지정될 수 있고, 미리 정해진 필드는 메모리에 대한 제1 데이터 크기 지정자 및 적어도 하나의 범용 레지스터에 대한 제2 데이터 크기 지정자를 정의하는 저장 위치를 가리킨다. 적어도 하나 이상의 명령어가 메모리에서의 소스 데이터 요소의 크기를 적어도 하나의 범용 레지스터에서의 목적지 데이터 요소의 크기보다 크도록 지정하는 경우, 메모리에서의 소스 데이터 요소의 일부분이 절단될 수 있다. 다른 형태에서, 적어도 하나 이상의 명령어가 메모리에서의 소스 데이터 요소의 크기를 적어도 하나의 범용 레지스터에서의 목적지 데이터 요소의 크기보다 크도록 지정하는 경우, 메모리에서의 소스 데이터 요소의 상위 부분은 메모리에서의 소스 데이터 요소의 하위 부분의 값에 기초하여 반올림된다. 다른 형태에서, 데이터 프로세싱 시스템은 메모리 및 데이터 처리 명령어를 실행하는 프로세서를 포함한다. 데이터 처리 명령어 중 적어도 하나는 메모리 외부의 데이터 프로세싱 시스템에서의 적어도 하나의 저장 위치에 저장된 데이터 요소의 크기를 지정하는 것과 별도로 또 그와 독립적으로 메모리에 저장된 데이터 요소의 크기를 지정하는 제어 정보를 포함한다.

다른 형태에서, 시스템 내의 프로세서 회로는 적어도 제1 명령어 및 이 제1 명령어에 후속하는 제2 명령어를 실행한다. 제1 명령어는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소의 스트림을 전송하여 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서 큐되게 한다. 제2 명령어는 적어도 제1 소스 피연산자를 포함하며 제2 명령어의 소스 피연산자로서 나타나는 적어도 하나의 범용 레지스터에 기초하여 데이터 요소의 스트림의 일부분을 조건부로 디큐한다. 데이터 요소의 스트림의 일부분을 조건부로 디큐잉하는 것은 적어도 하나의 범용 레지스터가 제2 명령어에 의해 지정된 미리 정해진 유형의 펑션에 대한 소스 피연산자로서 사용되는 경우에 수행될 수 있다. 다른 형태에서, 데이터 요소의 스트림의 일부분을 조건부로 디큐하는 것은 제2 명령어의 제어 필드의 값에 기초하여 수행된다. 제2 명령어는 제2 소스 피연산자를 더 포함할 수 있으며, 조건부 디큐잉은 적어도 하나의 범용 레지스터가 제1 소스 피연산자로서 나타나는 경우에 수행될 수 있다. 한 형태에서, 조건부 디큐잉은 적어도 하나의 범용 레지스터가 제2 소스 피연산자로서 나타나는 경우에 수행되지 않는다.

다른 측면에 따르면, 데이터 프로세싱 시스템에서 데이터 요소들을 선택적으로 디큐하는 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 적어도 제1 명령어 및 제1 명령어에 후속하는 제2 명령어가 실행된다. 데이터 요소의 스트림은 제1 명령어에 응답하여 메모리와 적어도 하나의 범용 레지스터 간에 전송된다. 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서의 데이터 요소의 스트림은 큐잉되어 있다. 제1 명령어에 후속하는 제2 명령어가 실행된다. 제2 명령어는 적어도 제1 소스 피연산자를 포함한다. 데이터 요소의 스트림의 일부분은 적어도 하나의 범용 레지스터가 제2 명령어의 소스 피연산자로서 나타나는 것에 기초하여 조건부로 디큐된다. 적어도 하나의 범용 레지스터가 제2 명령어에 의해 지정된 미리 정해진 유형의 펑션에 대한 소스 피연산자로서 사용되는 경우, 데이터 요소의 스트림의 일부분은 조건부로 디큐된다. 제2 소스 피연산자는 제2 명령어 내에 제공될 수 있으며, 적어도 하나의 범용 레지스터가 제1 소스 피연산자로서 나타나는 경우에 데이터 요소의 스트림의 일부분은 조건부로 디큐될 수 있다. 한 형태에서, 적어도 하나의 범용 레지스터가 제2 소스 피연산자로서 나타내는 경우에 디큐잉은 수행되지 않는다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 적어도 하나의 범용 레지스터를 포함한다. 프로세서 회로는 복수의 명령어를 실행하고, 이 복수의 명령어 중 제1 명령어는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소의 스트림을 전송하여 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서 큐되어지게 한다. 데이터 요소의 스트림의 일부분은 복수의 명령어 중의 제2 명령어가 복수의 명령어의 적절한 서브셋 내의 미리 결정된 명령어에 대응하는 것에 응답하여 조건부로 디큐된다. 프로세서 회로는 또한 적어도 하나의 범용 레지스터가 복수의 명령어 중 제2 명령어의 소스 피연산자로서 나타나는 것에 기초하여 데이터 요소의 스트림의 일부분을 조건부로 디큐할 수 있다. 프로세서 회로는 또한 복수의 명령어 중 제2 명령어의 제어 필드의 값에 기초하여 데이터 요소의 스트림의 일부분을 조건부로 디큐할 수 있다.

다른 측면에 따르면, 데이터 프로세싱 시스템에서 데이터 요소들을 선택적으로 디큐하는 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 복수의 명령어가 실행되고, 복수의 명령어 중 제1 명령어는 데이터 요소의 스트림을 메모리와 적어도 하나의 범용 레지스터 간에 전송한다. 데이터 요소의 스트림은 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서 큐된다. 복수의 명령어 중 제2 명령어가 복수의 명령어의 적절한 서브셋 내의 미리 정해진 명령어에 대응하는 것에 응답하여 데이터 요소의 스트림의 일부분은 조건부로 디큐된다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리, 및 적어도 하나의 범용 레지스터를 포함한다. 프로세서 회로는 복수의 명령어를 실행한다. 복수의 명령어 중 제1 명령어는 데이터 요소의 스트림을 메모리와 적어도 하나의 범용 레지스터 간에 전송하여 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서 큐되어지게 한다. 적어도 하나의 범용 레지스터가 복수의 명령어 중 제2 명령어의 목적지 피연산자로서 나타나는 것에 기초하여 데이터 요소의 스트림의 일부분은 조건부로 인큐(enqueue)된다.

다른 측면에 따르면, 데이터 프로세싱 시스템에서 데이터 요소들을 선택적으로 인큐하는 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 복수의 명령어가 실행되고, 복수의 명령어 중 제1 명령어는 데이터 요소의 스트림을 메모리와 적어도 하나의 범용 레지스터 간에 전송하여 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서 큐되어지게 한다. 적어도 하나의 범용 레지스터가 복수의 명령어 중 제2 명령어의 목적지 피연산자로서 나타나는 것에 기초하여 데이터 요소의 스트림의 일부분이 조건부로 인큐(enqueue)된다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 적어도 하나의 범용 레지스터를 포함한다. 프로세서 회로는 적어도 제1 명령어 및 이 제1 명령어에 후속하는 제2 명령어를 실행한다. 제1 명령어는 데이터 요소의 스트림을 메모리와 적어도 하나의 범용 레지스터 간에 전송하여 적어도 하나의 범용 레지스터 및 메모리중 적어도 하나에서 큐되어지게 한다. 제2 명령어는 적어도 제1 목적지 피연산자를 포함한다. 적어도 하나의 범용 레지스터가 제2 명령어의 목적지 피연산자로서 나타나는 것에 기초하여 데이터 요소의 스트림의 일부분이 조건부로 인큐된다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 적어도 하나의 범용 레지스터를 포함한다. 프로세서 회로는 적어도 제1 명령어 및 이 제1 명령어에 후속하는 제2 명령어를 실행한다. 제1 명령어는 데이터 요소의 스트림을 메모리와 적어도 하나의 범용 레지스터 간에 전송하여 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서 큐되어지게 한다. 제1 명령어는 또한 전송될 데이터 요소의 개수를 지정하고 적어도 하나의 범용 레지스터가 제2 명령어의 소스 피연산자로서 나타나는 것에 기초하여 데이터 요소의 스트림의 일부분으로부터의 복수의 데이터 요소를 조건부로 디큐(dequeue)한다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 적어도 하나의 범용 레지스터를 포함한다. 프로세서 회로는 적어도 제1 명령어 및 이 제1 명령어에 후속하는 제2 명령어를 실행한다. 제1 명령어는 데이터 요소의 스트림을 메모리와 적어도 하나의 범용 레지스터 간에 전송하여 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서 큐되어지게 한다. 제1 명령어는 또한 전송될 데이터 요소의 개수를 지정하고 적어도 하나의 범용 레지스터가 제2 명령어의 목적지 피연산자로서 나타나는 것에 기초하여 데이터 요소의 스트림의 일부분으로부터의 복수의 데이터 요소를 조건부로 인큐한다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리, 적어도 하나의 범용 레지스터 및 프로세서 회로를 포함한다. 프로세서 회로는 복수의 명령어를 실행한다. 복수의 명령어 중 제1 명령어는 데이터 요소의 스트림을 메모리와 적어도 하나의 범용 레지스터 간에 전송하여 메모리 및 적어도 하나의 범용 레지스터 중 적어도 하나에서 큐되어지게 한다. 복수의 명령어 중 제2 명령어 내의 제어 필드에 응답하여 데이터 요소의 스트림의 일부분의 인큐잉 및 디큐잉 중 적어도 하나가 조건부로 수행된다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 복수의 범용 레지스터를 포함하며, 각각의 범용 레지스터는 다중 데이터 요소를 보유한다. 프로세서 회로는 하나 이상의 명령어를 실행하며, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 복수의 범용 레지스터 중 적어도 2개 간에 복수의 데이터 요소를 전송하고, 적어도 하나 이상의 명령어는 복수의 범용 레지스터 중 적어도 2개 각각과 메모리 간에 전송될 레지스터 요소의 개수를 지정한다. 이 하나 이상의 명령어는 그 밖에도 전송될 레지스터 요소의 개수 이외에 레지스터 요소 중 어느 것을 로드 또는 저장할지도 지정한다. 다른 형태에서, 다중 데이터 요소의 서브셋만이 복수의 범용 레지스터 중 적어도 2개 각각과 메모리 간에 전송될 때, 임의의 미지정된 데이터 요소는 미리 정해진 값으로 채워진다.

다른 측면에 따르면, 데이터 프로세싱 시스템에서 데이터 요소들을 전송하는 방법은 피연산자를 메모리에 저장하는 단계를 포함한다. 다중 데이터 요소는 복수의 범용 레지스터 각각에 저장된다. 하나 이상의 명령어가 데이터 프로세싱 시스템에 의하여 실행된다. 이 하나 이상의 명령어 중 적어도 하나는 메모리와 복수의 범용 레지스터 중 적어도 2개 간에 복수의 데이터 요소의 전송이 일어나게 한다. 적어도 하나 이상의 명령어는 복수의 범용 레지스터 중 적어도 2개 각각과 메모리 간에 전송될 레지스터 요소의 개수를 지정한다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 복수의 범용 레지스터를 포함하며, 각각의 범용 레지스터는 다중 데이터 요소를 보유한다. 프로세서 회로는 하나 이상의 명령어를 실행하며, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 복수의 범용 레지스터 중 적어도 2개 간에 복수의 데이터 요소를 전송한다. 적어도 하나 이상의 명령어는 복수의 범용 레지스터 중 적어도 2개의 어느 데이터 요소가 전송될 것인지를 지정한다. 다중 데이터 요소의 서브셋만이 전송되는 경우, 임의의 미지정된 데이터 요소는 프로세서 회로에 의해 미리 정해진 값으로 채워진다. 한 형태에서, 적어도 하나 이상의 명령어에 의해 지정된 데이터 요소는 복수의 범용 레지스터 중 적어도 2개 내에 연속적으로 배치된다. 다른 형태에서, 적어도 하나 이상의 명령어에 의해 지정된 데이터 요소는 복수의 범용 레지스터 중 적어도 2개 내에 연속적으로 배치되지 않는다.

다른 측면에 따르면, 데이터 프로세싱 시스템에서 데이터 요소들을 전송하는 방법은 피연산자를 메모리에 저장하는 단계 및 다중 데이터 요소를 복수의 범용 레지스터 각각에 보유하는 단계를 포함한다. 하나 이상의 명령어가 실행되고, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 복수의 범용 레지스터 중 적어도 2개 간에 복수의 데이터 요소의 전송이 일어나게 하고, 적어도 하나 이상의 명령어는 복수의 범용 레지스터 중 적어도 2개의 어느 데이터 요소가 전송될 것인지를 지정한다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 복수의 범용 레지스터를 포함하며, 각각의 범용 레지스터는 다중 데이터 요소를 보유한다. 프로세서 회로는 하나 이상의 명령어를 실행하며, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 복수의 범용 레지스터 중 적어도 2개 간에 복수의 데이터 요소를 전송하고, 적어도 하나 이상의 명령어는 복수의 범용 레지스터 중 적어도 2개 각각과 메모리 간에 전송될 데이터 요소의 개수를 지정하고 또 전송될 데이터 요소의 총 개수도 지정한다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 적어도 하나의 범용 레지스터를 포함한다. 프로세서 회로는 하나 이상의 명령어를 실행하며, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송하기 위한 것이고, 하나 이상의 명령어 중 하나는, (a) 메모리에서 연속적인 데이터 요소들의 제1 부분 내의 데이터 요소들 간의 제1 오프셋, (b) 메모리와 적어도 하나의 범용 레지스터 간에 전송될 데이터 요소들의 제1 개수, 및 (c) 메모리에서 제1 부분과 데이터 요소들의 제2 부분 간의 제2 오프셋을 지정한다. 한 형태에서, 하나 이상의 명령어 중 하나는 또한 메모리에서의 데이터 요소의 데이터 요소 크기도 지정한다. 다른 형태에서, 하나 이상의 명령어 중 하나는 또한 적어도 하나의 범용 레지스터에서의 데이터 요소의 크기를 지정하는 것과 별도로 또 그와 독립적으로 메모리에서의 데이터 요소의 크기를 지정한다. 프로세서 회로는 메모리에서의 데이터 요소의 크기에 기초하여 전송될 데이터 요소의 총 개수를 결정한다. 프로세서 회로는 적어도 하나의 범용 레지스터에서의 데이터 요소의 크기에 기초하여 전송될 데이터 요소의 총 개수를 결정할 수 있다. 하나 이상의 명령어 중 하나는 또한 메모리와 적어도 하나의 범용 레지스터 간에 전송될 데이터 요소의 총 개수도 지정할 수 있다. 데이터 프로세싱 시스템은 또한 제1 범용 레지스터 및 제2 범용 레지스터를 포함할 수 있으며, 하나 이상의 명령어 중 하나는 하나 이상의 명령어 중 하나를 실행하는 것에 응답하여 제1 범용 레지스터 및 제2 범용 레지스터 둘다와 메모리 간에 데이터 요소를 전송한다. 하나 이상의 명령어 중 하나는 또한 제1 범용 레지스터 및 제2 범용 레지스터 둘다와 메모리 간에 전송될 데이터 요소의 총 개수도 지정할 수 있다. 전송된 데이터 요소의 총 개수가 제2 범용 레지스터를 완전히 채우지 않는 경우, 프로세서 회로는 임의의 나머지 비트 위치의 적어도 일부분을 미리 정해진 값으로 채울 수 있다. 하나 이상의 명령어 중 하나는 또한 제1 및 제2 범용 레지스터 각각과 메모리 간에 전송될 데이터 요소의 개수를 개별적으로 지정할 수 있다. 전송된 데이터 요소의 총 개수가 제2 범용 레지스터를 완전히 채우지 않는 경우, 프로세서 회로는 임의의 나머지 비트 위치의 적어도 일부분을 미리 정해진 값으로 채울 수 있다. 하나 이상의 명령어 중 하나는 또한 지정자를 포함할 수 있으며, 제1 개수의 데이터 요소를 전송하는 동안 제2 오프셋이 프로세서 회로에 의해 단지 한번만 사용된다. 하나 이상의 명령어 중 하나가 제2 오프셋이 단지 한번만 사용되는 것으로 지정하는 경우, 프로세서 회로는 원형 버퍼를 사용하여 메모리에서 데이터 요소를 전달할 수 있다. 하나 이상의 명령어 중 하나는 또한 지정자를 포함할 수 있으며, 전송될 데이터 요소의 제1 개수가 전송될 데이터 요소의 제1 부분의 2배보다 큰 경우 제2 오프셋이 프로세서 회로에 의해 1회 이상 사용된다.

다른 측면에 따르면, 데이터 프로세싱 시스템은 피연산자를 저장하는 메모리 및 적어도 하나의 범용 레지스터를 포함한다. 프로세서 회로는 하나 이상의 명령어를 실행하며, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송하고, 하나 이상의 명령어 중 하나는 메모리와 적어도 하나의 범용 레지스터 간에 비트 반전된 순서로(in a bit-reversed order) 하나 이상의 데이터 요소를 전송하는 것을 구현하는 기수 지정자(radix specifier)를 지정한다.

다른 측면에 따르면, 다중 어드레싱 모드(multiple addressing mode)를 사용하는 방법은 피연산자를 저장하는 메모리를 제공한다. 적어도 하나의 범용 레지스터가 제공된다. 하나 이상의 명령어가 실행되고, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송한다. 하나 이상의 명령어 중 적어도 하나는 메모리에서의 연속적인 데이터 요소들의 제1 부분 내의 데이터 요소들 간의 제1 오프셋을 지정한다. 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터(GPR) 간에 전송될 데이터 요소의 제1 개수를 지정한다. 하나 이상의 명령어 중 적어도 하나는 또한 메모리에서의 제1 부분과 데이터 요소들의 제2 부분 간의 제2 오프셋을 지정할 수 있다. 하나 이상의 명령어 중 적어도 하나는 또한 메모리에서의 데이터 요소의 데이터 요소 크기를 지정하는 데도 사용될 수 있다. 하나 이상의 명령어 중 적어도 하나는 또한 적어도 하나의 범용 레지스터에서의 데이터 요소의 크기를 지정하는 것과 별도로 또 그와 독립적으로 메모리에서의 데이터 요소의 크기를 지정하는 데도 사용될 수 있다. 프로세서는 메모리에서의 데이터 요소의 크기에 기초하여 전송될 데이터 요소의 총 개수를 결정하는 데 사용될 수 있다. 프로세서는 적어도 하나의 범용 레지스터에서의 데이터 요소의 크기에 기초하여 전송될 데이터 요소의 총 개수를 결정하는 데 사용될 수 있다. 하나 이상의 명령어 중 적어도 하나의 명령어는 또한 메모리와 적어도 하나의 범용 레지스터 간에 전송될 데이터 요소의 총 개수를 지정하는 데도 사용될 수 있다. 제1 범용 레지스터 및 제2 범용 레지스터가 제공되어 하나 이상의 명령어 중 하나를 실행하는 것에 응답하여 제1 범용 레지스터 및 제2 범용 레지스터 둘다와 메모리 간에 데이터 요소를 전송할 수 있다. 하나 이상의 명령어 중 하나는 또한 제1 범용 레지스터 및 제2 범용 레지스터 둘다와 메모리 간에 전송될 데이터 요소의 총 개수를 지정하는 데도 사용될 수 있다. 한 형태에서, 전송된 데이터 요소의 총 개수가 제2 범용 레지스터를 완전히 채우지 않은 경우에 제2 범용 레지스터에서의 임의의 나머지 채워지지 않은 비트 위치의 적어도 일부분은 미리 결정된 값으로 채워진다. 하나 이상의 명령어 중 하나는 또한 제1 및 제2 범용 레지스터 각각과 메모리 간에 전송될 데이터 요소의 개수를 개별적으로 지정하는 데도 사용될 수 있다. 한 형태에서, 전송된 데이터 요소의 총 개수가 제2 범용 레지스터를 완전히 채우지 않은 경우, 임의의 나머지 비트 위치의 적어도 일부분이 영(zero) 등의 미리 정해진 값으로 채워진다. 하나 이상의 명령어 중 하나에 지정자가 제공될 수 있으며, 이 지정자에 응답하여 제2 오프셋이 프로세서에 의해 단지 한번만 사용되어 제1 개수의 데이터 요소를 전송한다.

다른 측면에 따르면, 하나 이상의 명령어 중 하나가 제2 오프셋이 단지 한번만 사용되는 것으로 지정하는 경우 메모리에서의 데이터 요소는 원형 버퍼를 사용하여 프로세서의 제어 하에서 전달될 수 있다. 하나 이상의 명령어 중 하나에 지정자가 제공되며, 이 지정자에 응답하여 전송될 데이터 요소의 제1 개수가 메모리에서의 데이터 요소의 제1 부분에서의 데이터 요소의 개수의 2배보다 큰 경우 제2 오프셋이 프로세서에 의해 2회 이상 사용된다. 하나 이상의 명령어 중 하나에 기수 지정자가 제공될 수 있으며, 이 기수 지정자는 메모리와 적어도 하나의 범용 레지스터 간에 비트 반전된 순서로 하나 이상의 데이터 요소를 전송하는 것을 구현한다.

다른 측면에 따르면, 데이터 프로세싱 어드레싱 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 하나 이상의 명령어가 실행되고, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송한다. 하나 이상의 명령어 중 적어도 하나는 하나 이상의 명령어 중 하나의 기수 지정자를 지정하고, 이 기수 지정자는 메모리와 적어도 하나의 범용 레지스터 간에 비트 반전된 순서로 하나 이상의 데이터 요소를 전송하는 것을 구현한다.

다른 측면에 따르면, 데이터 프로세싱 시스템 어드레싱 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 하나 이상의 명령어를 실행하는 프로세서 회로가 제공된다. 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송하고, 하나 이상의 명령어 중 하나는 미리 정해진 데이터 요소들을 메모리에 비트 반전된 순서로 저장하는 것 및 미리 정해진 데이터 요소들을 적어도 하나의 범용 레지스터로 전송하는 것을 구현한다. 하나 이상의 명령어 중 적어도 하나는 또한 적어도 하나의 범용 레지스터로 전송할 데이터 요소의 개수도 지정한다. 다른 형태에서, 하나 이상의 명령어 중 적어도 하나는 또한 적어도 하나의 범용 레지스터에서의 데이터 요소의 크기를 지정하는 것과 별도로 또 그와 독립적으로 메모리에서의 데이터 요소의 크기도 지정한다.

다른 측면에 따르면, 데이터 프로세싱 시스템 어드레싱 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 하나 이상의 명령어를 실행하는 프로세서 회로가 제공되며, 이 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송하고, 하나 이상의 명령어 중 하나는 미리 정해진 데이터 요소들을 메모리에 순차적 순서로 저장하고 미리 정해진 데이터 요소들을 적어도 하나의 범용 레지스터로 비트-반전된 순서로 전송한다.

다른 측면에 따르면, 데이터 프로세싱 시스템 어드레싱 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 하나 이상의 명령어를 실행하는 프로세서 회로가 제공되며, 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송하고, 하나 이상의 명령어 중 하나는 미리 정해진 데이터 요소들을 적어도 하나의 범용 레지스터에 비트 반전된 순서로 저장하는 것 및 미리 정해진 데이터 요소들을 메모리로 전송하는 것을 구현한다.

다른 측면에 따르면, 데이터 프로세싱 시스템 어드레싱 방법은 피연산자를 저장하는 메모리를 제공하는 단계 및 적어도 하나의 범용 레지스터를 제공하는 단계를 포함한다. 하나 이상의 명령어를 실행하는 프로세서 회로가 제공되며, 하나 이상의 명령어 중 적어도 하나는 메모리와 적어도 하나의 범용 레지스터 간에 데이터 요소를 전송하고, 하나 이상의 명령어 중 하나는 미리 정해진 데이터 요소들을 적어도 하나의 범용 레지스터에 순차적 순서로 저장하고 미리 정해진 데이터 요소들을 메모리로 비트-반전된 순서로 전송한다.

상기 명세서에서, 본 발명은 특정의 실시예, 예 및 측면을 참조하여 기술되어 있다. 그렇지만, 당업자라면 이하의 청구항에 기술된 본 발명의 범위를 벗어나지 않고 여러가지 수정 및 변경이 행해질 수 있음을 잘 알 것이다. 예를 들어, 블록도들은 도시된 것과 다른 블록들을 포함할 수 있으며 또 더 많거나 더 적은 블록을 갖거나 다르게 배열되어 있을 수 있다. 또한, 다른 예로서, 본 명세서에 기술된 명령어들은 여러가지 다른 포맷을 가질 수 있으며 또 도시된 것과 다른 제어 필드 및 파라미터를 사용할 수 있다. 각각의 명령어는 심지어 다중 명령어로서 구현될 수 있다. 또한, 다른 예로서, 본 명세서에 기술된 레지스터들은 데이터 프로세싱 시스템 내의 어디에라도 위치하는 임의의 유형의 저장 회로일 수 있다. 따라서, 명세서 및 도면은 제한적 의미보다는 예시적인 의미로 보아야 하며, 이러한 수정 모두는 본 발명의 범위 내에 포함되는 것으로 보아야 한다.

이점, 다른 장점 및 문제점에 대한 해결 방안이 특정의 실시예와 관련하여 전술되어 있다. 그렇지만, 이점, 장점, 문제점에 대한 해결 방안 및 이점, 장점 또는 해결 방안이 얻어지거나 보다 두드러지게 할 수 있는 어떤 구성요소도 임의의 또는 모든 청구항의 중요한, 필요한 또는 필수적인 특징 또는 구성요소인 것으로서 해석되어서는 안된다. 본 명세서에서 사용되는 바와 같이, 용어 "포함한다", "포함하는" 또는 이의 임의의 다른 변형은 비배타적인 포함을 의미하는 것으로 보아야 하며, 따라서 일련의 구성요소를 포함하는 방법, 물품 또는 장치는 이들 구성요소 뿐만 아니라 명시적으로 열거되지 않거나 이러한 프로세스, 방법, 물품 또는 장치에 본질적이지 않은 다른 구성요소도 포함할 수 있다.

Claims (26)

1. 데이터 프로세싱 시스템으로서,

   피연산자들(operands)을 저장하기 위한 메모리,

   적어도 하나의 범용 레지스터 - 상기 메모리는 상기 적어도 하나의 범용 레지스터를 포함하지 않음 -, 및

   하나 이상의 명령어들을 실행하기 위한 프로세서 회로 - 상기 하나 이상의 명령어들 중 적어도 하나는 상기 메모리와 상기 적어도 하나의 범용 레지스터 간에 데이터 요소들을 전송하기 위한 것이고, 상기 하나 이상의 명령어들 중 하나는, (a) 상기 메모리 내의 연속적인 데이터 요소들의 제1 부분 내의 데이터 요소들 간의 제1 오프셋, (b) 상기 메모리와 상기 적어도 하나의 범용 레지스터 간에 전송될 데이터 요소들의 제1 개수, 및 (c) 상기 제1 부분과, 상기 메모리 내의 데이터 요소들의 제2 부분 간의 제2 오프셋을 지정함 -

   를 포함하며,

   상기 데이터 프로세싱 시스템은, 제1 범용 레지스터 및 제2 범용 레지스터를 더 포함하고, 상기 하나 이상의 명령어들 중 하나는, 상기 하나 이상의 명령어들 중 하나를 실행하는 것에 응답하여, 상기 메모리와 상기 제1 범용 레지스터 및 상기 범용 제2 레지스터 양자 간에 데이터 요소들을 전송하고, 상기 하나 이상의 명령어들 중 하나는 또한 상기 메모리와 상기 제1 범용 레지스터 및 상기 제2 범용 레지스터 양자 간에 전송될 데이터 요소들의 총 개수를 지정하는 데이터 프로세싱 시스템.
2. 다중 어드레싱 모드들(multiple addressing modes)을 사용하는 방법으로서,

   피연산자들을 저장하기 위한 메모리를 제공하는 단계,

   적어도 하나의 범용 레지스터를 제공하는 단계 - 상기 메모리는 상기 적어도 하나의 범용 레지스터를 포함하지 않음 -,

   하나 이상의 명령어들을 실행하는 단계 - 상기 하나 이상의 명령어들 중 적어도 하나는 상기 메모리와 상기 적어도 하나의 범용 레지스터 간에 데이터 요소들을 전송함 -,

   상기 하나 이상의 명령어들 중 적어도 하나로, 상기 메모리 내의 연속적인 데이터 요소들의 제1 부분 내의 데이터 요소들 간의 제1 오프셋을 지정하는 단계,

   상기 하나 이상의 명령어들 중 적어도 하나로, 상기 메모리와 상기 적어도 하나의 범용 레지스터 간에 전송될 데이터 요소들의 제1 개수를 지정하는 단계,

   상기 하나 이상의 명령어들 중 적어도 하나로, 상기 제1 부분과 상기 메모리 내의 데이터 요소들의 제2 부분 간의 제2 오프셋을 지정하는 단계, 및

   제1 범용 레지스터 및 제2 범용 레지스터를 제공하고, 상기 하나 이상의 명령어들 중 하나를 실행하는 것에 응답하여, 상기 메모리와 상기 제1 범용 레지스터 및 상기 제2 범용 레지스터 양자 간에 데이터 요소들을 전송하는 단계

   를 포함하고,

   상기 방법은 상기 하나 이상의 명령어들 중 하나를 이용하여, 상기 메모리와 상기 제1 범용 레지스터 및 상기 제2 범용 레지스터 양자 간에 전송될 데이터 요소들의 총 개수를 또한 지정하는 단계를 더 포함하는 다중 어드레싱 모드 사용 방법.
3. 제1항에 있어서,

   상기 하나 이상의 명령어들 중 하나는, 상기 메모리 내의 상기 데이터 요소들의 데이터 요소 크기(data element size)를 또한 지정하는 데이터 프로세싱 시스템.
4. 제1항에 있어서,

   상기 하나 이상의 명령어들 중 하나는, 상기 적어도 하나의 범용 레지스터 내의 데이터 요소들의 크기를 지정하는 것과는 개별적 및 독립적으로, 상기 메모리 내의 데이터 요소들의 크기를 또한 지정하는 데이터 프로세싱 시스템.
5. 제1항에 있어서,

   상기 프로세서 회로는, 상기 메모리 내의 데이터 요소들의 크기에 기초하여, 전송될 데이터 요소들의 총 개수를 결정하는 데이터 프로세싱 시스템.
6. 삭제
7. 삭제
8. 삭제
9. 삭제
10. 삭제
11. 삭제
12. 삭제
13. 삭제
14. 삭제
15. 삭제
16. 삭제
17. 삭제
18. 삭제
19. 삭제
20. 삭제
21. 삭제
22. 삭제
23. 삭제
24. 삭제
25. 삭제
26. 삭제

Images