KR20090045026A

KR20090045026A - 중첩 루프 및 프로그래밍 도구를 위한 재구성가능 코프로세서 아키텍처 템플릿

Info

Publication number: KR20090045026A
Application number: KR1020080104875A
Authority: KR
Inventors: 드 수자 호세 테세이라; 곤칼베스 마틴스 빅터 마누엘; 코레이아 로렌코 누노 칼라도; 디아스 산투스 알렉산더 미구엘; 도 로사리오 리베이로 넬슨 곤칼로
Original assignee: 코어윅스, 에스.에이.
Priority date: 2007-10-30
Filing date: 2008-10-24
Publication date: 2009-05-07
Also published as: US8276120B2; EP2056211A3; JP2010044731A; EP2056211B1; JP5419419B2; US20090113405A1; EP2056211A2

Abstract

제안된 템플릿으로부터 도출된 아키텍처들은 제네릭 시스템 온 칩(SoC)에 통합되고 바디들이 기능유닛 어레이에서 병렬로 수행되는 연산들의 표현들인 중첩 프로그램 루프를 실행하기 위해 재구성가능 코프로세서들로 구성된다. 데이터 어레이들은 하나 이상의 시스템 입력들로부터 그리고 내장 메모리 어레이로부터 병렬로 액세스된다. 처리된 데이터 어레이들은 다시 메모리 어레이에 혹은 시스템 출력들에 보내진다. 아키텍처들은 단지 하나의 연산 혹은 자료 액세스가 한번에 수행될 수 있는 표준 프로세서 상에서 실행에 비해 중첩 루프들을 가속화할 수 있게 한다. 발명은 특히, 멀티미디어 및 통신과 같은 디지털 신호 처리를 수반하는 다수의 애플리케이션들에서 사용될 수 있다. 아키텍처들은 바람직하게는 제어 흐름을 구현하는데 더 나은 폰 뉴만 프로세서들에 관련하여 사용된다. 아키텍처들은 데이터 스트림 입력들, 출력들, 내장 메모리들, 기능유닛들 및 구성 레지스터들의 수에서 쉽게 확장될 수 있다. 계산 시스템은 몇몇의 범용 프로세서들 및 이 아키텍처 템플릿로부터 도출되는 몇몇의 코프로세서들을 수반할 수 있다. 코프로세서들은 동기적으로, 혹은 비동기 선입선출 메모리들(FIFOs)을 사용하여 연결되어, 전역적으로는 비동기이고 국부적으로는 동기되는 시스템을 형성한다. 각각의 코프로세서는 원 프로그램에 중첩 루프들을 태그하고 재작성함으로써 프로그램될 수 있다. 프로그래밍 도구는 각각의 중첩 루프 그룹마다 코프로세서 구성을 생성하는데, 이것은 코프로세서 입력/출력 연산들 및 제어와 함께 원 코드에 자동으로 대체된다.

Description

중첩 루프 및 프로그래밍 도구를 위한 재구성가능 코프로세서 아키텍처 템플릿{RECONFIGURABLE COPROCESSOR ARCHITECTURE TEMPLATE FOR NESTED LOOPS AND PROGRAMMING TOOL}

본 발명은 일반적으로 컴퓨터 아키텍처에 관한 것으로, 특히 알고리즘들에서 중첩 루프들의 가속화에 관한 것이다.

계산장치들이 편재해지고 있고 많은 전자장치들이 이제 사람들의 일상생활에서 이들에 의해 휴대되는 물건들, 즉 이동전화들, PDA(personal digital assistants), 휴대 오디오 플레이어들 사이에서 발견될 수 있다.

이들 물건들은 폰 뉴만의 아키텍처로서 알려진 바와 동일한 계산 패러다임에 따르는 내장된 프로세서들에 의해 인에이블될 수 있었다. 내장된 장치들이 더 복잡해짐에 따라 이들은 점점 더 빠른 클럭 주파수들을 요구하고 점점 더 많은 파워를 소비한다. 이것은 종래의 프로세서들이 명령들을 순차로 실행하고 또한 데이터도 순차로 페치(fetch)하기 때문이다. 배터리 전원을 사용하는 장치들에 있어서 폰 뉴만 계산 패러다임은 유지될 수 없고 대안들이 발견되어야 한다.

최근에 멀티미디어 및 통신 알고리즘들의 요망되는 계산상의 요구들에 대항 기 위해 더욱 병렬 아키텍처들에 많은 관심이 있었다. 알고리즘들의 중대 부분들에서 병렬로 행해지는 연산들의 수를 증가시키기 위해서 애플리케이션 특정 집적회로들(ASICs)이 사용되었으며, 이에 따라 클럭 주파수를 증가시키는 것을 피하고 따라서 에너지 소비를 실제적 한계들 내에서 유지하였다. 그러나, ASIC들은 긴 개발시간들을 가지며, 일단 제조되면 이들은 변경될 수 없다. 이것은 빠르게 변하는 시장 활동력 및 최신의 전자장치들의 짧은 수명에 맞지 않는다.

프로그램가능 해결책들이 사실 더 바람직하며 이것은 재구성가능 계산(Reconfigurable Computing)의 기술이 어떻게 존속하게 되었는가에 있다. 재구성가능 컴퓨터는 구성 메모리들의 내용들을 변경함으로써 포스트-실리콘(post-silicon) 시간에 아키텍처가 변경될 수 있는 기계이다. 재구성가능 컴퓨터의 필수 요소는 프로그램가능 멀티플렉서(도 1)이다. 프로그램가능 멀티플렉서는 입력들(A, B), 및 출력(C)과 구성 비트(S)를 구비한다. S가 0으로 설정되면 A에서 C로의 경로가 생성되며, S가 1로 설정되면 B에서 C로서의 경로가 생성된다. 충분한 프로그램가능 멀티플렉서들을 구비하는 것은 기능유닛들 및 메모리 요소들이 의도대로 상호연결될 수 있게 하여, 서로 다른 알고리즘들을 더 잘 실행하기 위해 작동중에 서로 다른 하드웨어 아키텍처들을 생성할 수 있게 한다. 본 발명은 한 부류의 재구성가능 아키텍처들을 도출하기 위한 템플릿(template)이다.

현존의 재구성가능 아키텍처들은 2개의 주 종류들로서 (1) 미세-입도(fine-grained) 어레이들 및 (2) 조제-입도(coarse-grain) 어레이들로 분할될 수 있다.

미세-입도 어레이들은 필드 프로그램가능 게이트 어레이들(FPGA) 형태로 광 범위한 인기를 얻었다. FPGA는 큰 네트워크의 프로그램가능 스위치들에 의해 상호연결되는 협 비트 슬라이스들로 논리 기능들을 수행하기 위한 큰 어레이의 작은 프로그램가능 기능유닛들이다. 기능유닛들은 근본적으로 프로그램가능 룩업 테이블들(LUT)이며 한 네트워크의 스위치들은 위에 기술된 프로그램가능 멀티플렉서들로 구성된다. 상용 FPGA 장치들은 Xilinx, Altera, Actel, Lattice, 등과 같은 회사들을 통해 입수될 수 있다. FPGA들이 전기적 프로그래밍에 의해서 요구되는대로 회로들을 생성할 수 있게 할지라도, 대량 어레이의 LUT들 및 라우팅 스위치들은 상당한 면적 및 파워 페널티를 드러내는데, 전용의 하드웨어로 구현되는 동일 회로들은 훨씬 작고 에너지를 덜 요망할 것이다. 그러므로, 배터리로 동작되는 장치들에서 FPGA들의 사용은 통례가 아니라 예외였다.

FPGA들은 필요로 되는 상당한 회로면적들을 완화하고 성능을 향상시키기 위해서 표준 프로세서들 및 이를테면 곱셈기들 및 내장된 RAM들과 같은 특정 블록들과 결합되었다. 이렇게 하여, 알고리즘들의 보다 특정하고 중대한 부분들만이 재구성가능 구조 상에서 실행되고, 반면 이외 다른 덜 중대한 부분들은 내장 프로세서들에서 실행된다. 이러한 혼성 아키텍처들의 예들이 일부 연구자들에 의해 제안되었으며[4-16-11] FPGA 벤더들에 의해 시장에 도입되었다. 그러나, 이들 회로들은 실리콘 면적 면에서 여전히 낭비적이며 클럭 주파수들 및 구성 시간들 면에서 느리다.

조제-입도 어레이들은 감소된 적응성 및 일반성을 대가로 미세-입도 어레이들의 언급된 한계들을 극복한다. 조제-입도 어레이들은 매우 적은 수의 아키텍처들 의 연구자들[3 - 6 - 12 - 5 - 7 - 8 - 10 - 9 - 13 - 2 - 14 - 17] 및 창업 회사들[18 - 19]에 의해 제안된 최근 연구의 대상이었다. 이들 어레이들은 멀티미디어 및 통신과 같은 DSP 애플리케이션들을 더 잘 목표로 삼기 위해서 더 높은 입도 및 덜 복잡한 상호연결 네트워크들의 기능유닛들을 구비한다. 기능유닛들은 통상적으로 산술 및 논리 연산들을 통상적으로 몇 비트들의 슬라이스들로 수행하기보다는 몇 바이트들의 워드들로 수행한다. 결과는 덜 일반적이지만 훨씬 더 콤팩트하고 빠른 재구성가능 시스템이 되어, 실행시 신속하고 부분적으로 스와핑될 수 있는 소량의 구성 데이터를 요구한다.

또 다른 중요한 면은 재구성가능 유닛들이 어떻게 내장 마이크로프로세서들과 결합되는가이다. 초기에 재구성은 프로세서 기능유닛 수준에서 시작하였고 특별한 명령들에 의해 트리거되었다[15 - 12 - 1]. 나중에, 재구성가능 유닛들은 프로세서들에 단단히 결합되는 코프로세서들이 되었으며 작동하기 위해서 여전히 특별한 명령들을 요하였다[4 - 16 - 3 - 6 - 12]. 보다 최근에, 시스템 버스들에 부착되고 호스트 프로세서 명령 세트의 확장들을 전혀 요구하지 않는 코프로세서들이 주요 연구 토픽이 되었다[2 - 7 - 17]. 본 연구는 최신의 범주에 들어맞는다.

