KR100236527B1 - 벡터 레지스터의 복수 뱅크를 사용한 단일 명령복수 데이터 처 리 - Google Patents

벡터 레지스터의 복수 뱅크를 사용한 단일 명령복수 데이터 처 리 Download PDF

Info

Publication number
KR100236527B1
KR100236527B1 KR1019970012770A KR19970012770A KR100236527B1 KR 100236527 B1 KR100236527 B1 KR 100236527B1 KR 1019970012770 A KR1019970012770 A KR 1019970012770A KR 19970012770 A KR19970012770 A KR 19970012770A KR 100236527 B1 KR100236527 B1 KR 100236527B1
Authority
KR
South Korea
Prior art keywords
vector
register
srb
bank
data
Prior art date
Application number
KR1019970012770A
Other languages
English (en)
Other versions
KR19980018072A (ko
Inventor
누 옌 르
피터 송 성윤
에이. 모하메드 모아타즈
박 헌철
에스. 웡 로니
Original Assignee
윤종용
삼성전자주식회사
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 윤종용, 삼성전자주식회사 filed Critical 윤종용
Publication of KR19980018072A publication Critical patent/KR19980018072A/ko
Application granted granted Critical
Publication of KR100236527B1 publication Critical patent/KR100236527B1/ko

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00—Digital computers in general; Data processing equipment in general
    • G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003—Arrangements for executing specific machine instructions
    • G06F9/30007—Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/30025—Format conversion instructions, e.g. Floating-Point to Integer, decimal conversion
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F15/00—Digital computers in general; Data processing equipment in general
    • G06F15/76—Architectures of general purpose stored program computers
    • G06F15/80—Architectures of general purpose stored program computers comprising an array of processing units with common control, e.g. single instruction multiple data processors
    • G06F15/8053—Vector processors
    • G06F15/8076—Details on data register access
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30003—Arrangements for executing specific machine instructions
    • G06F9/30007—Arrangements for executing specific machine instructions to perform operations on data operands
    • G06F9/30036—Instructions to perform operations on packed data, e.g. vector, tile or matrix operations
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/30105—Register structure
    • G06F9/30109—Register structure having multiple operands in a single register
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/30105—Register structure
    • G06F9/30112—Register structure comprising data of variable length
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/3012—Organisation of register space, e.g. banked or distributed register file
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30098—Register arrangements
    • G06F9/3012—Organisation of register space, e.g. banked or distributed register file
    • G06F9/3013—Organisation of register space, e.g. banked or distributed register file according to data content, e.g. floating-point registers, address registers
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30145—Instruction analysis, e.g. decoding, instruction word fields
    • G06F9/3016—Decoding the operand specifier, e.g. specifier format
    • G06F9/30167—Decoding the operand specifier, e.g. specifier format of immediate specifier, e.g. constants
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/30181—Instruction operation extension or modification
    • G06F9/30189—Instruction operation extension or modification according to execution mode, e.g. mode flag

Abstract

벡터 프로세서는 복수의 데이타 엘리먼트들을 저장할 수 있는 벡터 레지스터들로된 두 개의 뱅크, 및 디폴트 뱅크를 나타내는 필드를 갖는 컨트롤 레지스터를 포함한다. 상기 벡터 프로세서를 위한 명령 세트는, 상기 디폴트 뱅크내에 있는 벡터 레지스터들을 식별하기 위한 레지스터 번호를 사용하는 명령들, 제1뱅크로부터의 레지스터 및 제2뱅크로부터의 레지스터를 포함하는 더블-사이즈 벡터 레지스터를 식별하기 위한 레지스터 번호를 사용하는 명령, 및 어느 하나의 뱅크로부터의 벡터 레지스터에 억세스하기 위한 뱅크 비트 및 레지스터 번호를 포함하는 명령들을 구비한다.

Description

벡터 레지스터의 복수 뱅크를 사용한 단일 명령 복수 데이타 처리
도1은 본 발명의 실시예에 따른 멀티미디어 프로세서의 블럭도.
도2는 도1의 멀티미디어 프로세서를 위한 벡터 프로세서의 블럭도.
도3은 도2의 벡터 프로세서를 위한 명령 훼치부의 블럭도.
도4는 도2의 벡터 프로세서를 위한 명령 훼치부의 블럭도.
도5a, 5b 및 5c는 도2의 벡터 프로세서의 레지스터-대-레지스터 명령, 로드 명령, 및 저장 명령에 대한 실행 파이프라인의 스테이지를 도시하는 도면.
도6a는 도2의 벡터 프로세서를 위한 실행 데이타 경로의 블럭도.
도6b는 도6a의 실행 데이타 경로에 대한 레지스터 화일의 블럭도.
도6c는 도6a의 실행 데이타 경로에 대한 병렬 프로세싱 논리부의 블럭도.
도7은 도2의 벡터 프로세서에 대한 로드/저장부의 블럭도.
도8은 본 발명의 실시예에 따른 벡터 프로세서의 명령 세트에 대한 포맷도.
* 도면의 주요부분에 대한 부호의 설명
100 : 멀티미디어 신호 프로세서(MSP) 105 : 코어 프로세싱
110 : 범용 프로세서 120 : 벡터 프로세서
130 : 캐쉬 서브시스템 140, 150 : 시스템 버스
142 : 시스템 타이머 146 : 비트 스트림 프로세서
148 : 인터럽트 콘트롤러 152 : 디바이스 인터페이스
156 : 국부 버스 인터페이스 158 : 메모리 콘트롤러
162, 192 : 명령어 캐쉬 164, 194 : 데이타 캐쉬
180 : 캐쉬 제어부 220 : 디코더
230 : 스케쥴러 310 : 주 명령어 버퍼
312 : 보조 명령어 버퍼 340, 342, 344 : 레지스터
350 : 가산기 420 : 제어 파이프
421 내지 427 : 실행 레지스터 514, 515 : 실행 스테이지
610 : 레지스터 화일 612, 614, 616, 618 : 선택회로
620, 626 : 곱셈기 630 : 산술 논리부
640 : 누산기
[발명의 목적]
[발명이 속하는 기술분야 및 그 분야의 종래기술]
본 발명은 디지탈 신호 프로세서에 관한 것으로, 특히 비디오 및 오디오 인코딩 및 디코딩과 같은 멀티미디어 기능을 위해 명령마다 복수 데이타 엘리먼트의 병렬 처리를 위한 프로세서에 관한 것이다.
실시간 비디오 인코딩 및 디코딩과 같은 멀티미디어 어플리케이션을 위한 프로그래머블 디지탈 신호 프로세서(DSP)는 제한된 시간내에 처리되어야만 하는 많은 양의 데이타를 위해 상당한 처리력을 필요로 한다. 디지탈 신호 프로세서를 위한 몇가지 아키텍춰가 알려져 있다. 대부분의 마이크로프로세서에 사용되는 것과 같은 범용 아키텍춰는 전형적으로 실시간 인코딩 또는 디코딩하는 충분한 연산력을 갖는 DSP를 제공하기 위해 고주파수를 필요로 한다. 이는 DSP의 값을 비싸게 한다.
매우 긴 명령 워드(VLIW) 프로세서는 비교적 간단한 작업과 같이 서로 달리 수행하는 많은 기능 유닛을 갖는 DSP이다. VLIW DSP를 위한 단일 명령은 128 바이트보다 길 수 있고, 개별적인 기능 유닛들이 병렬로 실행하는 개별적인 부품을 갖는다. VLIW DSP는 많은 기능 유닛들이 병렬로 수행할 수 있기 때문에 높은 연산력을 갖는다. VLIW DSP는 또한 각각의 기능 유닛이 비교적 작고 간단하기 때문에 비교적 값이 싸다. VLIW DSP의 문제점은 입력/출력 제어의 처리에서의 비효율성, 호스트 컴퓨터와의 통신, 및 VLIW DSP의 기능 유닛 상에서 병렬 실행에 적합하지 않는 다른 기능들이다. 부수적으로, VLIW 소프트웨어는 종래의 소프트웨어와는 다르며, 프로그램 툴과 VLIW 소프트웨어 아키텍춰에 익숙하지 않은 프로그래머가 부족하기 때문에 개발하기가 어려울 수 있다.
적당한 가격과, 높은 연산력, 및 익숙한 프로그래밍 환경을 제공하는 DSP가 멀티미디어 어플리케이션에 요구된다.
[발명이 이루고자 하는 기술적 과제]
본 발명의 특징에 따르면, 멀티미디어 디지탈 신호 프로세서(DSP)는 높은 처리력을 제공하기 위해 벡터 데이타(즉, 오퍼런드마다 복수 데이타 엘리먼트)를 조작하는 벡터 프로세서를 구비한다. 상기 프로세서는 RISC형 명령어 세트를 갖는 단일 명령 복수 데이타 아키텍춰를 이용한다. 프로그래머는 그들 대부분이 익숙한 범용 프로세서의 프로그래밍 환경에 익숙하기 때문에 벡터 프로세서의 프로그래밍 환경에 쉽게 적응할 수 있다.
DSP는 범용 벡터 레지스터 세트를 구비한다. 각 벡터 레지스터는 고정된 크기를 갖지만, 사용자가 선택할 수 있는 크기의 개별적인 데이타 엘리먼트로 파티션되어 있다. 따라서, 벡터 레지스터에 저장된 데이타 엘리먼트의 수는 엘리먼트에 대해 선택된 크기에 따른다. 예를 들어, 32 바이트 레지스터는 32개의 8비트 데이타 엘리먼트, 16개의 16비트 데이타 엘리먼트, 또는 8개의 32비트 데이타 엘리먼트로 나누어질 수 있다. 데이타 크기 및 유형의 선택은 벡터 레지스터와 연관된 데이타를 처리하는 명령에 의해 이루어지고, 명령을 위한 실행 데이타 경로는 명령에 의해 지시된 데이타 크기에 따르는 다수의 병렬 연산을 수행한다.
벡터 프로세서를 위한 명령은 오퍼런드로서 벡터 레지스터 또는 스칼라 레지스터를 가질 수 있고, 연산력이 높도록 병렬인 벡터 레지스터의 복수 데이타 엘리먼트를 조작한다. 본 발명에 따른 벡터 프로세서를 위한 예시적인 명령은 : 코프로세서 인터페이스 연산; 흐름 제어 연산; 로드/저장 연산; 및 논리/산술 연산을 포함한다. 상기 논리/산술 연산은 결과로 나타나는 데이타 벡터의 데이타 엘리먼트를 생성하기 위해 한 벡터 레지스터로부터의 데이타 엘리먼트를 하나 이상의 다른 벡터 레지스터로부터의 대응하는 데이타 엘리먼트와 결합하는 연산을 포함한다. 다른 논리/산술 연산은 하나 이상의 벡터 레지스터로부터의 여러 데이타 엘리먼트를 합성하거나 또는 벡터 레지스터로부터의 데이타 엘리먼트와 스칼라 양을 합성한다.
벡터 프로세서 아키텍춰의 확장은 각각 스칼라 데이타 엘리먼트를 포함하는 스칼라 레지스터를 더한다. 스칼라 및 벡터 레지스터의 조합은 벡터의 각 데이타 엘리먼트를 스칼라 값과 병렬로 결합하는 연산을 포함하도록 설정된 벡터 프로세서의 명령의 확장을 용이하게 한다. 예를 들어, 하나의 명령은 벡터의 데이타 엘리먼트에 스칼라 값을 곱한다. 스칼라 레지스터는 또한 벡터 레지스트로부터 추출되거나 또는 그것에 저장될 단일 데이타 엘리먼트를 저장하기 위한 장소를 제공한다. 상기 스칼라 레지스터는 또한 벡터 프로세서와 스칼라 레지스터만을 제공하는 아키텍춰를 갖는 코프로세서 간의 정보의 전달과, 로드/저장 연산을 위한 효율적인 어드레스의 계산이 용이하다.
본 발명의 다른 특징에 따르면, 벡터 프로세서의 벡터 레지스터는 뱅크로 구성되어 있다. 각 뱅크는 "현재의(current)" 뱅크로 선택되는 한편, 다른 뱅크는 "대체(alternative)" 뱅크이다. 벡터 프로세서의 제어 레지스터에 있는 "현재의 뱅크" 비트는 현재의 뱅크를 가리킨다. 벡터 레지스터를 식별하는데 필요한 비트수를 줄이기 위해, 일부 명령은 레지스터 번호만을 제공하여 현재의 뱅크에서 벡터 레지스터를 식별한다. 로드/저장 명령은 어느 한 뱅크로부터 벡터 레지스터를 식별하기 위한 부수적인 비트를 갖는다. 따라서, 로드/저장 연산은 현재의 뱅크에 있는 데이타의 조작 동안 대체 뱅크로 데이타를 훼치할 수 있다. 이는 화상 처리 및 그래픽 프로시져를 위한 소프트웨어 파이프라인을 용이하게 하고, 논리/산술 연산이 대체 레지스터 뱅크를 액세스하는 로드/저장 연산과는 다른 순서로 수행될 수 있기 때문에 데이타를 훼치할 때 프로세서 지연을 감소시킨다. 다른 명령에서, 대체 뱅크는 현재의 뱅크로부터의 벡터 레지스터와 대체 뱅크로부터의 대응하는 벡터 레지스터를 포함하는 이중 크기(double-size) 벡터 레지스터의 사용을 가능하게 한다. 이와 같은 이중 크기 레지스터는 명령 구문으로부터 식별될 수 있다. 벡터 프로세서에 있는 제어 비트는 디폴트 벡터 크기가 하나 또는 두개의 벡터 레지스터 중 어느 하나이도록 설정될 수 있다. 대체 뱅크는 또한 셔플(shuffle), 언셔플(unshuffle), 새춰레이트(saturate), 두개의 근원지와 두개의 목적지 레지스터를 갖는 조건 이동(conditional moves)와 같은 복잡한 명령의 구문에서 적은 수의 명시적 식별 오퍼런드의 사용을 가능하게 한다.
벡터 프로세서는 또한 쿼드(quad), 셔플, 언셔플, 페어-와이즈 최대 및 교환(pair-wise maximum and exchange), 및 새춰레이트와 같은 신규한 명령을 구현한다. 이들 명령들은 비디오 인코딩 및 디코딩과 같은 멀티미디어 기능에 공통인 연산을 수행하고, 다른 명령어 세트가 동일한 기능을 수행하는데 필요할 두개 이상의 명령을 대신한다. 따라서, 벡터 프로세서 명령어 세트는 멀티미디어 어플리케이션에서 프로그램의 효율성과 속도를 향상시킨다.
[발명의 구성 및 작용]
도1은 본 발명의 실시예에 따른 멀티미디어 신호 프로세서(MSP)(100)의 블럭도를 도시한다. 멀티미디어 프로세서(100)는 범용 프로세서(110)와 벡터 프로세서(120)를 포함하는 프로세싱 코어(105)를 구비한다. 프로세싱 코어(105)는 SRAM(160 및 190), ROM(170) 및 캐쉬 제어부(180)를 포함하는 캐쉬 서브시스템(130)을 통해 멀티미디어 프로세서(100)의 나머지 부분에 접속된다. 캐쉬 제어부(180)는 프로세서(110)를 위해 명령어 캐쉬(162)와 데이타 캐쉬(164)로서 SRAM(160)을 컨피그할 수 있고, 벡터 프로세서(120)를 위해 명령어 캐쉬(192)와 데이타 캐쉬(194)로서 SRAM(190)를 컨피그할 수 있다.
온-칩 ROM(170)은 프로세서(110)를 위해 데이타와 명령어를 포함하고 역시 캐쉬로서 컴피그될 수 있다. 예시적인 실시예에서, ROM(170)은 : 리셋 및 초기화 프로시져; 자기-시험 진단 프로시져; 인터럽트 및 예외 핸들러; 및 사운드블러스트 에뮬레이션을 위한 서브루틴; V. 34 모뎀 신호 프로세싱을 위한 서브루틴; 일반적인 텔레포니 기능; 1-D 및 3-D 그래픽스 서브루틴 라이브러리; 및 MPEG-1, MPEG-2, H. 261, H. 263, G. 728 및 G. 723과 같은 오디오 및 비디오 표준을 위한 서브루틴 라이브러리를 포함한다.
캐쉬 서브시스템(130)은 프로세서(110 및 120)에 접속되어 두개의 시스템 버스(140과 150)으로 향하고, 프로세서(110 및 120)를 위한 캐쉬 및 스위칭 스테이션 모두로서 동작하고, 디바이스 버스(140 및 150)에 결합되어 있다. 시스템 버스(150)는 높은 클럭 주파수로 동작하고, 외부 국부 메모리를 위한 인터페이스, 호스트 컴퓨터의 국부 버스, 직접 메모리 액세스, 및 다양한 아날로그 대 디지탈 및 디지탈 대 아날로그 변환기를 각각 제공하는 메모리 콘트롤러(158), 국부 버스 인터페이스(156), DMA 콘트롤러(154), 및 디바이스 인터페이스(152)에 접속된다. 버스(140)에 접속되어 있는 것은 시스템 타이머(142), UART(유니버셜 비동기 수신기 트랜시버)(144), 비트스트림 프로세서(146), 및 인터럽트 콘트롤러(148)이다. "멀티미디어 신호 프로세서에서 멀티프로세서 연산" 및 "비디오 데이타를 처리하기 위한 방법 및 장치"라는 발명의 명칭을 갖는 본 발명에 참조로 일체화된 특허출원은 프로세서(110 및 120)가 캐쉬 서브시스템(130) 및 버스(140 및 150)를 액세스하는 예시적인 디바이스 및 캐쉬 서브시스템(130)의 동작을 보다 상세히 설명한다.
프로세서(110 및 120)는 개별적인 프로그램 스래드를 실행하고 그들에 할당된 특정 작업의 보다 효율적인 실행을 위해 구조적으로 다르다. 프로세서(110)는 주로 실시간 연산 시스템의 실행과 같은 제어 기능 및 많은 각각의 연산을 필요로 하지 않는 유사한 기능을 위한 것이다. 따라서, 프로세서(110)는 고도의 연산력을 필요로 하지 않으며, 종래의 범용 프로세서 아키텍춰를 이용하여 구현될 수 있다. 벡터 프로세서(120)는 대부분 멀티미디어 프로세싱에 공통인 데이타 블럭에 대한 반복적인 연산을 포함하는 숫자 크러싱(number crushing)을 수행한다. 고도의 연산력과 비교적 간단한 프로그래밍을 위해, 벡터 프로세서(120)는 SIMD(Single Instruction Multimedia Data) 아키텍춰를 가지며, 예시적인 실시예에서, 벡터 프로세서(120)에서 대부분의 경로는 벡터 데이타 조작을 지원하기 위해 288 또는 576비트 폭이다. 부수적으로, 벡터 프로세서(120)를 위한 명령어 세트는 특히 멀티미디어 문제에 적합한 명령어를 포함한다.
예시적인 실시예에서, 프로세서(110)는 40MHz에서 동작하는 32비트 RISC 프로세서이고, ARM 7 표준에 의해 정의된 바와 같이 레지스터 세트를 포함하는 ARM 7 프로세서의 아키텍춰에 맞는다. ARM 7 RISC 프로세서를 위해 설정된 아키텍춰 및 명령어는 "ARM 7 DM 데이타 쉬트", 문서번호 : Advance RISC Machines Ltd.로부터 입수할 수 있는 ARM DDI 0010G에 설명되어 있다. 상기 ARM 7 DM 데이타 쉬트는 이하 그 전문이 본 발명의 참조로 일체화되어 있다. 부록 A는 예시적인 실시예에서 ARM 7 명령어의 확장을 설명한다.
벡터 프로세서(120)는 벡터 및 스칼라 양 모두를 조작한다. 예시적인 실시예에서, 벡터 데이타 프로세서(120)는 80MHz에서 동작하는 파이프라인된 RISC 엔진으로 구성된다. 벡터 프로세서(120)의 레지스터는 32비트 스칼라 레지스터, 32비트 특수 목적 레지스터, 288비트 벡터 레지스터의 두 뱅크, 및 이중 크기(즉, 576 비트)의 두 개의 벡터 누산 레지스터를 구비한다. 부록 C는 벡터 프로세서(120)의 예시적인 실시예를 위한 레지스터 세트를 설명한다. 예시적인 실시예에서, 프로세서(120)는 0에서 31까지의 범위에 이르는 5비트 레지스터 번호들에 의해 명령어에 식별된다. 또한 32벡터 레지스터의 두개 뱅크로 구성된 64개 288비트 벡터 레지스터가 존재한다. 각각의 벡터 레지스터는 1비트 뱅크 번호(0 또는 1) 및 0에서 31까지의 범위에 이르는 5비트 벡터 레지스터 번호로서 식별될 수 있다. 대부분의 명령어는 벡터 프로세서(120)의 제어 레지스터 VCSR에 저장된 디폴트 뱅크 비트 CBANK로 가리켜진 현재의 뱅크에 있는 벡터 레지스터를 액세스한다. 두번째 제어 비트 VEC 4는 디폴트로 레지스터 번호가 각 뱅크로부터의 레지스터를 포함하는 이중 크기 벡터 레지스터를 식별하는지를 가리킨다. 명령어의 구문은 스칼라 레지스터를 식별하는 레지스터 번호로부터 벡터 레지스터를 식별하는 레지스터 번호를 구별한다.
각각의 벡터 레지스터는 프로그램 가능한 크기의 데이타 엘리먼트로 파티션될 수 있다. 표1은 288비트 벡터 레지스터내의 데이타 엘리먼트를 지원하는 데이타 유형을 도시한다.
[표 1]
Figure kpo00002
부록 D는 본 발명의 예시적인 실시예에서의 지원되는 데이타 크기와 유형의 자세한 설명을 제공한다.
int 9 데이타형의 경우, 9비트 바이트가 288비트 벡터 레지스터에 순차적으로 팩되지만, 다른 데이타형의 경우 288비트 벡터 레지스터의 매 9번째 비트가 사용되지 않는다. 288비트 벡터 레지스터는 328비트 또는 9비트 정수 데이타 엘리먼트, 16개의 16비트 정수 데이타 엘리먼트 또는 8개의 32비트 정수 또는 부동 소수점 엘리먼트를 보유할 수 있다. 부수적으로, 두개의 벡터 레지스터가 이중 크기 벡터의 데이타 엘리먼트에 조합될 수 있다. 본 발명의 예시적인 실시예에서, 제어 비트 VEC 64를 제어 및 상태 레지스터 VCSR에 세팅함으로서 이중 크기(576비트)가 벡터 레지스터의 디폴트 크기인 모드 VEC 64에 위치시킨다.
또한 멀티미디어 프로세서(100)는 프로세서(110 및 120) 모두에 액세스할 수 있는 32비트 확장 레지스터(115)의 세트를 수용한다. 부록 B는 본 발명의 예시적인 실시예에서 확장 레지스터 세트 및 그 기능을 설명한다. 벡터 프로세서(120)의 확장 레지스터 및 스칼라 및 특수 목적 레지스터는 몇몇 환경에서 프로세서(110)에 액세스할 수 있다. 두개의 특수 "사용자" 확장 레지스터는 두개의 판독 포트를 가짐으로서 프로세서(110 및 120)가 레지스터를 동시에 판독할 수 있다. 다른 확장 레지스터는 동시에 액세스될 수 없다.
벡터 프로세서(120)는 벡터 프로세서(120)가 실행중 또는 아이들인 지를 가리키는 두개의 선택적인 상태 VP_ RUN 및 VP_ IDLE를 갖는다. 프로세서(110)는 벡터 프로세서(120)가 상태 VP_ IDLE에 있을 때 벡터 프로세서(120)의 스칼라 또는 특수 목적 레지스터를 판독 또는 기록할 수 있지만, 벡터 프로세서(120)가 상태 VP_ RUN에 있는 동안 벡터 프로세서(120)의 레지스터를 판독 또는 기록하는 프로세서(110)의 결과는 정의되어 있지 않다.
프로세서(110)를 위한 ARM 7 명령어 세트의 확장은 벡터 프로세서(120)의 확장 레지스터 및 스칼라 또는 특수 목적 레지스터를 액세스하는 명령어를 포함한다. 명령어 MFER 및 MFEP는 확장 레지스터 및 벡터 프로세서(120)의 스칼라 또는 특수 목적 레지스터에서 프로세서(110)의 범용 레지스터로 각각 데이타를 이동시킨다. 명령어 MTER 및 MTEP는 각각 프로세서(110)의 범용 레지스터에서 확장 레지스터 및 벡터 프로세서(120)의 및 스칼라 또는 특수 목적 레지스터로 데이타를 이동시킨다. TESTSET 명령어는 확장 레지스터를 판독하고 모두 확장 레지스터의 비트 30을 1로 세트시킨다. 명령어 TESTSET는 프로세서(110)가 나온 결과를 판독(또는 사용)한 프로세서(120)에 시그날하기 위해 비트 30을 세트시킴으로서 사용자/생산자 동기화를 용이하게 한다. STARTVP와 INTVP를 위한 다른 명령어는 벡터 프로세서(120)의 동작 상태를 제어한다.
프로세서(110)는 벡터 프로세서(120)의 동작을 제어하기 위해 마스터 프로세서로서 동작한다. 프로세서(110와 120)간의 제어의 비동기 분할을 사용함으로서 프로세서(110 및 120)의 동기화 문제를 간단하게 한다. 프로세서(110)는 벡터 프로세서(120)가 상태 VP_ IDLE에 있는 동안 벡터 프로세서(120)를 위한 프로그램 카운터에 명령어 어드레스를 기록함으로서 벡터 프로세서(120)를 초기화시킨다. 다음에 프로세서(110)는 벡터 프로세서(120)를 상태 VP_ RUN으로 바꾸는 STARTVP 명령어를 실행한다. 상태 VP_ RUN에서, 벡터 프로세서(120)는 캐쉬 서브시스템(130)을 통해 명령어를 훼치하고 자신의 프로그램의 실행을 계속하면서 프로세서(110)와 병렬로 그와 같은 명령어를 실행한다. 시작되면, 벡터 프로세서(120)는 예외를 만날때까지 실행을 계속하고, 적당한 조건이 충족되면 VCJOIN 또는 VCINT 명령어를 실행하거나 또는 프로세서(120)에 의해 인터럽트된다. 벡터 프로세서(120)는 벡터 프로세서(120)가 상태 VP_ IDLE에 재진입할 때 그 결과를 확장 레지스터에 기록하고, 그 결과를 프로세서(110 및 120)의 공유 어드레스 공간에 기록하거나 또는 그 결과를 프로세서(110)가 액세스하는 스칼라 또는 특수 목적 레지스터에 위치시킴으로서 프로그램 실행의 결과를 프로세서(120)로 넘긴다.
벡터 프로세서(120)는 그 자신의 예외를 처리하지 않는다. 예외를 유발하는 명령어를 실행하면, 벡터 프로세서(120)는 상태 VP_ IDLE에 진입하고 직접 라인을 통해 인터럽트 요구를 프로세서(110)에 시그날한다. 벡터 프로세서(120)는 프로세서(110)가 다른 STARTVP 명령어를 실행할 때까지 상태 VP_ IDLE에 남는다. 프로세서(110)는 예외의 성질을 판단하기 위해 벡터 프로세서(120)의 레지스터 VISRC를 판독하고, 벡터 프로세서(120)를 다시 초기화시킴으로서 가능한 한 예외를 처리한 다음, 필요하다면 예외를 재시작하기 위해 벡터 프로세서(120)를 다이렉트할 책임이 있다.
프로세서(110)에 의해 실행된 INTVP 명령어는 벡터 프로세서(120)로 하여금 아이들 상태 VP_ IDLE로 진입하게 한다. 예를 들어, 명령어 INTVP는 비디오 디코딩과 같은 하나의 작업에서 사운드 카드 에뮬레이션과 같은 다른 작업으로 벡터 프로세서를 전환시키는 멀티태스킹 시스템에 사용될 수 있다.
벡터 프로세서 명령어 VCINT 및 VCJOIN은 명령어에 의해 가리켜진 조건이 충족되었다면, 벡터 프로세서(120)에 의한 실행을 중지하고, 벡터 프로세서(120)를 상태 VP_ IDLE에 놓으며 이와 같은 요구가 마스크될 때까지 인터럽트 요구를 프로세서(110)에 발행하는 흐름 제어 명령어이다. 벡터 프로세서(120)의 프로그램 카운터(특수 목적 레지스터)는 VCINT 또는 VCJOIN 명령어 이후 명령어 어드레스를 가리킨다. 프로세서(110)는 벡터 프로세서(120)의 인터럽트 소스 레지스터 VISRC를 점검하여 VCINT 또는 VCJOIN 명령어가 인터럽트 요구를 유발하였는지를 결정한다. 벡터 프로세서(120)가 보다 큰 데이타 버스를 가지고 그 레지스터를 저장 및 복구하는데 보다 효율적이기 때문에, 벡터 프로세서(120)에 의해 실행된 소프트웨어는 구문 전환 동안 레지스터를 저장 및 복구하여야 한다. 상기 일체로 된 특허 출원 발명의 명칭 "마이크로 프로세서에서 효율적인 구문 저장 및 복구"는 구문 전환을 위한 예시적인 시스템을 설명한다.
도2는 도1의 벡터 프로세서(120)의 예시적인 실시예의 주요 기능 블럭도이다. 벡터 프로세서(120)는 명령어 훼치부(IFU)(21), 디코더(220), 스케쥴러(230), 실행 데이타 경로(240), 및 로드/저장부(LSU)(250)를 구비한다. IFU(210)는 명령어를 훼치하고 분기와 같은 흐름 제어 명령어를 처리한다. 명령어 디코더(220)는 IFU(210)로부터 도달 순서로 사이클 마다 하나의 명령어를 디코드하고, 명령어로부터 디코드된 필드 값을 스케쥴러(230)의 FIFO에 기록한다. 스케쥴러(230)는 연산의 실행 스테이지에 필요하다면 실행 제어 레지스터로 발행된 필드 값을 선택한다. 발행 선택은 실행 데이타 경로(240) 또는 로드/저장부(250)와 같은 프로세싱 자원의 의존성과 이용가능성에 따른다. 실행 데이타 경로(240)는 벡터 또는 스칼라 데이타를 조작하는 논리/산술 명령어를 실행한다. 로드/저장부(25)는 벡터 프로세서(120)의 어드레스 공간을 액세스하는 로드/저장 명령어를 실행한다.
도3은 주 명령어 버퍼(310)와 보조 명령어 버퍼(312)로 나누어지는 명령어 버퍼를 포함하는 IFU(210)의 실시예에 대한 블럭도를 도시한다. 주 버퍼(310)는 현재의 프로그램 카운트에 대응하는 명령어를 포함하는 8개의 연속하는 명령어를 수용한다. 보조 버퍼(312)는 버퍼(310)의 명령어를 즉시 따라가는 8개의 명령어를 수용한다. IFU(210)는 또한 버퍼(310 또는 312)의 다른 흐름 제어 명령어의 목표를 포함하는 8개의 연속하는 명령어를 수용하는 분기 목표 버퍼(314)를 포함한다. 예시적인 실시예에서, 벡터 프로세서(120)는 각 명령어가 32비트 길이인 RISC형 명령어 세트를 사용하고, 버퍼(310, 312 및 314)는 8×32비트 버퍼로 256비트 명령어 버스를 통해 캐쉬 서브시스템(130)에 접속된다. IFU(210)는 캐쉬 서브시스템(130)에서 임의의 버퍼(310, 312 또는 314)로 단일 클럭 사이클로 8개의 명령어를 로드할 수 있다. 레지스터(340, 342 및 344)는 각각 버퍼(310, 312 및 314)에 로드된 명령어에 대한 베이스 어드레스를 가리킨다.
멀티플렉서(332)는 주 명령어 버퍼(310)로부터 현재의 명령어를 선택한다. 만일 현재의 명령어가 흐름 제어 명령어가 아니고 명령어 레지스터(330)에 저장된 명령어가 실행의 디코드 스테이지로 진행하면, 현재의 명령어는 명령어 레지스터(330)에 저장되고, 프로그램 카운트는 증가된다. 프로그램 카운트를 증가시켜 버퍼(310)의 마지막 명령어를 선택한 후, 다음 세트의 8 명령어가 버퍼(310)에 로드된다. 만일 버퍼(312)가 소정의 8 명령어를 포함하면, 버퍼(312) 및 레지스터(342)의 내용은 즉시 버퍼(310) 및 레지스터(340)로 이동되고, 8개 이상의 명령어가 캐쉬 시스템(130)으로부터 보조 버퍼(312)로 프리훼치된다. 가산기(350)는 레지스터(342)에 있는 베이스 어드레스로부터 다음 명령어 세트의 어드레스와 멀티플렉서(352)에 의해 선택된 오프셋을 결정한다. 가산기(350)로부터 결과로 나타나는 어드레스가 레지스터(342)가 레지스터(340)로 이동하거나 이동한 후 레지스터(342)에 저장된다. 산출된 어드레스는 또한 8개 명령어를 위한 요구로서 캐쉬 서브시스템(130)으로 전달된다. 만일 캐쉬 제어 시스템(130)에 대한 이전의 호출이 버퍼(310)가 요구한 버퍼(312)로 다음 8 명령어를 제공하지 않았다면, 이전에 요구된 명령어는 캐쉬 서스시스템(130)으로부터 수신될 때 버퍼(310)에 즉시 저장된다.
만일 현재의 명령어가 흐름 제어 명령어이면, IFU(210)는 흐름 제어 명령어에 대한 조건을 평가하고 흐름 제어 명령어의 뒤에 오는 프로그램 카운트를 갱신함으로서 명령어를 처리한다. 조건을 바꿀 수 있는 이전 명령어가 완료되지 않았기 때문에 만일 조건이 결정되지 않으면 IFU(210)는 보류된다. 만일 분기가 취해지지 않으면, 프로그램 카운터는 증가되고 다음 명령어가 상술된 바와 같이 선택된다. 만일 분기가 취해지고 분기 목표 버퍼(314)가 분기의 목표를 포함하고 있으면, 버퍼(314) 및 레지스터(344)의 내용이 버퍼(310) 및 레지스터(340)로 이동되어, IFU(210)는 캐쉬 서브시스템(130)으로부터 명령어를 대기하지 않고 명령어를 디코더(220)에 계속 제공할 수 있다.
분기 목표 버퍼(314)에 대한 명령어를 프리훼치하기 위해, 스캐너(320)는 버퍼(310 및 312)를 스캔하여 현재의 프로그램 카운트의 뒤에 오는 다음 흐름 제어 명령어를 찾는다. 만일 흐름 제어 명령어가 버퍼(310 또는 312)에서 발견되면, 스캐너(320)는 명령어를 수용하고 있는 버퍼(310 또는 312)의 베이스 어드레스로부터 흐름 제어 명령어의 목표 어드레스를 포함하는 8개의 명령어의 정렬된 세트로 오프셋을 결정한다. 멀티플렉서(352 및 354)는 흐름 제어 명령어로부터의 오프셋과 레지스터(340 또는 342)로부터의 베이스 어드레스를 버퍼(314)에 대해 새로운 베이스 어드레스를 생성하는 가산기(350)로 공급한다. 새로운 베이스 어드레스는 다음에 분기 목표 버퍼(314)에 대해 8 명령어를 공급하는 캐쉬 서브시스템(130)으로 전달된다.
"감소 및 조건 분기" 명령어 VD1CBR, VD2CBR 및 VD3CBR 및 "변경 제어 레지스터" 명령어 VCHGCR와 같은 흐름 제어 명령어를 취급하는데 있어, IFU(210)는 프로그램 카운트 이외에 레지스터 값을 바꿀 수 있다. IFU(210)가 흐름 제어 명령어가 아닌 명령어를 발견하면, 해당 명령어는 그곳에서 명령어 레지스터(330)에서 디코더(220)로 전달한다.
디코더(220)는 도4에 도시된 바와 같이 스케쥴러(230)의 FIFO 버퍼(410)이 필드에 제어 값을 기록함으로서 명령어를 디코드한다. FIFO 버퍼(410)는 네 행의 플립-플롭을 수용할 수 있는데, 이들 각각은 한 명령어의 실행을 제어하기 위한 5필드의 정보를 수용할 수 있다. 행 0 내지 3은 가장 오래된 것에서 가장 최근의 명령어에 대한 정보를 각각 보유하고, FIFO 버퍼(410)의 정보는, 명령어가 완료됨에 따라 오래된 정보가 제거될 때 보다 낮은 행으로 시프트 다운한다. 스케쥴러(230)는 실행 레지스터(421 내지 427)를 수용하고 있는 제어 파이프(420)로 로드될 명령어의 필요한 필드를 선택함으로서 실행 스테이지에 명령어를 발행한다. 대부분의 명령어는 순서에 어긋난 발행 및 실행으로 스케쥴될 수 있다. 특히, 로드/저장 연산과 논리/산술 연산의 순서는 로드/저장 연산 및 논리/산술 연산 간에 오퍼런드 종속성이 존재하지 않는 한 임의적이다. FIFO 버퍼(410)의 필그 값의 비교는 임의의 오퍼런드 종속성이 존재하는 지를 가리킨다.
도5a는 벡터 프로세서(120)의 어드레스 공간을 액세스하지 않고의 레지스터-대-레지스터 연산을 수행하는 명령어에 대한 6개의 스테이지 실행 파이프라인을 도시한다. 명령어 훼치 스테이지(511)에서, IFU(210)는 상술된 바와 같이 명령어를 훼치한다. 훼치 스테이지는 IFU(210)가 파이프라인 지연, 미해결 분기 조건, 또는 프리훼치된 명령어를 제공하는 캐쉬 서브시스템(130)에서의 지연에 의해 보류되지 않는 한, 한 클럭 사이클을 필요로 한다. 디코드 스테이지(512)에서, 디코더(220)는 IFU(210)로부터 명령어를 디코드하고, 스케쥴러(230)에 명령어에 대한 정보를 기록한다. 디코드 스테이지(512)는 또한 FIFO(410)의 어떠한 행도 새로운 연산에 사용할 수 없는 한 한 클럭 사이클을 필요로 한다. 연산은 FIFO(410)에서 첫번째 사이클 동안 제어 파이프(420)로 발생될 수 있지만, 보다 오래된 연산의 발행에 의해 지연될 수 있다.
실행 데이타 경로(240)는 레지스터-대-레지스터 연산을 수행하고 로드/저장 연산을 위해 데이타 및 어드레스를 공급한다. 도6a는 실행 데이타 경로(240)의 실시예의 블럭도를 도시하고, 실행 스테이지(514, 515 및 515)와 결합하여 서술된다. 실행 레지스터(421)는 판독 스테이지(514) 동안 클럭 사이클에서 판독된 레지스터 화일(610)에 두개의 레지스터를 식별하는 신호들을 제공한다. 도6b는 레지스터 화일(610)의 블럭도를 도시한다. 레지스터 화일(610)는 두개의 판독 및 두개의 기록을 각 클럭 사이클마다 수용하기 위해 두개의 판독 및 두개의 기록 포트를 갖는다. 각각의 포트는 선택 회로(612, 614, 616 및 618) 및 288비트 데이타 버스(613, 615, 617 및 619)를 포함한다. 회로(612, 614, 616 및 618)과 같은 선택회로는 기술분야에 공지되어 있고, 디코더(220)가 전형적으로 명령어로부터 추출되는 5비트 레지스터 번호로부터 유도하는 어드레스 신호 WRADDR1, WRADDR2, RDADDR1 또는 RDADDR2, 명령어 또는 제어 상태 레지스터 VCSR로부터의 뱅크 비트, 및 레지스터가 벡터 레지스터 또는 스칼라 레지스터 인지를 가리키는 명령어 구문을 이용한다. 데이타 판독은 멀티플렉서(656)를 통해 로드/저장부(250)으로 또는 멀티플렉서(622 및 624)를 통해 곱셈기(640), 산술 논리부(620), 또는 누산기(640)을 통해 라우트될 수 있다. 대부분의 연산은 두개의 레지스터를 판독하고, 판독스테이지(514)는 한 사이클에 완료된다. 그러나, 곱셈과 덧셈 명령어 VMAD 및 이중 크기 벡터를 조작하는 명령어와 같은 일부 명령어는 판독 스테이지(514)가 한 클럭 사이클보다 길도록 두개 레지스터 이상으로부터 데이타를 필요로 한다.
실행 스테이지(515) 동안, 곱셈기(620), 산술 논리부(630) 및 누산기(640)는 레지스터 화일(610)로부터 이전에 판독된 데이타를 처리한다. 실행 스테이지(515)는 소정의 데이타를 판독하는데 다수의 사이클이 필요하다면 판독 스테이지(514)를 오버랩할 수 있다. 실행 스테이지(515)의 기간은 처리된 데이타 엘리먼트의 유형(정수 또는 부동 소수점) 및 양(판독 사이클의 수)에 의존한다. 실행 레지스터(422, 423 및 425)로부터의 신호는 실행 스테이지 동안 수행된 첫번째 연산 동안 산술 논리부(630), 누산기(640) 및 곱셈기(620)로의 입력 데이타를 제어한다. 실행 레지스터(432, 433 및 435)로부터의 신호는 실행 스테이지(515) 동안 수행된 두번째 연산을 제어한다.
도6c는 곱셈기(620) 및 ALU(630)의 실시예에 대한 블럭도이다. 곱셈기(620)는 8개의 독립적인 36×36비트 곱셈기(626)를 포함하는 정수 곱셈기이다. 각각의 곱셈기(626)는 제어 회로에 의해 함께 접속된 4개의 9×9비트 곱셈기를 포함한다. 8비트 및 9비트 데이타 엘리먼트 크기의 경우, 스케쥴러(230)로부터의 제어신호는 각 곱셈기(626)가 네개의 곱셈을 수행하도록 상호 4개의 9×9비트 곱셈기로부터 분리시키고, 곱셈기(620)는 사이클 동안 32개의 독립적인 곱셈을 수행한다. 16비트 데이타 엘리먼트의 경우, 제어회로는 함께 동작하는 9×9비트 곱셈기의 쌍들을 연결하고, 곱셈기(620)는 16개의 병렬 곱셈을 수행한다. 32비트 정수 데이타 엘리먼트 유형의 경우, 8개의 곱셈기(626)는 클럭 사이클마다 8개의 병렬 곱셈을 수행한다. 곱셈의 결과는 9비트 데이타 엘리먼트 크기에 대해 576비트 결과를 그리고 다른 데이타 크기에 대해서는 512비트를 제공한다.
ALU(630)는 두 클럭 사이클 동안 곱셈기(620)로부터 결과로 나타나는 576비트 또는 512비트 결과를 처리할 수 있다. ALU(630)는 8개의 독립적인 36비트 ALU(636)를 포함한다. 각각의 ALU(636)는 부동 소수점 덧셈 및 곱셈을 위해 32×32비트 부동 소수점부를 포함한다. 부수적인 회로는 정수 쉬프트, 산술 및 논리함수를 실행한다. 정수 조작의 경우, 각각의 ALU(636)는 독립적인 8비트 및 9비트 조작을 수행할 수 있고 16비트 및 32비트 정수 데이타 엘리먼트에 대해 두개 또는 네개 세트로 함께 링크될 수 있는 네개의 부를 포함한다.
누산기(640)는 결과를 누산하고 중간 결과에서 보다 높은 정확도를 위해 두개의 576비트 레지스터를 포함한다.
기록 스테이지(516)동안, 실행 스테이지로부터의 결과는 레지스터 화일(610)에 저장된다. 두개의 레지스터는 단일 클럭 사이클 동안 기록될 수 있고, 입력 곱셈기(602 및 605)는 기록될 두개의 데이타 값을 선택한다. 연산을 위한 기록 스테이지(516)의 기간은 연산의 결과로서 기록될 데이타의 양과 레지스터 화일(610)에 기록함으로서 로드 명령어를 완료할 수 있는 LSU(250)으로부터의 완료에 따른다. 실행 레지스터(426 및 427)로부터의 신호는 논리부(630), 누산기(640) 및 곱셈기(620)로부터의 데이타가 기록되는 레지스터를 선택한다.
도5b는 로드 명령의 실행을 위한 실행 파이프라인(520)을 도시한다. 실행 파이프라인(520)을 위한 명령어 훼치 스테이지(511), 디코드 스테이지(512) 및 발생 스테이지(513)는 레지스터-대-레지스터 연산에 대해 서술된 것과 동일하다. 판독 스테이지(514)는 또한 실행 데이타 경로(240)가 레지스터 화일(610)로부터의 데이타를 사용하여 캐쉬 서브시스템(130)에의 호출을 위한 어드레스를 결정한다는 것을 제외하고 상술된 것과 동일하다. 어드레스 스테이지(525)에서, 멀티플렉서(652, 654 및 656)는 실행 스테이지(526 및 527)를 위해 로드/저장부(250)에 제공되는 어드레스를 선택한다. 로드 연산을 위한 정보는 스테이지(526 및 527) 동안 FIFO(410)에 유지되는 반면에 로드/저장부(250)는 연산을 취급한다.
도7은 로드/저장부(250)의 실시예를 도시한다. 스테이지(256)동안, 스테이지(525)에서 결정된 어드레스로부터의 데이타를 위해 캐쉬 서브시스템(130)에 대해 호출된다. 예시적인 실시예는 프로세서(110 및 120)를 포함하는 다수의 디바이스들이 캐쉬 서브시스템(130)을 통해 국부 어드레스 공간을 액세스할 수 있는 트랜잭션에 근거한 캐쉬 호출을 이용한다. 요청된 데이타는 캐쉬 서브시스템(130)을 호출한 후 몇 사이클 동안 이용할 수 없지만, 로드/저장부(250)는 다른 호출이 계류하는 동안 캐쉬 서브시스템을 호출할 수 있다. 따라서, 로드/저장부(250)는 보류되지 않는다. 요청된 데이타를 제공하기 위해 캐쉬 서브시스템(130)에 필요한 클럭 사이클의 수는 데이타 캐쉬(194)를 히트 또는 미스하였는가에 따른다.
드라이브 스테이지(527)에서, 캐쉬 서브시스템(130)은 로드/저장부(250)에 대해 데이타 신호를 어써트한다. 캐쉬 서브시스템(130)은 로드/저장부(250)에 사이클마다 데이타의 256비트(32바이트)를 제공할 수 있다. 바이트 정렬기(710)는 288비트 값을 제공하기 위해 대응하는 9비트 저장 장소에 각각의 32바이트를 정렬시킨다. 288비트 포맷은 때때로 9비트 데이타 엘리먼트를 사용하는 MPEG 엔코딩 및 디코딩과 같은 멀티미디어 어플리케이션에 용이하다. 288비트 값은 판독 데이타 버퍼(720)에 기록된다. 기록 스테이지(528)의 경우, 스케쥴러(230)는 데이타 버퍼(720)로부터의 288비트 양을 레지스터 화일(610)에 기록하기 위해 FIFO 버퍼(410)에서 실행 레지스터(426 또는 427)로 필드(4)를 운반한다.
도5c는 저장 명령어의 실행을 위한 실행 파이프라인(530)을 도시한다. 실행 파이프라인(530)을 위한 명령어 훼치 스테이지(511), 디코드 스테이지(512) 및 발생 스테이지(513)는 상술된 바와 동일하다. 판독 스테이지(514)는 또한 판독 스테이지가 저장될 데이타 및 어드레스 산출을 위한 데이타를 판독한다는 점을 제외하고 상술된 바와 같다. 저장될 데이타는 로드/저장부(250)의 데이타 버퍼(730)에 기록된다. 멀티플렉서(740)는 9비트 바이트를 제공하기 위한 포맷인 데이타를 8비트 바이트를 갖는 종래의 포맷으로 변환한다. 버퍼(730)로부터의 변환된 데이타 및 어드레스 산출 스테이지(525)로부터의 연관된 어드레스는 SRAM 스테이지(536)동안 캐쉬 서브시스템(130)에 병렬로 보내진다.
벡터 프로세서(120)의 예시적인 실시예에서, 각 명령어는 32비트 길이이고, 도8에 도시된 9개의 포맷중 한 포맷을 가지며 REAR, REAI, RRRM5, RRRR, RI, CT, RRRM9, RRRM9* 및 RRRM9**의 표식을 갖는다. 부록 E는 벡터 프로세서(120)를 위한 명령어 세트를 설명한다.
효율적인 어드레스를 결정할 때 스칼라 레지스터를 이용하는 일부 로드, 저장 및 캐쉬 연산은 REAR 포맷을 갖는다. REAR 포맷 명령은 000b인 비트 29-31에 의해 식별되고, 스칼라 레지스터를 위한 두개의 레지스터 번호 SRb 및 SRi 및 비트 D에 의존하는 스칼라 또는 벡터일 수 있는 레지스터의 레지스터 번호 Rn으로 식별되는 3개의 오퍼런드를 갖는다. 뱅크 비트 B는 레지스터 Rn에 대한 뱅크를 식별하거나 또는 디폴트 벡터 레지스터 크기가 이중 크기이면 벡터 레지스터 Rn이 이중 크기 벡터 레지스터인지를 가리킨다. 오피코드 필드 Opc는 오퍼런드에 대해 수행된 연산을 식별하고, 필드 TT는 로드 또는 저장으로서 전송 유형을 식별한다. 전형적인 REAR 포맷 명령은 스칼라 레지스터 SRb 및 SRi의 내용을 더함으로서 결정된 어드레스로부터 레지스터 Rn을 로드하는 명령어 VL이다. 만일 비트 A가 세트되면 산출된 어드레스는 스칼라 레지스터 SRb에 저장된다.
REAI 포맷 명령은 필드 IMM으로부터의 8비트 중간 값이 스칼라 레지스터 SRi의 내용 대신에 사용된다는 것을 제외하고 REAR 명령과 동일하다. REAR 및 REAI 포맷은 데이타 엘리먼트 크기 필드를 가지고 있지 않다.
RRRM5 포맷은 두개의 소스 오퍼런드와 하나의 목적지 오퍼런드를 갖는 명령어를 위한 것이다. 이들 명령은 세개의 레지스터 오퍼런드 또는 두개의 레지스터 오퍼런드중 어느 하나와 5비트 중간 값을 갖는다. 부록 E에 도시된 바와 같이 필드 D, S 및 M의 엔코딩은 첫번째 소스 오퍼런드 Ra가 스칼라 또는 벡터 레지스터인지; 두번째 소스 오퍼런드 Rb/IM 5가 스칼라 레지스터, 벡터 레지스터, 또는 5비트 중간 값인지; 그리고 목적지 레지스터 Rd가 스칼라 또는 벡터 레지스터인지를 판단한다.
RRRR 포맷은 네개의 레지스터 오퍼런드를 갖는 명령어를 위한 것이다. 레지스터 번호 Ra 및 Rb는 소스 레지스터를 가리킨다. 레지스터 번호 Rd는 목적지 레지스터를 가리키고, 레지스터 번호 Rc는 필드 Opc에 따라 소스 또는 목적지 레지스터중 어느 하나를 가리킨다. 모든 오퍼런드는 비트 S가 레지스터 Rb를 가리키도록 세트되어 있지 않는 한 벡터 레지스터이다. 필드 DS는 벡터 레지스터를 위한 데이타 엘리먼트 크기를 가리킨다. 필드 Opc는 32비트 데이타 엘리먼트를 위한 데이타 유형을 선택한다.
RI 포맷 명령은 중간 값을 레지스터로 로드한다. 필드 IMM은 18비트까지의 중간 값을 수용한다. 레지스터 번호 Rd는 현재의 뱅크에 있는 벡터 레지스터 또는 비트 D에 따른 스칼라 레지스터중 어느 하나인 목적지 레지스터를 가리킨다. 필드 DS 및 F는 각각 데이타 엘리먼트 크기와 유형을 가리킨다. 32비트 정수 데이타 엘리먼트의 경우, 18비트 중간 값은 레지스터 Rd로 로드되기 전에 확장된 부호이다. 부동 소수점 데이타 엘리먼트의 경우, 비트 18, 비트 17 내지 10 및 비트 9 내지 0은 각각 32비트 부동 소수점 값의 부호, 지수 및 가수를 가리킨다.
CT 포맷은 흐름 제어 명령어를 위한 것이고 오피 코드 필드 Opc, 조건 필드 Cond 및 23비트 중간값 IMM을 포함한다. 조건 필드에 의해 가리켜진 조건이 참일 때 분기가 취해진다. 가능한 조건은 "항상", "보다 적은", "같은", "적거나 같은", "-이상인", "같지 않은", "-이상이거나 같은" 및 "오버플로우"이다. 상태 및 제어 레지스터 VSCR에 있는 비트 GT, EQ, LT 및 SO는 조건을 평가하는데 사용된다.
포맷 RRRM9는 3개의 레지스터 오퍼런드 또는 두개의 레지스터 오퍼런드중 어느 하나와 9비트 중간 값을 제공한다. 비트 D, S 및 M의 조합은 어떤 오퍼런드가 벡터 레지스터, 스칼라 레지스터 또는 9비트 중간 값인지를 가리킨다. 필드 DS는 데이타 엘리먼트 크기를 가리킨다. RRRM9* 및 RRRM9** 포맷은 RRRM9 포맷의 특수한 경우이고 오피 코드 필드 Opc에 의해 식별된다. RRRM9* 포맷은 소스 레지스터 번호 Ra를 조건 코드 Cond 및 ID 필드로 교체한다. RRRM9* 포맷은 중간 값의 최상위 비트를 조건 코드 Cond 및 비트 K로 교체한다. RRRM9* 및 RRRM9**의 부가적인 설명은 조건 이동 명령 VCMOV, 엘리먼트 마스크를 갖는 조건 이동 CMOVM과 관련하여 부록 E에 제시되어 있고 마스크 CMPV 명령과 비교하고 그것을 세트시킨다.
비록 본 발명이 특정 실시예를 참조로 서술되었지만, 본 설명은 단지 본 출원의 예일 뿐이며 한정하는 것으로 간주되어서는 안된다. 개시된 실시예의 다양한 변형과 조합은 다음의 특허청구 범위 영역으로서 한정된 바와 같이 본 발명의 영역내에서 포괄된다.
<부록 A>
예시적인 실시예에서, 프로세서(110)는 ARM7 프로세서용 표준과 호환하는 범용 프로세서이다. ARM7내의 레지스터의 설명을 위한 ARM 아키텍춰 문서 또는 ARM7 데이타 쉬트(1994년 12월 발행된 문서 번호 ARM DDI 0020C)를 참조한다.
벡터 프로세서(120)와 인터렉트하기 위해 프로세서(110)는 벡터 프로세서를 시작하고 정지시키며; 동기화를 위한 것을 포함하여 벡터 프로세서 상태를 태스트하고; 벡터 프로세서(120)에 있는 스칼라/특수 목적 레지스터로부터의 데이타를 프로세서(110)의 범용 레지스터로 전송하고; 및 범용 레지스터로부터의 데이타를 벡터 프로세서 스칼라/특수 목적 레지스터로 전송한다. 범용 레지스터와 벡터 프로세서 벡터 레지스터 간에 직접적인 전송 수단은 존재하지 않는다. 이와 같은 전송은 중간으로서 메모리를 필요로 한다.
표 A1은 벡터 프로세서 명령어를 위한 ARM7 명령어 세트로의 확장을 설명한다.
[표 A1]
Figure kpo00003
Figure kpo00004
표 A2는 결함이 있는 명령을 실행하기 전에 검출되어 보고된 ARM7 예외를 열거한다. 예외 벡터 어드레스가 16 진수 주석으로 제시되어 있다.
[표 A2]
Figure kpo00005
다음은 ARM7 명령어 세트로의 확장 구문을 설명한다. 명명법 설명과 명령어 포맷을 위해서는 ARM 아키텍춰 문서 또는 ARM7 데이타 쉬트(1994년 12월 발행된 문서번호 ARM DDI 0020C)를 참조한다.
ARM 아키텍춰는 코프로세서 인터페이스를 위해 세개의 명령어를 제공한다 :
1. 코프로세서 데이타 연산(CDP)
2. 코프로세서 데이타 전송(LDC, STC)
3. 코프로세서 레지스터 전송(MRC, MCR)
MSP 아키텍춰 확장은 세가지 모든 형식을 이용한다.
코프로세서 데이타 연산 포맷(CDP)은 ARM7로 다시 통신할 필요가 없는 연산에 사용된다.
Figure kpo00006
CDP 포맷에 있는 필드는 다음과 같은 규약을 갖는다:
Figure kpo00007
코프로세서 데이타 전송 포맷(LDC, STC)은 벡터 프로세서의 레지스터의 서브셋을 직접 메모리로 로드하거나 저장하는데 사용된다. ARM7 프로세서는 워드 프로세서를 공급하는 것을 담당하고, 벡터 프로세서는 데이타를 공급하거나 또는 수락하고 전송된 워드 수를 제어한다. 상세한 설명을 위해서는 ARM7 데이타 쉬트를 참조한다.
Figure kpo00008
포맷에 있는 필드는 다음과 같은 규약을 갖는다:
Figure kpo00009
코프로세서 레지스터 전송 포맷(MRC, MCR)은 ARM7과 벡터 프로세서 간에 직접 정보를 통신하는데 사용된다. 이 포맷은 ARM7 레지스터와 벡터 프로세서 스칼라 또는 특수 목적 레지스터 간을 이동시키는데 사용된다.
Figure kpo00010
포맷에 있는 필드는 다음 규약을 갖는다:
Figure kpo00011
확장 ARM 명령어 설명
확장 ARM-명령어는 알파벳 순서로 설명된다.
CACHE Cache 연산
포맷
Figure kpo00012
어셈블러 구문
STC{cond} p15, cOpc, 〈Address〉
CACHE{cpnd} Opc, 〈Address〉
여기서 cond={eq, he, cc, mi, pl, vs, vc, hi, Is, ge, It, gt, Ie, ai, nv} 및 Opc={0, 1, 3}. LDC/STC 포맷의 CRn 필드가 Opc를 명시하는데 사용되기 때문에, 오피코드의 십진 표현은 첫번째 구문에서 글자 'c'가 선행하여야 한다(즉, 0 대신 c0를 사용한다.)는 것에 유의한다. 어드레스 모드 구문에 대해서는 ARM7 데이타 쉬트를 참조한다.
설명
이 명령어는 Cond가 참일 때에만 실행된다. Opc〈3:0〉는 다음 연산을 명시한다 :
Figure kpo00013
연산
EA가 어떻게 산출되는지에 대해서는 ARM7 데이타 쉬트를 참조한다.
예외
ARM7 보호 위반
INTVP 인터럽트 벡터 프로세서
포맷
Figure kpo00014
어셈블러 구문
CDP{cond} p7, 1, c0, c0, co
INTVP{cond}
여기서 cond={eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, It, gt, le, al, ns}
설명
이 명령은 Cond가 참일 때 실행된다. 이 명령은 벡터 프로세서에게 중지하도록 시그날한다. ARM7은 벡터 프로세서가 중지할 때를 대기하지 않고 다음 명령을 계속 실행한다.
MFER 비지-대기 루프는 만일 벡터 프로세서가 이 명령이 실행된 후 정지되었는지를 확인하는데 사용된다. 이 명령은 만일 벡터 프로세서가 이미 VP_ IDLE 상태에 있다면 어떠한 영향도 없다.
비트 19:12, 7:15 및 3:0이 할당된다.
예외
이용가능하지 않은 벡터 프로세서
MFER 확장 레지스터로부터 이동
포맷
Figure kpo00015
어셈블러 구문
MRC{cond} p7, 2, Rd, cp, 0
MFER{cond} Rd, RNAME
여기서 cond={eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0, ... r15}, P={0, 1}, ER={0, ..15} 및 RNAME은 아카텍춰하게 명시된 레지스터니모닉(즉, PERO 또는 CSR)을 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. ARM7 레지스터 Rd는 이하의 표에 도시된 바와 같이, P : ER〈3 : 0〉로 명시된 확장 ER 레지스터로부터 이동된다. 확장 레지스터 설명에 대해서는 1.2절을 참조한다.
Figure kpo00016
비트 19 : 17 및 7 : 5는 예약되어 있다.
설명
사용자 모드에 있는 동안 PERx를 액세스하려고 시도하는 것은 보호 위반.
MFVP 벡터 프로세서로부터의 이동
포맷
Figure kpo00017
어셈블러 구문
MRC{cond} p7. 1. Rd. Crn. Crm. 0
MFER{cond} Rd, RNAME
여기서 cond={eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0, … r15}, CRn={c0, … c15}, CRm={c0, … c15} 및 RNAME은 아카텍춰하게 명시된 레지스터 니모닉(즉, SPO 또는 VSR)을 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. ARM7 레지스터 Rd는 벡터 프로세서의 스칼라/특수 목적 레지스터 CRn〈1 : 0〉: CRm〈3 : 0〉로부터 이동된다. 레지스터 전송을 위한 벡터 프로세서 레지스터 번호 할당에 대해서는 3.2.3절을 참조한다.
CRn〈3 : 2〉는 물론 비트 7.5는 예약되어 있다.
벡터 프로세서 레지스터 맵은 이하의 표에 도시된다. 벡터 프로세서 특수 목적 레지스터(SP0-SP15)에 대해서는 표 15를 참조한다.
Figure kpo00018
SR0은 항상 제로의 32비트로서 판독되고 그것에 대한 기록은 무시된다.
설명
벡터 프로세서는 이용할 수없음.
MTER 확장 레지스터로의 이동
Figure kpo00019
어셈블러 구문
MRC{cond} p7, 2, Rd, cp, cER, 0
MFER{cond} Rd, RNAME
여기서 cond={eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0, … r15}, P={0, 1}, ER={0, … 15} 및 RNAME은 아카텍춰하게 명시된 레지스터 니모닉(즉, PERO 또는 CSR)을 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. ARM7 레지스터 Rd는 이하의 표에 도시된 바와 같이 P : ER〈3 : 0〉으로 명시된 확장 레지스터 ER로부터 이동된다.
Figure kpo00020
비트 19 : 17 및 7 : 5는 예약되어 있다.
설명
사용자 모드에 있는 동안 PERx를 액세스하려고 시도하는 것은 보호 위반.
MTVP 벡터 프로세서로부터의 이동
포맷
Figure kpo00021
어셈블러 구문
MRC{cond} p7. 1. Rd. Crn. Crm. 0
MFER{cond} Rd. RNAME
여기서 cond={eq, ne, cs, cc, mi, pl, vs, vc, hi, ls, ge, lt, gt, le, al, nv}, Rd={r0, … r15}, CRn={c0, … c15}, CRm={c0, … c15} 및 RNAME은 아카텍춰하게 명시된 레지스터 니모닉(즉, SPO 또는 VSR)을 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. ARM7 레지스터 Rd는 벡터 프로세서의 스칼라/특수 목적 레지스터 CRn〈1:0〉:CRm〈3:0〉로부터 이동된다.
CRn〈3:2〉는 물론 비트 7.5는 예약되어 있다.
벡터 프로세서 레지스터 맵이 이하의 표에 도시되어 있다.
Figure kpo00022
예외
벡터 프로세서는 이용할 수 없음.
PFTCH 프리훼치
포맷
Figure kpo00023
어셈블러 구문
LDC{cond} p15, 2, 〈Address〉
PFTCH{cond} 〈Address〉
여기서 cond={eq, he, cs, cc, mi, pl, rs, vc, hi, ls, ge, lt, gt, le, al, nv}. 어드레스 모드 구문에 대해서는 ARM7 데이타 쉬트를 참조한다.
설명
본 명령은 Cond가 참일 때에만 실행된다. EA에 의해 명시된 캐쉬 라인은 ARM7 데이타 캐쉬로 프리훼치된다.
연산
EA가 어떻게 계산되는지에 대해서는 ARM7 데이타 쉬트를 참조한다.
예외 : 없음
STARTVP 시작 벡터 프로세서
포맷
Figure kpo00024
어셈블러 구문
LDP{cond} p7, 0, c0, c0
STARTVP {cond}
여기서 cond={eq, he, cs, cc, mi, pl, vs, vc, hi, ls, ge, it, gt, le, al, nv}.
설명
본 명령은 Cond가 참일 때에만 실행된다. 이 명령은 벡터 프로세서에게 시그날하여 실행을 시작할 수 있게 하고 VISRC〈vjp〉와 VISRC〈vip〉를 자동적으로 클리어한다. ARM7은 벡터 프로세서가 실행을 시작할 때까지 대기하지 않고 다음 명령을 계속 실행한다.
벡터 프로세서의 상태는 이 명령이 실행되기 전에 소정 상태로 초기화되어야 한다. 이 명령은 벡터 프로세서가 이미 VP_RUN 상태에 있으면 아무런 영향도 미치지 않는다.
비트 19:12, 7:5 및 3:0은 예약되어 있다.
예외
벡터 프로세서는 이용할 수 없다.
TESTSET 테스트와 세트
포맷
Figure kpo00025
어셈블러 구문
MRC{cond} p7, 0, Rd, c0, cER, 0
TESTSET{cond} Rd, RNAME
여기서 cond={eq, he, cs, cc, mi, pl, rs, re, hi, ls, ge, lt, gt, le, al, nv}. Rd={r0, … r15}, ER={0, … 15} 그리고 RNAME는 아카텍춰하게 명시된 레지스터 니모닉(즉, UER1 또는 VASYNC)를 가리킨다.
설명
본 명령은 Cond가 참일 때에만 실행된다. 이 명령은 UERx의 내용을 RD로 반환하고, UERx〈30〉를 1로 세트시킨다. 만일 ARM7 레지스터 15가 목적지 레지스터로 명시되어 있으면, 짧은 비지웨이트(busywait) 루프가 구현될 수 있도록 UERx〈30〉은 CPSR의 Z비트에서 반환된다.
예외 : 없음
〈부록 B〉
멀티미디어 프로세서(100)의 아키텍춰는 프로세서(110)가 MFER과 MTER 명령어로서 액세스하는 확장 레지스터를 정의한다. 상기 확장 레지스터는 전용 확장 레지스터와 사용자 확장 레지스터를 포함한다.
상기 전용 확장 레지스터는 대부분 멀티미디어 신호 프로세서의 동작을 제어하는데 사용된다. 이들은 표 B1에 도시되어 있다.
[표 B1]
Figure kpo00026
제어 레지스터는 MSP(100)의 동작을 제어한다. CTR에 있는 모든 비트는 리셋시 클리어된다. 레지스터 정의가 표 B2에 도시되어 있다.
[표 B2]
CTR 정의
Figure kpo00027
Figure kpo00028
상태 레지스터는 MSP(100)의 상태를 가리킨다. 필드 STR에 있는 모든 비트는 리셋시 클리어된다. 레지스터 정의가 표 B3에 도시되어 있다.
[표 B3]
STR 정의
Figure kpo00029
프로세서 버젼 레지스터는 프로세서들의 멀티미디어 신호 프로세서 군의 특수한 프로세서의 특수 버젼을 식별한다.
벡터 프로세서 인터럽트 마스크 레지스터 VIMSK는 프로세서(110)로의 벡터 프로세서 예외의 보고를 제거한다. VIMSK에 있는 각 비트는, VISRC 레지스터에 있는 대응하는 비트와 함께 세트될 때 예외를 인에이블시켜 ARM7을 인터럽트시킨다. 벡터 프로세서 예외가 검출되는 방법에는 영향을 미치지 않지만, 예외가 ARM7을 인터럽트시켜야 하는 지에 대해서만 영향을 미친다. VIMSK에 있는 모든 비트는 리셋시 클리어한다. 레지스터 정의가 표 B4에 도시되어 있다.
[표 B4]
Figure kpo00030
ARM7 명령어 어드레스 브레이크포인트 레지스터는 ARM7 프로그램을 디버스하는데 도움이 된다. 레지스터 정의가 표 B5에 도시되어 있다.
[표 B5]
Figure kpo00031
ARM7 데이타 어드레스 브레이크포인트 레지스터는 ARM7 프로그램을 디버그하는데 도움이 된다. 레지스터 정의가 표 B6에 도시되어 있다.
[표 B6]
Figure kpo00032
스크래치 패드 레지스터는 캐쉬 서브시스템(130)에 있는 SRAM을 이용하여 형성된 스크래치 패드의 어드레스와 크기를 컨피그한다. 레지스터 정의가 표 B7에 도시되어 있다.
[표 B7]
SPREG
Figure kpo00033
사용자 확장 레지스터는 대부분 프로세서(110 및 120)의 동기화에 사용된다. 사용자 확장 레지스터는 비트 30으로 맵핑된 단지 하나의 비트만을 갖도록 현재 정의되어 있고, 예를 들어 "MFER R15, UERx"와 같은 명령은 비트 값을 Z 플래그로 반환한다. 비트 UERx〈31〉 및 UERx〈29:0〉는 항상 제로로 판독된다. 사용자 확장 레지스터가 표 B8에 설명되어 있다.
[표 B8]
확장 레지스터
Figure kpo00034
표 B9는 파우어-온 리셋시 확장 레지스터의 상태를 도시한다.
[표 B9]
Figure kpo00035
〈부록 C〉
벡터 프로세서(120)의 아키텍춰 상태는 : 32개의 32비트 스칼라 레지스터; 32개의 288비트 벡터 레지스터의 2뱅크; 한쌍의 576비트 벡터 누산 레지스터; 한 세트의 32비트 특수 목적 레지스터를 구비한다. 스칼라, 벡터 및 누산기 레지스터는 범용 목적 프로그래밍을 위해 의도되었고, 다른 많은 데이타 형을 지원한다.
다음 주석은 이와 같은 그리고 후속하는 절에 사용된다 : VR은 벡터 레지스터를 가리킨다; VRi는 i번째 벡터 레지스터(제로 오프셋)를 가리킨다; VR[i]는 벡터 레지스터 VR에서 i번째 데이타 엘리먼트를 가리킨다; VR〈a:b〉는 벡터 레지스터 VR에서 비트 a 내지 b를 가리킨다; 그리고 VR[i]〈a:b〉는 벡터 레지스터 VR에서 i번째 데이타 엘리먼트의 a 내지 b를 가리킨다.
벡터 아키텍춰는 하나의 벡터 레지스터내에 다수의 엘리먼트를 위한 데이타형 및 크기의 부가된 치수를 갖는다. 벡터 레지스터가 고정된 크기이므로, 그것이 수용할 수 있는 데이타 엘리먼트의 수는 엘리먼트의 크기에 따른다. MSP 아키텍춰는 표 C1에 도시된 바와 같이 다섯개의 엘리먼트 크기를 갖는다.
[표 C1]
Figure kpo00036
MSP 아키텍취는 명령에 있는 명시된 데이타 형과 크기에 따라 벡터 테이타를 해석한다. 현재 2의 보수(정수) 포맷이 대부분의 아키텍춰 명령의 바이트, 바이트 9, 하프워드 및 워드 엘리먼트 크기에 지원된다. 게다가, 대부분의 아키텍춰 명령을 위한 워드 엘리먼트로서 IEEE 754 단일 정확도 포맷이 지원된다.
프로그래머는 명령어 시퀀스가 의미있는 결과를 내는 한 임의의 소정 방법으로 데이타를 자유로이 해석할 수 있다. 예를 들어, 프로그래머는 바이트 9 크기를 사용하여 8비트 부호없는 숫자를 저장할 수 있고, 똑같이 바이트 크기 데이타 엘리먼트에 8비트 부호없는 숫자를 자유로이 저장할 수 있고 프로그래머가 "거짓" 오버플로우 결과를 취급할 수 있는 한 제공된 2의 보수 아키텍춰 명령을 사용하여 자유로이 그들을 연산할 수 있다.
SR0 내지 SR31이라고 하는 32 스칼라 레지스터가 존재한다. 스칼라 레지스터는 32비트 폭이고, 정의된 크기중 어느 한 크기의 한 데이타 엘리먼트를 수용할 수 있다. 스칼라 레지스터 SR0는 레지스터 SR0이 항상 제로의 32비트로서 판독되고 레지스터 SR0에의 기록이 무시된다는 점에서 특수하다. 바이트, 바이트 9 및 하프워드 데이타 형은 최상위 비트가 정의되지 않은 값을 갖는 스칼라 레지스터의 최하위 비트에 저장된다.
레지스터가 데이타 형 표시기를 가지지 않기 때문에, 프로그래머는 각 명령에 사용되고 있는 레지스터의 데이타 형을 알아야만 한다. 이는 32비트 레지스터가 32비트 값을 수용하는 것으로 간주되는 다른 아키텍춰와는 다르다. MSP 아키텍춰는 데이타 형 A의 결과가 데이타 형 A에 대해 정된 비트만을 정확히 수정하는 것을 명시한다. 예를 들어, 바이트 9 가산의 결과는 32비트 목적지 스칼라 레지스터의 하위 9비트만을 수정한다. 상위 23비트의 값은 명령어에 대해 달리 지시되지 않는 한 정의되어 있지 않다.
64벡터 레지스터는 각각 32 레지스터를 갖는 2뱅크로 조직된다. 뱅크 0은 첫번째 32 레지스터를 수용하고, 뱅크 1은 두번째 32 레지스터를 수용한다. 두개의 뱅크는 하나의 뱅크가 현재의 뱅크로 세트되고 다른 뱅크가 대체 뱅크로 세트되는 방식으로 사용된다. 모든 벡터 명령은 대체 뱅크에 있는 벡터 레지스터를 액세스할 수 있는 명령들을 로드/저장 및 레지스터가 이동시키는 것을 제외하고, 디폴트로서 현재의 뱅크에 있는 레지스터를 사용한다. 벡터 제어 및 상태 레지스터 VCSR에 있는 CBANK 비트는 뱅크 0 또는 뱅크 1을 현재의 뱅크로 세트시키는데 사용된다.(다른 뱅크는 대체 뱅크가 된다) 현재의 뱅크에 있는 벡터 레지스터는 VR0 내지 VR31이라고 불리우고, 대체 뱅크에 있는 벡터 레지스터는 VRA0 내지 VRA31라고 불리운다.
선택적으로, 두개의 뱅크는 576비트의 32 이중 크기 벡터 레지스터를 각각 제공하도록 개념적으로 합병될 수 있다. 제어 레지스터 VCSR에 있는 VEC64비트는 이와 같은 모드를 명시한다. VEC64 모드에서, 어떠한 현재 및 대체 뱅크는 존재하지 않으며, 벡터 레지스터 번호는 두개의 뱅크로부터 대응하는 288비트 벡터 레지스터 쌍을 지칭한다. 즉,
VRi〈576:0〉=VR1i〈287:0〉 : VR0i〈287:0〉
여기서, VR0및 VR1i는 뱅크 1 및 뱅크 0 각각에 레지스터 번호 VRi를 갖는 벡터 레지스터를 지칭한다. 이중 크기 벡터 레지스터는 VR0 내지 VR31로 불리운다.
벡터 레지스터는 표 C2에 도시된 바와 같이 바이트, 바이트 9, 하프워드 또는 워드 크기의 다수 엘리먼트를 수용할 수 있다.
[표 C2]
Figure kpo00037
한 벡터 레지스터내의 엘리먼트 크기의 혼합은 지원되지 않는다. 바이트 9 엘리먼트 크기를 제외하고, 단지 288비트의 256만이 사용된다, 특히, 매 9번째 비트는 사용되지 않는다. 바이트, 하프워드 및 워드 크기에 있는 사용되지 않는 32비트는 예약되고, 프로그래머는 그들 값에 대해 어떠한 가정도 해서는 안된다.
벡터 누산 레지스터는 목적지 레지스터에 있는 결과보다 정확도가 높은 중간 결과를 위한 기억장치를 제공하도록 의도된다. 벡터 누산 레지스터는 VAC1H, VAC1L, VAC0H 및 VAC0L이라고 하는 네개의 288비트 레지스터로 구성된다. VAC0H : VAC0L 쌍은 디폴트로서 세개의 명령어에 의해 사용된다. VEC64 모에서만, VAC1H : VAC1L 쌍이 64 바이트 9 벡터 연산을 에뮬레이트하는데 사용된다. 뱅크 1이 VEC32 모드에서 현재의 뱅크로 세트되더라도, VAC0H : VAC0L 쌍이 사용된다.
소스 벡터 레지스터에서와 같이 동일한 수의 엘리먼트를 갖는 확장된 정확도 결과를 내기 위해, 표 C3에 도시된 바와 같이 레지스터 쌍에 걸쳐 확장된 정확도 엘리먼트가 절약된다.
[표 C3]
Figure kpo00038
VAC1H 및 VAC1L 쌍은 엘리먼트의 수가 바이트 9(및 바이트), 하프워드, 및 워드 각각에 대해 64, 32, 또는 16인 VEC64 모드에서만 사용된다.
메모리로부터 직접 로드되거나 또는 메모리에 직접 저장될 수 없는 33 특수 목적 레지스터가 존재한다. RASR0 내지 RASR15라고 불리우는 16개의 특수 목적 레지스터는 내부의 반환 어드레스 스택을 형성하고 서브루틴 호출 및 반환 명령에 의해 사용된다. 17개의 32비트 특수 목적 레지스터가 표 C4에 도시되어 있다.
[표 C4]
Figure kpo00039
벡터 제어 및 상태 레지스터 VCSR 정의가 표 C5에 도시되어 있다.
[표 C5]
Figure kpo00040
Figure kpo00041
벡터 프로그램 카운터 레지스터 VPC는 벡터 프로세서(120)에 의해 실행될 다음 명령의 어드레스이다. AMR7 프로세서(110)는 벡터 프로세서(120)의 연산을 시작하기 위해 STARTVP 명령을 발생하기 전에 레지스터 VPC를 로드하여야 한다.
벡터 예외 프로그램 카운터 VEPC는 가장 최근의 예외를 유발할 가능성이 있는 명령어의 어드레스를 명시한다. MSP 100은 정확한 예외 즉, "가장 가능성이 있는" 용어를 지원하지 않는다.
벡터 인터럽트 소스 레지스터 VISRC는 ARM7 프로세서(110)에 대한 인터럽트 소스를 가리킨다. 예외(들)의 검출시 적당한 비트(들)가 하드웨어에 의해 세트된다. 소프트웨어는 벡터 프로세서(120)가 실행을 재개할 수 있기 전에 레지스터 VISRC를 클리어하여야 한다. 레지스터 VISRC에 설정된 임의의 비트는 벡터 프로세서(120)로 하여금 상태 VP_IDLE에 진입하게 한다. 만일 대응하는 인터럽트 인에이블 비트가 VIMSK로 세트되어 있으면, 프로세서(110)에 대한 인터럽트가 시그날된다. 표 C6은 레지스터 VISRC의 내용을 정의한다.
[표 C6]
VISRC 정의
Figure kpo00042
벡터 인터럽트 명령어 레지스터 VIINS는 VCINT 또는 VCJOIN 명령이 ARM7 프로세서(110)를 인터럽트하기 위해 실행될 때 VCINT 또는 VCJOIN 명령으로서 갱신된다.
벡터 카운터 레지스터 VCR1, VCR2 및 VCR3는 감소 및 분기 명령 VD1CBR, VD2CBR2 및 VD3CBR이고, 실행될 루프 카운트로서 초기화된다. 명령어 VD1CBR이 실행될 때, 레지스터 VCR1은 1만큼 감소된다. 만일 카운트 값이 제로가 아니고 명령어에 명시된 조건이 VFLAG와 일치하면, 이때 분기가 취해진다. 만일 그렇지 않으면, 분기는 취해지지 않는다. 레지스터 VCR1은 어느 경우에나 1만큼 감소된다. 레지스터 VCR2 및 VCR3도 이와 동일하게 사용된다.
벡터 전역 마스크 레지스터 VGMRO는 VEC32에서 영향을 미칠 목적지 벡터 레지스터의 엘리먼트와, VEC64 모드에서 VR〈287:0〉내에 있는 엘리먼트를 가리킨다. VGMR0의 각 비트는 벡터 목적지 레지스터의 9비트의 갱신을 제어한다. 특히, VGMR0〈i〉는 VEC32 모드의 VRd〈9i+8:9i〉와 VEC64 모드의 VRd〈9i+8:9i〉의 갱신을 제어한다. VR0d는 VEC64 모드에서 뱅크 0이 목적지 레지스터를 가리키고, VRd는 VEC32 모드에서 뱅크 0 또는 1중 어느 하나일 수 있는 현재의 뱅크에 있는 목적지 레지스터를 가리킨다. 벡터 전역 마스크 레지스터 VGMR0는 VCMOVM 명령을 제외하고 모든 명령의 실행에 사용된다.
벡터 전역 마스크 레지스터 VGMR1은 VEC64 모드에서 영향을 받는 VR〈575:288〉내의 엘리먼트를 가리킨다. VGMR1의 각 비트는 뱅크 1에서 벡터 목적지 레지스터에 있는 9비트의 갱신을 제어한다. 특히, VGMR1〈i〉는 VR1d〈9i+8:9i〉의 갱신을 제어한다. 레지스터 VGMR1〈i〉은 VR1d〈9i+8:9i〉의 갱신을 제어한다. 레지스터 VGNR1은 VEC32 모드에서 사용되지 않지만, VEC64 모드에서 VCMOVM 명령을 제외하고 VEC32 명령에 사용되지 않는다.
벡터 오버플로우 레지스터 VOR0은 VEC32모드에 있는 엘리먼트와 벡터 산술 연산후 오버플로우 결과를 수용하고 있는 VEC64모드에 있는 VR〈287:0〉내의 엘리먼트를 가리킨다. 이 레지스터는 스칼라 산술 연산에 의해 수정되지 않는다. 세트되는 비트 VOR0〈i〉는 바이트 또는 바이트 9의 i번째 엘리먼트, 하프워드의 (i idiv 2)번째 엘리먼트 또는 워드 데이타형 연산의 (i idiv 4)번째 엘리먼트가 오버플로우 결과를 포함하고 있다는 것을 가리킨다. 예를 들어, 비트 1 및 비트 3은 각각 첫번째 하프워드 및 워드 엘리먼트의 오버플로우를 가리키도록 세트될 것이다. VOR0에 있는 비트들의 이와 같은 맵핑은 VGMR0 또는 VGMR1에 있는 비트의 맵핑과는 다르다.
벡터 오버플로우 레지스터 VOR1은 벡터 산술 연산후 오버플로우 결과를 포함하고 있는 VEC64 모드에서 VR〈575:288〉내의 엘리먼트를 가리키는데 사용된다. 레지스터 VOR1은 VEC32 모드에서 사용되지도 않고 스칼라 산술 연산에 의해 수정되지도 않는다. 세트되고 있는 비트 VOR1〈i〉은 바이트 또는 바이트 9의 i번째 엘리먼트, 하프워드의 (i idiv 2)번째 엘리먼트, 또는 오버플로우 결과를 포함하고 있는 워드 데이타형 연산의 (i idiv 4)번째 엘리먼트를 가리킨다. 예를 들어, 비트 1 및 비트 3은 VR〈575:288〉에서 각각 첫번째 하프워드 및 워드 엘리먼트의 오버플로우를 가리키도록 세트될 것이다. VOR1에 있는 비트들의 맵핑은 VGMR0 또는 VGMR1에 있는 비트들의 맵핑과는 다르다.
벡터 명령 어드레스 브레이크포인트 레지스터 VIABR은 벡터 프로그램을 디버그하는데 도움이 된다. 레지스터 정의가 표 C7에 도시되어 있다.
[표 C7]
Figure kpo00043
벡터 데이타 어드레스 브레이크포인트 레지스터 VDABR은 벡터 프로그램을 디버그하는데 도움이 된다. 이 레지스터 정의가 표 C8에 도시되어 있다.
[표 C8]
VDABR 정의
Figure kpo00044
벡터 이동 마스크 레지스터 VMMR0는 모든 명령에 대해 VCSR〈SMM〉=1일 때는 물론 모든 경우에 VCMOVM 명령에 의해 사용된다. 레지스터 VMMR0는 VEC32 모드에서 영향을 받을 목적지 벡터 레지스터의 엘리먼트와 VEC64 모드에서 VR〈287:0〉내의 엘리먼트를 가리킨다. VMMR0의 각 비트는 벡터 목적지 레지스터의 9비트의 갱신을 제어한다. 특히, VMMR0〈i〉는 VEC32 모드에서 VRd〈9i+8:9i〉과 VEC64 모드에서 VR0d〈9i+8:9i〉의 갱신을 제어한다. VR0d는 VEC64에서 뱅크 0의 목적지 레지스터를 가리키고, VRd는 VEC32 모드에서 뱅크 0 또는 1중 어느 하나일 수 있는 현재의 뱅크에서 목적지 레지스터를 가리킨다.
벡터 이동 마스크 레지스터 VMMR1는 모든 명령에 대해 VCSR〈SMM〉=1일 때는 물론 모든 경우에 VCMOVM 명령에 의해 사용된다. 레지스터 VMMR1는 VEC64 모드에서 영향을 받을 VR〈575:287〉내의 엘리먼트를 가리킨다. VMMR1의 각 비트는 뱅크 1에서 벡터 목적지 레지스터의 9비트의 갱신을 제어한다. 특히, VGMR1〈i〉는 VR1d〈9i+8:9i〉의 갱신을 제어한다. 레지스터 VGMR1은 VEC32 모드에서 사용되지 않는다.
벡터 및 ARM7 동기화 레지스터 VASYNC는 프로세서(110 및 120)간의 동기화의 생산자/소비자를 제공한다. 현재, 단지 비트 30만이 정의되어 있다. ARM7 프로세스는 벡터 프로세서(120)가 상태 VP_RUN 또는 VP_IDLE에 있는 동안 명령어 MFER, MTER 및 TESTSET를 사용하여 레지스터 VASYNC를 액세스할 수 있다. 레지스터 VASYNC는 이들 명령들이 첫번째 16 벡터 프로세서의 특수 목적 레지스터를 벗어나 액세스할 수 없기 때문에 TVP 또는 MFVP 명령을 통해 ARM7 프로세스에 액세스할 수 없다. 벡터 프로세서는 VMOV 명령을 통해 레지스터 VASYNC를 액세스할 수 있다.
표 C9는 파우어-온 리셋시 벡터 프로세서의 상태를 도시한다.
[표 C9]
Figure kpo00045
특수 목적 레지스터는 벡터 프로세서가 명령을 실행할 수 있기 전에 ARM7 프로세서(110)에 의해 초기화된다.
〈부록 D〉
각 명령은 소스 및 목적지 오퍼런드의 데이타 형을 암시하거나 또는 명시한다. 일부 명령은 한 가지 이상의 데이타 형과 동등하게 적용되는 시맨틱스를 갖는다. 일부 명령은 소스에 대한 하나의 데이타 형을 취하는 시맨틱스를 가지며, 그 결과에 대해 다른 데이타 형을 만든다. 본 부록은 예시적인 실시예에 의해 지원되는 데이타 형을 설명한다. 본 장의 표 1은 지원되는 데이타 형 int8, int9, int16, int32 및 부동 데이타를 설명한다. 부호없는 정수 포맷은 지원되지 않고 부호없는 정수 값은 먼저 사용되기 전에 2의 보수 포맷으로 변환되어야 한다. 프로그래머는 오버플로우가 적절히 처리되는 한 부호없는 정수 또는 그가 선택한 임의의 다른 포맷으로서 산술 명령을 자유로이 사용한다. 아카텍춰는 2의 보수 정수 및 32비트 부동 소수점 데이타 형만의 오버플로우를 정의한다. 아카텍춰는 부호없는 오버플로우에 필요한 8, 9, 16 또는 32비트 연산의 캐리 아웃을 검출할 수 없다.
표 D1은 로드 연산에 의해 지원되는 데이타 크기를 도시한다.
[표 D1]
로드 연산에 의해 지원되는 데이타 크기.
Figure kpo00046
아키텍춰는 데이타 형 경계일 메모리 어드레스 정렬을 명시한다. 즉, 바이트의 경우, 어떠한 정렬 조건도 존재하지 않는다. 하프워드의 경우, 정렬 조건은 하프워드 경계이다. 워드의 경우, 정렬 조건은 워드 경계이다.
표 D2는 저장 연산에 의해 지원되는 데이타 크기를 도시한다.
[표 D2]
Figure kpo00047
스칼라이거나 또는 벡터이거나 하나 이상의 dam형이 레지스터에 맵핑되기 때문에, 일부 데이타 형에 정의된 결과를 갖지 않는, 목적지 레지스터에 비트가 존재할 수 있다. 사실, 벡터 목적지 레지스터에 대한 바이트 9 데이타 크기 연산과 스칼라 목적지 레지스터에 대한 워드 데이타 크기 연산을 위한 이외에, 그 값이 연산에 의해 정의되지 않은 목적지 레지스터에 비트가 존재한다. 이들 비트들의 경우, 아키텍춰는 그들 값이 정의될 것을 지정한다. 표 D3은 각각의 데이타 크기에 대해 정의되지 않은 비트들을 도시한다.
[표 D3]
Figure kpo00048
프로그래밍시 프로그래머는 항상 소스 및 목적지 레지스터 또는 메모리의 데이타 형을 알고 있어야 한다. 한 엘리먼트 크기에서 다른 것으로 데이타 형 변환은 잠재적으로 벡터 레지스터에 저장되는 수가 다른 엘리먼트로 되는 결과가 된다. 예를 들어, 하프워드에서 워드 데이타 형으로 벡터 레지스터의 변환은 동일한 수의 변환된 엘리먼트를 저장하기 위해 두개의 벡터 레지스터를 필요로 한다. 역으로, 벡터 레지스터에서 사용자가 정의한 포맷을 가질 수 있는 워드 데이타 형에서 하프포맷으로의 변환은 벡터 레지스터의 1/2에 동일한 수의 엘리먼트 그리고 다른 절반에 나머지 비트들을 발생시킨다. 어느 경우건, 데이타 형 변환은 소스 엘리먼트와는 다른 크기인 변환된 엘리먼트의 배열에 아키텍춰의 문제를 야기한다.
원칙적으로, MSP 아키텍춰는 엘리먼트의 수를 묵시적으로 변환시키는 연산을 결과로서 제공한다. 아키텍춰는 프로그래머가 목적지 레지스터에 있는 엘리먼트의 수를 바꾼 결과를 알고 있어야만 한다고 본다. 아키텍춰는 하나의 데이타 형에서 동일한 크기의 다른 데이타 형으로 변환하는 연산만을 제공하고, 프로그래머로 하여금 하나의 데이타 형에서 크기가 다른 데이타 형으로 변환할 때 데이타 크기의 차이를 조정할 것으로 요구한다.
부록 E에 서술된 것과 같이 VSHFLL 및 VUNSHFLL와 같은 특수한 명령은 하나의 데이타 크기를 갖는 하나의 벡터에서 다른 데이타 크기를 갖는 다른 벡터로의 변환을 단순히 한다. 예를 들면 벡터 VRa에서 보다 작은 엘리먼트 크기, int8에서 보다 큰 엘리먼트 예를 들면 int16으로의 2의 보수 데이타 형을 변환하는 것에 관련된 기본적인 스텝은 다음과 같다 :
1. 바이트 데이타 형을 이용하여 다른 벡터 VRb를 갖는 VRa에 있는 엘리먼트를 두개의 벡터 VRc: VRd로 셔플한다. VRa에 있는 엘리먼트는 이중 크기 레지스터 VRc: VRd에 있는 int16 데이타 엘리먼트의 하위 바이트로 이동되고, 그 값이 무관한 VRb의 엘리먼트가 VRc: VRd의 상위 바이트로 이동된다. 이 연산은 바이트에서 하프워드로 각 엘리먼트의 크기를 배가시키면서, VRa의 엘리먼트 절반을 VRc로, 다른 절반을 VRd로 효율적으로 이동시킨다.
2. VRc에 있는 엘리먼트를 부호 확장하기 위해 8비트 산술 쉬프트시킴.
예를 들면 벡터 VRa에 있는 보다 큰 엘리먼트 크기, int16에서 예를 들면 보다 작은 크기, int6로 2의 보수 데이타 형을 변환하는 것에 관련된 기본 스텝은 다음과 같다 :
1. int16 데이타 형에 있는 각 엘리먼트가 바이트 크기로 표현가능한 지를 점검한다. 만일 필요하다면, 양쪽 모두에 엘리먼트를 포화시켜 보다 작은 크기에 끼워 맞춘다.
2. VRa의 엘리먼트를 다른 VRb로서 두개의 벡터 VRc: VRd속에 언셔플한다. VRa및 VRb에 있는 각 엘리먼트의 상위 절반은 VRc로 이동되고 하위 절반은 VRd로 이동된다. 이는 VRd의 하위 절반에 있는 VRa의 모든 엘리먼트의 하부 절반을 효율적으로 수집한다.
3. 특수 명령이 다음과 같은 데이타 형 변환에 제공된다 : 단일 정확도 부동 소수점에 대해 int32; 고정 소수점에 대해 단일 정확도 부동 소수점(X, Y 주석); int32에 대해 단일 정확도 부동 소수점; int9에 대해 int8; int16에 대해 int9; 및 int9에 대해 int16.
벡터 프로그래밍에 유연성을 제공하기 위해, 대부분의 벡터 명령은 엘리먼트 마스크를 사용하여 벡터내의 선택된 엘리먼트에 대해서만 연산한다. 벡터 전역 마스크 레지스터 VGMR0 및 VGMR1는 벡터 명령에 의해 목적지 레지스터 및 벡터 누산기에서 수정된 엘리먼트를 식별한다. 바이트 및 바이트 9 데이타 크기 연산의 경우, VGMR0(또는 VGMR1)에 있는 32비트 각각은 연산될 엘리먼트를 식별한다. 세트되고 있는 비트 VGMR0〈i〉는 여기서 i가 0에서 31까지인 바이트 크기의 엘리먼트 i가 영향을 받게 될 것이라는 것을 가리킨다. 하프워드 데이타 크기 연산의 경우, VGMR0(또는 VGMR1)에 있는 32비트의 각 쌍은 연산될 엘리먼트를 식별한다. 세트되고 있는 비트들 VGMR0〈2i+:2i+1〉는 여기서 i가 0에서 15까지인 엘리먼트 i가 영향을 받을 것이라는 것을 가리킨다. 만일 VGMR0에 있는 쌍의 한 비트만이 하프워드 데이타 크기 연산을 위해 세트되면, 대응하는 바이트에 있는 비트만이 수정된다. 워드 데이타 크기 연산의 경우, VGMR0(또는 VGMR1)에 있는 네개 비트의 각 세트는 연산될 엘리먼트를 식별한다. 세트되고 있는 비트들 VGMR0〈4i+:4i+3〉는 여기서 i가 0에서 7까지인 엘리먼트 i가 영향을 받을 것이라는 것을 가리킨다. 만일 VGMR0에 있는 네개 세트에 있는 모든 비트들이 워드 데이타 크기 연산을 위해 세트되어 있지 않으면, 대응하는 바이트에 있는 비트만이 수정된다.
VGMR0 및 VGMR1는 VCMOM 명령을 사용하여 벡터 레지스터를 벡터 또는 스칼라 레지스터 또는 중간값과 비교함으로서 세트될 수 있다. 이 명령은 지정된 데이타 크기에 따라 마스크를 적절히 세트시킨다. 스칼라 레지스터가 하나의 데이타 엘리먼트만을 수용하도록 정의되어 있기 때문에, 스칼라 연산(즉, 목적지 레지스터가 스칼라인)은 엘리먼트 마스크에 의해 영향을 받지 않는다.
벡터 프로그래밍에서의 유연성을 위해 , 대부분의 MSP 명령은 세 가지 형태의 벡터 및 스칼라 연산을 지원한다. 이들은 다음과 같다 :
1. 벡터=벡터 op 벡터
2. 벡터=벡터 op 스칼라
3. 스칼라=스칼라 op 스칼라
스칼라 레지스터가 B 오퍼런드로서 명시된 2의 경우, 스칼라 레지스터에 있는 하나의 엘리먼트는 벡터 A 오퍼런드 내의 엘리먼트의 수와 일치할 필요가 있는 수만큼 복제된다. 복제된 엘리먼트는 지정된 스칼라 오퍼런드에 있는 엘리먼트와 동일한 값이다. 스칼라 오퍼런드는 중간 오퍼런드 형태로 스칼라 레지스터 또는 명령으로부터 올 수 있다. 중간 오퍼런드의 경우, 만일 지정된 데이타 형이 중간 필드 크기로서 이용할 수 있는 것 보다 큰 데이타 크기를 이용한다면 적당하게 부호 확장된다.
많은 멀티미디어 어플리케이션에서, 소스, 중간 및 결과의 정밀도에 대해 많은 관심이 모아져야만 한다. 또한, 정수 곱셈 명령은 두개의 벡터 레지스터에 저장될 수 있는 "이중 정밀도" 중간 결과를 만든다.
MSP 아키텍춰는 현재 8, 9, 16 및 32비트 엘리먼트를 위한 2의 보수 정수 포맷과 32비트 엘리먼트를 위한 IEEE 754 단일 정확도 포맷을 지원한다. 오버플로우는 명시된 데이타 형으로서 표현할 수 있는 가장 양의 또는 가장 음의 값을 벗어난 결과로 정의된다. 오버플로우가 발생할 때, 목적지 레지스터에 기록된 값은 무효 숫자가 아니다. 언더플로우는 부동 소수점 연산에 대해서만 정의되어 있다.
달리 정의하지 않는 한, 모든 부동 소수점 연산은 VCSR〈RMODE〉에 명시된 네개의 라운딩 모드중 하나를 이용한다. 일부 명령은 라운드 어웨이 프럼 제로(round away from zero)(라운드 이븐(round even)) 라운딩 모드라고 알려진 것을 이용한다.
포화(saturation)는 많은 멀티미디어 어플리케이션에 있어서 중요한 기능이다. MSP 아키텍춰는 네가지 모든 정수 및 부동 소수점 연산에서의 포화를 지원한다. 레지스터 VCSR에 있는 비트 ISAT는 정수 포화 모드를 명시한다. 고속 IEEE 모드로도 알려진 부동 소수점 포화 모드는 VCSR에서 FSAT로 명시되어 있다. 포화 모드가 인에이블되면, 가장 양의 또는 가장 음의 값을 벗어난 결과가 가장 양의 또는 가장 음의 값으로 각각 세트된다. 이 경우 오버플로우는 발생할 수 없고, 오버플로우 비트는 세트될 수 없다.
표 D4는 결함이 있는 명령이 실행되기 전에 검출되어 보고되는 정확한 예외를 열거한다.
[표 D4]
Figure kpo00049
표 D5는 결함이 있는 명령 이외의 차후의 프로그램에 있는 몇가지 명령을 실행한 후 검출되어 보고된 부정확한 예외를 열거한다.
[표 D5]
Figure kpo00050
〈부록 E〉
벡터 프로세서를 위해 세트된 명령은 표 E1에 도시된 바와 같이 11개로 분류할 수 있다.
[표 E1]
벡터 명령 분류 요약.
Figure kpo00051
Figure kpo00052
표 E2는 흐름 제어 명령을 열거한다.
[표 E2]
Figure kpo00053
논리적 분류는 부울린 데이타 형을 지원하고, 엘리먼트 마스크에 의해 영향을 받는다. 표 E3은 흐름 제어 명령을 열거한다.
[표 E3]
논리적 명령.
Figure kpo00054
쉬프트/회전 분류 명령은 int8, int9, int16 및 int32 데이타 형(부동 데이타 형 없음)에 대해 연산하고, 엘리먼트 마스크에 의해 영향을 받는다. 표 E4는 쉬프트/회전 분류 명령을 열거한다.
[표 E4]
Figure kpo00055
산술 분류 명령은 일반적으로, int8, int9, int16, int32 부동 데이타형을 지원하고, 엘리먼트 마스크에 의해 영향을 받는다. 지원되지 않는 데이타 형에 대한 특정한 제한에 대해서는, 이하의 각 명령에 대한 상세한 설명을 참조한다. VCMPV 명령은 엘리먼트 마스크에 대해 연산을 하기 때문에 엘리먼트 마스크에 의해 영향을 받지 않는다. 표 E5는 산술 분류 명령을 열거한다.
[표 E5]
산술 분류.
Figure kpo00056
MPEG 명령은 MPEG 엔코딩 및 디코딩에 특별히 적합한 명령어의 분류이지만, 다양한 방법을 사용될 수 있다. MPEG 명령은 int8, int9, int16 및 int32 데이타 형을 지원하고, 엘리먼트 마스크에 의해 영향을 받는다. 표 E6은 MPEG 명령을 열거한다.
[표 E6]
Figure kpo00057
각각의 데이타 형 변환 명령은 특정 데이타 형을 지원하고, 아키텍춰가 레지스터에 있는 하나 이상의 데이타 형을 지원하지 않기 때문에 엘리먼트 마스크에 의해 영향을 받지 않는다. 표 E7은 데이타 형 변환 명령을 열거한다.
[표 E7]
Figure kpo00058
명령의 엘리먼트간 산술 분류는 int8, int9, int16, int32 및 부동 데이타형을 지원한다. 표 E8은 엘리먼트간 산술 분류를 열거한다.
[표 E8]
Figure kpo00059
명령의 엘리먼트간 이동 분류는 바이트, 바이트 9, 하프워드 및 워드 데이타 크기를 지원한다. 표 E9는 명령의 엘리먼트간 이동 분류를 열거한다.
[표 E9]
Figure kpo00060
로드/저장 명령은 바이트, 하프워드 및 워드 데이타 크기 이외에 특수한 바이트 9 관련 데이타 크기 연산을 지원하고, 엘리먼트 마스크에 의한 영향을 받지 않는다. 표 E10은 로드/저장 분류에 있는 명령들을 열거한다.
[표 E10]
로드/저장 분류.
Figure kpo00061
대부분의 레지스터 이동 명령은 int8, int9, int16, int32 및 부동 데이타형을 지원하고, 엘리먼트 마스크에 의한 영향을 받지 않는다. VCMOCM 명령만이 엘리먼트 마스크에 의한 영향을 받는다. 표 E11은 명령의 레지스터 이동 분류를 열거한다.
[표 E11]
Figure kpo00062
표 E12는 캐쉬 서브시스템(130)을 제어하는 캐쉬 연산 분류에 있는 명령을 열거한다.
[표 E12]
Figure kpo00063
[명령어 설명 명명]
명령어 세트의 명세를 간단히 하기 위해, 부록 전반에 걸쳐 특수한 용어가 사용된다. 예를 들어, 명령어 오퍼런드는 달리 정의되지 않는 한, 바이트, 바이트 9, 하프워드 또는 워드 크기의 부호가 있는 2의 보수 정수이다. "레지스터"라는 용어는 범용(스칼라 또는 벡터) 레지스터를 가리키는데 사용된다. 다른 종류의 레지스터는 명시적으로 설명되어 있다. 어셈블리 언어 구문에서, 첨자 b, b9, h 및 w는 데이타 크기(바이트, 바이트 9, 하프워드 및 워드) 및 정수 데이타 형(int8, int9, int16 및 int32) 모두를 지칭한다. 또한, 명령어 오퍼런드, 연산, 및 어셈블리 언어 구문을 설명하는데 사용된 용어와 기호는 다음과 같다 :
Rd : 목적지 레지스터 (벡터, 스칼라 또는 특수 목적용)
Ra, Rb : 소스 레지스터 a 및 b (벡터, 스칼라 또는 특수 목적용)
Rc : 소수 또는 목적지 레지스터 c (벡터 또는 스칼라)
Rs : 데이타 소스 레지스터 저장 (벡터 또는 스칼라)
S : 32비트 스칼라 또는 특수 목적 레지스터
VR : 현재의 뱅크 벡터 레지스터
VRA : 대체 뱅크 벡터 레지스터
VR0: 뱅크 0 벡터 레지스터
VR1: 뱅크 1 벡터 레지스터
VRd : 벡터 목적지 레지스터 (VRA가 명시되어 있지 않는 한 현재의 뱅크에 대한 디폴트)
VRa, VRb : 벡터 소스 레지스터 a 및 b
VRc : 벡터 소스 또는 목적지 레지스터 c
VRs : 벡터 저장 데이타 소스 레지스터
VAC0H : 벡터 누산기 레지스터 0 하이
VAC0L : 벡터 누산기 레지스터 0 로우
VAC1H : 벡터 누산기 레지스터 1 하이
VAC1L : 벡터 누산기 레지스터 1 로우
SRd : 스칼라 목적지 레지스터
SRa, SRb : 스칼라 소스 레지스터 a 및 b
SRb+ : 유효 어드레스로 베이스 레지스터의 갱신
SRs : 스칼라 저장 데이타 소스 레지스터
SP : 특수 목적 레지스터
VR[i] : 벡터 레지스터 VR에 있는 i번째 엘리먼트
VR[i]〈a : b〉: 벡터 레지스터 VR에 있는 i번째 엘리먼트의 비트 a 내지 b
VR[i]〈msb〉: 벡터 레지스터 VR에 있는 i번째 엘리먼트의 최상위 비트
EA : 메모리 액세스를 위한 유효 어드레스
MEM : 메모리
BYTE[EA] : EA에 의해 어드레스되는 메모리의 한 바이트
HALF[EA] : EA에 의해 어드레스되는 메모리의 하프워드. 비트 〈15 : 8〉는 EA+1에 의해 어드레스된다.
WORD[EA] : EA에 의해 어드레스되는 메모리의 워드. 비트 〈31 : 24〉는 EA+3에 의해 어드레스된다.
NumElem : 소정의 데이타 형에 대한 엘리먼트의 수를 가리킨다. 이는 VEC32 모드에서 바이트 및 바이트 9, 하프워드, 또는 워드 데이타 크기 각각에 대해 32, 16 또는 8이다. 이는 VEC64 모드에서 바이트 및 바이트 9, 하프워드, 또는 워드 데이타 크기 각각에 대해 64, 32 또는 16이다. 스칼라 연산의 경우, NumElem은 0이다.
EMASK[i] : i번째 엘리먼트에 대한 엘리먼트 마스크를 가리킨다. 이는 바이트 및 바이트 9, 하프워드 또는 워드 데이타 크기에 대해 각각 VGMR0/1,~VGMR0/1, VMMR0/1,~VMMR0/1를 표현한다. 스칼라 연산의 경우, 엘리먼트 마스크는 EMASK[i]=0일지라도 세트되는 것으로 가정한다.
MMSK[i] : i번째 엘리먼트에 대한 엘리먼트 마스크를 지칭한다. 이는 바이트 및 바이트 9, 하프워드 또는 워드 데이타 크기에 대해 각각 VMMR0 또는 VMMR1에 있는 1, 2 또는 4 비트를 표현한다.
VCSR : 벡터 제어 및 상태 레지스터
VCSR〈x〉: VCSR에 있는 비트 또는 비트들을 가리킨다. "x"는 필드명이다.
VPC : 벡터 프로세서 프로그램 카운터
VECSIZE : 벡터 레지스터 크기는 VEC32에서는 32이고 VEC64에서는 64이다.
SPAD : 스크래치 패드
C 프로그래밍 구조는 연산의 제어 흐름을 설명하는데 사용된다. 예외는 다음과 같다 :
= 할당
: 연결
{x
Figure kpo00064
Figure kpo00065
y}는 x 또는 y 사이의 선택을 가리킨다. (논리적이 아님 또는)
sex 지정된 데이타 크기로의 부호 확장
sex_dp 지정된 데이타 크기의 이중 정확도로 부호 확장
sign
Figure kpo00066
부호 확장된 (산술) 우측 쉬프트
zex 지정된 데이타 크기로의 제로 확장
zero
Figure kpo00067
제로 확장된 (논리적) 우측 쉬프트
Figure kpo00068
좌측 쉬프트 (제로 필 인 (fill in))
trnc7 선두 7비트 (하프워드로부터)를 트렁케이트
trnc7 선두 1비트 (바이트9로부터)를 트렁케이트
% 모듈로 연산자
Figure kpo00069
expression
Figure kpo00070
식의 절대값
/ 나눔 (부동 데이타 형의 경우, 네개의 IEEE 라운딩 모드중 하나를 이용한다)
// 나눔 (라운드 어웨이 프럼 제로 라운딩 모드를 이용한다)
saturate() 정수 데이타 형의 경우, 오버플로우를 생성하는 대신에 가장 음의 또는 가장 양의 값까지 포화, 부동 데이타 형의 경우, 포화는 양의 무한대, 음의 제로, 양의 제로, 또는 음의 무한대까지일 수 있다.
전반적인 명령어 포맷은 도 8에 도시되어 있고 이하 서술된다.
REAR 포맷은 로드, 저장 및 캐쉬 연산 명령에 의해 사용되고, REAR 포맷에 있는 필드는 표 E13에 제시된 바와 같이 다음의 의미를 갖는다.
[표 E13]
REAR 포맷.
Figure kpo00071
비트 17 : 15는 예약되어 있고, 아키텍춰에서 차후 확장과 호환하기 위해 제로이어야 한다. B : D 및 TT 필드의 일부 엔코딩은 정의되지 않는다.
프로그래머는 이와 같은 엔코딩이 이용될 때 아키텍춰가 예상되는 결과를 지정하지 않기 때문에 이들 엔코딩을 사용해서는 안된다. 표 E14는 VEC32 및 VEC64 모드 모두에서 지원되는 (LT로서 TT 필드에서 인코드됨) 스칼라 로드 연산을 도시한다.
[표 E14]
Figure kpo00072
표 E15는 비트 VCSR〈0〉이 클리어할 때 VEC32 모드에서 (LT로서 TT 필드에서 엔코드됨) 지원되는 벡터 로드 연산을 도시한다.
[표 E15]
VEC32 모드에서 REAR 로드 Ops.
Figure kpo00073
B 비트는 현재의 또는 대체 뱅크를 가리키는데 사용된다.
표 E16은 VCSR〈0〉비트가 클리어일 때 VEC64 모드에서 (LT로서 TT 필드에서 엔코드됨) 지원되는 벡터 로드 연산을 도시한다.
[표 E16]
Figure kpo00074
B 비트는 현재 및 대체 뱅크의 개념이 VEC64 모드에서 존재하지 않기 때문에 64바이트 벡터 연산을 가리키는데 사용된다.
표 E17은 VEC32 및 VEC64 모드 모두에서 (ST로서 TT 필드에서 엔코드됨) 지원되는 스칼라 저장 연산을 열거한다.
[표 E17]
Figure kpo00075
표 E18은 VCSR〈0〉 비트가 클리어일 때 VEC32 모드에서 (ST로서 TT 필드에서 엔코드됨) 지원되는 벡터 저장 연산을 열거한다.
[표 E18]
Figure kpo00076
표 E19은 VCSR〈0〉 비트가 세트될 때 VEC64 모드에서 (ST로서 TT 필드에서 엔코드됨) 지원되는 벡터 저장 연산을 열거한다.
[표 E19]
VEC32 모드에서의 REAR 벡터 저장 연산.
Figure kpo00077
B 비트는 현재 및 대체 뱅크의 개념이 VEC64 모드에 존재하지 않기 때문에 64바이트 벡터 연산을 가리키는데 사용된다.
REAI 포맷은 로드, 저장 및 캐쉬 연산 명령에 의해 사용된다. 표 E20은 REA1 포맷에 있는 필드는 필드의 의미를 도시한다.
[표 E. 20]
REAI 포맷.
Figure kpo00078
RAER 및 REAI 포맷은 전달형에 대해 동일한 엔코딩을 이용한다. 추가적인 엔코딩에 대해서는 REAR 포맷을 참조한다.
RRRM5 포맷은 3개의 레지스터 또는 두개의 레지스터 및 5 비트 중간 오퍼런드를 제공한다. 표 E21은 RRRM5 포맷에 대한 필드를 가리킨다.
[표 E21]
Figure kpo00079
비트 19 : 15는 예약되어 있고, 아키텍취에서의 추후 확장과 호환하도록 제로이어야 한다.
모든 벡터 레지스터 오퍼런드는 달리 정의되지 않는 한 현재의 뱅크 (이는 뱅크 0 또는 뱅크 1중 어느 하나일 수 있다.)를 참조한다. 표 E22는 DS〈1 : 0〉이 00, 01 또는 10일 때 D : S : M 엔코딩을 열거한다.
[표 E22]
DS가 11과 같지 않을 때 RRRM5 D:S:M 엔코딩.
Figure kpo00080
DS〈1:0〉이 11일때, D:S:M 엔코딩은 다음과 같은 의미를 갖는다.
[표 E23]
Figure kpo00081
RRR 포맷은 네개의 레지스터 오퍼런트를 제공한다.
표 E24는 RRRR 포맷의 필드를 도시한다.
[표 E24]
Figure kpo00082
모든 벡터 레지스터 오퍼런드는 달리 정의되지 않는 한 현재의 뱅크 (이는 뱅크 0 또는 뱅크 1중 어느 하나일 수 있다)를 참조한다.
RI 포맷은 로드 중간 임시 명령에 의해 사용된다. 표 E25는 RI 포맷의 필드를 가리킨다.
[표 E25]
RI 포맷.
Figure kpo00083
F : DS〈1: 0〉필드의 임의의 엔코딩은 정의되어 있지 않다. 프로그래머는 아키텍춰가 이와 같은 엔코딩이 사용되면 예상되는 결과를 명시하지 않기 때문에 이들 엔코딩을 사용해서는 안된다. Rd로 로드되는 값은 표 E26에 도시된 바와 같이 데이타형에 따른다.
[표 E26]
Figure kpo00084
CT 포맷은 표 E27에 도시된 필드를 포함한다.
[표 E27]
Figure kpo00085
분기 조건은 VCSR[GT : EQ : LT] 필드를 이용한다. 오버플로우 조건은 세트되면 GT, EQ 및 LT 비트에 선행하는 VCSR[SO] 비트를 이용한다. VCCS와 VCBARR은 상술된 것과는 달리 Cond〈2 : 0〉 필드를 해석한다. 세부사항을 대해서는 그들 명령 설명을 참조한다.
RRRM9 포맷은 3개의 레지스터 또는 두개의 레지스터 및 9비트 중간 오퍼런드를 명시한다. 표 E28은 RRRM9 포맷의 필드를 가리킨다.
[표 E28]
RRRM9 포맷.
Figure kpo00086
비트 19 : 15는 D : S : M 엔코딩이 중간 오퍼런드를 명시하지 않을 때 예약되고, 차후의 호환성을 보장하기 위해 제로이어야 한다.
모든 벡터 레지스터 오퍼런드는 달리 정의되지 않는 한 현재의 뱅크(이는 뱅크 0 또는 뱅크 1 중 어느 하나일 수 있다.)를 참조한다. D : S : M 엔코딩은 중간 필드로부터 추출된 중간 값이 표 E29에 도시된 바와 같이 DS〈1 : 0〉엔코딩에 따른다는 것을 제외하고 RRRM5 포맷에 대한 표 E22와 표 E23에 도시된 것과 동일하다.
[표 E29]
Figure kpo00087
중간 포맷은 부동 데이타 형과는 사용할 수 없다.
다음에서, MSP 벡터 명령은 알파벳 순서로 나타난다. 주 :
1. 명령은 달리 정의되지 않는 한 엘리먼트 마스크에 의해 영향을 받는다. CT 포맷 명령은 엘리먼트 마스크에 의해 영향을 받지 않는다. 로드, 저장 및 캐쉬 명령으로 구성되는 REAR 및 REAI 포맷 명령도 역시 엘리먼트 마스크에 의해 영향을 받지 않는다.
2. 9비트 중간 오퍼런드는 부동 데이타 형과 사용할 수 없다.
3. 연산 설명에서, 벡터 형식만이 제시된다. 스칼라 연산의 경우, 오로지 하나만을 가정하면 0번째 엘리먼트가 정의된다.
4. RRRM5 및 RRRM9 포맷의 경우, 다음 엔코딩이 정수 데이타 형(b, b9, h, w)에 사용된다.
Figure kpo00088
5. RRRM5 및 RRRM9 포맷의 경우, 다음 엔코딩이 부동 데이타 형에 사용된다.
Figure kpo00089
6. 오버플로우를 유발하는 모든 명령에 대해, VCSR〈ISAT〉비트가 세트될 때 int8, int9, int16, int32 최대 또는 최소 한계값까지의 포화가 적용된다. 따라서, 부동 소수점 결과는 VCSR〈FSAT〉비트가 세트될 때 -무한대, -제로, +제로 또는 +무한대까지 포화된다.
7. 구문으로 보아, .n은 바이트 9 데이타 크기를 가리키기 위해 .b9 대신에 사용될 수 있다.
8. 모든 명령에 대해, 목적지 레지스터 또는 벡터 누산기로 반환된 부동 소수점 결과는 IEEE 754 단일 정확도 포맷이다. 부동 소수점 결과는 누산기의 하부에 기록되고 상부는 수정되지 않는다.
[VAAS3 덧셈 및 (-1, 0, 1)의 부호 덧셈]
Figure kpo00090
설명
벡터/ 스칼라 레지스터 Ra의 내용이 Rb에 더해져 중간 결과를 내고, 다음이 이 중간 결과는 Ra의 부호와 더해지며; 최종적인 결과는 벡터/스칼라 레지스터 Rd에 저장된다.
Figure kpo00091
}
예외
오버플로우.
[VADAC 덧셈 및 누산]
Figure kpo00092
설명
Ra 및 Rb 오퍼런드의 각 엘리먼트를 벡터 누산기의 각 이중 정확도 엘리먼트와 더하고, 각 엘리먼트의 이중 정확도 합을 벡터 누산기와 목적지 레지스터 Rc 및 Rd 모두에 저장한다. Ra 및 Rb는 지정된 데이타형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타형(int8, int9, int16 및 int32 각각에 대해 16, 18, 32 및 64비트)을 이용한다. 각각의 이중 크기 정확도 엘리먼트의 상부는 VACH와 Rc에 저장되고, Rc에 저장되고, Rc에 있는 그 결과는 정의되지 않는다.
Figure kpo00093
}
[VADACL 덧셈 및 로우 누산]
Figure kpo00094
설명
Ra 및 Rb/ 중간 오퍼런드의 각 엘리먼트를 벡터 누산기의 각각의 확장된 정확도 엘리먼트와 더하고, 확장된 정확도 합계를 벡터 누산기에 저장하고, 그 하위 정확도를 목적지 레지스터 Rb로 반환한다.
Ra 및 Rb/중간은 지정된 데이타형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타형(int8, int9, int16 및 int32 각각에 대해 16, 18, 32 및 64비트)을 이용한다. 각각의 확장된 정확도 엘리먼트의 상부는 VACH에 저장된다.
연산
Figure kpo00095
[VADD 덧셈]
Figure kpo00096
설명
Ra 및 Rb/중간 오퍼런드를 더하고 그 합계를 목적지 레지스터 Rd로 반환한다.
연산
Figure kpo00097
예외
오버플로우, 부동 소수점 무효 오퍼런드
[VADDH 인접하는 두개의 엘리먼트 덧셈]
Figure kpo00098
연산
for (i=0 ; i <NumElem -1; i++){
Rd[i]=Ra[i]+Ra[i+1];
}
Rd[NumElem-1]=Ra[NumElem-1]+[VRb[0]∥SRb];
예외
오버플로우, 부동 소수점 무효 오퍼런드
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향을 받지 않는다.
[VAND AND]
Figure kpo00099
어셈블러 구문
VAND.dt VRd, VRa, VRb
VAND.dt VRd, VRa, SRb
VAND.dt VRd, VRa, #IMM
VAND.dt SRd, SRa, SRb
VAND.dt SRd, SRa, #IMM
여기서 dt = {b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo00100
설명
Ra 및 Rb/중간 오퍼런드를 논리적으로 AND하고, 그 결과를 목적지 레지스터 Rd로 반환한다.
연산
for (i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)};
Rd[i]<k>=Ra[i]<k>& Bop[i]<k>, k=for all bits in element i ;
}
예외
없음.
[VANDC AND 보수]
Figure kpo00101
어셈블러 구문
VANDC.dt VRd, VRa, VRb
VANDC.dt VRd, VRa, SRb
VANDC.dt SRd, SRa, SRb
VANDC.dt SRd, SRa, #IMM
여기서 dt = {b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo00102
설명
Ra 및 Rb/중간 오퍼런드의 보수를 논리적으로 더하고, 그 결과를 목적지 레지스터 Rd에 반환한다.
연산
for (i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)};
Rd[i]<k>=Ra[i]<k>& -Bop[i]<k>, k=for all bits in element i ;
}
예외
없음.
[VASA 산술 쉬프트 누산기]
Figure kpo00103
어셈블러 구문
VASAL.dt
VASAR.dt
여기서 dt = {b, b9, h, w}이고, R은 좌측 또는 우측의 쉬프트 방향을 지칭한다.
Figure kpo00104
설명
벡터 누산기 레지스터의 각 데이타 엘리먼트는 제로가 우측(만일 R=0이면)에서부터 채우며 1비트 위치만큼 쉬프트되거나 또는 부호 확장(만일 R=1이면)으로 1비트 위치만큼 우로 쉬프트된다. 그 결과는 벡터 누산기에 저장된다.
연산
for (i=0 ; i<NumElem && EMASK[i] ; i++){
if (R=1)
VAC0H[i]:VAC0L[i]=VAC0H[i]:VAC0L[i] sign>>1;
else
VAC0H[i]:VAC0L[i]=VAC0H[i]:VAC0L[i] <<1;
}
예외
오버플로우.
[VASL 좌측 산술 쉬프트]
Figure kpo00105
어셈블러 구문
VASL.dt VRd, VRa, SRb
VASL.dt VRd, VRa, #IMM
VASL.dt SRd, SRa, SRb
VASL.dt SRd, SRa, #IMM
여기서 dt = {b, b9, h, w}
Figure kpo00106
설명
벡터/ 스칼라 레지스터 Ra의 각 데이타 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 쉬프트 양만큼 제로가 우측에서 부터 채우며 1비트 좌로 쉬프트되고, 그 결과는 그 부호에 따라 최대 양 또는 최대 음의 값까지 포화된다. 상기 쉬프트 양은 부호없는 정수가 되도록 정의된다.
연산
shift_amount={SRb % 32 ∥IMM<4:0>};
for(i=0;i<NumElem && EMASK[i];i++){
Rd[i]=saturate(Ra[i]<<shift_amount);
}
예외
없음.
프로그래밍 주석
shift_amount는 SRb 또는 IMM〈4 : 0〉으로부터 5비트 숫자로서 취해진다. 바이트, 하프워드 데이타 형인 경우, 프로그래머는 데이타 크기에 있어 비트의 숫자보다 적거나 같은 쉬프트 양을 정확히 명시할 책임이 있다. 만일 쉬프트 양이 지정된 데이타 크기보다 크면, 엘리먼트는 제로로 채워질 것이다.
[VASR 우측 산술 쉬프트]
Figure kpo00107
어셈블러 구문
VASR. dt VRd, VRa, SRb
VASR. dt VRd, VRa, #IMM
VASR. dt SRd, SRa, SRb
VASR. dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}
Figure kpo00108
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드의 최하위 비트에 주어진 쉬프트 양만큼 최상위 비트 위치에서 부호가 확장되어 우로 산술적을 쉬프트되고, 그 결과는 벡터/스칼라 레지스터 Rd에 저장된다. 쉬프트 양은 부호없는 정수가 되도록 정의된다.
shift_amount={SRb % 32∥IMM<4:0>};
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Rd[i]=Ra[i]sign>>shift_amount;
}
예외
없음.
프로그래밍 주석
shift_amount는 SRb 또는 IMM〈4:0〉으로부터 5비트 숫자로서 취해진다. 바이트, 바이트 9, 하프워드 데이타형인 경우, 프로그래머는 데이타 크기에 있어 비트의 숫자보다 적거나 같은 쉬프트 양을 정확히 명시할 책임이 있다. 만일 쉬프트 양이 지정된 데이타 크기보다 크면, 엘리먼트는 부호 비트로 채워질 것이다.
Figure kpo00109
어셈블러 구문
VASS3.dt VRd, VRa, VRb
VASS3.dt VRd, VRa, SRb
VASS3.dt SRd, SRa, SRb
여기서 dt = {b, b9, h, w}
Figure kpo00110
설명
벡터/스칼라 레지스터 Ra의 내용이 Rb에 더해져 중간 결과를 내고, 다음에 Ra의 부호가 상기 중간 결과로부터 감산되고, 최종결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for (i=0; i<NumElem && EMASK[i] ; i++){
if(Ra[i]>0) extsgn3=1;
else if (Ra[i]<0) extsgn3=-1;
else extsgn3=0;
Rd[i]=Ra[i]+Rb[i]-extsgn3;
}
예외
오버플로우.
[VASUB 뺄셈 절대값]
Figure kpo00111
어셈블러 구문
VASUB.dt VRd, VRa, VRb
VASUB.dt VRd, VRa, SRb
VASUB.dt VRd, VRa, #IMM
VASUB.dt SRd, SRa, SRb
VASUB.dt SRd, SRa, #IMM
여기서 dt = {b, b9, h, w, f}.
Figure kpo00112
설명
벡터/스칼라 레지스터 Rb 또는 IMM 필드의 내용이 벡터/스칼라 레지스터 Ra의 내용으로부터 감산되고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i=0 ;i<NumElem && EMASK[i] ; i++){
Bop[i]={Rb[i]∥SRb∥sex(IMM<8:0>)};
Rd[i]=│Ra[i]-Bop[i]│;
}
예외
오버플로우.
[VAVG 두 엘리먼트의 평균]
Figure kpo00113
어셈블러 구문
VAVG.dt VRd, VRa, VRb
VAVG.dt VRd, VRa, SRb
VAVG.dt SRd, SRa, SRb
여기서 dt = {b, b9, h, w, f}. VAVGT를 이용하여 정수 데이타 형에 대한 "트렁케이트(truncate)" 라운딩 모드를 지정한다.
Figure kpo00114
설명
벡터/스칼라 레지스터 Ra의 내용이 벡터/스칼라 레지스터 Rb의 내용에 더해져 중간 결과를 내고, 상기 중간 결과를 2로 나누고, 최종 결과가 벡터/스칼라 레지스터 Rd에 저장된다. 정수 데이타형의 경우, 라운딩 모드는 만일 T = 1이면 트렁케이트하고, 만일 T = 0(디폴트)이면 제로로부터 라운트 어웨이된다. 부동 데이타형의 경우, 라운딩 모드는 제로로부터 라운트 어웨이된다. 부동 데이타형의 경우, 라운딩 모드는 VCSR〈RMODE〉에 지정되어 있다.
연산
for(i=0 ; i<NumElem && EMASK[i]; i++){
Bop[i]=(Rb[i]=(Rb∥SRb∥sex(IMM<8:0>)};
Rd[i]=(Ra[i]+Bop[i])//2;
}
예외
없음.
[VAVGH 인접하는 두개의 엘리먼트의 평균]
Figure kpo00115
어셈블러 구문
VAVGH.dt VRd, VRa, VRb
VAVGH.dt VRd, VRa, SRb
여기서 dt = {b, b9, h, w, f}. VAVGHT를 이용하여 정수 데이타 형에 대한 "트렁케이트(truncate)" 라운딩 모드를 지칭한다.
Figure kpo00116
설명
각 엘리먼트에 대해, 엘리먼트의 인접하는 두개의 쌍을 평균한다. 정수 데이타 형의 경우, 라운팅 모드는 만일 T = 1이면 트렁케이트하고, 만일 T =0(디폴트)이면 제로로부터 라운트 어웨이된다. 부동 데이타 형의 경우, 라운딩 모드는 VCSR〈RMODE〉에 지정되어 있다.
Figure kpo00117
연산
for(i=0 ; i<NumElem -1 ; i++){
Rd[i]=(Ra[i]+Ra[i+1])//2;
}
Rd[NumElem-1]=(Ra[NumElem-1]+(VRb[0]∥SRb])//2;
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향을 받지 않는다.
[VAVGQ Quad 평균]
Figure kpo00118
어셈블러 구문
VAVGQ.dt VRd, VRa, VRb
여기서 dt = {b, b9, h, w}. VAVGQT를 이용하여 정수 데이타형에 대한 "트렁케이트(truncate)" 라운딩 모드를 지칭한다.
Figure kpo00119
설명
이 명령은 VEC64 모드에 지원되지 않는다.
이하의 도면에 도시된 바와 같이, T(트렁케이트를 위해 1, 제로에서 라운드 어웨이를 위해 0, 디폴트)에서 지정된 라운딩 모드를 사용하여 네개의 엘리먼트의 평균을 산출한다. 최좌측 엘리먼트(Dn-1)는 정의되어 있지 않다.
Figure kpo00120
연산
for (i=0 ; i<NumElem-1; i++){
Rd[i]=(Ra[i]+Rb[i]+Ra[i+1]+Rb[i+1]))//4;
}
예외
없음.
[VCACHE 캐쉬 연산]
Figure kpo00121
어셈블러 구문
VCACHE.fc SRb, SRj
VCACHE.fc SRb, #IMM
VCACHE.fc SRb+, SRj
VCACHE.fc SRb+, #IMM
여기서 fc = {0, 1}.
설명
이 명령은 벡터 데이타 캐쉬의 소프트웨어 관리를 위해 제공된다. 상기 데이타 캐쉬의 일부 또는 전부가 스크래치 패드로 컨피그될 때, 이 명령은 스크래치 패드에 영향을 주지 않는다.
다음 선택이 지원된다.
Figure kpo00122
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향을 받지 않는다.
[VCAND 보수 AND]
Figure kpo00123
어셈블러 구문
VCAND.dt VRd, VRa, VRb
VCAMD.dt VRd, VRa, SRb
VCAND.dt VRd, VRa, #IMM
VCAND.dt SRd, SRa, SRb
VCAND.dt SRd, SRa, #IMM
여기서 dt = {b, b9, h, w}. .w과 .f는 동일한 연산을 지정한다는 것에 유의한다.
Figure kpo00124
설명
Ra 및 Rb/중간 오퍼런드의 보수를 논리적으로 AND하고, 그 결과를 목적지 레지스터 Rd로 반환한다.
연산
for (i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)};
Rd[i]<k>=-Ra[i]<k> & Bop[i]<k>, k=for all bits in element i ;
}
예외
없음.
[VCBARR 조건 베리어]
Figure kpo00125
어셈블러 구문
VCBARR.cond
여기서 cond = {0, -7}. 각각의 조건은 나중에 니모닉으로 주어질 것이다.
설명
조건이 유효한 한, 명령 및 차후의 모든 명령 (나중에 프로그램 순서로 나타나는 명령)을 정체시킨다. Cond〈2 : 0〉필드는 CT 포맷에서 다른 조건 명령과는 달리 해석된다.
다음 조건이 현재 정의되어 있다 :
Figure kpo00126
연산
while(Cond=true)
stall all later instructions;
예외
없음.
프로그래밍 주석
이 명령은 명령 실행을 강제로 일련화시키기 위해 소프트웨어에 제공된다. 이 명령은 부정확한 실행을 강제로 정확히 보고하도록 하는데 사용될 수 있다. 예를 들면, 만일 이 명령이 예외를 유발할 수 있는 산술 명령 즉후에 사용되면, 이 예외는 프로그램 카운터가 이 명령을 어드레스하는 것으로 보고될 것이다.
[VCBR 조건 분기]
Figure kpo00127
어셈블러 구문
VCBR.cond #Offset
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}
설명
만일 Cond이 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
If((Cond=VCSR[SO, GT, EQ,, LT])｜(Cond=un))
VPC=VPC+sex(Offset<22:0>*4);
else VPC=VPC+4;
예외
무효 명령 어드레스.
[VCBRI 조건 분기 인다이렉트]
Figure kpo00128
어셈블러 구문
VCBRI.cond SRb
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
If((Cond=VCSR[SO,GT,EQ,LT])｜(Cond=un))
VPC=SRb<31:2> : b'00;
else VPC=VPC +4;
예외
무효 명령 어드레스.
[VCCS 조건 콘택스트 스위치]
Figure kpo00129
어셈블러 구문
VCCS #Offset
설명
만일 VIMSK〈cse〉가 참이면 콘택스트 스위치 서브루틴으로 점프한다. 이는 지연된 분기가 아니다.
만일 VIMAK〈cse〉가 참이면, VPC+4(반환 어드레스)가 반환 어드레스 스택에 저장된다. 그렇지 않으면, 실행은 VPC+4로 계속된다.
연산
If(VIMSK<cse>=1){
if(VSP<4>>15){
VISRC<RASO>=1;
signal ARM7 with RASO exception;
VP_STATE=VP_IDLE;
}else{
RSTACK[VSP<3:0>]=VPC+4;
VSP<4:0>=VSP<4:0>+1;
VPC=VPC+sex(Offset<22:0>*4);
}
}else VPC=VPC+4;
예외
반환 어드레스 스택 오버플로우.
[VCHGCR 제어 레지스터 변경]
Figure kpo00130
어셈블러 구문
VCHGCR 모드
설명
이 명령은 벡터 프로세서의 동작 모드를 바꾼다.
모드에 있는 각 비트는 다음을 지정한다 :
Figure kpo00131
연산
예외
없음.
프로그래밍 주석
이 명령은 VMOV 명령으로 가능하기 보다는 보다 효율적인 방법으로 VCSR에 있는 제어 비트를 바꾸기 위해 하드웨어에 제공된다.
[VCINT 조건 인터럽트 ARM7]
Figure kpo00132
어셈블러 구문
VCINT.cond #ICODE
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 실행을 중지하고 만일 인에이블 되면 ARM7을 인터럽트한다.
연산
If((Cond=VCSR[SO,GT,EQ,LT])｜(Cond=un)){
VISRC<vip>= 1;
VIINS=[VCINT.cond #ICODE instruction];
VEPC=VPC;
if(VIMSK<vie>=1)signal ARM7 interrupt;
VP_STATE=VP_IDLE;
}
else VPC=VPC+4;
예외
VCINT 인터럽트.
[VCJOIN ARM7 태스크와 조건 결합]
Figure kpo00133
어셈블러 구문
VCJOIN.cond #Offset
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참으면 실행을 중지하고 만일 인에이블 되면 ARM7을 인터럽트한다.
연산
If((Cond=VCSR[SO,GT,EQ,LT])｜(Cond=un)){
VISRC<vjp>= 1;
VIINS=[VCJOIN.cond #Offset instruction];
VEPC=VPC;
if(VIMSK<vje>=1)signal ARM7 interrupt;
VP_STATE=VP_IDLE;
}
else VPC=VPC+4;
예외
VCJOIN 인터럽트.
[VCJSR 서브루틴으로 조건 점
Figure kpo00134
어셈블러 구문
VCJSR.cond #Offset
여기서 cond={un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 서브루틴으로 점프한다. 이는 지연된 분기가 아니다.
만일 Cond가 참이면 VPC+4(반환 어드레스)가 반환 어드레스 스택에 저장된다. 만일 그렇지 않으면, 실행은 VPC+4로서 계속된다.
연산
If((Cond=VCSR[SO,GT,EQ,LT])｜(Cond=un)){
if(VSP<4>>15){
VISRC<RASO>=1;
signal ARM7 with RASO exception;
VP_STATE=VP_IDEL;
}else{
RSTACK[VSP<3:0>]=VPC+4;
VSP<4:0>=VSP<4:0>+1;
VPC=VPC+sex(Offset<22:0>*4;
}
}else VPC=VPC+4;
예외
반환 어드레스 스택 오버플로우.
[VCJSRI 서브루틴 인다이렉트로 조건 점프]
Figure kpo00135
어셈블러 구문
VCJSRI.cond SRb
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond이 참이면 서브루틴으로 인다이렉트 점프한다. 이는 지연된 분기가 아니다.
만일 Cond가 참이면 VPC+4(반환 어드레스)가 반환 어드레스 스택에 저장된다. 만일 그렇지 않으면, 실행은 VPC+4로서 계속된다.
연산
If((Cond=VCSR[SO,GT,EQ,LT])｜(Cond=un)){
if(VSP<4:0>>15){
VISRC<RASO>=1;
signal ARM7 with RASO exception;
VP_STATE=VP_IDLE;
}else{
RSTACK[VSP<3:0>]=VPC+4;
VSP<4:0>=VSP<4:0>+1;
VPC=SRb<31:2> : b'00;
}
}else VPC=VPC+4;
예외
반환 어드레스 스택 오버플로우.
[VCMOV 조건 이동]
Figure kpo00136
어셈블러 구문
VCMOV.dt Rd, Rb, cond
VCMOV.dt Rd, #IMM. cond
여기서 dt = {b, b9, h, w, f}. cond={un, lt,eq, le, gt, ne, ge, ov}. .f 데이타형이 9비트 중간 오퍼런드와 함께 지원되지 않는다는 것을 제외하고, .f와 .w는 동일한 연산을 지정하고 있다는 것에 유의한다.
Figure kpo00137
설명
만일 Cond이 참이면 레지스터 Rb의 내용이 레지스터 Rd로 이동된다. ID〈1 : 0〉는 소스 및 목적지 레지스터를 부가적으로 명시한다.
VR 현재의 뱅크 벡터 레지스터
SR 스칼라 레지스터
SY 동기화 레지스터
VAC 벡터 누산기 레지스터 (VAC 레지스터 엔코딩에 대해서는 VMOV 설명을 참조한다.)
Figure kpo00138
연산
If((Cond=VCSR[SOV,GT,EQ,LT])｜(Cond=un))
for (i=0; i<NumElem ; i++)
Rd[i]={Rb[i]∥SRb∥sex(IMM<8:0>)};
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다. VCMOVM은 엘리먼트 마스크에 의한 영향을 받는다.
벡터 누산기에 있는 확장된 부동 소수점 정확도 표현은 8 엘리먼트에 대해 모든 576 비트를 사용한다. 따라서, 누산기에 관계된 벡터 레지스터 이동은 .b9 데이타 크기를 명시하여야 한다.
[VCMOVM 엘리먼트 마스크와 조건 이동]
Figure kpo00139
어셈블러 구문
VCMOVM.dt Rd, Rb, cond
VCMOVM.dt Rd, #IMM.cond
여기서 dt = {b, b9, h, w, f}, cond={un, lt, eq, le, gt, ne, ge, ov}. .f 데이타 형이 9비트 중간 오퍼런드와 함께 지원되지 않는다는 것을 제외하고, .f와 .w는 동일한 연산을 지정하고 있다는 것에 유의한다.
Figure kpo00140
설명
만일 Cond이 참이면 레지스터 Rb의 내용이 레지스터 Rd로 이동된다. ID〈1 : 0〉는 소스 및 목적지 레지스터를 부가적으로 명시한다 :
VR 현재의 뱅크 벡터 레지스터
SR 스칼라 레지스터
VAC 벡터 누산기 레지스터(VAC 레지스터 엔코딩에 대해서는 VMOV 설명을 참조한다.)
Figure kpo00141
연산
If((Cond=VCSR[SO,GT,EQ,LT])｜(Cond=un))
for (i=0; i<NumElem && MMASK[i] ; i++)
Rd[i]=(Rb[i]∥SRb∥sex(IMM<8:0>)};
예외
없음.
프로그래밍 주석
이 명령은 VMMR 엘리먼트 마스크에 의한 영향을 받는다- VCMOV은 엘리먼트 마스크에 의해 영향받지 않는다.
벡터 누산기에 있는 확장된 부동 소수점 정확도 표현은 8 엘리먼트에 대해 모든 576비트를 사용한다. 따라서, 누산기에 관계된 벡터 레지스터 이동은 .b9 데이타 크기를 명시하여야 한다.
[VCMPV 마스크의 비교 및 세트 ]
Figure kpo00142
어셈블러 구문
VCMPV.dt VRa, VRb, cond, mask
VCMPV.dt VRa, SRb, cond, mask
여기서 dt = {b, b9, h, w, f}, cond={lt, eq, le, gt, ne, ge}. 마스크={VGMR, VMMR}. 만일 어떠한 마스크도 지정되어 있지 않으면, VGMR이 가정된다.
Figure kpo00143
설명
벡터 레지스터 VRa 및 VRb의 내용이 (VRa[i]-VRb[i]를 수행함으로서 엘리먼트 와이즈 비교되고, (만일 K=0이면) VGMR 또는 (만일 K=1이면) VMMR 레지스터에 있는 대응하는 비트 #i가 비교의 결과가 VCMPV 명령의 Cond 필드와 일치되면 세트된다. 예를 들면, 만일 Cond 필드가 (LT)보다 작으면, VGMR[i] 또는 VMMR[i] 비트가 만일 VRa[i]〈 VRb[i]이면 세트될 것이다.
연산
for (i=0; i<NumElem : i++){
Bop[i]={Rb[i]∥SRb∥sex(IMM<8:0>)};
relationship[i]=Ra[i]? Bop[i];
if(k=l)
MMASK[i]=(relationship[i]=Cond)? True : False;
else
EMASK[i]=(relationship[i]=Cond)? True : False;
}
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
[VCNTLZ 선두 제로의 카운트]
Figure kpo00144
어셈블러 구문
VCNTLZ.dt VRd, VRb
VCNTLZ.dt SRd, SRb
여기서 dt = {b, b9, h, w}.
Figure kpo00145
설명
Rb에 있는 각 엘리먼트에 대해, 선두 제로의 수를 카운트하고, Rd에 있는 카운트를 반환한다.
연산
for (i=0; i<NumElem && EMASK[i]; i++){
Rd[i]=number of leading zeroes(Rb[i]);
}
예외
없음.
프로그래밍 주석
만일 엘리먼트에 있는 모든 비트가 제로이면, 이때 그 결과는 엘리먼트 크기(바이트, 바이트 9, 하프워드 또는 워드 각각에 대해 8, 9, 16 또는 32)와 같다.
선두 제로들의 카운트는 (만일 VCMPR 명령이 후에 사용되면) 엘리먼트 위치의 인덱스와 반전관계를 갖는다. 엘리먼트 위치로 변환하기 위해, 소정의 데이타형에 대해 NumElem으로부터 VCNTLZ의 결과를 감산한다.
[VCOR OR의 보수]
Figure kpo00146
어셈블러 구문
VCOR.dt VRd, VRa, VRb
VCOR.dt VRd, VRa, SRb
VCOR.dt VRd, VRa, #IMM
VCOR.dt SRd, SRa, SRb
VCOR.dt SRd, SRa, #IMM
여기서 dt = {b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo00147
설명
Ra 및 Rb/중간 오퍼런드의 보수를 논리적으로 OR하고 그 결과를 목적지 레지스터 Rd로 반환한다.
연산
for (i=0; i<NumElem && EMASK[i]; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)};
Rd[i]<k>=-Ra[i]<k>｜Bop<k>, k=for all bits in element i;
}
예외
없음.
[VCRSR 서브루틴으로부터 조건 반환]
Figure kpo00148
어셈블러 구문
VCRSR.cond
여기서 cond = {un, lt, eq, le, gt, ne, ge, ov}.
설명
만일 Cond가 참이면, 반환 어드레스 스택에 저장된 반환 어드레스로부터 실행이 계속된다. 만일 그렇지 않으면, VPC+4로서 실행을 계속한다.
연산
If((Cond=VCRS[SO,GT,EQ,LT])｜(Cond=un)){
if(VSP<4:0>=0){
VISRC<RASU>=1;
signal ARM7 with RASU exception;
VP_STATE=VP_IDLE;
}else{
VSP<4:0>=VSP<4:0>-1;
VPC=RSTACK[VSP<3:0>];
VPC<1:0>=b'00;
}
}else VPC=VPC+4;
예외
무효 명령 어드레스. 어드레스 스택 오버플로우 반환
[VCVTB9 바이트 9 데이타 형의 변환]
Figure kpo00149
어셈블러 구문
VCVTB9.md VRd, VRb
VCVTM9.md SRd, SRb
여기서 md = {bb9, b9h, hb9}.
Figure kpo00150
설명
Rb에 있는 각 엘리먼트는 바이트에서 바이트9(bb9), 바이트 9에서 하프워드(b9h) 또는 하프워드에서 바이트 9(hb9)로 변환된다.
연산
if(md<1:0>=0){ //bb0 for byte to byte 9 conversion
VRd =VRb;
VRd<9i+8>=VRb<9i+7>, i=0 to 31(or 63 in VEC64 mode)}
else if (md<1:0>=2){ //b9h for byte 9 to halfword conversion
VRd=VRb;
Vrd<18i+16:18i+9>=VRb<18i+8>, i=0 to 15(or 31 in VEC64 mode)}
else if (md<1:0>=3) //hb9 for halfword to byte 9 conversion
VRd<18i+8>=VRb<18i+9>, i=0 to 15(or 31 in VEC64 mode)
else VRd=undefined;
예외
없음.
프로그래밍 주석
b9h 모드와 함께 이 명령을 사용하기 전에, 프로그래머는 셔플 연산으로 벡터 레지스터에 있는 감소된 엘리먼트 수를 조정할 필요가 있다. hb9 모드와 함께 이 명령을 사용한 후, 프로그래머는 셔플 연산으로 목적지 벡터 레지스터에 있는 증가된 엘리먼트 수를 조정할 필요가 있다. 이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
[VCVTFF 부동 소수점을 고정 소수점으로 변환하기]
Figure kpo00151
어셈블러 구문
VCVTFF VRd, VRa, SRb
VCVTFF VRd, VRa, #IMM
VCVTFF SRd, SRa, SRb
VCVTFF SRd, SRa, #IMM
Figure kpo00152
설명
벡터/스칼라 레지스터 Ra의 내용이 32비트 부동 소수점에서 포맷 〈X, Y〉의 고정 소수점 실수로 변환되는데, 여기서 Y의 폭은 Rb (모듈로 32) 또는 IMM 필드에 의해 지정되고, X의 폭은 (32-Y의 폭)에 의해 지정된다. X는 정수 부분을 지칭하고, Y는 분수 부분을 지칭한다. 그 결과는 벡터/스칼라 레지스터 Rd에 저장된다.
연산
Y_size={SRb % 32 ∥IMM<4:0>};
for (i=0; i<NumElem; i ++){
Rd[i]=convert to <32-Y_size. Y_size> format(Ra[i]);
}
예외
오버플로우.
프로그래밍 주석
이 명령은 워드 데이타 크기만을 지원한다. 이 명령은 아키텍춰가 레지스터내의 복수 데이타 형을 지원하지 않기 때문에 엘리먼트 마스크를 사용하지 않는다. 이 명령은 정수 데이타형에 대해 제로 라운딩 모드로부터 라운드 어웨이를 사용한다.
[VCVTIF 정수에서 부동 소수점으로의 변환]
Figure kpo00153
어셈블러 구문
VCVTIF VRd, VRb
VCVTIF VRd, SRb
VCVTIF SRd, SRb
Figure kpo00154
설명
벡터/스칼라 레지스터 Rb의 내용이 int32에서 부동 데이타 형으로 변환되고 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for (i=0; i < NumElem : i ++){
Rd[i]=convert to floating point format(Rb[i]);
}
예외
없음.
프로그래밍 주석
이 명령은 워드 데이타 크기만 지원한다. 이 명령은 아키텍춰가 레지스터내의 복수 데이타형을 지원하지 않기 때문에 엘리먼트 마스크를 사용하지 않는다.
[VD1CBR VCR1의 감소 및 조건 분기]
Figure kpo00155
어셈블러 구문
VD1CBR.cond #Offset
여기서 cond = {un, lt, eq, gt, ne, ge, ov}
설명
VCR1을 감소하고 만일 Cond가 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
VCR1=VCR1-1;
If((VCR1 >0)&((Cond=VCSR[SO,GT,EQ,LT])｜(Cond=un)))
VPC=VPC+sex(Offset<22:0>*4);
else VPC=VPC+4;
예외
무효 명령 어드레스.
프로그래밍 주석
VCR1은 분기 조건이 점검되기 전에 감소된다는 것에 유의한다. VGR1이 0일때 이 명령의 실행은 루프 카운트를 232-1로 효과적으로 세트시킨다.
[VD2CBR VCR2의 감소 및 조건 분기]
Figure kpo00156
어셈블러 구문
VD2CBR.cond #Offset
여기서 cond = {un, lt, eq, gt, ne, ge, ov}
설명
VCR2을 감소하고 만일 Cond가 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
VCR2=VCR2-1;
If((VCR2>0)&((Cond=VCSR[SO.GT,EQ,LT])｜(Cond=un)))
VPC=VPC+sex(Offset<22:0>*4);
else VPC=VPC+4;
예외
무효 명령 어드레스.
프로그래밍 주석
VCR2는 분기 조건이 점검되기 전에 감소된다는 것에 유의한다. VCR2이 0일 때 이 명령의 실행은 루프 카운트를 232-1로 효과적으로 세트시킨다.
[VD3CBR VCR3의 감소 및 조건 분기]
Figure kpo00157
어셈블러 구문
VD3CBR.cond #Offset
여기서 cond = {un, lt, eq, gt, ne, ge, ov}
설명
VCR3을 감소하고 만일 Cond가 참이면 분기한다. 이는 지연된 분기가 아니다.
연산
VCR3=VCR3-1;
If((VCR3>0)&(Cond=VCSR[SO,GT,EQ,LT])｜(Cond=un)))
VPC=VPC+sex(Offset<22:0>*4);
else VPC=VPC+4;
예외
무효 명령 어드레스.
프로그래밍 주석
VCR3은 분기 조건이 점검되기 전에 감소된다는 것에 유의한다. VCR3이 0일때 이 명령의 실행은 루프 카운트를 232-1로 효과적으로 세트시킨다.
[VDIV2N 2n로 나누기]
Figure kpo00158
어셈블러 구문
VDIV2N.dt VRd, VRa, SRb
VDIV2N.dt VRd, VRa, #IMM
VDIV2N.dt SRd, SRa, SRb
VDIV2N.dt SRd, SRa, #IMM
여기서 dt = {b, b9, h, w}
Figure kpo00159
설명
벡터/스칼라 레지스터 Ra의 내용을 여기서 n이 스칼라 레지스터 Ra 또는 IMM의 양의 정수 내용인 2n으로 나누고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다. 이 명령은 라운딩 모드로서 트렁케이트(라운드 투워드 제로)를 사용한다.
연산
N={SRb % 32 ∥IMM<4:0>};
for(i=0; i <NumElem && EMASK[i]; i++){
Rd[i]=Ra[i]/2N;
}
예외
없음.
프로그래밍 주석
N은 SRb 또는 IMM〈4 : 0〉로부터 5 비트로서 취해진다. 바이트, 바이트 9, 하프워드 데이타 형의 경우, 프로그래머는 데이타 크기에 있는 정확도보다 적거나 같은 N의 값을 정확하게 명시할 책임이 있다. 만일 명시된 데이타 크기의 정확도 보다 크면, 엘리먼트가 부호 비트에 채워질 것이다. 이 명령은 라운드 투워드 제로 라운딩 모드를 이용한다.
VDIV2N.F 2n부동으로 나누기
Figure kpo00160
어셈블러 구문
VDIV2N.f VRd, VRa, SRb
VDIV2N.f VRd, VRa, #IMM
VDIV2N.f SRd, SRa, SRb
VDIV2N.f SRd, SRa, #IMM
Figure kpo10001
설명
벡터/ 스칼라 레지스터 Ra의 내용을 여기서 n이 스칼라 레지스터 Rb 또는 IMM의 양의 정수 내용인 2n으로 나누고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
N={SRb % 32 ∥ IMM <4:0>} ;
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Rd[i]=Ra[i]/2N;
}
예외
없음.
프로그래밍 주석
N은 SRb 또는 IMM〈4 : 0〉로부터 5 비트 수로서 취해진다는 것에 유의한다.
VDIV 초기화 나누기 -불완전
Figure kpo10002
어셈블러 구문
VDIVI.ds VRb
VDIVI.ds SRb
여기서 ds ={b, b9, h, w}
Figure kpo10003
설명
비복원 부호가 있는 정수 나눗셈의 초기 단계를 수행한다. 피젯수는 누산기에 있는 이중 정확도 부호가 있는 정수이다. 만일 젯수가 단일 정확도이면, 이중 정확도로 부호가 확장되어 VACOH 및 VACOL에 저장되어야 한다. 젯수는 Rb에 있는 단일 정확도의 부호가 있는 정수이다.
만일 피젯수의 부호가 젯수의 부호와 동일하면, Rb가 누산기 하이로부터 감산된다. 만일 그렇지 않으면, Rb가 누산기 하이에 가산된다.
연산
for(i=0 ; i < NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb}
if (VAC0H[i]<msb>=Bop[i]<msb>
VAC0H[i]=VAC0H[i]-Bop[i] ;
else
VAC0H[i]=VAC0H[i]+Bop[i] ;
}
예외
없음.
프로그래밍 주석
프로그래머는 나눗셈 단계이전에 제로 케이스로 오버플로우 또는 나눗셈을 검출 할 책임이 있다.
VDIVS 나눗셈 단계-불완전
Figure kpo10004
어셈블러 구문
VDIVS.ds VRb
VDIVS.ds SRb
여기서 ds={b, b9, h, w}
Figure kpo10005
설명
비복원 부호가 있는 나눗셈의 하나의 순환 단계를 수행한다. 이 명령은 데이타 크기(즉, int9 데이타 형에 대해 int8에 대해 8번, int9에 대해 9번, int16에 대해 16 및 int32에 대해 32)만큼 실행되어야 한다. VDIVI 명령은 누산기에서 초기의 부분 나머지를 만드는 나눗셈 단계 이전에 사용되어야 한다. 젯수는 Rb에 있는 부호가 있는 단일 정확도 정수이다. 일단 지수 비트가 단계마다 추출되면 누산기의 최하위 비트로 쉬프트된다.
누산기에 있는 부분 나머지의 부호가 Rb에 있는 젯수의 부호와 동일하면, Rb가 누산기 하이로부터 감산된다. 그렇지 않으면, Rb는 누산기 하이에 더해진다.
만일 누산기에 있는 결과로 나타나는 부분 나머지(덧셈 또는 뺄셈의 결과)가 젯수의 부호와 동일하면, 지수 비트는 1이다. 그렇지 않으면, 지수 비트는 0이다. 누산기는 지수 비트를 채우도록 한 비트 위치만큼 좌로 쉬프트된다.
나눗셈 단계의 결과에서, 나머지는 누산기 하이에 있고 지수는 누산기 로우에 있다. 지수는 1의 보수 형태이다.
연산
VESL 1만큼 좌로 엘리먼트 쉬프트
Figure kpo10006
어셈블러 구문
VESL.dt SRc, VRd, VRa, SRb
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo10007
설명
벡터 레지스터 Ra에 있는 엘리먼트를 1위치 만큼 좌로 쉬프트하여, 스칼라 레지스터 Rb로부터 채운다. 쉬프트 아웃되는 최좌측 엘리먼트는 스칼라 레지스터 Rc에 반환되고 다른 엘리먼트는 벡터 레지스터 Rd에 반환된다.
Figure kpo10008
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VESR 1만큼 우로 엘리먼트 쉬프트
Figure kpo10009
어셈블러 구문
VESL.dt SRc,VRd, VRa, SRb
여기서 dt ={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo10010
설명
벡터 레지스터 Ra에 있는 엘리먼트를 1위치 만큼 우로 쉬프트하여, 스칼라 레지스터 Rb로부터 채운다. 쉬프트 아웃되는 최우측 엘리먼트는 스칼라 레지스터 Rc에 반환되고 다른 엘리먼트는 벡터 레지스터 Rd에 반환된다.
Figure kpo10011
연산
SRc=VRa[0] ;
for(i=0 ; i < NumElem -2 ; i++)
VRd[i]=VRa[i+1] ;
VRd[NumElem-1]=SRb ;
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VEXRT 한 엘리먼트의 추출
Figure kpo10012
어셈블러 구문
VEXTRT.dt SRd,VRa, SRb
VEXTRT.dt SRd, VRa, #IMM
여기서 dt={b, b9, h, w}. .f와 .w는 동일한 연산을 명시하고 있다는 것에 유의한다.
Figure kpo10013
설명
그 인덱스가 스칼라 레지스터 Rb 또는 IMM 필드로서 명시된 Ra 벡터 레지스터로부터 엘리먼트를 추출하고 그것을 스칼라 레지스터 Rd에 저장한다.
연산
index32={SRb % 32 ∥ IMM<4:0>} ;
index64={SRb % 64 ∥IMM<5:0>} ;
index=(VCSR<vec64>)? index64 : index32 ;
SRd=VRa[index] ;
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VEXTSGN2 (1, -1)의 부호를 추출
Figure kpo10014
어셈블러 구문
VEXTSGN2.dt VRd, VRa
VEXTSGN2.dt SRd, SRa
여기서 dt={b, b9, h, w}
Figure kpo10015
설명
벡터/ 스칼라 레지스터 Ra 엘리먼트와이즈의 내용의 부호값이 계산되고 그 결과가 벡터/ 스칼라 레지스터 Rd에 저장된다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Rd[i]=(Ra[i]<0)? -1 : 1 ;
}
예외
없음.
VEXTSGN3 (1, 0, -1)의 부호 추출
Figure kpo10016
어셈블러 구문
VEXTSGN3.dt VRd. VRa
VEXTSGN3.dt SRd. SRa
여기서 dt={b, b9, h, w}
Figure kpo10017
설명
벡터/ 스칼라 레지스터 Ra 엘리먼트와이즈의 내용의 부호값이 계산되고 그 결과가 벡터/ 스칼라 Rd에 저장된다.
연산
for (i=0 ; i < NumElem && EMASK[i] ; i++){
if (Ra[i]>0) Rd[i]=1 ;
else if (Ra[i]<0) Rd[i]=-1 ;
else Rd[i]=0 ;
}
예외
없음.
VENSRT 한 엘리먼트의 삽입
Figure kpo10018
어셈블러 구문
VENSRT.dt VRd. SRa. SRb
VINSRT.dt VRd. SRa. #IMM
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo10019
설명
스칼라 레지스터 Rb 또는 IMM 필드로 명시된 인덱스에서 스칼라 레지스터 Ra에 있는 엘리먼트를 벡터 레지스터 Rd에 삽입한다.
연산
index32={SRb % 32 ∥ IMM<4:0>} ;
index64={SRb % 64 ∥ IMM<5:0>} ;
index=(VCSR<vec64>)? index64 : index32 ;
VRd[index]=SRa ;
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VL 로드
Figure kpo10020
어셈블러 구문
VL.lt Rd, SRb, SRi
VL.lt Rd, SRb, #IMM
VL.lt Rd, SRb+, SRj
VL.lt Rd, SRb+, #IMM
여기서 lt={b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd={VRd, VRAd, SRd}. .b와 .ds9는 동일한 연산을 명시하고 .64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VLOFF를 사용한다.
설명
현재 또는 대체 뱅크에 있는 벡터 레지스터 또는 스칼라 레지스터를 로드한다.
연산
EA=SRb+{SR1∥sex(IMM<7:0>)} ;
if(A〓1)SRb=EA ;
Rd=see table below ;
Figure kpo10021
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VLCB 순환 버퍼로부터 로드
Figure kpo10022
어셀블러 구문
VLCB.lt Rd, SRb, SRi
VLCB.lt Rd, SRb, #IMM
VLCB.lt Rd, SRb+, SRi
VLCB.lt Rd, SRb+, #IMM
여기서 lt={b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd={VRd, VRAd, SRd}. .b와 .ds9는 동일한 연산을 명시하고 .64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VLCBOFF를 사용한다.
설명
SRb+1에 있는 BEGIN 포인터와 SRb+2에 있는 END 포인터로 가리켜진 순환 버퍼로부터 벡터 레지스터 또는 스칼라 레지스터를 로드한다.
만일 어드레스 갱신 연산은 물론 로드 이전에 END 어드레스보다 크면 유효 어드레스가 조정된다. 또한, 순환 버퍼 바운드는 각각 .h 및 .w 스칼라 레지스터에 대해 하프워드 및 워드 경계상에서 정렬되어야 한다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
BEGIN=SRb+1;
END=SRb+2;
cbsize=END-BEGIN ;
if(EA>END)EA=BEGIN+(EA-END) ;
if(A〓1)SRb=EA ;
Rd=see table below ;
Figure kpo10023
예외 무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
프로그래머는 다음 조건을 확실히 하여야 예상된대로 작동한다.
BEGIN〈EA〈2*END-BEGIN
즉, EA-END〈END-BEGIN은 물론 EA〉BEGIN
VLE 이중 로드
Figure kpo10024
어셈블러 구문
VLD.lt Rd, SRb, SRi
VLD.lt Rd, SRb, #IMM
VLD.lt Rd, SRb+, SRi
VLD.lt Rd, SRb+, #IMM
여기서 lt={b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd={VRd, VRAd, SRd}. .b와 .ds9는 동일한 연산을 명시하고 .64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬=-오프 로드를 위해 VLDOFF를 사용한다.
설명
현재 또는 대체 뱅크에 있는 두개의 벡터 레지스터 또는 두개의 스칼라 레지스터를 로드한다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)};
if(A==1)SRb=EA;
Rd:Rd+1=see table below
Figure kpo10025
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VL1 중간 로드
Figure kpo10026
어셈블러 구문
VLI.dt VRd, #IMM
VLI.dt SRd, #IMM
여기서 dt={b, b9, h, w, f}
설명
중간값을 스칼라 또는 벡터 레지스터로 로드한다.
스칼라 레지스터 로드의 경우, 바이트, 바이트9, 하프워드 또는 워드는 데이타 형에 따라 로드된다. 바이트, 바이트9 및 하프워드 데이타 형의 경우, 영향받지 않는 바이트(바이트9)는 수정되지 않는다.
연산
Rd=이하의 표를 참조한다 :
Figure kpo10027
예외
없음.
VLQ Quad 로드
Figure kpo10028
어셈블러 구문
VLQ.lt Rd, SRb, SRi
VLQ.lt Rd, SRb, #IMM
VLQ.lt Rd, SRb+, SRi
VLQ.lt Rd, SRb+, #IMM
여기서 lt={b, bz9, ds9, h, w, 4, 8, 16, 32, 64}, Rd={VRd, VRAd, SRd}. .b와 .ds9는 동일한 연산을 명시하고 .64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VSQOFF를 사용한다.
설명
현재 또는 대체 뱅크에 있는 네개의 벡터 레지스터 또는 네개의 스칼라 레지스터를 로드한다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if(A〓1)SRb=EA ;;
Rd: Rd+1 : Rd+2 : Rd+3=see table below ;
Figure kpo10029
Figure kpo10030
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VLR 반전 로드
Figure kpo10031
어셈블러 구문
VLR.lt Rd, SRb, SRi
VLR.lt Rd, SRB, #IMM
VLR.lt Rd, SRb+, SRi
VLR.lt Rd, SRb+, #IMM
여기서 lt={4, 8, 16, 32, 64}, Rd={VRd, VRAd}, 64와 VRAd는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해 VLROFF를 사용한다.
설명
역 엘리먼트 순으로 벡터 레지스터를 로드한다. 이 명령은 스칼라 목적지 레지스터를 지원하지 않는다.
연산
EA=SRb+{SRisex(IMM<7:0>)} ;
if(A〓1)SRb=EA ;
Rd=see table below ;
Figure kpo10032
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다.
VLSL 논리적 좌측 쉬프트
Figure kpo10033
어셈블러 구문
VLSL.lt VRd, VRd, VRa, SRb
VLSL.dt VRd, VRa, #IMM
VLSL.dt SRd, SRa, SRb
VLSL.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}.
Figure kpo10034
설명
벡터/스칼라 레지스터 Ra에 있는 각 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 쉬프트 양만큼 제로가 최하위 비트(LSB) 위치에 채워지면서 논리적으로 좌로 비트 쉬프트되고, 그 결과는 벡터/ 스칼라 레지스터 Rd에 저장된다.
연산
shift_amount={SRb % 32∥IMM<4:0>) ;
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Rd[i]=Ra[i]<<shift_amount ;
}
예외
없음.
프로그래밍 주석
shift amount은 SRb 또는 IMM〈4 : 0〉로부터 5 비트 숫자로서 취해진다는 것에 유의한다. 바이트, 바이트9, 하프워드 데이타 형의 경우, 프로그래머는 데이타 크기에 있는 비트의 수보다 적거나 또는 같은 쉬프트 양을 정확하게 명시할 책임이 있다. 만일 쉬트프 양이 명시된 데이타 크기보다 크면, 엘리먼트는 제로로 채워질 것이다.
VLSR 논리적 우측 쉬프트
Figure kpo10035
어셈블러 구문
VLSR.dt VRd, VRa, SRb
VLSR.dt VRd, VRa, #IMM
VLSR.dt SRd, SRa, SRb
VLSR.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}.
Figure kpo10036
설명
벡터/스칼라 레지스터 Ra에 있는 각 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 쉬프트 양만큼 제로가 최상위 비트(MSB) 장소에 채워지면서 논리적으로 우로 비트 쉬프트되고, 그 결과는 벡터/ 스칼라 레지스터 Rd에 저장된다.
연산
shift_amount={SRb % 32∥IMM<4:0>) ;
for(i=0 ; i < NumElem && EMASK[i] ; i++){
Rd[i]=Ra[i] zero >>shift_amount ;
}
예외
없음.
프로그래밍 주석
shift amount은 SRb 또는 IMM〈4 : 0〉로부터 5 비트 숫자로서 취해진다는 것에 유의한다. 바이트, 바이트9, 하프워드 데이타 형의 경우, 프로그래머는 데이타 크기에 있는 비트의 수보다 적거나 또는 같은 쉬프트 양을 정확하게 명시할 책임이 있다. 만일 쉬트프 양이 명시된 데이타 크기보다 크면, 엘리먼트는 제로로 채워질 것이다.
VLWS 스트라이드로 로드
Figure kpo10037
어셈블로 구문
VLWS.lt Rd, SRb, SRi
VLWS.lt Rd, SRb, #IMM
VLWS.lt Rd, SRb+, SRi
VLWS.lt Rd, SRb+, #IMM
여기서 lt={4, 8, 16, 32}, Rd={VRd, VRAd}. 64 모드는 지원되지 않는다. 대신에 VL을 사용한다. 캐쉬-오프 로드를 위해 VLWSOFF를 사용한다.
설명
유효 어드레스에서 시작하여, 스칼라 레지스터 SRb+1를 스트라이드 제어 레지스터로서 이용하여 32바이트가 메모리에서 벡터 레지스터 VRd로 로드된다.
LT는 블럭 크기, 각 블럭에 대해 로드할 연속적인 바이트의 수를 명시한다. SRb+1는 스트라이드(stride), 두개의 연속하는 블럭의 시작을 분리하는 바이트의 수를 명시한다.
스트라이드는 블럭 크기와 같거나 커야 한다. EA는 데이타 크기가 정렬되어야 한다. 스트라이드와 블럭 크기는 복수의 데이타 크기이어야 한다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if(A==1)SRb=EA ;
Block_size={4∥8∥16∥32} ;
Stride=SRb+1<31:0> ;
for(i=0 ; i < VECSIZE/Block_size ; i++)
for (j=0 ; j<Block_size ; j++)
VRd[i*Block_size+j]<8:0>=sex BYTE[EA+i*Stride+j] ;
예외
무효 데이타 어드레스. 정렬되지 않은 액세스.
VMAC 곱셈과 누산
Figure kpo10038
어셈블러 구문
VMAC.dt VRa, BRb
VMAC.dt VRa, SRb
VMAC.dt VRa, #IMM
VMAC.dt SRa, SRb
VMAC.dt SRa, #IMM
여기서 dt={b, h, w, f}
Figure kpo10039
설명
이중 정확도 중간 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 상기 중간 결과의 각 이중 정확도 엘리먼트를 벡터 누산기의 각 이중 정확도 엘리먼트에 더하고 ; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장한다.
Ra와 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 형이다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Aop[i]={VRa[i]∥SRa} ;
Bop[i]={VRb[i]∥SRa} ;
if(dt〓float)VACL[i]=Aop[i]*Bop[i]+VACL[i] ;
else VACH[i] ; VACL[i]=Aop[i]*Bop[i]+VACH[i] : VACL[i] ;
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 이용한다.
Figure kpo10040
어셈블러 구문
VMACF.dt VRa, VRb
VMACF.dt VRa, SRb
VMACF.dt VRa, #IMM
VMACF.dt SRa, SRb
VMACF.dt SRa, #IMM
여기서 dt={b, h, w}
Figure kpo10041
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 상기 이중 정확도 중간 결과를 좌로 1비트 쉬프트 하고 ; 쉬프트된 중간 결과의 각 이중 정확도 엘리먼트를 벡터 누산기의 각 이중 정확도 엘리먼트에 더하고 ; 각 엘리먼트의 이중 정확도를 합계를 상기 벡터 누산기에 저장한다.
VRa와 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
VACH[i] : VACL[i]=((VRa[i]*Bop[i]<<1)+VACH[i] : VACL[i] ;
}
예외
오버플로우
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다-대신에 int16 데이타 형을 이용한다.
VMACL 로우의 곱셈과 누산
Figure kpo10042
어셈블러 구문
VMACL.dt VRd, VRa, VRb
VMACL.dt VRd, VRa, SRb
VMACL.dt VRd, VRa, #IMM
VMACL.dt SRd, SRa, SRb
VMACL.dt SRd, SRa, #IMM
여기서 dt={b, h, w, f}.
Figure kpo10043
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 : 상기 중간 결과의 각 이중 정확도 엘리먼트를 벡터 누산기의 각 이중 정화도 엘리먼트에 더하고 : 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장하고 ; 그 하부를 목적지 레지스터 VRd에 저장한다.
VRa와 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 형이다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb] ;
if(dt〓float)VACL[i]=VRa[i]*Bop[i]+VACL[i] ;
else VACH[i] : VACL[i]=VRa[i]*Bop[i]+VACH[i] : VACL[i] ;
VRd[i]=VACL[i] ;
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 -대신에 int16 데이타 형을 이용한다.
VMAD 곱셈과 덧셈
Figure kpo10044
어셈블러 구문
VMAD.dt VRc, VRd, VRa, VRb
VMAD.dt SRc, SRd, SRa, SRb
여기서 dt={b, h, w}.
Figure kpo10045
설명
이중 정확도 중간 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 상기 중간 결과의 각 이중 정확도 엘리먼트를 Rc의 각 엘리먼트에 더하고 ; 각 엘리먼트의 이중 정확도 합계를 상기 목적지 레지스터 Rd+1 : Rd에 저장한다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Aop[i]={VRa[i]∥SRa] ;
Bop[i]={VRb[i]∥SRb] ;
Cop[i]={VRc[i]∥SRc] ;
Rd+1[i] : Rd[i]=Aop[i]*Bop[i]+sex_dp(Cop[i]) ;
}
예외
없음.
VMAD L 로우의 곱셈과 덧셈
Figure kpo10046
어셈블러 구문
VMADL.dt VRc, VRd, VRa, VRb
VMADL.dt SRc, SRd, SRa, SRb
여기서 dt={b, h, w, f}
Figure kpo10047
설명
이중 정확도 중간 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 상기 중간 결과의 각 이중 정확도 엘리먼트를 Rc의 각 엘리먼트에 더하고 ; 각 엘리먼트의 이중 정확도 합계를 상기 목적지 레지스터 Rd에 저장한다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 유형이다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Aop[i]={VRa[i]∥SRa] ;
Bop[i]={VRb[i]∥SRb] ;
Cop[i]={VRc[i]∥SRc] ;
if(dt〓float)Lo[i]=Aop[i]*Bop[i]+Cop[i] ;
else Hi[i] : Lo[i]=Aop[i]*Bop[i]+sex_dp(Cop[i]) ;
Rd[i]=Lo[i] ;
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
VMAS 누산기로부터의 곱셈과 뺄셈
Figure kpo10048
어셈블러 구문
VMAS.dt VRa, VRb
VMAS.dt VRa, SRb
VMAS.dt VRa, #IMM
VMAS.dt SRa, SRb
VMAS.dt SRa, #IMM
여기서 dt={b, h, w, f}.
Figure kpo10049
설명
이중 정확도 중간 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 벡터 누산기의 각 이중 정확도 엘리먼트로부터 상기 중간 결과의 각 이중 정확도 엘리먼트를 빼고 ; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장한다.
Ra와 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 형이다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb} ;
if(dt〓float)VACL[i]=VACL[i]-VRa[i]*Bop[i] ;
else VACH[i] : VACL[i]=VACH[i] : VACL[i]-VRa[i]*Bop[i] ;
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 - 대신에 int16 데이타 형을 이용한다.
VMASF 누산기 분수로부터의 곱셈과 뺄셈
Figure kpo10050
어셈블러 구문
VMASF.dt VRa, VRb
VMASF.dt VRa, SRb
VMASF.dt VRa, #IMM
VMASF.dt SRa, SRb
VMASF.dt SRa, #IMM
여기서 dt={b, h, w}.
Figure kpo10051
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 이중 정확도 중간 결과를 우로 1만큼 쉬프트하고 ; 벡터 누산기의 각 이중 정확도 엘리먼트로부터 상기 쉬프트된 중간 결과의 각 이중 정확도 엘리먼트를 빼고 ; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장한다.
VRa와 Vb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
VACH[i] : VACL[i]=VACH[i] ; VACL[i]-VRa[i]*Bop[i] ;
}
예외
오버플로우.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다- 대신에 int16 데이타 형을 이용한다.
VMASL 누산기 로우로부터의 곱셈과 뺄셈
Figure kpo10052
어셈블러 구문
VMASL.dt VRd, VRa, VRb
VMASL.dt VRd, VRa, SRb
VMASL.dt VRd, VRa, #IMM
VMASL.dt SRd, SRa, SRb
VMASL.dt SRd, SRa, #IMM
여기서 dt={b, h, w, f}.
Figure kpo10053
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 벡터 누산기의 각 이중 정확도 엘리먼트로부터 상기 중간 결과의 각 이중 정확도 엘리먼트를 빼고 ; 각 엘리먼트의 이중 정확도 합계를 상기 벡터 누산기에 저장하고 ; 그 하부를 목적지 레지스터 VRd로 반환한다.
VRa와 Rb는 지정된 데이타 형을 사용하는데 반해, VAC는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 VACH에 저장된다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 형이다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb} ;
if(dt〓float)VACL[i]=VACL[i]-VRa[i]*Bop[i] ;
else VACH[i] : VACL[i]=VACH[i] : VACL[i]-VRa[i]*Bop[i] ;
VRd[i]=VACL[i] ;
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 - 대신에 int16 데이타 형을 이용한다.
VMAXE 페어와이즈 최대 및 교환
Figure kpo10054
어셈블러 구문
VMAXE.dt VRd. VRb
여기서 dt={b, b9, h, w, f}
Figure kpo10055
설명
VRa는 VRb와 같다. VRa가 VRb와 다르면, 그 결과는 정의되지 않는다.
벡터 레지스터 VRb의 각 홀수/ 짝수 데이타 엘리먼트가 쌍으로 비교되고 각 데이타 엘리먼트 쌍의 큰 값이 짝수 장소에 저장되고 각 데이타 엘리먼트 쌍의 작은 값이 벡터 레지스터 Rd의 홀수 장소에 저장된다.
연산
for(j=0 ; i<NumElem && EMASK[i] ; i=i+2){
VRd[i]=(VRb[i]>VRb[i+1])? VRb[i] : VRb[i+1] ;
VRd[i+1]=(VRb[i]>VRb[i+1])? VRb[i+1] : VRb[i] ;
}
예외
없음.
VMOV 이동
Figure kpo10056
어셈블러 구문
VMOV.dt Rd, Rb
여기서 dt={b, b9, h, w, f}, Rd와 Rb는 아키텍춰적으로 지정된 레지스터 명을 지칭한다. .w와 .f는 동일한 연산을 지정한다는 것에 유의한다.
Figure kpo10057
설명
레지스터 Rb의 내용이 레지스터 Rd로 이동된다. 그룹 필드는 소스 및 목적지 레지스터 그룹을 명시한다. 레지스터 그룹 주석은 다음과 같다 :
VR 현재의 뱅크 벡터 레지스터
VRA 대체 뱅크 벡터 레지스터
SR 스칼라 레지스터
RASR 반환 어드레스 스택 레지스터
VAC 벡터 누산기 레지스터(이하의 VAC 레지스터 엔코딩을 참조한다.)
Figure kpo10058
벡터 레지스터는 이 명령으로서 스칼라 레지스터로 이동될 수 없다는 것에 유의한다. VEXTRT 명령이 상기 목적을 위해 제공된다.
VAC 레지스터 엔코딩을 위해 다음 표를 사용한다 :
Figure kpo10059
연산
Rd=Rb
예외
예외 상태를 VCSR 또는 VISRC에 세트함으로서 대응하는 예외를 초래할 것이다.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의해 영향받지 않는다. 대체 뱅크 개념은 VEC64 모드에 존재하지 않기 때문에, 이 명령은 VEC64 모드에 있는 대체 뱅크로부터 또는 에 이동하는데 사용될 수 없다.
VMUL 곱셈
Figure kpo10060
어셈블러 구문
VMUL.dt VRd, VRd, VRa, VRb
VMUL.dt SRc, SRd, SRa, SRb
여기서 dt={b, h, w}.
Figure kpo10061
설명
이중 정확도 결과를 내기 위해 Ra의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 각 엘리먼트의 이중 정확도 합계를 상기 목적지 레지스터 Rc : Rd로 반환한다.
Ra와 Rb는 지정된 데이타 형을 사용하는데 반해, Rc : Rd는 적당한 이중 정확도 데이타 형(int8, int16 및 int32 각각에 대해 16, 32 및 64)을 사용한다. 각 이중 정확도 엘리먼트의 상부는 Rc에 저장된다.
연산 for(i=0 ; i<NumElem && EMASK[i] ; i++){
Aop[i]={VRa[i]∥SRa} ;
Bop[i]={VRb[i]∥SRb} ;
Hi[i] : Lo[i]=Aop[i]*Bop[i] ;
Rc[i]=Hi[i] ;
Rd[i]=Lo[i] ;
}
예외
없음.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 - 대신에 int16 데이타 형을 사용한다. 이 명령은 또한 확장된 결과가 지원된 데이타 형이 아니기 때문에 부동 데이타 형을 지원하지 않는다.
VMULA 누산기에 대한 곱셈
Figure kpo10062
어셈블러 구문
VMULA.dt VRa, VRb
VMULA.dt VRa, SRb
VMULA.dt VRa, #IMM
VMULA.dt SRa, SRb
VMULA.dt SRa, #IMM
여기서 dt={b, h, w, f}.
Figure kpo10063
설명
이중 정확도 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 그 결과를 누산기에 기록한다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 유형이다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb} ;
if(dt==float)VACL[i]=VRa[i]*Bop[i] ;
else VACH[i] : VACL[i]=VRa[i]*Bop[i] ;
}
예외
없음.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 - 대신에 int16 데이타 형을 사용한다.
VMULAF 누산기 분수에 대한 곱셈
Figure kpo10064
어셈블러 구문
VMULAF.dt VRa, VRb
VMULAF.dt VRa, SRb
VMULAF.dt VRa, #IMM
VMULAF.dt SRa, SRb
VMULAF.dt SRa, #IMM
여기서 dt={b, h, w}.
Figure kpo10065
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 상기 이중 정확도 중간 결과를 좌로 1 비트 쉬프트하고 ; 그 결과를 누산기에 기록한다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
VACH[i] : VACL[i]=(VRa[i]*Bop[i])<<1 ;
}
예외
없음
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 - 대신에 int16 데이타 형을 사용한다.
VMULF 분수 곱셈
Figure kpo10066
어셈블러 구문
VMULF.dt VRd, VRa, VRb
VMULF.dt VRd, VRa, SRb
VMULF.dt VRd, VRa, #IMM
VMULF.dt SRd, SRa, SRb
VMULF.dt SRd, SRa, #IMM
여기서 dt={b, h, w}.
Figure kpo10067
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 상기 이중 정확도 중간 결과를 좌로 1비트 쉬프트 하고 ; 그 결과의 상부를 목적지 레지스터 VRd+1 및 목적지 레지스터 VRd로 반환한다. VRd는 짝수 번호의 레지스터이어야 한다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Hi[i] : Lo[i]=(VRa[i]*Bop[i])<< l ;
VRd+l[i]=Hi[i] ;
VRd[i]=Lo[i] ;
}
예외
없음
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 - 대신에 int16 데이타 형을 사용한다.
VMULFR 분수 곱셈 및 라운드
Figure kpo10068
어셈블러 구문
VMULFR.dt VRd, VRa, VRb
VMULFR.dt VRd, VRa, SRb
VMULFR.dt VRd, VRa, #IMM
VMULFR.dt SRd, SRa, SRb
VMULFR.dt SRd, SRa, #IMM
여기서 dt={b, h, w}.
Figure kpo10069
설명
이중 정확도 중간 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 상기 이중 정확도 중간 결과를 좌로 1비트 쉬프트 하고 ; 상기 쉬프트된 중간 결과를 상부로 라운드하고 ; 그 상부를 목적지 레지스터 VRd로 반환한다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Hi[i] : Lo[i]=(VRa[i]*Bop[i])<< l ;
if(Lo[i]<msb>==l)Hi[i]=Hi[i]+l ;
VRd[i]=Hi[i] ;
}
예외
없음
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 - 대신에 int16 데이타 형을 사용한다.
VMULL 로우 곱셈
Figure kpo10070
어셈블러 구문
VMULL.dt VRd, VRa, VRb
VMULL.dt VRd, VRa, SRb
VMULL.dt VRd, VRa, #IMM
VMULL.dt SRd, SRa, SRb
VMULL.dt SRd, SRa, #IMM
여기서 dt={b, h, w, f}.
Figure kpo10071
설명
이중 정확도 결과를 내기 위해 VRa의 각 엘리먼트를 Rb에 있는 각 엘리먼트와 곱하고 ; 그 결과의 상부를 목적지 레지스터 VRd로 반환한다.
부동 데이타 형의 경우, 모든 오퍼런드와 결과는 단일 정확도 유형이다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb} ;
if(dt==float)Lo[i]=VRa[i]*Bop[i] ;
else Hi[i] : Lo[i]=VRa[i]*Bop[i] ;
VRd[i]=Lo[i] ;
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
프로그래밍 주석
이 명령은 int9 데이타 형을 지원하지 않는다 - 대신에 int16 데이타 형을 사용한다.
VMULF NAND
Figure kpo10072
어셈블러 구문
VNAND.dt VRd, VRa, VRb
VNAND.dt VRd, VRa, SRb
VNAND.dt VRd, VRa, #IMM
VNAND.dt SRd, SRa, SRb
VNAND.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다.
Figure kpo10073
설명
Ra에 있는 각 엘리먼트의 각 비트를 Rb/ 중간 오퍼런드에 있는 대응하는 비트와 논리적으로 NAND하고 ; 그 결과를 Rd에 반환한다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Rd[i]<k>=-(Ra[i]<k>& Bop[i]<k>), for k=all bits in element i ;
}
예외
없음
VNOR NOR
Figure kpo10074
어셈블러 구문
VNOR.dt VRd, VRa, VRb
VNOR.dt VRd, VRa, SRb
VNOR.dt VRd, VRa, #IMM
VNOR.dt SRd, SRa, SRb
VNOR.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다.
Figure kpo10075
설명
Ra에 있는 각 엘리먼트의 각 비트를 Rb/ 중간 오퍼런드에 있는 대응하는 비트와 논리적으로 NOR하고 ; 그 결과를 Rd에 반환한다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Rd[i]<k>=-(Ra[i]<k>l Bop[i]<k>), for k=all bits in element i ;
}
예외
없음
VOR OR
Figure kpo10076
어셈블러 구문
VOR.dt VRd, VRa, VRb
VOR.dt VRd, VRa, SRb
VOR.dt VRd, VRa, #IMM
VOR.dt SRd, SRa, SRb
VOR.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다.
Figure kpo10077
설명
Ra에 있는 각 엘리먼트의 각 비트를 Rb/ 중간 오퍼런드에 있는 대응하는 비트와 논리적으로 OR하고; 그 결과를 Rd에 반환한다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Rd[i]<k>=Ra[i]<k>｜Bop[i]<k>, for k=all bits in element i ;
}
예외
없음
VORC OR 보수
Figure kpo10078
어셈블러 구문
VORC.dt VRd, VRa, VRb
VORC.dt VRd, VRa, SRb
VORC.dt VRd, VRa, #IMM
VORC.dt SRd, SRa, SRb
VORC.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}. .w와 .f는 동일한 연산을 명시한다.
Figure kpo10079
설명
Ra에 있는 각 엘리먼트의 각 비트를 Rb/ 중간 오퍼런드에 있는 대응하는 비트와 논리적으로 OR하고 ; 그 결과를 Rd에 반환한다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Rd[i]<k>=Ra[i]<k>｜-Bop[i]<k>, for k=all bits in element i ;
}
예외
없음
VPFTCH 프리훼치
Figure kpo10080
어셈블러 구문
VPFTCH.ln SRb, SRi
VPFTCH.ln SRb, #IMM
VPFTCH.ln SRb+, SRi
VPFTCH.ln SRb+, #IMM
여기서 ln={1, 2, 4, 8}.
설명
유효 어드레스에서 시작하여 복수의 벡터 데이타 캐쉬 라인을 프리훼치한다. 캐쉬 라인의 수는 다음과 같이 지정된다 :
LN〈1 : 0〉=00 : 1 64 바이트 캐쉬 라인이 프리훼치된다.
LN〈1 : 0〉=01 : 2 64 바이트 캐쉬 라인이 프리훼치된다.
LN〈1 : 0〉=10 ; 4 64 바이트 캐쉬 라인이 프리훼치된다.
LN〈1 : 0〉=11 : 8 64 바이트 캐쉬 라인이 프리훼치된다.
연산
예외
무효 데이타 어드레스 예외
프로그래밍 주석
EA〈31 : 0〉는 국부 메모리에 있는 바이트 어드레스를 지칭한다.
VPFTCHSP 스크래치 패드에 대한 프리훼치
Figure kpo10081
어셈블러 구문
VPFTCHSP.ln SRp, SRb, SRi
VPFTCHSR.ln SRp, SRb, #IMM
VPFTCHSP.ln SRp, SRb+, SRi
VPFTCHSP.ln SRp, SRb+, #IMM
여기서 In={1, 2, 4, 8}. VPFTCH와 VPFTCHSP는 동일한 오피코드를 갖는다.
설명
메모리에서 스크래치 패드로 복수의 64 바이트 블럭을 전송한다. 유효 어드레스는 메모리에 시작 어드레스를 제공하고 SRp는 스크래치 패드에 시작 어드레스를 제공한다. 64 바이트 블럭의 수는 다음과 같이 명시된다 :
LN〈1 : 0〉=00 : 1 64 바이트 블럭이 전송된다.
LN〈1 : 0〉=01 : 2 64 바이트 블럭이 전송된다.
LN〈1 : 0〉=10 : 4 64 바이트 블럭이 전송된다.
LN〈1 : 0〉=11 : 8 64 바이트 블럭이 전송된다.
만일 유효 어드레스가 64 바이트 경계 상에 있지 않으면, 먼저 64 바이트 경계로 정렬되도록 트렁케이트된다. 만일 SRp에 있는 스크래치 패드 포인터 어드레스가 64 바이트 경계 상에 있지 않으면, 이 또한 64 바이트 경계로 정렬되도록 트렁케이트된다. 상기 정렬된 스크래치 패드 포인터 어드레스는 전송된 바이트의 수 만큼 증가된다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if (A==l)SRb=EA ;
Num_bytes={64∥128∥256∥512} ;
Mem_adrs=EA<31:6> : 6b'000000 ;
SRp=SRp<31:6> : 6b'000000 ;
for (i=0 ; i<Num_bytes ; i++)
SPAD[SRp++]=MEM[Mem_adrs+i] ;
예외
무효 데이타 어드레스 예외
VROL 좌로 회전
Figure kpo10082
어셈블러 구문
VROL.dt VRd, VRa, SRb
VROL.dt VRd, VRa, #IMM
VROL.dt SRd, SRa, SRb
VROL.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}.
Figure kpo10083
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 비트 양만큼 좌로 회전되고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
rotate_amount={SRb % 32∥IMM<4:0>} ;
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Rd[i]=Ra[i] rotate_left rotate_amount ;
}
예외
없음
프로그래밍 주석
rotate amount는 SRb 또는 IMM〈4 : 0〉으로부터 5 비트 숫자로서 취해진다. 바이트, 바이트9, 하프워드 데이타 형인 경우, 프로그래머는 데이타 크기에 있어 비트의 숫자보다 적거나 같은 회전 양을 정확히 명시할 책임이 있다. 만일 회전 양이 지정된 데이타 크기보다 크면, 결과는 정의되지 않는다.
좌로 n 회전은 우로 ElemSize-n 회전과 같다. 여기서, ElemSize는 소정의 데이타 크기에서 비트들의 수를 지칭한다.
VROR 우로 회전
Figure kpo10084
어셈블러 구문
VROR.dt VRd, VRa, SRb
VROR.dt VRd, VRa. #IMM
VROR.dt SRd, SRa, SRb
VROR.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}.
Figure kpo10085
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 스칼라 레지스터 Rb 또는 IMM 필드에 주어진 비트 양만큼 우로 회전되고, 그 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
rotate_amount={SRb % 32∥IMM<4:0>} ;
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Rd[i]=Ra[i] rotate_right rotate_amount ;
}
예외
없음.
프로그래밍 주석
rotate_amount는 SRb 또는 IMM〈4:0〉으로부터 5비트 숫자로서 취해진다. 바이트, 바이트9, 하프워드 데이타 형인 경우, 프로그래머는 데이타 크기에 있어 비트의 숫자보다 적거나 같은 회전 양을 정확히 명시할 책임이 있다. 만일 회전 양이 지정된 데이타 크기보다 크면, 결과는 정의되지 않는다.
좌로 n 회전은 우로 ElemSize-n 회전과 같다. 여기서, ElemSize는 소정의 데이타 크기에서 비트들의 수를 지칭한다.
VROUND 부동 소수점에서 정수로 라운드
Figure kpo10086
어셈블러 구문
VROUND.rm VRd, VRb
VROUND.rm SRd, SRb
여기서 rm={ninf, zero, near, pinf}.
Figure kpo10087
설명
부동 소수점 데이타 포맷에 있는 벡터/스칼라 레지스터 Rb의 내용은 가장 가까운 32비트 정수(워드)로 라운드되고, 그 결과는 벡터/스칼라 레지스터 Rd에 저장된다. 라운딩 모드는 RM에 정의되어 있다.
Figure kpo10088
연산
for (i=0 ; i<NumElem : i++){
Rd[i]=Convert to int32 (Rb[i]) ;
}
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSATl 보다 하위의 라운드까지 포화
Figure kpo10089
어셈블러 구문
VSATL.dt VRd, VRa, VRb
VSATL.dt VRd, VRa. SRb
VSATL.dt VRd, VRa, #IMM
VSATL.dt SRd, SRa, SRb
VSATL.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}. .f 데이타 형은 9비트 중간과 함께 지원되지 않는다는 것에 유의한다.
Figure kpo10090
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 벡터/스칼라 레지스터 Rb 또는 IMM 필드에 있는 그것의 대응하는 하위 한계에 대해 점검된다. 만일 데이타 엘리먼트의 값이 상기 하위 한계보다 작으면, 하위 한계와 같도록 세트되고, 최종 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Rd[i]=(Ra[i]<Bop[i])? Bop[i] : Ra[i] ;
}
예외
없음.
VSATU 보다 상위의 라운드까지 포화
Figure kpo10091
어셈블러 구문
VSATU.dt VRd, VRa, VRb
VSATU.dt VRd, VRa. SRb
VSATU.dt VRd, VRa, #IMM
VSATU.dt SRd, SRa, SRb
VSATU.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w, f}. .f 데이타 형은 9비트 중간과 함께 지원되지 않는다는 것에 유의한다.
Figure kpo10092
설명
벡터/스칼라 레지스터 Ra의 각 데이타 엘리먼트는 벡터/스칼라 레지스터 Rb 또는 IMM 필드에 있는 그것의 대응하는 상위 한계에 대해 점검된다. 만일 데이타 엘리먼트의 값이 상기 상위 한계보다 크면, 상위 한계와 같도록 세트되고, 최종 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Rd[i]=(Ra[i]<Bop[i])? Bop[i] : Ra[i] ;
}
예외
없음.
VSHFL 셔플
Figure kpo10093
어셈블러 구문
VSHFL.dt VRc, VRd, VRa, VRb
VSHFL.dt VRc, VRd, VRa, SRb
여기서 dt={b, b9, h, w, f}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo10094
설명
벡터 레지스터 Ra의 내용이 Rb와 셔플되고, 그 결과가 이하에 도시된 바와 같이 벡터 레지스터 Rc : Rd에 저장된다.
Figure kpo10095
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VSHFLH 하이 셔플
Figure kpo10096
어셈블러 구문
VSHFLH.dt VRd, VRa, VRb
VSHFLH.dt VRd, VRa, SRb
여기서 dt={b, b9, h, w, f}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo10097
설명
벡터 레지스터 Ra의 내용이 Rb와 셔플되고, 그 결과의 상부가 이하에 도시된 바와 같이 벡터 레지스터 Rd에 저장된다.
Figure kpo10098
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VSHFLL 로우 셔플
Figure kpo10099
어셈블러 구문
VSHFLL.dt VRd, VRa, VRb
VSHFLL.dt VRd, VRa, SRb
여기서 dt={b, b9, h, w, f}. .w와 .f는 동일한 연산을 명시한다는 것에 유의한다.
Figure kpo10100
설명
벡터 레지스터 Ra의 내용이 Rb와 셔플되고, 그 결과의 하부가 이하에 도시된 바와 같이 벡터 레지스터 Rd에 저장된다.
Figure kpo10101
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VST 저장
Figure kpo10102
어셈블러 구문
VST.st Rs, SRb, SRi
VST.st Rs, SRb, #IMM
VST.st Rs, SRb+, SRi
VST.st Rs, SRb+, #IMM
여기서 st={b, b9t, h, w, 4, 8, 16, 32, 64}. Rs={VRs, VRAs, SRs} .b와 .b9t는 동일한 연산을 명시하고, .64와 VRAs는 함께 명시될 수 없다는 것에 유의한다. 캐쉬-오프 저장을 위해서는 VSTOFF를 사용한다.
설명
벡터 또는 스칼라 레지스터를 저장한다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if(A==l)SRb=EA ;
MEM[EA]=see table below ;
Figure kpo10103
예외
무효 데이타 어드레스, 정렬되지 않은 액세스
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSTCB 순환 버퍼에의 저장
Figure kpo10104
어셈블러 구문
VSTCB.st Rs, SRb, SRi
VSTCB.st Rs, SRb, #IMM
VSTCB.st Rs, SRb+, SRi
VSTCB.st Rs, SRb+, #IMM
여기서 st={b, b9t, h, w, 4, 8, 16, 32, 64}, Rs={VRs, VRAs, SRs}. .b와 .b9t는 동일한 연산을 지정하고 .64와 VRAd는 함께 지정될 수 없다는 것에 유의한다. 캐쉬-오프 로드를 위해서는 VSTCBOFF를 사용한다.
설명
SRb+1에 있는 BEGIN 포인터와 SRb+2에 있는 END 포인터에 의해 가리켜진 순환 버퍼로부터 벡터 또는 스칼라 레지스터를 저장한다.
어드레스 갱신 연산은 물론 저장하기 전에 END 어드레스보다 크면 유효 어드레스가 조정된다. 또한, 순환 버퍼 바운드는 .f와 .w 스칼라 로드를 위해 각각 하프워드 및 워드 경계 상에서 정렬되어야 한다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
BEGIN=SRb+1;
END=SRb+2;
cbsize=END-BEGIN ;
if(EA>END)EA=BEGIN+(EA-END) ;
if(A==l) SRb=EA ;
MEM[EA]=see table below ;
Figure kpo10105
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
프로그래머는 다음 조건을 확실히 하여 다음 명령이 예상된 대로 동작하게 하여야 한다.
BEGIN<EA<2*END-BEGIN
즉, EA-END<END-BEGIN은 물론 EA<BEGIN.
VSTD 이중 저장
Figure kpo10106
어셈블러 구문
VSTD.st Rs, SRb, SRi
VSTD.st Rs, SRb, #IMM
VSTD.st Rs, SRb+, SRi
VSTD.st Rs, SRb+, #IMM
여기서 st={b, b9t, h, w, 4, 8, 16, 32, 64}, Rs={VRs, VRAs, SRs}. .b와 .b9t는 동일한 연산을 지정하고 .64와 VRAs는 함께 지정될 수 없다는 것에 유의한다. 캐쉬-오프 저장을 위해서 VSTDOFF를 이용한다.
설명
현재 또는 대체 뱅크로부터의 두개의 벡터 레지스터 또는 네개의 스칼라 레지스터를 저장한다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if(A==l)SRb=EA ;
MEM[EA]=see table below ;
Figure kpo10107
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSTQ Quad 저장
Figure kpo10108
어셈블러 구문
VSTQ.st Rs, SRb, SRi
VSTQ.st Rs, SRb, #IMM
VSTQ.st Rs, SRb+, SRi
VSTQ.st Rs, SRb+, #IMM
여기서 st={b, b9t, h, w, 4, 8, 16, 32, 64}, Rs={VRs, VRAs, SRs}. .b와 .b9t는 동일한 연산을 지정하고 .64와 VRAs는 함께 지정될 수 없다는 것에 유의한다. 캐쉬-오프 저장을 위해서는 VSTQOFF를 사용한다.
설명
연산
현재 또는 대체 뱅크로부터의 네개의 벡터 레지스터 또는 네개의 스칼라 레지스터를 저장한다.
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if(A==l)SRb=EA ;
MEM[EA]=see table below ;
Figure kpo10109
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSTR 반전 저장
Figure kpo10110
어셈블러 구문
VSTR.st Rs, SRb, SRi
VSTR.st Rs, SRb, #IMM
VSTR.st Rs, SRb+, SRi
VSTR.st Rs, SRb+, #IMM
여기서 st={4, 8, 16, 32, 64}, Rs={VRs, VRAs}. .64와 VRAs는 함께 지정될 수 없다는 것에 유의한다. 캐쉬-오프 저장을 위해서는 VSTROFF를 이용한다.
설명
연산
벡터 레지스터를 역 엘리먼트 순으로 저장한다. 이 명령은 스칼라 데이타 소스 레지스터를 지원하지 않는다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if(A==l)SRb=EA ;
MEM[EA]=see table below ;
Figure kpo10111
예외
무효 데이타 어드레스, 정렬되지 않은 액세스.
프로그래밍 주석
이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
VSTWS 스트라이드로 저장
Figure kpo10112
어셈블러 구문
VSTWS.st Rs, SRb, SRi
VSTWS.st Rs, SRb, #IMM
VSTWS.st Rs, SRb+, SRi
VSTWS.st Rs, SRb+, #IMM
여기서 st={8, 16, 32}, Rs={VRs, VRAs}. .64 모드는 지원되지 않는다-대신에 VST를 사용한다. 캐쉬-오프 저장을 위해서 VSTWSOFF를 이용한다.
설명
유효 어드레스에서 시작하여, 스칼라 레지스터 SRb+1를 스트라이드 제어 레지스터로서 사용하여 32바이트가 벡터 레지스터 VRs에서 메모리에 저장된다.
ST는 블럭 크기, 각 블럭에서 저장되는 연속하는 바이트의 수를 지정하고, SRb+1은 스트라이드, 두개의 연속하는 블럭의 시작을 분리하는 바이트의 수를 지정한다.
스크라이드는 블럭 크기와 같거나 커야 한다. EA는 데이타 크기가 정렬되어야 한다. 스트라이드와 블럭 크기는 복수의 데이타 크기 유형이어야 한다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if(A==l)SRb=EA ;
Block_size={4∥8∥16∥32} ;
Stride=SRb+1<31:0> ;
for(i=0 ; i<VECSIZE/Block_size ; i++)
for(j=0 ; j<Block_size ; j++)
BYTE[EA+i*Stride+j]=VRs[i*Block_size+j]<7:0> ;
예외
무효 데이타 어드레스, 정렬되지 않은 0액세스.
VSUB 뺄셈
Figure kpo10113
어셈블러 구문
VSUB.dt VRd, VRa, VRb
VSUB.dt VRd, VRa, SRb
VSUB.dt VRd, VRa, #IMM
VSUB.dt SRs, SRa, SRb
VSUB.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w, f}.
Figure kpo10114
설명
벡터/스칼라 레지스터 Rb의 내용이 벡터/스칼라 레지스터 Ra의 내용으로부터 감산되고, 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={Rb[i]∥SRb∥sex(IMM<8:0>)} ;
Rd[i]=Ra[i] Bop[i] ;
}
예외
오버플로우, 부동 소수점 무효 오퍼런드.
VSUBS 뺄셈과 세트
Figure kpo10115
어셈블러 구문
VSUBS.dt SRd, SRa, SRb
VSUBS.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w, f}.
Figure kpo10116
설명
SRb가 SRa로부터 감산되고 ; 결과가 SRd에 저장되고, VCSR에 있는 VFLAG 비트가 세트된다.
연산
Bop={SRb∥sex(IMM<8:0>)} ;
SRd=SRa-Bop ;
VCSR<lt,eq,gt>=status(SRa-Bop) ;
예외
오버플로우, 부동 소수점 무효 오퍼런드.
VUNSHFL 언셔플
Figure kpo10117
어셈블러 구문
VUNSHFL.dt VRc, VRd, VRa, VRb
VUNSHFL.dt VRc, VRd, VRa, SRb
여기서 dt={b, b9, h, w, f}. .w와 .f는 동일한 연산을 지정한다는 것에 유의한다.
Figure kpo10118
설명
벡터 레지스터 VRb의 내용이 이하에 도시된 바와 같이 벡터 레지스터 VRc : VRd으로 Rb와 언셔플된다.
Figure kpo10119
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VUNSHFLH 하이로 언셔플
Figure kpo10120
어셈블러 구문
VUNSHFLH.dt VRd, VRa, VRb
VUNSHFLH.dt VRd, VRa, SRb
여기서 dt={b, b9, h, w, f}. .w와 .f는 동일한 연산을 지정한다는 것에 유의한다.
Figure kpo10121
설명
벡터 레지스터 VRa의 내용이 Rb와 언셔플되고, 그 결과의 상부가 이하에 도시된 바와 같이 벡터 레지스터 VRd에 반환된다.
Figure kpo10122
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VUNSHFLL 로우로 언셔플
Figure kpo10123
어셈블러 구문
VUNSHFLL.dt VRd, VRa, VRb
VUNSHFLL.dt VRd, VRa, SRb
여기서 dt={b, b9, h, w, f}. .w와 .f는 동일한 연산을 지정한다는 것에 유의한다.
Figure kpo10124
설명
벡터 레지스터 VRa의 내용이 Rb와 언셔플되고, 그 결과의 하부가 이하에 도시된 바와 같이 벡터 레지스터 VRd로 반환된다.
Figure kpo10125
연산
예외
없음.
프로그래밍 주석
이 명령은 엘리먼트 마스크를 사용하지 않는다.
VWBACK 기록
Figure kpo10126
어셈블러 구문
VWBACK.ln SRb, SRi
VWBACK.ln SRb, #IMM
VWBACK.ln SRb+, SRi
VWBACK.ln SRb+, #IMM
여기서 ln={1, 2, 4, 8}.
설명
그 인덱스가 벡터 데이타 캐쉬에 있는 EA(그 태그가 EA와 일치하는 것에 반대되는 것으로)에 의해 지정된 캐쉬 라인은 만일 수정된 데이타를 포함하고 있으면 메모리에 갱신된다. 만일 하나 이상의 캐쉬 라인이 지정되어 있으면, 다음의 순차적인 캐쉬 라인이 수정된 데이타를 포함하면 메모리에 갱신된다. 캐쉬 라인의 수는 다음과 같이 지정된다 :
LN〈1:0〉=00: 1 64 바이트 캐쉬 라인이 기록된다.
LN〈1:0〉=01: 2 64 바이트 캐쉬 라인이 기록된다.
LN〈1:0〉=10: 4 64 바이트 캐쉬 라인이 기록된다.
LN〈1:0〉=11: 8 64 바이트 캐쉬 라인이 기록된다.
만일 유효 어드레스가 64바이트 경계상에 있지 않으면, 먼저 64바이트 경계로 정렬되도록 트렁케이트된다.
연산
예외
무효 데이타 어드레스 예외.
프로그래밍 주석
EA〈31:0〉는 국부 메모리에 있는 바이트를 지칭한다.
VWBACKSP 스크래치 패드로부터 기록
Figure kpo10127
어셈블러 구문
VWBACKSP.ln SRp, SRb, SRi
VWBACKSP.ln SRp, SRb, #IMM
VWBACKSP.ln SRp, SRb+, SRi
VWBACKSP.ln SRp, SRb+, #IMM
여기서 ln={1, 2, 4, 8}. VWBACK와 VWBACKSP는 동일한 오피코드를 사용한다는 것에 유의한다.
설명
스크래치 패드에서 메모리로 복수의 64 바이트 블럭을 전송한다. 유효 어드레스는 메모리에 시작 어드레스를 제공하고 SRp는 스크래치 패드에 시작 어드레스를 제공한다. 64 바이트 블럭의 수는 다음과 같이 지정된다 :
LN〈1:0〉00: 1 64 블럭이 전송된다.
LN〈1:0〉01: 2 64 블럭이 전송된다.
LN〈1:0〉10: 4 64 블럭이 전송된다.
LN〈1:0〉11: 8 64 블럭이 전송된다.
만일 유효 어드레스가 64 바이트 경계상에 있지 않으면, 먼저 64 바이트 경계로 정렬되도록 트렁케이트된다. 만일 SRp에 있는 스크래치 패드 포인터 어드레스가 64 바이트 경계상에 있지 않으면, 이도 역시 64 바이트 경계로 정렬되도록 트렁케이트된다. 상기 정렬된 스크래치 패드 포인터 어드레스는 전송된 바이트의 수만큼 증가된다.
연산
EA=SRb+{SRi∥sex(IMM<7:0>)} ;
if(A==l)SRb=EA ;
Num_bytes={64∥128∥256∥512} ;
Mem_adrs=EA<31:6> : 6b'000000 ;
SRp=SRp<31:6> : 6b'000000 ;
for(i=0 ; i<Num_bytes ; i++)
SPAD[SRp++]=MEM[Mem_adrs+i] ;
예외
무효 데이타 어드레스 예외.
프로그래밍 주석
EA〈31:0〉는 국부 메모리에 있는 바이트를 지칭한다.
VXNOR XNOR(익스클루시브 NOR)
Figure kpo10128
어셈블러 구문
VXNOR.dt VRd, VRa, VRb
VXNOR.dt VRd, VRa, SRb
VXNOR.dt VRd, VRa, #IMM
VXNOR.dt SRd, SRa, SRb
VXNOR.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}.
Figure kpo10129
설명
벡터/스칼라 레지스터 Ra의 내용이 벡터/스칼라 레지스터 Rb의 내용에 논리적으로 XNOR되고, 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)} ;
Rd[i]<k>=-(Ra[i]<k>^Bop<k>), for k=all bits in element i ;
}
예외
없음.
VXOR XOR(익스클루시브 OR)
Figure kpo10130
어셈블러 구문
VXOR.dt VRd, VRa, VRb
VXOR.dt VRd, VRa, SRb
VXOR.dt VRd, VRa, #IMM
VXOR.dt SRd, SRa, SRb
VXOR.dt SRd, SRa, #IMM
여기서 dt={b, b9, h, w}.
Figure kpo10131
설명
벡터/스칼라 레지스터 Ra의 내용이 벡터/스칼라 레지스터 Rb의 내용에 논리적으로 XOR되고 결과가 벡터/스칼라 레지스터 Rd에 저장된다.
연산
for(i=0 ; i<NumElem && EMASK[i] ; i++){
Bop[i]={VRb[i]∥SRb∥sex(IMM<8:0>)};
Rd[i]<k>=Ra[i]<k>^Bop[i]<k>, for k=all bits in element i ;
}
예외
없음.
VXORALL 모든 엘리먼트의 XOR(익스클루시브 OR)
Figure kpo10132
어셈블러 구문
VXORALL.dt SRd, VRd
여기서 dt={b, b9, h, w}. .b와 .b9는 동일한 연산을 지칭한다는 것에 유의한다.
Figure kpo10133
설명
VRb에 있는 각 엘리먼트의 최하위 비트가 함께 XOR되고, 1 비트 결과가 SRd의 최하위 비트에서 반환된다. 이 명령은 엘리먼트 마스크에 의한 영향을 받지 않는다.
연산
예외
없음.