[2]에서 연구는 자체-타이밍 비동기 데이터-구동 구현을 제시하는데, 이것은 채택된 타이밍 방식의 어려움들을 주었으며, 완전한 맞춤 실리콘 구현을 필요로 하였고, 표준 셀 기반 기술에서 사용하기에 다소 비현실적이다. 아키텍처는 필요로 되는 한 시퀀스의 메모리 주소들을 생성하기 위해서 마이크로코드 명령들을 실행하는 2개의 어드레스 생성 프로세서들을 특징으로 한다.

[7]에서 아키텍처는 LUT-기반의 곱셈기들을 포함하는 획일적인 8-비트 기능유닛들을 사용하는데, 이것은 대부분의 멀티미디어 및 통신 애플리케이션들에서 사용되는 16비트 혹은 32비트 데이터 워드들로 확장(scale)하기가 어렵다. 계층적 상호접속 방법은 컴파일을 용이하게 하기에 충분하게 구성된다. 그러나, 이 연구는 다양한 애플리케이션들에 적응될 수 있고 확장될 수 있는 아키텍처 템플릿이 아니라 단일 아키텍처 설계를 나타낸다.

본 발명에 가장 가까운 연구는 [17]에 기술된 것으로, 한 어레이의 조제-입도 기능유닛들로 구성된 아키텍처 템플릿이 한 세트의 내장 메모리들 및 주소 생성 모듈들에 상호접속되었다. 주소 생성 모듈들은 복합 주소 시퀀스들의 발생을 위해서 일련의 산술 및 논리 유닛들(ALUs) 및 곱셈기들에 공급하는 종속연결된 카운터들로 구현된다. 한 세트의 지연 라인들은 기능유닛들 및 메모리 연산들의 제어를 동기화한다.

본 접근에서, 주소 발생 블록들은 프로그램가능 누산기들로 구현되어, ALU들 및 곱셈기들을 사용하는 것에 비해 하드웨어의 복잡성을 감소시킨다. 동기화를 위해 지연라인들을 증가시키는 대신에, 단일 지연라인, 그리고 서로 다른 지연들을 가진 다수 그룹들의 인에이블 신호들을 발생하기 위해 프로그램가능 랩 어라운드(wrap around) 횟수들을 구비한 복수의 카운터들을 사용한다. 이에 따라, 어떤 주소들의 발생은 서로들에 대해 상대적으로 지연될 수 있어, 불균형 파이프라인 그래프들에 의해 표현된 루프 바디들을 실행시킬 수 있다. 인에이블 신호들은 각각의 기능유닛을 통해 데이터 신호들을 동반하며, 따라서 이들은 다음 기능유닛에 필요한 지연을 갖고 도착한다.

본 접근은 본 프로그래밍 도구의 동작을 용이하게 하기 위해서 상호연결 네트워크들(부분적 크로스바들)을 명료히 구성한다. 사실 아키텍처 템플릿 및 프로그 래밍 도구는 프로그래밍이 어렵거나 자동화하기가 곤란한 하드웨어 구조들을 생성하는 것을 피하기 위해서 함께 설계되었다.

반드시 내장 프로세스의 데이터 입력들 및 출력들은 아닌 데이터 소스들 및 데이터 싱크들도 고려한다. 데이터의 출처 및 목적지는 시스템 내 임의의 하드웨어일 수 있고 반드시 시스템 클럭에 동기되는 것은 아니다. 이 목적을 위해서 프로세서 버스들보다 더 간단한 인터페이스를 제공하며, 코어를 다른 클럭 속도로 동작하는 다른 코어들에 연결하기 위해 비동기 FIFO들을 사용한다.

제안된 템플릿으로부터 도출된 아키텍처들은 제네릭 시스템 온 칩(SoC)에 통합되고 바디들이 기능유닛 어레이에서 수행되는 연산들의 표현들인 중첩 프로그램 루프를 실행하기 위해 재구성가능 코프로세서들로 구성된다. 기능유닛들은 표현들에 나타낸 원자적 연산들을 수행할 수 있어야 한다. 데이터 어레이들은 하나 이상의 시스템 입력들로부터 그리고 내장 메모리 어레이로부터 병렬로 액세스된다. 처리된 데이터 어레이들은 다시 메모리 어레이에 혹은 시스템 출력들에 보내진다.

아키텍처들은 단지 하나의 연산 혹은 자료 액세스가 한번에 수행될 수 있는 표준 프로세서 상에서 실행에 비해 중첩 루프들을 가속화할 수 있게 한다. 발명은 특히, 멀티미디어 및 통신과 같은 디지털 신호 처리를 수반하는 다수의 애플리케이션들에서 사용될 수 있다. 아키텍처들은 바람직하게는 제어 흐름을 구현하는데 더 나은 폰 뉴만 프로세서들에 관련하여 사용된다. 아키텍처들은 복합 시퀀스들의 주소들을 생성할 수 있는 주소 발생 블록을 특징으로 한다. 구성 레지스터 파일은 데이터 경로 및 주소 발생 블록을 프로그램하기 위한 정보를 저장한다. 구성 레지스 터 파일은 주소지정이 가능하고, 따라서 시스템은 부분적으로 그리고 런타임으로 재구성될 수 있다.

아키텍처들은 프로그램된 회수의 반복들 동안 혹은 기능유닛들에 사전에 프로그램된 어떤 조건들이 플래그될 때까지 루프한다. 초기화는 제어 레지스터를 사용하여 행해지며, 폴링은 상태 레지스터를 사용하여 가능하고, 요청들은 요청 신호의 발현시 서비스된다.

아키텍처들은 데이터 스트림 입력들, 출력들, 내장 메모리들, 기능유닛들 및 구성 레지스터들의 수에서 쉽게 확장될 수 있다.

몇몇의 범용 프로세서들 및 제안된 아키텍처 템플릿으로부터 도출되는 몇몇의 코프로세서들을 수반하는 계산 시스템들을 고찰한다. 프로세서들 및 코프로세서들은 동기적으로, 혹은 비동기 선입선출 메모리들(FIFOs)을 사용하여 연결되어, 전역적으로는 비동기이고 국부적으로는 동기되는 시스템을 형성한다.

각각의 코프로세서는 원 프로세서 코드에 중첩 루프들을 태그하고 재작성함으로써 프로그램된다. 프로그래밍 도구는 각각의 중첩 루프 그룹마다 코프로세서 구성을 생성하는데, 이것은 코프로세서 입력/출력 연산들 및 제어와 함께 원 코드에 자동으로 대체된다.

코프로세서 내 가용 하드웨어는 하드웨어 그래프로서 모델링된다. 루프 바디들에서 표현들은 데이터 흐름 그래프들로서 모델링된다. 데이터 흐름 그래프의 소스 노드들은 메모리 출력들 혹은 시스템 입력들이며 싱크 노드들은 메모리 입력들 혹은 시스템 출력들이다. 어레이 주소들에서 표현들은 주소 흐름 그래프들로서 모 델링된다. 주소 흐름 그래프들은 메모리 포트들로부터, 주소 발생 노드들을 통해, 마지막으로 타이밍 노드들로 데이터 흐름 그래프들을 계속하므로써, 완전한 시스템 그래프를 형성한다.

주소들의 발생을 위한 타이밍 정보는 시스템 그래프로부터 추출될 수 있다. 타이밍 정보는 인에이블 신호들의 형태로 데이터와 함께 보내지고 기능유닛들을 동기화하는데 사용된다.

시스템 그래프는 데이터 흐름 및 주소 흐름 그래프들을 하드웨어 그래프에 맵핑하기 위해서, 싱크들로부터 소스들로 횡단되는데, 사용된 자원들은 마크된다. 서로 다른 하드웨어 자원들이 의도된 흐름을 구현하기 위해 할당되게 되는 결과를 가져오는 복수의 프로그램가능 멀티플렉서 선택들이 있을 때마다, 다음에 무엇을 시도할 것인가에 대한 결정이 취해진다. 결정 후에 맵핑이 불가능하게 되면 가장 최근의 하드웨어 맵핑은 취소된다. 대안적 결정들이 있다면, 또 다른 결정이 시도된다. 더 이상의 대안적 결정들이 없다면 이전 결정이 취소된다. 이 과정은 맵핑 솔루션이 발견될 때까지 혹은 맵핑의 불가능함이 입증될 때까지 계속된다. 이 절차는 남김없이 완전하다.

A) 중첩 루프들

제안된 아키텍처 템플릿로부터 도출된 코프로세서들은 n비트 데이터 워드들을 조작할 수 있다. 다음을 구별한다.

· 상수들; 구성 레지스터 파일로부터 읽혀진 단일 데이터 워드들

· 변수들: 기능유닛 출력들로부터 읽혀진 단일 데이터 워드들

· 어레이들: 메모리들로부터 읽혀진 일단의 데이터.

아키텍처들은 다음의 메타-언어 정의들에 따라 하나 이상의 연속적인 중첩 루프 그룹들을 실행할 수 있다.

{nested_loop_group}

//curled brackets indicates repetition

nested_loop_group ::=

//"::=" means definition

for(index=0; index<index_end; index++) \{

//index and index_end are integers

// '\'is an escape character removing the meta meaning of

// the next character

{nested_loop_group;}

{assignment_statement;}

{break_statement;}

\}

assignment_statement::=

(variable | array_element) = expression

//'|'means exclusive or

array_element ::= array_name\[address_expression\]

address_expression ::=

(((address_expression | alpha) * index + (address_expression | beta))

%modulo) + offset

//alpha, beta, modulo and offset are integers

expression ::=

F({(expression | array | variable | constant)})

//where F is a function computed by some functional unit

//given a list of inputs or arguments separated by blank

//spaces

break_statement ::= break( expression );

//causes execution to break if expression evaluates to non //zero

B) 아키텍처

제안된 아키텍처의 템플릿의 상위 수준 도가 도 2에 도시되었다. 이것은 기본적으로 한 어레이의 기능유닛들(FU) 및 한 어레이의 내장된 메모리들(EM)로 구성된다.

FU들에 의해 처리되는 데이터는 독출 크로스바에 의해 EM들, 다른 FU들의 시스템 입력들 혹은 출력들로부터 나온다. 각각의 FU는 단일 데이터 출력을 생성하나, 2차 출력으로서 어떤 플래그들을 생성할 수도 있다. 이들 플래그들은 독출 크로스바에 의해 다른 FU들에 보내지며 이들 FU들에서 플래그들은 제어 입력들로서 사용된다. FU들에 의해 처리된 데이터는 다시 EM들에 기입되거나, 기입 크로스바에 의해 정의된 루트들을 사용하여 시스템 출력들에 보내진다.

메모리들의 주소들은 주소 발생기에서 온다. 메모리 대역폭은 이 시스템의 수행에서 중요하기 때문에, 도 2에서 모든 내장된 메모리들은 이중 포트 메모리들로서 도시되었다. 단일 포트 메모리들이 사용될 수도 있을 것이다.

구성 레지스터 파일은 프로그램가능 FU들, 독출 및 기입 크로스바들, 및 주소 발생 블록들의 구성을 정의하는 데이터를 내포하는 한 세트의 레지스터들을 유지한다. 또한, 주소들 및 데이터의 계산에서 사용되는 어떤 상수들도 저장한다. 구성 레지스터 파일은 제어 및 상태 레지스터들에 액세스하는 데에도 사용되는 구성 인터페이스를 통해 액세스된다. 구성 레지스터 파일은 주소지정이 가능하므로, 시스템은 부분적으로 그리고 런타임으로 재구성될 수 있다.

주소 발생 블록을 도 3에서 볼 수 있다. 이의 아키텍처는 자체가 아키텍처의 최 상위 도와 유사한데, 즉, 재구성가능 프로세서 내의 작은 재구성가능 프로세서 와 비슷하다. FU 어레이 대신에 누산기 어레이(AA)가 있으며, 독출 및 기입 크로스바들은 각각 입력 크로스바 및 출력 크로스바처럼 나타나 있다.

AA는 타이밍 유닛으로부터 오는 신호들에 의해 인에이블되는 일단의 특별한 누산기들을 내포한다. 일부 누산기들은 출력 크로스바에 의해 메모리 포트들에 보내지는 주소들을 발생한다. 또한, 출력 크로스바는 다른 메모리들의 주소들로서 사용될 어떤 메모리들에 저장된 주소들을 보낸다. 이것은 메모리 공간을 희생하여 주소들의 발생에 있어 극도의 융통성을 제공한다. 다른 누산기들은 AA 자체에 피드백되는 중간값들을 생성한다. 입력 크로스바는 중간값들의 피드백을 제공하며 복합 주소 시퀀스들을 발생하기 위해서 구성 레지스터로부터 상수들을 누산기들에 보낸다.

주소들은 중첩 루프 인덱스들의 함수들이다. 타이밍 유닛은 AA를 인에이블하기 위해 다수 그룹들의 신호들을 발생한다. 인에이블 신호들은 인에이블 크로스바에 의해 AA에 보내진다. 또한, 인에이블 크로스바는 외부 데이터의 입력 시간을 맞추고 동기화하기 위해 시스템 입력들에 인에이블 신호들을 보낸다. 누산기들의 인에이블들은 이의 메모리 포트에 생성된 주소를 동반하는데, 독출 포트의 경우에 인에이블 신호들은 FU들을 통해 메모리로부터 독출된 데이터를 동반한다. FU들에서 인에이블 신호들은 인에이블하여 데이터가 동기된 상태에 있도록 데이터와 동일 량만큼 지연된다.

도 3에 도시된 제어 블록은 코프로세서를 초기화, 기동 및 폴링하는 사용자 명령들에 응답한다. 이것은 또한, 기능유닛들에서 어떤 상태가 검출된 경우, 혹은 시스템 입력들에 데이터가 없거나 출력들이 오버프로된 경우, 코프로세서를 정지시킨다.

루프 인덱스들은 중첩 루프 신택스에서 위에 주어진 바와 같은 단위 증분들만큼 진전한다. 각각의 중첩 루프 그룹은 마지막 카운트 값이 프로그램되는 종속연결된 카운터들을 사용하여 타이밍 유닛에 구현되는 일 그룹의 인덱스들을 사용한다.

타이밍 유닛이 도 4에 도시되었다. 프로그램가능 카운터들은 제1 행이 루프 인덱스들 i, j, 및 k에 대해 인에이블 신호들을 구현하는 행렬로 상호연결된다. 후속되는 행들은 루프 인덱스들이 지연된 것들을 생성한다. 마지막 행은 항시 루프 인덱스들이 가장 지연된 것을 내포한다. 제1 카운터는 인덱스 i를 나타내고 매 클럭 사이클에서 증분된다. 카운터가 마지막 값에 도달할 때 카운터는 랩 어라운드하고 1만큼 다음 외각 카운터를 전진시키기 위해 출력 신호 펄스를 가한다. 최종 카운터가 끝에 도달하였을 때 최외각 루프는 종료하고 중첩 루프 그룹이 행해진다. 우선순위 엔코더는 종속연결된 카운터들에 프로그램된 눌(null)이 아닌 마지막 카운트 값들로부터 최외각 루프(end_sel)를 확인한다. 이 정보는 어떤 카운터 컬럼이 처리를 종료하고 제어 블록에서 사용될 것인지를 나타낼 것이다.

프로그램가능 값들에 의해 기본 인덱스 i 인에이블을 지연시키는 회로가 도 5에 도시되었다. 각각의 플립-플롭 D는 한 사이클만큼 i_en(t) 신호를 지연시킨다. 프로그램가능 멀티플렉서들은 원하는 지연을 선택한다. 브레이크 조건이 있다면(이하 참조) 지연유닛의 상태는 플립-플롭들을 디저블시키고 출력 인에이블들을 마스 킹함으로써 중지된다. 시스템에 P 메모리 포트들이 있다면 인에이블들을 많아야 P개 지연시킨 것들이 필요하게 된다. 실제로는 더 적은 수의 지연된 것들이 구현될 수도 있다.

실제 주소들은 1의 증분들만큼 반드시 전진하는 것은 아니기 때문에, 도 6 및 도 7에 도시된 누산기 유닛들은 위에서와 같이 address_expression 에 의해 주어진 형태의 보다 복합적인 주소 시퀀스를 생성한다.

도 6에 도시된 기본 누산기 유닛(BAU)은 RESTART_EN 신호가 펄스로 가해진 후에 START 입력에 의해 명시된 값으로 초기화하며, INCR 입력에 의해 명시된 값들을 누산한다. 누산기의 현재 및 다음 출력들은 각각 신호들 CNT 및 CNT_NXT에 의해 주어진다.

도 7에 도시된 복합 누산기 유닛은 BAU에 다음 기능을 추가한다: 누산들은 구성 입력 MODULO에 의해 명시된 모듈로(modulo)로 행해지며 OFFSET 입력신호에 의해 명시된 값에 더해진다. 각각의 누산기는 이의 EN 및 RESTART_EN 신호들을 인에이블 크로스바로부터 선택하며, 이는 타이밍 유닛에서 생성된 인에이블 신호 그룹들에 의해 구동된다. 도 8에 도시된 바와 같이, 먼저 인에이블 그룹(지연된 것)이 선택되고 이어서 선택된 그룹 내로부터 EN 및 RESTART_EN에 대한 인에이블 신호들이 선택된다. 시스템에서 외부 데이터의 입력을 어크놀리지(acknowledge)하는데 사용되는 인에이블 신호들을 선택하기 위해 유사한 방식이 사용된다. 이에 따라 외부 데이터의 입력은 시간에 맞추어지 동기화될 수 있다.

도 9는 입력 크로스바로부터 누산기 입력들의 선택을 도시한 것이다. START, OFFSET 및 INCR 신호들은 구성 레지스터들에 저장된 상수들로부터, 혹은 다른 누산기들에 의해 생성된 CNT 및 CNT_NXT 신호들로부터 선택될 수 있다.

도 10은 출력 크로스바에서 메모리 포트 주소들의 선택을 도시한 것이다. 누산기들에 의해 생성된 CNT 신호들 혹은 메모리들로부터 독출된 데이터는 메모리 포트들의 주소들을 형성하기 위해 선택될 수 있다. 누산기들의 EN 및 RESTART_EN 신호들은 생성된 주소들을 메모리 포트들에 연결한다. 메모리 포트가 독출 포트라면 인에이블들은 독출된 데이터를 기능유닛들에 동반시키거나, 독출된 데이터가 주소로서 사용될 것이라면, 인에이블들은 데이터를 다시 출력 크로스바에 연결한다. 메모리 포트가 기입 포트라면 EN 및 RESTART_EN 신호들은 무시된다.

도 11은 독출 크로스바에 의해 기능유닛들을 위한 입력들의 선택을 도시한 것이다. 입력들은 시스템 입력들, 메모리 출력포트들로부터, 혹은 다른 기능유닛들의 출력들로부터 올 수 있다. 이 아키텍처 테플릿은 임의의 기능유닛이 인에이블 신호들을 다음 기능유닛에 통과시키고 이들을 기능유닛들 자체와 동일한 수의 레이턴시 사이클들을 지연시키는 특별한 입력을 구비해야만 하는 것을 고려한다. 이에 따라 인에이블 신호들은 보존되고 이들이 참조하는 데이터 근처에 유지된다. 기능유닛들은 이 기능유닛부터 관계되는 것을 끊는 입력의 EN 신호 유실시 입력 RESTART_EN 신호를 출력 EN 신호에 보내게 구성될 수 있다. 이와 같이 하는 것의 유용성은 나중에 명백하게 될 것이다.