Claims (8)

  1. 벡터 프로세서에 있어서, 벡터 레지스터들의 제1뱅크, 벡터 레지스터들의 제2뱅크, 디폴트 뱅크 필드를 포함하는 컨트롤 레지스터, 및 벡터 레지스터들의 상기 제1 및 제2뱅크들을 위한 선택회로,를 구비하고 ; 상기 제1뱅크내의 각각의 벡터 레지스터는, 상기 제1뱅크내의 다른 벡터 레지스터들에 할당된 레지스터 번호와 구별되는, 레지스터 번호가 할당되며 ; 상기 제2뱅크내의 각각의 벡터 레지스터는, 상기 제2뱅크내의 다른 벡터 레지스터들에 할당된 레지스터 번호와는 구별되면서 상기 제1뱅크내의 대응되는 벡터 레지스터에 할당된 레지스터 번호와는 동일한, 레지스터 번호가 할당되고 ; 상기 선택회로는 제1모드에서 작동되어, 상기 벡터 프로세서에 의해 실행되는 명령으로부터의 레지스터 번호와 상기 디폴트 뱅크 필드로부터의 값의 조합에 의해 식별되는, 벡터 레지스터에 억세스가능하게 되는 것을 특징으로 하는 벡터 프로세서.
  2. 제1항에 있어서, 상기 선택회로가 제2모드에서 작동되어 상기 제1뱅크로부터의 제1벡터 레지스터 및 상기 제2뱅크로부터의 제2벡터 레지스터에 억세스 가능하게 되며 ; 상기 제1 및 제2벡터 레지스터들은 상기 벡터 프로세서에 의해 실행되는 명령으로부터 레지스터 번호가 할당되고, 제1 및 제2레지스터의 조합체는 상기 제1벡터 레지스터에 저장될 수 있는 벡터값보다 큰 벡터값을 위해 사용되는 것을 특징으로 하는 벡터 프로세서.
  3. 제2항에 있어서, 상기 선택회로가 제3모드에서 작동되어, 상기 벡터 프로세서에 의해 실행되는 명령으로부터의 레지스터 번호 및 뱅크값의 조합에 의해 식별되는, 벡터 레지스터에 억세스가능하게 되는 것을 특징으로 하는 벡터 프로세서.
  4. 제1항에 있어서, 상기 선택회로가 제2모드에서 작동되어, 상기 벡터 프로세서에 의해 실행되는 명령으로부터의 레지스터 번호 및 뱅크값의 조합에 의해 식별되는, 벡터 레지스터에 억세스가능하게 되는 것을 특징으로 하는 벡터 프로세서.
  5. 제4항에 있어서, 상기 선택회로가 벡터량들에 대해 수행하는 논리연산들을 나타내는 명령들을 위해 제1모드에서 작동 가능하게 되며, 로드/저장 연산들을 위해 제2모드에서 작동가능하게 되는 것을 특징으로 하는 벡터 프로세서.
  6. 벡터 프로세서를 작동시키기 위한 방법에 있어서, 제1뱅크 내의 각각의 벡터 레지스터들에 대해 할당된 레지스터 번호가 상기 제1뱅크 내의 다른 벡터 레지스터들에 할당된 레지스터 번호들과는 구별되도록, 제1뱅크 내의 벡터 레지스터들에 레지스터 번호를 할당하는 단계 ; 제2뱅크 내의 각각의 벡터 레지스터들에 대해 할당된 레지스터 번호가 상기 제2뱅크내의 다른 벡터 레지스터들에 할당된 레지스터 번호들과는 구별되고 상기 제1뱅크내의 대응되는 벡터 레지스터에 할당된 레지스터 번호와는 동일하게 되도록, 제2뱅크내의 벡터 레지스터들에 레지스터 번호를 할당하는 단계 ; 레지스터 번호를 포함하는 명령을 형성하는 단계 ; 및 상기 명령에 포함된 레지스터 번호가 할당되고 상기 벡터 프로세서의 컨트롤 레지스터의 필드에 의해 지시되는 뱅크 내에 있는, 벡터 레지스터에 억세스하는 과정을 포함하는 방식으로 상기 명령을 실행하는 단계 ; 를 구비하는 것을 특징으로 하는 벡터 프로세서를 작동시키기 위한 방법.
  7. 제6항에 있어서, 레지스터 번호를 포함하는 제2의 명령을 형성하는 단계 ; 및 레지스터 번호가 할당되고 상기 제1뱅크 내에 있게 되는 벡터 레지스터에 억세스하는 과정 및 레지스터 번호가 할당되고 상기 제2뱅크 내에 있게 되는 벡터 레지스터에 억세스하는 과정을 포함하는 방식으로, 상기 제2명령을 실행하는 단계;를 추가로 구비하는 것을 특징으로 하는 벡터 프로세서를 작동시키기 위한 방법.
  8. 제7항에 있어서, 제1 및 제2벡터 레지스터들에 억세스하는 상기 과정이, 상기 제1벡터 레지스터내에 저장된 제1세트의 데이타 엘리먼트들 및 상기 제2벡터 레지스터 내에 저장된 제2세트의 데이타 엘리먼트들을 갖는 단일 벡터를 처리하는 과정을 포함하는 것을 특징으로 하는 벡터 프로세서를 작동시키기 위한 방법.