도 12는 기입 크로스바에 시스템 출력들 및 메모리 입력들의 선택을 도시한 것이다. 이들은 기능유닛 출력들로부터 선택된다. 인에이블들은 데이터를 동반하며 메모리 기입 인에이블들 혹은 출력 요청 신호들로서 사용될 것임에 유의한다.

제어/구성 인터페이스, 데이터 입력 인터페이스 및 데이터 출력 인터페이스가 도 13에 도시되었다.

제어/구성 인터페이스는 이것이 선택되고 있음을 나타내고 내부 레지스터들을 선택하는데 사용되는 Address 입력벡터를 유효화하기 위해 Request_in 입력신호를 갖는다. Write/not Read 신호는 의도된 동작을 선택한다. 데이터는 ctr_data_in 포트들에 기입되고 ctr_data_out 포트로부터 독출된다. Request_out 신호는 이를테면 처리의 종료 혹은 어떤 상태가 검출되어 코프로세서가 멈추게 되었다는 이벤트들을 플래그한다.

데이터 입력 인터페이스는 Req_in 입력신호 벡터를 갖는다. 각각의 요소 Req_in[i]는 데이터 입력 인터페이스 i가 선택되고 있고 입력 데이터를 내포하는 Data_in[i] 벡터를 유효화함을 나타낸다. Ack_in[i] 신호는 Data_in[i]를 읽기 위한 요청 Req_in[i]이 수락되어 실행되었음을 코어 구동 인터페이스 i에 알리는데 사용된다. Ack_in[i] 신호는 인에이블 크로스바에 의해 선택되는 주소 생성기 블록에서 온다.

데이터 출력 인터페이스는 Req_out 출력 신호 벡터를 갖는다. 각각의 요소 Req_out[i]는 데이터 출력 인터페이스 i가 선택되고 있고 출력 데이터를 내포하는 Data_out[i] 벡터를 유효화함을 나타낸다. 이 인터페이스에 의해 내보내진 데이터를 수락할 때 수신확인 신호 Ack_out[i] 가 외부로부터 발현되어야 하며, 그렇지 않으면 코프로세서는 데이터 유실을 방지하기 위해 정지할 것이다. 외부에 관점에 서, 마지막 요청으로부터 데이터를 수락하는 것이 불가능하지 않는 한, Ack_out[i]은 항시 발현되어야 한다.

도 14는 아키텍처들을 위한 기본 제어 레지스터를 도시한 것이다. 이것은 3개의 비트들로서, 코프로세서를 초기화하는 Init 비트, 코프로세서를 인에이블하는 En 비트, 및 신호 Request_out에 의해 코프로세서로부터의 Req_en 인에이블 제어 요청들을 내포한다.

도 15는 기본 상태 레지스터를 도시한 것이다. 이것은 코프로세서의 폴링을 허용하기 위해 단일 Busy 비트를 내포한다.

기본 제어 유닛이 도 16에 도시되었다. 코프로세서는 제어 비트 En 및 I/O 인에이블 비트가 발현될 때마다 인에이블되고, END(t) 혹은 break 신호들이 비-발현된 상태에 있게 될 때까지 인에이블 상태에 있는다. 이들 신호들이 펄스로 가해질 때마다, 논리 '1'이 플립-플롭 내 잡히고, 이것은 코프로세서를 디저블시킨다. 인에이블된 코프로세서는 신호 i_en(t)를 발현함으로써 최내각 루프 인덱스가 인에이블 되게 하고, 이에 따라 외각 루프 인덱스들 그리고 인에이블 그룹들의 모든 지연된 것들을 인에이블한다.

제어 출력 요청들이 인에이블화되면 (Req_en = '1') break 신호 혹은 가장 지연된 END(t-DP) 가 펄스로 가해질 때 Request_out 신호가 발현된다.

END(t) 및 END(t-DP) 신호들은 최외각 루프의 랩 어라운드된 신호들이며, 멀티플렉서는 모두 지연이 없는 신호들 i_en, j_en, 혹은 k_en, 그리고 DP 사이클들만큼 지연된 것들로부터 인덱스 인에이블을 선택하기 위해 도 4에 설명된 신호 end_sel를 사용한다.

상태 레지스터의 Busy 신호가 도 16에 도시된 바와 같이 발생된다. 코프로세서는 i_en(t)를 활성화하여 인에이블되거나, 처리를 마치지 않았다면, 즉 END(t-DP) 혹은 break이 발현되지 않았다면, 비지 상태이다.

break 신호는 지연유닛에서 루프 인덱스 인에이블들의 발생을 디저블시키는데 사용된다(도 4). 이것은 기본적으로 break 신호의 등록 및 반전된 한 사이클 지연된 것이다.

기능유닛들로부터 브레이크 조건들의 선택이 도 17에 도시되었다. 확장성(scalability)의 이유로 각각의 기능 i 유닛은 단일 브레이크 조건 신호 cond_i를 생성할 수 있을 뿐이다. 내부적으로, 기능유닛 i은 여러 가지 이유들로 브레이크 조건이 나타나게 프로그램될 수 있다. 그러나, 외부 견지에서, 기능유닛당 단일 브레이크 신호가 있다. 구성 비트 cond_i_en는 브레이크 조건 cond_i 가 인에이블되는지를 알려준다.

I/O 종속 시스템 인에이블들의 선택이 도 18에 도시되었다. 루프 바디 표현들이 시스템 입력 i을 수반한다면, 코프로세서는 Req_in_i 신호에 의해 알려지게 되는 그 입력에 사용가능 데이터가 있다면 인에이블될 수 있을 뿐이다. 유사하게, 루프 바디 표현들의 결과들이 시스템 출력 j에 보내지고 있다면, 코프로세서는 Ack_out_j 신호 신호에 의해 알려지게 되는 또 다른 시스템에 의해 실제로 독출되고 있다면 인에이블될 수 있을 뿐이다. 이 신호가 발현될 때 이것은 마지막 사이클에서 보내진 데이터가 읽혀졌음을 의미한다. 발현되었을 때, 구성 비트들 no_in_i 및 no_out_j은 시스템 입력 i 및 시스템 출력 j이 루프 바디 표현들에 없고 따라서 시스템을 디저블시킬 수 없음을 나타낸다.

C) 프로그래밍 도구

코프로세서 프로그래밍 흐름이 도 19에 도시되었다. 사용자는 위에 주어진 신택스에 따라 중첩 루프 시퀀스 코드를 작성함으로써 시작한다. 코프로세서 프로그래밍 도구는 중첩 루프 시퀀스 코드 및 하드웨어 아키텍처의 디스크립션을 입력하고, 코프로세서 구성 시퀀스를 복수의 포맷들, 즉 텍스트 파일, 소프트웨어 include 파일 및 하드웨어 디스크립션 언어(HDL)로 된 구성 메모리 이미지들로 출력한다. 텍스트 파일은 사람이 읽을 수 있으며 사용자에게 피드백을 주기 위해 사용된다. 소프트웨어 include 파일은 시퀀스의 구성 메모리 이미지들을 내포하는데, 이것은 코프로세서를 구성하고 실행시킬 어떤 프로그램에 포함될 수 있다. HDL 구성 이미지들은, 고속 시스템 검증을 위해서, 혹은 상세한 시스템 검증을 위한 HDL 시뮬레이션을 위해서 FPGA 에뮬레이션에서 사용된다. 또한, 아키텍처의 소프트웨어 모델은 FPGA 에뮬레이션의 속도와 HDL 시뮬레이션의 상세간에 절충을 제공하는 하드웨어 디스크립션 파일들로부터 컴파일된다. 소프트웨어에 의해 생성된 결과들(출력 데이터), HDL 및 FPGA 모델들은 사용자에 의해 분석되고 입력 중첩 루프 코드의 개량을 안내하는데 사용된다.

하드웨어 아키텍처는 사용된 기능유닛들을 참조하는 파일에 기술된다. 기능유닛들의 디스크립션은 기능유닛 저장소에 두어진다. 하드웨어 디스크립션 파일의 신택스는 이하 주어지는 것과 같을 것이다.

//Constant declaration section

{({constant_name})}

//Input/output declaration section

{input input_name\[range\]}

{output output_name\[range\]}

range ::= integer..0

//Memory declaration section

{memory memory_name (singleport | twoport | dualport)

addrA\[range\] dataA\[range\]

[addrB\[range\] dataB\[rage\]]}

//Functional unit declaration section

{functional_unit functional_unit_name functional_unit_type}

//Read Crossbar declaration section