KR1019970012770A 1996-08-19 1997-04-07 벡터 레지스터의 복수 뱅크를 사용한 단일 명령복수 데이터 처 리 KR100236527B1 (ko)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
US08/697,086 US5838984A (en) 1996-08-19 1996-08-19 Single-instruction-multiple-data processing using multiple banks of vector registers
US8/697,086 1996-08-19

Publications (2)

Publication Number Publication Date
KR19980018072A KR19980018072A (ko) 1998-06-05
KR100236527B1 true KR100236527B1 (ko) 1999-12-15

Family

ID=24799731

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1019970012770A KR100236527B1 (ko) 1996-08-19 1997-04-07 벡터 레지스터의 복수 뱅크를 사용한 단일 명령복수 데이터 처 리

Country Status (7)

Country Link
US (1) US5838984A (ko)
JP (1) JP3983857B2 (ko)
KR (1) KR100236527B1 (ko)
CN (1) CN1117316C (ko)
DE (1) DE19735348B4 (ko)
FR (1) FR2752965B1 (ko)
TW (1) TW345650B (ko)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9122474B2 (en) 2011-11-15 2015-09-01 Samsung Electronics Co., Ltd. Apparatus and method for reducing overhead caused by communication between clusters

Families Citing this family (131)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6643765B1 (en) 1995-08-16 2003-11-04 Microunity Systems Engineering, Inc. Programmable processor with group floating point operations
US5961631A (en) * 1997-07-16 1999-10-05 Arm Limited Data processing apparatus and method for pre-fetching an instruction in to an instruction cache
US5864703A (en) * 1997-10-09 1999-01-26 Mips Technologies, Inc. Method for providing extended precision in SIMD vector arithmetic operations
US7197625B1 (en) 1997-10-09 2007-03-27 Mips Technologies, Inc. Alignment and ordering of vector elements for single instruction multiple data processing
US6230259B1 (en) 1997-10-31 2001-05-08 Advanced Micro Devices, Inc. Transparent extended state save
US6157996A (en) * 1997-11-13 2000-12-05 Advanced Micro Devices, Inc. Processor programably configurable to execute enhanced variable byte length instructions including predicated execution, three operand addressing, and increased register space
US6334176B1 (en) * 1998-04-17 2001-12-25 Motorola, Inc. Method and apparatus for generating an alignment control vector
US6282634B1 (en) * 1998-05-27 2001-08-28 Arm Limited Apparatus and method for processing data having a mixed vector/scalar register file
US6862563B1 (en) 1998-10-14 2005-03-01 Arc International Method and apparatus for managing the configuration and functionality of a semiconductor design
US20060168431A1 (en) * 1998-10-14 2006-07-27 Peter Warnes Method and apparatus for jump delay slot control in a pipelined processor
US7308559B2 (en) * 2000-02-29 2007-12-11 International Business Machines Corporation Digital signal processor with cascaded SIMD organization
WO2001069411A2 (en) 2000-03-10 2001-09-20 Arc International Plc Memory interface and method of interfacing between functional entities
JP3940542B2 (ja) * 2000-03-13 2007-07-04 株式会社ルネサステクノロジ データプロセッサ及びデータ処理システム
JP2001283413A (ja) * 2000-03-29 2001-10-12 Tdk Corp スピンバルブ膜の製造方法
US6857061B1 (en) * 2000-04-07 2005-02-15 Nintendo Co., Ltd. Method and apparatus for obtaining a scalar value directly from a vector register
US6877084B1 (en) 2000-08-09 2005-04-05 Advanced Micro Devices, Inc. Central processing unit (CPU) accessing an extended register set in an extended register mode
US6981132B2 (en) 2000-08-09 2005-12-27 Advanced Micro Devices, Inc. Uniform register addressing using prefix byte
US7155601B2 (en) * 2001-02-14 2006-12-26 Intel Corporation Multi-element operand sub-portion shuffle instruction execution
US7711763B2 (en) 2001-02-21 2010-05-04 Mips Technologies, Inc. Microprocessor instructions for performing polynomial arithmetic operations
US7181484B2 (en) * 2001-02-21 2007-02-20 Mips Technologies, Inc. Extended-precision accumulation of multiplier output
US7162621B2 (en) 2001-02-21 2007-01-09 Mips Technologies, Inc. Virtual instruction expansion based on template and parameter selector information specifying sign-extension or concentration
US7599981B2 (en) * 2001-02-21 2009-10-06 Mips Technologies, Inc. Binary polynomial multiplier
US7039060B2 (en) * 2001-03-07 2006-05-02 Mips Tech Inc System and method for extracting fields from packets having fields spread over more than one register
US7127593B2 (en) * 2001-06-11 2006-10-24 Broadcom Corporation Conditional execution with multiple destination stores
US6986025B2 (en) * 2001-06-11 2006-01-10 Broadcom Corporation Conditional execution per lane
US7861071B2 (en) * 2001-06-11 2010-12-28 Broadcom Corporation Conditional branch instruction capable of testing a plurality of indicators in a predicate register
US7685212B2 (en) * 2001-10-29 2010-03-23 Intel Corporation Fast full search motion estimation with SIMD merge instruction
US7818356B2 (en) 2001-10-29 2010-10-19 Intel Corporation Bitstream buffer manipulation with a SIMD merge instruction
US7739319B2 (en) * 2001-10-29 2010-06-15 Intel Corporation Method and apparatus for parallel table lookup using SIMD instructions
US20040054877A1 (en) 2001-10-29 2004-03-18 Macy William W. Method and apparatus for shuffling data
US7624138B2 (en) 2001-10-29 2009-11-24 Intel Corporation Method and apparatus for efficient integer transform
US7725521B2 (en) * 2001-10-29 2010-05-25 Intel Corporation Method and apparatus for computing matrix transformations
US7631025B2 (en) * 2001-10-29 2009-12-08 Intel Corporation Method and apparatus for rearranging data between multiple registers
US20100274988A1 (en) * 2002-02-04 2010-10-28 Mimar Tibet Flexible vector modes of operation for SIMD processor
US20030231660A1 (en) * 2002-06-14 2003-12-18 Bapiraju Vinnakota Bit-manipulation instructions for packet processing
US7793084B1 (en) 2002-07-22 2010-09-07 Mimar Tibet Efficient handling of vector high-level language conditional constructs in a SIMD processor
WO2004015563A1 (en) * 2002-08-09 2004-02-19 Intel Corporation Multimedia coprocessor control mechanism including alignment or broadcast instructions
US6986023B2 (en) * 2002-08-09 2006-01-10 Intel Corporation Conditional execution of coprocessor instruction based on main processor arithmetic flags
US7392368B2 (en) * 2002-08-09 2008-06-24 Marvell International Ltd. Cross multiply and add instruction and multiply and subtract instruction SIMD execution on real and imaginary components of a plurality of complex data elements
GB2394571B (en) * 2002-10-23 2005-08-10 Motorola Inc Arrangement system and method for vector permutation in single-instruction multiple-data microprocessors
JP2004302647A (ja) * 2003-03-28 2004-10-28 Seiko Epson Corp ベクトルプロセッサおよびレジスタのアドレス指定方法
US20040215924A1 (en) * 2003-04-28 2004-10-28 Collard Jean-Francois C. Analyzing stored data
US7610466B2 (en) * 2003-09-05 2009-10-27 Freescale Semiconductor, Inc. Data processing system using independent memory and register operand size specifiers and method thereof
US7275148B2 (en) * 2003-09-08 2007-09-25 Freescale Semiconductor, Inc. Data processing system using multiple addressing modes for SIMD operations and method thereof
US7315932B2 (en) 2003-09-08 2008-01-01 Moyer William C Data processing system having instruction specifiers for SIMD register operands and method thereof
GB2409067B (en) * 2003-12-09 2006-12-13 Advanced Risc Mach Ltd Endianess compensation within a SIMD data processing system
GB2411976B (en) * 2003-12-09 2006-07-19 Advanced Risc Mach Ltd A data processing apparatus and method for moving data between registers and memory
GB2409066B (en) * 2003-12-09 2006-09-27 Advanced Risc Mach Ltd A data processing apparatus and method for moving data between registers and memory
GB2409064B (en) * 2003-12-09 2006-09-13 Advanced Risc Mach Ltd A data processing apparatus and method for performing in parallel a data processing operation on data elements
GB2411975B (en) * 2003-12-09 2006-10-04 Advanced Risc Mach Ltd Data processing apparatus and method for performing arithmetic operations in SIMD data processing
GB2409059B (en) * 2003-12-09 2006-09-27 Advanced Risc Mach Ltd A data processing apparatus and method for moving data between registers and memory
GB2409065B (en) * 2003-12-09 2006-10-25 Advanced Risc Mach Ltd Multiplexing operations in SIMD processing
GB2409061B (en) * 2003-12-09 2006-09-13 Advanced Risc Mach Ltd Table lookup operation within a data processing system
GB2411974C (en) * 2003-12-09 2009-09-23 Advanced Risc Mach Ltd Data shift operations
GB2409068A (en) * 2003-12-09 2005-06-15 Advanced Risc Mach Ltd Data element size control within parallel lanes of processing
GB2411973B (en) * 2003-12-09 2006-09-27 Advanced Risc Mach Ltd Constant generation in SMD processing
GB2409063B (en) * 2003-12-09 2006-07-12 Advanced Risc Mach Ltd Vector by scalar operations
GB2409062C (en) * 2003-12-09 2007-12-11 Advanced Risc Mach Ltd Aliasing data processing registers
GB2409060B (en) * 2003-12-09 2006-08-09 Advanced Risc Mach Ltd Moving data between registers of different register data stores
GB2410097B (en) * 2004-01-13 2006-11-01 Advanced Risc Mach Ltd A data processing apparatus and method for performing data processing operations on floating point data elements
GB2411978B (en) * 2004-03-10 2007-04-04 Advanced Risc Mach Ltd Inserting bits within a data word
US7302627B1 (en) * 2004-04-05 2007-11-27 Mimar Tibet Apparatus for efficient LFSR calculation in a SIMD processor
US7873812B1 (en) 2004-04-05 2011-01-18 Tibet MIMAR Method and system for efficient matrix multiplication in a SIMD processor architecture
US7493481B1 (en) * 2004-05-17 2009-02-17 Netxen, Inc. Direct hardware processing of internal data structure fields
US9557994B2 (en) 2004-07-13 2017-01-31 Arm Limited Data processing apparatus and method for performing N-way interleaving and de-interleaving operations where N is an odd plural number
US20060070042A1 (en) * 2004-09-24 2006-03-30 Muratori Richard D Automatic clocking in shared-memory co-simulation
US20060179265A1 (en) * 2005-02-08 2006-08-10 Flood Rachel M Systems and methods for executing x-form instructions
US20060218377A1 (en) * 2005-03-24 2006-09-28 Stexar Corporation Instruction with dual-use source providing both an operand value and a control value
US7933405B2 (en) * 2005-04-08 2011-04-26 Icera Inc. Data access and permute unit
US7421566B2 (en) 2005-08-12 2008-09-02 International Business Machines Corporation Implementing instruction set architectures with non-contiguous register file specifiers
US20070038984A1 (en) 2005-08-12 2007-02-15 Gschwind Michael K Methods for generating code for an architecture encoding an extended register specification
US7734897B2 (en) * 2005-12-21 2010-06-08 Arm Limited Allocation of memory access operations to memory access capable pipelines in a superscalar data processing apparatus and method having a plurality of execution threads
US20070283129A1 (en) * 2005-12-28 2007-12-06 Stephan Jourdan Vector length tracking mechanism
US7565514B2 (en) * 2006-04-28 2009-07-21 Freescale Semiconductor, Inc. Parallel condition code generation for SIMD operations
US7958181B2 (en) 2006-09-21 2011-06-07 Intel Corporation Method and apparatus for performing logical compare operations
US9223751B2 (en) * 2006-09-22 2015-12-29 Intel Corporation Performing rounding operations responsive to an instruction
US8127113B1 (en) 2006-12-01 2012-02-28 Synopsys, Inc. Generating hardware accelerators and processor offloads
US20090300324A1 (en) * 2007-01-19 2009-12-03 Nec Corporation Array type processor and data processing system
US20080229062A1 (en) * 2007-03-12 2008-09-18 Lorenzo Di Gregorio Method of sharing registers in a processor and processor
US8095735B2 (en) * 2008-08-05 2012-01-10 Convey Computer Memory interleave for heterogeneous computing
US9710384B2 (en) * 2008-01-04 2017-07-18 Micron Technology, Inc. Microprocessor architecture having alternative memory access paths
US8561037B2 (en) 2007-08-29 2013-10-15 Convey Computer Compiler for generating an executable comprising instructions for a plurality of different instruction sets
US8156307B2 (en) * 2007-08-20 2012-04-10 Convey Computer Multi-processor system having at least one processor that comprises a dynamically reconfigurable instruction set
US8122229B2 (en) * 2007-09-12 2012-02-21 Convey Computer Dispatch mechanism for dispatching instructions from a host processor to a co-processor
US9015399B2 (en) 2007-08-20 2015-04-21 Convey Computer Multiple data channel memory module architecture
CN101377735B (zh) * 2007-08-28 2011-09-28 凌阳科技股份有限公司 于多模处理器中以串行位决定指令长度的装置及方法
US8078836B2 (en) 2007-12-30 2011-12-13 Intel Corporation Vector shuffle instructions operating on multiple lanes each having a plurality of data elements using a common set of per-lane control bits
US8205066B2 (en) * 2008-10-31 2012-06-19 Convey Computer Dynamically configured coprocessor for different extended instruction set personality specific to application program with shared memory storing instructions invisibly dispatched from host processor
US20100115233A1 (en) * 2008-10-31 2010-05-06 Convey Computer Dynamically-selectable vector register partitioning
US8423745B1 (en) 2009-11-16 2013-04-16 Convey Computer Systems and methods for mapping a neighborhood of data to general registers of a processing element
US8434074B2 (en) * 2010-02-24 2013-04-30 Intel Corporation Register allocation with SIMD architecture using write masks
KR20110103256A (ko) * 2010-03-12 2011-09-20 삼성전자주식회사 다중 입출력 오퍼레이션 지원 프로세서 및 그 방법
US20120185670A1 (en) * 2011-01-14 2012-07-19 Toll Bret L Scalar integer instructions capable of execution with three registers
US9128701B2 (en) * 2011-04-07 2015-09-08 Via Technologies, Inc. Generating constant for microinstructions from modified immediate field during instruction translation
KR20120134549A (ko) 2011-06-02 2012-12-12 삼성전자주식회사 Ｓｉｍｄ 프로세서를 이용한 병렬 연산 처리 장치 및 방법
US9804844B2 (en) 2011-09-26 2017-10-31 Intel Corporation Instruction and logic to provide stride-based vector load-op functionality with mask duplication
US9424042B2 (en) * 2011-12-06 2016-08-23 Intel Corporation System, apparatus and method for translating vector instructions
US9898283B2 (en) * 2011-12-22 2018-02-20 Intel Corporation Processors, methods, systems, and instructions to generate sequences of integers in which integers in consecutive positions differ by a constant integer stride and where a smallest integer is offset from zero by an integer offset
WO2013095634A1 (en) * 2011-12-23 2013-06-27 Intel Corporation Systems, apparatuses, and methods for performing a horizontal partial sum in response to a single instruction
US9792115B2 (en) 2011-12-23 2017-10-17 Intel Corporation Super multiply add (super MADD) instructions with three scalar terms
CN107102844B (zh) * 2011-12-23 2021-06-08 英特尔公司 超级乘加（超级madd）指令
US9465612B2 (en) 2011-12-28 2016-10-11 Intel Corporation Systems, apparatuses, and methods for performing delta encoding on packed data elements
WO2013100989A1 (en) 2011-12-28 2013-07-04 Intel Corporation Systems, apparatuses, and methods for performing delta decoding on packed data elements
WO2013101232A1 (en) 2011-12-30 2013-07-04 Intel Corporation Packed rotate processors, methods, systems, and instructions
US10289412B2 (en) * 2012-02-09 2019-05-14 Qualcomm Incorporated Floating point constant generation instruction
EP2856303B1 (en) * 2012-05-30 2017-08-02 Intel Corporation Vector and scalar based modular exponentiation
US10430190B2 (en) 2012-06-07 2019-10-01 Micron Technology, Inc. Systems and methods for selectively controlling multithreaded execution of executable code segments
CN102819692A (zh) * 2012-08-10 2012-12-12 上海交通大学 基于fpga的rna二级结构预测装置、系统及其实现方法
CN102930008B (zh) * 2012-10-29 2015-10-07 无锡江南计算技术研究所 向量查表方法
US9639371B2 (en) * 2013-01-29 2017-05-02 Advanced Micro Devices, Inc. Solution to divergent branches in a SIMD core using hardware pointers
CN104375803B (zh) * 2013-08-13 2017-10-24 华为技术有限公司 一种数据处理的方法及装置
CN104461939A (zh) * 2014-12-16 2015-03-25 清华大学 扩展处理器寄存器堆容量的方法
US10296489B2 (en) * 2014-12-27 2019-05-21 Intel Corporation Method and apparatus for performing a vector bit shuffle
US10296334B2 (en) * 2014-12-27 2019-05-21 Intel Corporation Method and apparatus for performing a vector bit gather
US10503502B2 (en) * 2015-09-25 2019-12-10 Intel Corporation Data element rearrangement, processors, methods, systems, and instructions
GB2543303B (en) * 2015-10-14 2017-12-27 Advanced Risc Mach Ltd Vector data transfer instruction
US9733899B2 (en) * 2015-11-12 2017-08-15 Arm Limited Lane position information for processing of vector
US10152321B2 (en) * 2015-12-18 2018-12-11 Intel Corporation Instructions and logic for blend and permute operation sequences
US20170177350A1 (en) * 2015-12-18 2017-06-22 Intel Corporation Instructions and Logic for Set-Multiple-Vector-Elements Operations
CN111176608A (zh) * 2016-04-26 2020-05-19 中科寒武纪科技股份有限公司 一种用于执行向量比较运算的装置和方法
CN111651202B (zh) * 2016-04-26 2023-09-22 中科寒武纪科技股份有限公司 一种用于执行向量逻辑运算的装置
CN108009976A (zh) * 2016-10-27 2018-05-08 超威半导体公司 用于图形处理单元(gpu)计算的超级单指令多数据(超级simd)
US10216479B2 (en) * 2016-12-06 2019-02-26 Arm Limited Apparatus and method for performing arithmetic operations to accumulate floating-point numbers
EP3747167B1 (en) * 2018-02-19 2022-08-31 Huawei Technologies Co., Ltd. Multi-cloud vpc routing and registration
JP7296574B2 (ja) * 2019-03-04 2023-06-23 パナソニックＩｐマネジメント株式会社 プロセッサ及びプロセッサの制御方法
US11132198B2 (en) 2019-08-29 2021-09-28 International Business Machines Corporation Instruction handling for accumulation of register results in a microprocessor
CN110727412B (zh) * 2019-09-14 2022-01-07 无锡江南计算技术研究所 一种基于掩码的混合浮点乘法低功耗控制方法及装置
US11551148B2 (en) * 2020-04-29 2023-01-10 Marvell Asia Pte Ltd System and method for INT9 quantization
CN112230995B (zh) * 2020-10-13 2024-04-09 广东省新一代通信与网络创新研究院 一种指令的生成方法、装置以及电子设备
CN113064841B (zh) * 2021-01-04 2023-06-06 统信软件技术有限公司 一种数据存储方法、处理方法、计算设备及可读存储介质
CN115794671B (zh) * 2023-02-07 2023-04-14 成都申威科技有限责任公司 一种兼容向量数据的访存系统及方法

Family Cites Families (13)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPS59160267A (ja) * 1983-03-02 1984-09-10 Hitachi Ltd ベクトル処理装置
US4791555A (en) * 1983-10-24 1988-12-13 International Business Machines Corporation Vector processing unit
JPH0648486B2 (ja) * 1986-10-08 1994-06-22 日本電気株式会社 ベクトルデ−タ処理装置
JP2679994B2 (ja) * 1987-08-14 1997-11-19 株式会社日立製作所 ベクトル処理装置
JP2941817B2 (ja) * 1988-09-14 1999-08-30 株式会社日立製作所 ベクトル処理装置
US5226142A (en) * 1990-11-21 1993-07-06 Ross Technology, Inc. High performance register file with overlapping windows
US5493687A (en) * 1991-07-08 1996-02-20 Seiko Epson Corporation RISC microprocessor architecture implementing multiple typed register sets
US5438669A (en) * 1991-11-20 1995-08-01 Hitachi, Ltd. Data processor with improved loop handling utilizing improved register allocation
JP2823767B2 (ja) * 1992-02-03 1998-11-11 松下電器産業株式会社 レジスタファイル
JPH06274528A (ja) * 1993-03-18 1994-09-30 Fujitsu Ltd ベクトル演算処理装置
JP2883784B2 (ja) * 1993-04-27 1999-04-19 株式会社東芝 マイクロコンピュータ
US5669013A (en) * 1993-10-05 1997-09-16 Fujitsu Limited System for transferring M elements X times and transferring N elements one time for an array that is X*M+N long responsive to vector type instructions
WO1995032466A1 (en) * 1994-05-19 1995-11-30 Vlsi Technology, Inc. Flexible register mapping scheme

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9122474B2 (en) 2011-11-15 2015-09-01 Samsung Electronics Co., Ltd. Apparatus and method for reducing overhead caused by communication between clusters
KR101783312B1 (ko) * 2011-11-15 2017-10-10 삼성전자주식회사 클러스터 간의 통신으로 인한 오버헤드를 최소화하는 장치 및 방법