{functional_unit_name.input_name <=

({functional_unit_name.output_name})

({memory_name.(dataA | dataB)})

({constant_name})

//Write Crossbar declaration section

{output_name <= ({functional_unit_name.output_name})}

{memory_name.(data | dataB) <=

({functional_unit_name.output_name})}

//Address Generator declaration section

//Timing Unit

number_of_nested_loops := integer

number_of_enable_delay_groups := integer

//enable groups become named en_grp_0, en_grp_1, ..., up to

//en_grp_number_of_enable_delay_groups-1

//enabled signals in enable group I become named

//en_grp_i.en_0, en_grp_i.en_0, ..., up to

//en_grp_i.en_number_of_nested_loops-1

//Accumulators declaration section

number_of_baus := integer

number_of_caus := integer

//accumulators become named bau_0, bau_1, ..., up to

//bau_number_of_baus-1 or cau_0, cau_1, ..., up to

//cau_number_of_caus-1

//Enable Crossbar declaration section

{(bau | cau)_name.(en restart_en) <=

({en_grp_name.(en restart_en)})}

// Input Crossbar declaration section

{(bau | cau)_name.start <=

({bau_name.cnt_nxt} {constant_name})}

{(bau | cau)_name.incr <=

({bau_name.cnt} {constant_name})}

{cau_name.offset <= ({bau_name.cnt} {constant_name})}

// Output Crossbar declaration section

{memory_name.(addrA | addrB) <=

({cau_name.cnt} {memory_name.(data | dataB)})}

아키텍처 디스크립션의 예는 다음과 같다.

//Input/output declaration section

input I0[31..0]

output O0[31..0]

//Memory declaration section

memory M0 dualport

addrA[511..0],dataA[31..0] addrB[511..0] dataB[31..0]

memory M1 dualport

addrA[511..0] dataA[31..0] addrB[511..0] dataB[31..0]

memory M2 dualport

addrA[511..0] dataA[31..0] addrB[511..0] dataB[31..0]

//Functional unit declaration section

functional_unit ADD1 adder_32

functional_unit ADD2 adder_32

functional_unit MULT1 mult_32

functional_unit MULT2 mult_32

functional unit MUX mux_2_1_32

//Read Crossbar declaration section

ADD1.d_input0 <= (I0 M0.dataA M1.dataA MULT1.d_output)

ADD2.d_input1 <= (I0 M0.dataB const_rd MULT2.d_output)

MUX.s_input <= (ADD1.zero_flag ADD2.zero_flag)

MUX.d_input0 <= (MULT1.d_output M2.dataA)

MUX.d_input1 <= (MULT2.d_output M2.dataB)

// and so on for other FUs

//Write Crossbar declaration section

O0 <= (ADD1.d_output MULT1.d_output)

M0.dataB <= (ADD1.d_output MULT1.d_output)

M1.dataB <= (ADD2.d_output MULT2.d_output)

// and so on for other memory ports

//Address Generator declaration section

//Timing Unit

number_of_nested_loops := 3

number_of_enable_delay_groups := 3

//Accumulators declaration section

number_of_baus := 4

number_of_caus := 2

//Enable Crossbar declaration section

cau_0.(en restart_en) <= (en_grp_0.en_0 en_grp_1.en_1)

// same for other baus and caus

bau_0.(en restart) <= (en_grp_1.en_1 en_grp_2.en_2)

// same for other baus and caus

// Input Crossbar declaration section

bau_1.start <= (bau_2.cnt_nxt const_addr)

bau_1.incr <= (const_addr_incr bau_2.cnt)

cau_2.offset <= (const_addr_offset bau_3.cnt)

// same for other baus and caus

// Output Crossbar declaration section

M0.addrA <= (cau_3.cnt cau_0.cnt M2.dataB)

// same for other memories

구성 디스크립션 텍스트 파일은 아키텍처 디스크립션 파일과 유사한 신택스로 작성되나, 목적지를 위한 모든 가능한 소스들을 나열하는 대신, 선택된 소스를 특정한다. 즉, 이것은 이뉴머레이션(enumeration)을 배타적 선언판단(exclusive disjunction)으로 대체한다. 가능한 신택스의 디스크립션은 다음과 같다.

{config_sequence}

config_sequence ::=

label: config_sequence begin {configuration} end

configuration ::=

configuration begin config_body end

config_body ::=

data_path_config addr_gen_config

data_path_config ::=

fu_config read_xbar_config write_xbar_config

fu_config ::=

{fu_name.parameter_name = parameter_value}

//parameter name and parameter value depend on the

//functional unit being used

read_xbar_config ::=

{functional_unit_name.input_name <=

(input_name | functional_unit_name.output_name |

memory_name.(dataA |dataB) | constant_name )}

write_xbar_config ::=

{memory_name.((dataA | dataB) write) <=

functional_unit_name.(output_name (out_en|out_restart_en))}

{output_name.(data_out req_out) <=

functional_unit_name.(output_name (out_en|out_restart_en))}

addr_gen_config ::=

tu_config acc_config enable_xbar_config input_xbar_config

output_xbar_config

tu_config ::= end_array delay_array

end_array ::= ({integer})

//list must have number_of_nested_loops elements

delay_array ::= ({integer})

//list must have number_of_enable_delay_groups elements

acc_config ::=

cau_name.modulo = integer

enable_xbar_config ::=

{(bau | cau)_name.(en restart_en) <=

en_grp_name.(en_name en_name)}

input_xbar_config ::=

(bau | cau)_name.start <=

(constant_name | bau_name.cnt_nxt )

(bau | cau)_name.incr <=

(constant_name | (bau | cau)_name.cnt )

cau_name.offset <= (constant_name | (bau | cau)_name.cnt)

output_xbar:config ::=

memory_name.(addrA | addrB) <=

((bau | cau)_name.cnt | memory_name.(data | dataB))

코프로세서 프로그래밍 도구의 알고리즘이 이하 개괄된다.

coprocessorTool (nested_loop_sequence_code){

SG = parseNLSC(nested_loop_sequence_code);

nodeList = createNodelist(SG);

HG = parseHW(architecture_description)

if (map(nodeList.head, SG, HG) == true)

writeConfigurationImages();

exit(SUCCESSFUL);

else

exit(UNSUCCESSFUL;)

}

제1 단계는 중첩 루프 바디들에서 표현들을 분석하고 각각의 중첩 루프 그룹에 대한 하위-그래프들로 구성된 완전한 시스템 그래프 SG를 생성하는 것이다. 이것은 함수 parseNLSC (nested_loop_sequence_code)에 의해 행해진다. 각각의 중첩 루프 그룹은 구성 메모리 이미지를 발생시킨다. 각 중첩 루프 그룹에 대한 하위-그래프는 2개의 부분들로서 데이터 흐름 그래프 및 주소 흐름 그래프를 갖는다.

데이터 흐름 그래프(DFG)는 다음 유형들의 노드들을 갖는다.

소스 노드들:

· 메모리 노드(데이터 출력 포트들)

· 시스템 데이터 입력 노드

· 구성 상수 노드

싱크 노드들:

· 메모리 노드(데이터 입력 포트들)

· 시스템 데이터 출력 노드

중간 노드들

· 기능 유닛 노드

주소 흐름 그래프(AFG)는 다음 유형들의 그래프들을 갖는다.

소스 노드들:

· 메모리 노드(데이터 출력 포트들)

· 타이밍 유닛 노드(인에이블 신호 출력 포트들)

· 구성 상수 노드

싱크 노드들:

· 메모리 노드(주소 입력 포트들)

· 시스템 데이터 노드(어크놀리지 신호들)

중간 노드들

· 누산기 유닛 노드

DFG 및 AFG에서 에지들은 소스 노드들에서 중간 노드들로, 중간 노드들에서 다른 중간 노드들로, 그리고 중간 노드들에서 싱크 노드들로 보내진다.

DFG 및 AFG는 AFG의 메모리 싱크 노드들을 DFG의 메모리 소스 노드들에 합체함으로써 단일 구성 그래프(CG)에 종속연결될 수 있다. 완전한 시스템 그래프 SG는 연속한 CG들을 종속연결함으로써 구성될 수 있다. 한 CG는 현 CG의 메모리 싱크 노드들을 다음 CG의 메모리 소스 노드들에 합체함으로써 다음 CG에 종속연결된다. 이것은 다음 코프로세서 구성에서 사용될 데이터를 내장 메모리들에 남겨놓을 수 있게 한다. 이 메커니즘은 의식적인 혹은 의도적인 캐싱 메커니즘이라 할 수 있고, 이것은 추계통계적 소재(stochastic locality)를 활용하는 종래의 캐시들보다 더 낫게 수행할 것이다.

다음 예는 CG가 도출되는 중첩 루프 그룹을 도시한 것이다.

u = α₀*(i-8)+ β₀

v=j

w = ((α₁*i+β₁)*j + β₂)%γ+δ

x = M₂.dataA[j-5]

for(i=0; i<i_end; i++) {

for(j=0; j<j_end; j++)

d[u] += a[v]*b[w] + c[x];

}

이 예에서 중첩 루프 그룹에 대한 DFG가 도 20에 도시되었다. 볼 수 있는 바와 같이, DFG는 중첩 루프 그룹의 바디 내 표현을 따른다. 그래프의 각 노드는 FU 노드이거나 메모리 노드를 나타낸다. 독출, 기입 혹은 FU 동작들은 파이프라인으로 되고 각 동작에 대한 레이턴시를 도 20에 나타내었다. 메모리 독출들 a[v] 혹은 b[v]에서 메모리 기입 d[u]까지, 그래프에서 가장 긴 경로는 9 사이클들이 걸린다. 메모리 독출 c[x]에서 메모리 기입 d[u]까지 경로는 4 사이클들이 걸린다. 이것은 메모리 독출 c[x]가 메모리 독출들 a[v] 및 b[w]에 비해 9-4=5 사이클들 지연될 것이며 메모리 기입 d[u]가 메모리 독출들 a[v] 및 b[w]에 비해 9-1=8 사이클들 지연될 것임을 의미한다. 제시된 아키텍처의 템플릿에 있어선 주소들을 계산하는데 있 어 전혀 지연들이 없다. 이에 따라, 레이턴시에 차이들은 단지 서로 다른 수의 파이프라인 스테이지들에 의한 FU들에서만 온다. 그러나, 이 방법을 주소들의 계산이 레이턴시에 의해 영향을 받는 경우로 확장하는 것은 수월하다.

주소들 u, v, w, x를 계산하기 위한 AFG가 도 21에 도시되었다. 주소들의 계산은 타이밍 유닛에 의해 발생된 인에이블 신호들 i_en 및 j_en에 의해 진전한다. D 사이클들 지연될 필요가 있는 주소들은 신호들 i_en(t-D) 및 j_en(t-D)로 지연된 인에이블 그룹을 사용한다. 주소 u, v, x는 한 BAU만이 계산될 필요가 있고, 주소 w는 더 복잡하며 BAU에 의해 공급되는 CAU를 필요로 함에 유의한다.

동음이의어 메모리 노드들 u(t-8), v(t), w(t), 및 x(t-5)을 합체함으로써 DFG 및 AFG를 종속연결하는 것은 이 예에서 중첩 루프 그룹에 대한 CG를 만든다. 한 시퀀스의 중첩 루프 그룹들이 있으므로, 각각의 CG들은 유사한 방법으로 종속연결되어 완전한 SG를 만들어낼 것이다.

SG를 생성한 후에 이 그래프에서 노드들은 시스템 출력 노드들로부터 시스템 입력 노드들을 향하여, 넓이 우선 방식으로, 리스트에 순서화된다. 주어진 예에 있어서 노드들의 순서는 d[u], +=, +, c[x], *, x(t-5), a[v], b[w], v(t) 및 w(t)이 될 수도 있을 것이다. 이것은 주 알고리즘 흐름에서 함수 createNodelist(SG)가 행하는 것이다.

다음에, 함수 parseHW(architecture_description)는 함수에 의해 하드웨어를 기술하는 그래프를 생성한다. 하드웨어 그래프는 위에 주어진 아키텍처 디스크립션에 따른다. 일부 하드웨어 노드들은 SG 노드들로서 I/O, 메모리, 기능유닛, 주소 누산기들, 구성 상수들, 타이밍 유닛 노드들에 맵핑하며, 다른 하드웨어 노드들은 SG 내 노드들에 대응은 없으나, 신호들을 메모리 포트, 크로스바 멀티플렉서, 기능유닛 포트에 보내는데 유용하다. 몇몇의 레벨들의 기능유닛들을 거쳐, 시스템 출력들 및 메모리 입력들에서 시스템 입력들 및 메모리 출력들까지 이어지는 경로들의 선택들은 각 구성에 대한 데이터를 구성한다. 구성들의 수만큼의 다수회 하드웨어 그래프를 전개하는 것은 SG가 매핑되는 완전한 하드웨어 그래프 HG를 제공한다.

다음 단계는 SG 내 노드들을 HG 내 노드들에 맵핑하는 것이다. 순환적 맵 절차가 이하 개괄된다.

bool map (node, SG, HG){

descendantHwNodes =

getHwNodes(node.getDescendants(), HG);

candidateHwNodes =

descendantHwNodes.getHwCommonAscendants(HG);

if (candidateHwNodes == null)

return(false);

foreach hwNode in candidateHwNodes {

if (hwNode.type != node.type)

next;

if(hwNode.isUsed())

next;

hwNode.route(descendantHwNodes, HG);

if(node.next == null)

return(true);

if((map(node.next, SG, HG))

return(true);

hwNode.unroute(descendentHwNodes, HG);

}

return false;

}

위에 의사-코드에 따라, SG 노드를 HG 노드에 맵핑할 때 행할 첫번째 것은 그래프에서 그 노드의 바로 밑의 자손 노드들을 얻는 것이다. 이들 노드들은 알고리즘이 그래프 싱크들로부터 그래프 소스들로 진행하기 때문에, 이미 HG 노드에 맵핑되었다. 자손 HG 노드들로부터 작업하여, SG에 대응을 갖고 있고 미사용된 멀티플렉서들에 의해 도달될 수 있는 공통의 바로 위 선조 HG 노드들의 리스트를 계산한다. 이것은 해당 노드에 맵핑될 수 있는 가능한 HG 노드들의 리스트이다. 적합한 후보들을 발견하기 위해서 이 리스트 내 노드들이 탐색된다. 먼저, 후보 HG 노드는 가산기, 곱셈기, 메모리 등의 노드와 동일 유형이어야 한다. 두 번째로, 노드는 사용중이 아니어야 한다. 이들 테스트들 중 어느 하나가 실패한다면 절차는 비성공을 리턴한다. 이들 체크들을 수행하였을 때, HG 노드는 이의 자손들에 보내지게 되는데, 즉, 자손들의 입력 멀티플렉서들은 노드로부터 데이터를 수신하게 설정된다. 이것이 맵핑될 마지막 노드라면 절차는 성공을 리턴한다. 그렇지 않다면, 맵 절차는 SG 내 다음 노드에 순환적으로 적용된다. 성공적이라면, 절차는 성공을 리턴한다. 그렇지 않다면, 이것은 현재 혹은 이전 노드들의 현 맵핑으로는 다음 노드들의 맵핑이 달성될 수 없다는 것을 의미한다. 이 경우, 자손들에의 루트들은 행해지지 않으며 다음 후보 HG 노드가 시도된다. 모든 후보 노드들이 비성공적으로 시도된 후에 절차는 비공성을 리턴한다.

본 발명으로 만들어진 재구성가능 코프로세서 인스턴스의 적용예가 다음에 제시된다. 예는 MEGP 1 층 III(MP3) 디코더 알고리즘이다. 알고리즘은 (1) 종래의 프로세서에서 그리고 (2) 코프로세서 인스턴스에 의해 가속된 동일 종래의 프로세서 상에서 실행되었다. 프로세서는 수행의 0,81 DMIPS을 가진 32비트 하바드 아키텍처이다. 코프로세서 인스턴스는 다음의 파라미터화로서, 2 중첩 루프들, 32비트 데이터 경로, 2 가산기들/누산기들, 2 곱셈기들/시프터들, 총 4k바이트의 ROM 및 8k 바이트 RAM의 3 이중포트 메모리 블록들에 의해 생성되었다.

한 세트의 MP3 벤치마크들을 실행한 실험결과들을 표 1에 나타내었다. 종래의 프로세서 상에 알고리즘의 초기 프로파일링으로부터 두 절차들인 폴리페이스 합성 및 역 수정 이산 코사인 변환이 시간의 95%를 취하고 있음을 발견한다. 이에 따라, 코프로세서에서 이들 절차들을 가속한다면 가속에 대한 잠재력은 20이다. 폴리페이스 합성 절차는 평균 18.7배 가속되었다. IMDCT 절차는 평균 43.9배 가속되었 다. 이것은 11.9배의 총 알고리즘 가속을 가져왔다. 프로세서 및 코프로세서에 의해 형성된 완전한 시스템의 프로파일링은 주 절차들간에 더 균형잡힌 처리 부하 분배를 드러낸다. 완전한 시스템에서 폴리페이스 합성 및 IMDCT 절차들은 가속 전에 95% 처리 부하와는 완전히 대조적으로, 처리 부하의 단지 34%만을 차지한다.

	폴리페이스 합성	IMDCT	다른 절차들	총계
프로세서에서 프로파일링 (%)	24	71	5	100
가속	18.7	43.9	1	11.9
프로세서 + 코프로세서에서 프로파일링 (%)	15	19	66	100

표 1 MP3 결과들

이 예에서 실리콘 면적은 코프로세서 인스턴스를 부가한 결과로서 두배가 되었다. 수행은 12로 곱해졌기 때문에, 이것은 동일 수준의 성능을 여전히 유지하면면서도, 프로세서-코프로세서 시스템이 파워를 대략 6배 덜 소비함을 의미한다.

본 재구성가능 코프로세서 아키텍처 템플릿은 발명의 원리를 단지 나타냄이 명백함에 틀림이 없다. 인용된 아키텍처에 변형들 및 수정들은 발명의 범위 및 원리에서 벗어남이 없이 행해질 수 있다. 모든 이들 수정들 및 변형들은 다음 청구 본 발명의 범위 내에 포함되고 다음 청구항들에 의해 보호되어야 한다.

참조문헌들

[1] Katherine Compton, Scott Hauck, Reconfigurable computing: a survey of systems and software, ACM Computing Surveys (CSUR), v.34 n.2, p.171-210, June 2002.

[2] A. Abnous, "Low-Power Domain-Specific Processors for Digital Signal Processing," PhD thesis, Dept. of EECS, UC Berkeley, CA, USA, 2001.

[3] T. Miyamori, K. Olukotun, "REMARC: Reconfigurable Multimedia Array Coprocessor," IEICE Trans. on Information and Systems, vol. E82-D, No. 2, February 1999, pp. 389-397.

[4] John Reid Hauser , John Wawrzynek, Augmenting a microprocessor with reconfigurable hardware, 2000.

[5] Seth Copen Goldstein, Herman Schmit, Matthew Moe, Mihai Budiu, Srihari Cadambi, R. Reed Taylor, Ronald Laufer, PipeRench: a co/processor for streaming multimedia acceleration, Proceedings of the 26th annual international symposium on Computer architecture, p.28-39, May 01-04, 1999, Atlanta, Georgia.

[6] Hartej Singh, Ming-Hau Lee, Guangming Lu, Nader Bagherzadeh, Fadi J. Kurdahi, Eliseu M. Chaves Filho, MorphoSys: An Integrated Reconfigurable System for Data-Parallel and Computation-Intensive Applications, IEEE Transactions on Computers, v.49 n.5, p.465-481, May 2000.

[7] Ahmad Alsolaim , Janusz Starzyk , Jugen Becker , Manfred Glesner, Architecture and Application of a Dynamically Reconfigurable Hardware Array for Future Mobile Communication Systems, Proceedings of the 2000 IEEE Symposium on Field-Programmable Custom Computing Machines, p.205, April 17-19, 2000.

[8] Reiner W. Hartenstein , Rainer Kress, A datapath synthesis system for the reconfigurable datapath architecture, Proceedings of the 1995 conference on Asia Pacific design automation (CD-ROM), p.77-es, August 29-September 01, 1995, Makuhari, Massa, Chiba, Japan.

[9] Elliot Waingold , Michael Taylor , Devabhaktuni Srikrishna , Vivek Sarkar , Walter Lee , Victor Lee , Jang Kim , Matthew Frank , Peter Finch , Rajeev Barua , Jonathan Babb , Saman Amarasinghe , Anant Agarwal, Baring It All to Software: Raw Machines, Computer, v.30 n.9, p.86-93, September 1997.

[10] E. Mirsky, A. DeHon, "MATRIX: A Reconfigurable Computing Architecture with Configurable Instruction Distribution and Deployable Resources," FCCM '96 - IEEE Symposium on FPGAs for Custom Computing Machines, Napa, CA, April 1996.

[11] Alan Marshall, Tony Stansfield , Igor Kostarnov, Jean Vuillemin, Brad Hutchings, A reconfigurable arithmetic array for multimedia applications, Proceedings of the 1999 ACM/SIGDA seventh international symposium on Field programmable gate arrays, p.135-143, February 21-23, 1999, Monterey, California.

[12] R. D. Witting and P.Chow, OneChip: An FPGA processor with reconfigurable logic. In Proceedings of the IEEE Symposium on FPGAs for Cistom Computing Machines (FCCM'6), pages 126-135, 1996.

[13] J.M. Rabaey, "Reconfigurable Computing: The Solution to Low Power Programmable DSP" Proceedings 1997 ICASSP Conference, Munich, April 1997.

[14] Ebeling, C., Cronquist, D., and Franklin, P. 1996 RaPID Reconfigurable Pipelined Datapath. In the 6th International Workshop on Field-Programmable Logic and Applications.

[15] R. Razdan and M. D. Smith. High-performance microarchitectures with hardware-programmable functional units. In Proceedings of the IEEE/ACM International Symposium on Mircoarchitecture, pages 172-180, 1994.

[16] C. R. Rupp, M. Landguth, T. Garverick, E. Gomersall, H. Holt, J.M. Arnold, and M. Gokhale. The NAPA adapative processing architecture. In Porceedings of the IEEE Symposium on FPGAs for Custom Computing Machines (FCCM'98), pages 28-37, 1998.

[17] Salvatore M. Carta, Danilo Pani, Luigi Raffo. Reconfigurable Coprocessor for Multimedia Application Domain, In Journal of VLSI Signal Processing 44, 135-152, 2006.

[18] CHAMELEON SYSTEMS, Inc. 2000. CS2000 Advance Product Specification. Chameleon Systens Inc., Sna Jose, CA.

[19] Pact XPP Technologies, "XPP-III Processor Overview (White Paper)", July 2006.

도 1은 프로그램가능 멀티플렉서.

도 2는 프로세서 아키텍처 템플릿의 최 상위 도.

도 3은 주소 발생 유닛의 아키텍처.

도 4는 타이밍 유닛 행렬.

도 5는 지연유닛.

도 6은 기본 누산기 유닛.

도 7은 복합 누산기 유닛.

도 8은 인에이블 크로스바에서 누산기 인에이블 및 재시작 인에이블 신호들의 선택도.

도 9는 입력 크로스바에서 각각의 누산기 유닛에 대한 시작, 증분 및 오프셋 신호들의 선택도.

도 10은 출력 크로스바에서 누산기 카운트 신호들로부터의 메모리 포트 주소의 선택도.

도 11은 기능유닛 입력들을 위한 신호들의 선택도.

도 12는 시스템 출력들 및 메모리 입력들의 선택도.

도 13은 제어/구성, 데이터 입력 및 데이터 출력 인터페이스들.

도 14는 제어 레지스터.

도 15는 상태 레지스터.

도 16은 제어 회로.

도 17은 기능유닛들에 의해 발행된 브레이크 조건들의 선택도.

도 18은 I/O 종속 시스템 인에이블의 선택도.

도 19는 코프로세서 프로그래밍 흐름도.

도 20은 데이터 흐름 그래프의 예시도.

도 21은 주소 흐름 그래프 예시도.

Claims

산술 및 논리 연산들을 내포하는 중첩 루프들의 표현들을 계산하는데 특별화된, 재구성가능 코프로세서의 아키텍처 템플릿에 있어서,

애플리케이션 영역에 따라 선택되는 것으로, 한 선형 어레이의 특정되지 않은 수 및 유형의 재구성가능한, 파이프라인된 혹은 되지 않은, 기능유닛들;

중간 데이터 및 주소 계산들을 저장하기 위한, 한 선형 어레이의 특정되지 않은 수 및 유형의 내장된 메모리들;

상기 내장된 메모리들에 대한 복합 시퀀스들의 주소들을 계산하기 위한, 재구성가능한 주소 발생기 블록;

상기 기능유닛 입력들에 시스템 입력들, 메모리 데이터 출력포트들, 및 프로그램된 상수들을 연결하기 위해서, 사전-합성 시간에 정의되는, 부분적 및 재구성가능한 독출 크로스바;

기능 유닛 출력들을 시스템 출력들 혹은 메모리 데이터 입력포트들에 연결하기 위해서, 사전-합성 시간에 정의되는, 부분적 및 재구성가능한 기입 크로스바;

제어, 상태, 및 구성 레지스터들을 내포하는 레지스터 파일로서, 상기 구성 레지스터들은 상기 재구성가능 기능유닛들, 재구성가능 주소 발생기 블록, 부분적 및 재구성가능한 연결 크로스바들의 구성을 저장하고 상기 데이터 및 주소 계산들에서 사용되는 상수들을 더 저장하는, 상기 레지스터 파일을 포함하는, 재구성가능 코프로세서의 아키텍처 템플릿.
제1항에 있어서, 상기 재구성가능 주소 발생기 블록은,

주소들의 발생을 시작, 정지 및 재개하여, 이에 따라 상기 코프로세서로 하여금 실행을 시작, 정지 및 재개하게 하는, 제어유닛;

상기 다양한 내장된 메모리들에 저장된 어레이들을 인덱스하기 위해 주소들의 적시에 발생과, 상기 기능유닛들에 기능들을 적시에 활성화하며, 시스템 출력들 및 메모리 기입들을 적시에 요청하는데 사용되는, 인에이블 신호들을 발생하는 프로그램가능 타이밍 유닛;

복합 주소 시퀀스들을 생성하기 위해 상호접속되는 한 선형 어레이의 프로그램가능 누산기들;

상기 어레이 내 상기 누산기들에 상기 인에이블 신호들을 연결하고, 상기 시스템 입력들에서 외부 데이터의 읽음을 어크놀리지하는, 사전 합성 시간에 정의되는, 부분적 및 재구성가능 인에이블 크로스바;

누산기 출력들 및 구성 상수들을 다른 누산기 입력들에 연결하는, 사전-합성 시간에 정의되는, 부분적 및 재구성가능 입력 크로스바;

상기 발생된 주소들을 형성하는 누산기 출력들, 및 각각의 인에이블 신호들을 메모리 주소 포트들에 연결하고, 메모리에 저장된 주소들의 경우에 메모리 데이터 포트들을 메모리 주소 포트들에 루트를 정하는, 사전-합성 시간에 정의되는, 부분적 및 재구성가능 출력 크로스바를 포함하는, 재구성가능 코프로세서의 아키텍처 템플릿.
제2항에 따른 재구성가능 주소 발생기 블록으로서, 상기 프로그램가능 타이밍 유닛은,

한 행렬의 프로그램가능 카운터들로서, 각 행은 사이클들에서 동일 지연을 갖는 것이 특징인 일 그룹의 인에이블 신호들을 생성하고, 컬럼들의 수는 코프로세서가 행할 수 있는 최대 수의 중첩 루프들을 나타내며, 한 컬럼 내 모든 카운터들은 동일 최종 한계로 프로그램되는 것으로, 상기 카운터들이 제어하는 루프의 반복 횟수를 결정하는, 상기 한 행렬의 프로그래가능 카운터들;

주어진 구성에서 실제 수의 중첩 루프들을, 프로그램 컬럼들의 수를 사용하여, 결정하는 엔코더;

최대 허용된 지연까지 전역 인에이블 신호를 지연시키고, 각 인에이블 그룹에 대해 프로그램된 지연을 가진 인에이블 신호들을 출력하며, 아키텍처에서 최대 허용된 지연과는 다를 수 있는, 현 구성에서의 지연없는 인에이블 및 최대 지연을 포함하는 지연유닛을 포함하는, 재구성가능 주소 발생기 블록.
제3항에 따른 프로그램가능 타이밍 유닛으로서, 상기 한 행렬의 프로그램가능 카운터들에 의해 생성된 상기 인에이블 신호들은 데이터 스트림들을 서로에 대하여 지연시키고, 서로 다른 지연들을 갖는 기능유닛들에 의해 야기되는 데이터 흐름 그래프에서의 서로 다른 레이턴시들을 보상하는데 사용되며, 입력들 혹은 메모리들로부터 데이터의 읽기 시간을 정하는 동작, 인에이브들 및 데이터가 동등하게 지연되는 기능유닛들을 통해 데이터를 동반시키는 동작, 출력들 혹은 메모리들에 데이터의 쓰기의 시간을 정하는 동작을 수행하는, 프로그램가능 타이밍 유닛.
제2항에 따른 재구성가능 주소 발생기 블록으로서, 상기 프로그램가능 누산기들은,

상기 누산기의 시작값을 명시하는 입력신호로서, 이 입력은 또 다른 누산기에 의해서, 혹은 상기 입력 크로스바를 통해 구성 상수에 의해 구동될 수 있는, 상기 입력신호,

상기 누산기의 증분값을 명시하는 입력신호로서, 이 입력은 또 다른 누산기에 의해서 혹은 상기 입력 크로스바를 통해 구성 상수에 의해 구동되는, 상기 입력신호;

상기 누산기의 동작을 인에이블하는 인에이블 신호;

시작 값을 재 로딩하는 재시작 인에이블 신호;

상기 누산기가 복합 누산기 유닛인 경우 상기 누산기의 오프셋 값을 명시하는 입력신호로서, 이 입력은 또 다른 누산기에 의해서 혹은 상기 입력 크로스바를 통해 구성 상수에 의해 구동되는, 상기 입력신호;

상기 누산기가 복합 누산기 유닛인 경우 상기 누산기의 모듈로 값을 명시하는 구성 레지스터;

상기 발생된 주소로서 혹은 또 다른 누산기의 입력으로서 사용될 출력 누산된 값을 포함하는, 재구성가능 주소 발생기 블록.
제1항에 있어서, 상기 구성, 상태 및 제어 레지스터 파일은

미세 입도를 런타임으로 부분적 재구성하게 할 수 있는, 주소지정가능, 독출/기입 메모리 맵핑된 인터페이스;

외부 원조를 알리거나 요청하는 출력 요청 신호를 포함하는, 재구성가능 코프로세서의 아키텍처 템플릿.
제1항에 있어서, 상기 기능유닛 어레이에서 각 기능유닛은 상기 코프로세서를 중지시킬 수 있는 브레이크 신호를 발행하는, 재구성가능 코프로세서의 아키텍처 템플릿.
제1항에 있어서, 복수 시스템 입력들은 슬레이브 요청/어크놀리지 인터페이스들이며 복수 시스템 출력들은 마스터 요청/어크놀리지 인터페이스들인, 재구성가능 코프로세서의 아키텍처 템플릿.
제8항에 있어서, 시스템 입력 요청들 혹은 시스템 출력 어크놀리지들의 부재(absence)는 실행되는 표현들이 시스템 입력들로부터 데이터를 독출하고/하거나 시스템 출력에 데이터를 기입하는 것이라면 상기 코프로세서를 정지할 것인, 재구성가능 코프로세서의 아키텍처 템플릿.
제2항에 따른 재구성가능 주소 발생기 블록으로서, 상기 제어 유닛은 상기 코프로세서를 인에이블 및 디저블하며, 최외각 루프 인덱스가 랩 어라운드할 때 처리를 종료하며, 입력 데이터 부재, 출력 데이터 오버플로, 혹은 기능유닛들로부터 하나 이상의 브레이크 조건들이 나타날 때 상기 코프로세서를 정지시키는, 재구성가능 주소 발생기 블록.
제1항에 따른 아키텍처 템플릿용 코프로세서 프로그래밍 도구에 있어서,

상기 코프로세서의 아키텍처 디스크립션의 컴파일러;

통상의 프로세서를 위한 원 프로그램에 태그되고 재작성되며, 통상의 프로그래밍 언어의 신택스와 근본적으로 유사한 신택스를 사용하는, 중첩 루프 시퀀스들을 위한 파서(parser);

상기 코프로세서의 특정 구성으로 변환하는, 중첩 루프 시퀀스의 코드에 대한 컴파일러를 포함하는, 코프로세서 프로그래밍 도구.
제1항의 하드웨어 아키텍처 템플릿에 따르는 아키텍처 디스크립션 파일에 있어서,

재구성가능 기능유닛들의 수 및 유형의 디스크립션;

내장 메모리들의 수, 유형, 데이터 및 주소 폭들;

상기 재구성가능 주소 발생기 블록의 디스크립션;

상기 재구성가능 독출 및 기입 크로스바들의 디스크립션을 포함하는, 아키텍 처 디스크립션 파일.
제12항에 있어서, 상기 재구성가능 주소 발생기 블록의 디스크립션은

프로그램가능 타이밍 유닛 블록의 디스크립션;

프로그램가능 누산기들의 수 및 유형의 디스크립션;

재구성가능 인에이블, 입력 및 출력 크로스바들의 디스크립션을 포함하는, 아키텍처 디스크립션 파일.
제13항의 재구성가능 주소 발생 블록의 디스크립션으로서, 상기 프로그램가능 타이밍 유닛의 디스크립션은,

그룹 내 중첩 루프들의 수의 디스크립션;

발생될 인에이블 신호의 서로 다른 지연된 인에이블 신호들의 수의 디스크립션을 포함하는, 재구성가능 주소 발생 블록의 디스크립션.
제12항의 아키텍처 디스크립션 파일에 따른 구성 디스크립션 파일에 있어서,

파라미터/값 쌍들 관점에서 기능유닛들의 구성의 디스크립션;

포트들이 기능유닛 입력들에 아니면 출력들에 연결되는지로부터 함축적으로 추론된 독출 혹은 기입 모드들 관점에서 내장 메모리들의 구성;

재구성가능 주소 발생기 블록의 구성의 디스크립션;

재구성가능 독출 및 기입 크로스바들의 구성의 디스크립션을 포함하는, 아키 텍처 디스크립션 파일.
제15항의 구성 디스크립션 파일로서, 상기 재구성가능 주소 발생기 블록의 구성의 디스크립션은,

프로그램가능 타이밍 유닛 블록의 구성의 디스크립션;

각 프로그램가능 누산기의 구성의 디스크립션;

인에이블, 입력 및 출력 크로스바들의 구성의 디스크립션을 포함하는, 구성 디스크립션 파일.
제16항의 재구성가능 주소 발생 블록의 디스크립션으로서, 상기 프로그램가능 타이밍 유닛 구성의 디스크립션은,

각 중첩 루프의 최종 한계들의 디스크립션;

각 인에이블 신호 그룹에 대한 사이클 지연들의 수의 디스크립션을 포함하는, 재구성가능 주소 발생블록의 디스크립션.
제16항의 재구성가능 주소 발생 블록의 디스크립션에서, 상기 프로그램가능 누산기들의 디스크립션은,

구성 상수들에 연결된 경우 시작 및 증분 값들;

누산기가 복합 누산기 유닛이고 오프셋 입력이 구성 상수에 연결된 경우 오프셋 값;

누산기가 복합 누산기 유닛인 경우 모듈로 값을 포함하는, 재구성가능 주소 발생 블록의 디스크립션.
제11항에 있어서,

완전한 시스템 그래프를 도출하기 위해서 중첩 루프 바디들에서 산술 및 논리 표현들을 파싱하는 기능;

시스템 그래프 노드들의 순서화된 리스트를 생성하여, 이 순서로 아키텍처를 표현하는 하드웨어 그래프에 맵핑하게 될, 상기 시스템 그래프 노드들의 순서화된 리스트 생성 기능;

청구항 13의 아키텍처 디스크립션 파일을 파싱하여 하드웨어 그래프를 생성하는 기능;

시스템 그래프 내 각 노드를 하드웨어 그래프 내 노드에 순환적으로 맵핑하는 기능을 포함하는, 코프로세서 프로그래밍 도구.
제19항에 있어서, 상기 시스템 그래프는, 한 시퀀스의 구성 하위-그룹들을 포함하며, 각 구성 그래프는 중첩 루프 그룹에 대응하는, 코프로세서 프로그래밍 도구.
제20항의 시스템 그래프로서, 각 구성 하위-그래프는,

데이터 흐름 하위-그래프;

주소 흐름 하위-그래프를 포함하는, 시스템 그래프.
제21항의 구성 그래프로서, 상기 데이터 흐름 하위-그래프는,

소스 노드들로서, 메모리 노드(데이터 출력 포트들), 시스템 데이터 입력 노드, 구성 상수 노느들;

싱크 노느들로서, 메모리 노드(데이터 입력 포트들), 시스템 데이터 출력 노드;

중간 노드로서, 기능 유닛 노드를 포함하는, 구성 그래프.
제21항의 구성 그래프로서, 상기 주소 흐름 하위-그래프는,

소스들로서, 메모리 노드(데이터 출력 포트들), 타이밍 유닛 노드(인에이블 신호 출력 포트들), 구성 상수 노드;

싱크 노드들로서, 메모리 노드(주소 입력 포트들), 시스템 데이터 입력 노드(어크놀리지 신호들);

중간 노드로서, 누산기 유닛 노드를 포함하는, 구성 그래프.
제1항에 있어서, 중첩 루프 바디들에서 각 데이터 표현은 변수들, 어레이들 혹은 구성 상수들을 수반하는 논리 및 산술 표현에 변수 혹은 어레이의 할당으로 구성되는, 재구성가능 코프로세서의 아키텍처 템플릿.
제23항의 데이터 표현들에서, 각 어레이의 인덱스는 ((alpha*i + beta)%gamma) + delta 형태를 취해야 하며, i는 루프 변수이고, alpha, beta, gamma 및 delta는 내측에서 i까지 루프 변수를 사용하여 동일 형태의 표현들에 의해 순환적으로 정의될 수 있는, 데이터 표현.
제19항에 있어서, 시스템 그래프 내 노드를 하드웨어 그래프 내 노드에 순환적으로 맵핑하는 기능은, 주어진 시스템 노드에 맵핑될 수 있는 모든 후보 하드웨어 노드들의 리스트를 생성하고; 시스템 노드를 각 후보 하드웨어 노드에 시험적으로 맵핑하고 리스트 내 다음 시스템 노드를 맵핑하기를 순환적으로 시도하며; 성공적이면 현 맵핑을 유지하여 true를 리턴하며; 성공적이지 않으면 다음 후보 하드웨어 노드를 시도하고; 모든 후보들이 성공적이지 않은 것으로 시도된다면 false를 리턴하게 진행하는, 코프로세서 프로그래밍 도구.
제1항에 있어서, 많아야 메모리 데이터 포트들만큼의 다수의 메모리 액세스들이 병렬로 그리고 단일 사이클 내 수행될 수 있고, 모든 기능유닛들은 병렬로 그리고 단일 사이클 내 결과들을 생성할 수 있는, 재구성가능 코프로세서의 아키텍처 템플릿.
제1항에 있어서, 시스템의 수행은 클럭 주기 증가를 피하기 위해 연결 크로스바들에서 드문 링크들을 유지하면서, 기능유닛들 및 내장 메모리들이 수를 증가 시킴으로써 확장될 수 있는, 재구성가능 코프로세서의 아키텍처 템플릿.
제1항에 있어서,결과적인 코프로세서들은 동기적으로 연결되거나 동기식 선입선출 메모리들(FIFO)을 사용하여 연결되어, 전역적으로 비동기이고 국부적으로 동기적인 시스템을 형성하는, 재구성가능 코프로세서의 아키텍처 템플릿.