Also Published As

Publication number Publication date
DE19735348A1 (de) 1998-03-12
JPH10116268A (ja) 1998-05-06
DE19735348B4 (de) 2006-10-05
JP3983857B2 (ja) 2007-09-26
CN1174353A (zh) 1998-02-25
KR19980018072A (ko) 1998-06-05
FR2752965A1 (fr) 1998-03-06
TW345650B (en) 1998-11-21
FR2752965B1 (fr) 2004-09-24
US5838984A (en) 1998-11-17
CN1117316C (zh) 2003-08-06

Similar Documents

Publication Publication Date Title
KR100236527B1 (ko) 벡터 레지스터의 복수 뱅크를 사용한 단일 명령복수 데이터 처 리
US6058465A (en) Single-instruction-multiple-data processing in a multimedia signal processor
EP0901071B1 (en) Methods for interfacing a processor to a coprocessor
EP0927393B1 (en) Digital signal processing integrated circuit architecture
EP1010065B1 (en) Coprocessor data access control
JP2931890B2 (ja) データ処理装置
US5983336A (en) Method and apparatus for packing and unpacking wide instruction word using pointers and masks to shift word syllables to designated execution units groups
US5969975A (en) Data processing apparatus registers
JP2001202245A (ja) 改良式命令セットアーキテクチャを有するマイクロプロセッサ
KR20100017744A (ko) 콤팩트 명령 세트 인코딩
KR20050010800A (ko) 확장가능한 프로세서 아키텍처에 진보된 명령어들을부가하는 방법 및 장치
CN101802779A (zh) 具有可重新组构的浮点单元的处理器
US5983338A (en) Method and apparatus for interfacing a processor to a coprocessor for communicating register write information
KR100267089B1 (ko) 스칼라/벡터연산이조합된단일명령복수데이터처리
GB2402764A (en) Instruction endcoding within a data processing apparatus having multiple instruction sets
US20020138712A1 (en) Data processing device with instruction translator and memory interface device
JPH1165839A (ja) プロセッサの命令制御機構
KR100267092B1 (ko) 멀티미디어신호프로세서의단일명령다중데이터처리
US6925548B2 (en) Data processor assigning the same operation code to multiple operations
EP0927390B1 (en) Processing of conditional select and move instructions
US7024540B2 (en) Methods and apparatus for establishing port priority functions in a VLIW processor
KR20000048529A (ko) 데이터 처리장치의 레지스터 제어
KR20000048530A (ko) 데이터 처리장치 레지스터

Legal Events

Date Code Title Description
A201 Request for examination
E701 Decision to grant or registration of patent right
GRNT Written decision to grant
FPAY Annual fee payment

Payment date: 20120925

Year of fee payment: 14

FPAY Annual fee payment

Payment date: 20130930

Year of fee payment: 15

FPAY Annual fee payment

Payment date: 20141001

Year of fee payment: 16

FPAY Annual fee payment

Payment date: 20151001

Year of fee payment: 17

LAPS Lapse due to unpaid annual fee