KR20220008809A - 헤테로지니어스 프로그래머블 디바이스를 위한 하드웨어-소프트웨어 설계 동안 흐름 수렴 - Google Patents

헤테로지니어스 프로그래머블 디바이스를 위한 하드웨어-소프트웨어 설계 동안 흐름 수렴 Download PDF

Info

Publication number
KR20220008809A
KR20220008809A KR1020217034941A KR20217034941A KR20220008809A KR 20220008809 A KR20220008809 A KR 20220008809A KR 1020217034941 A KR1020217034941 A KR 1020217034941A KR 20217034941 A KR20217034941 A KR 20217034941A KR 20220008809 A KR20220008809 A KR 20220008809A
Authority
KR
South Korea
Prior art keywords
dpe
compiler
interface block
hardware
constraint
Prior art date
Application number
KR1020217034941A
Other languages
English (en)
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 KR20220008809A publication Critical patent/KR20220008809A/ko

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/20—Software design
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F30/00—Computer-aided design [CAD]
    • G06F30/30—Circuit design
    • G06F30/34—Circuit design for reconfigurable circuits, e.g. field programmable gate arrays [FPGA] or programmable logic devices [PLD]
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • 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/3005—Arrangements for executing specific machine instructions to perform operations for flow control
    • 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/46—Multiprogramming arrangements
    • G06F9/461—Saving or restoring of program or task context
    • G06F9/463—Program control block organisation
    • 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/46—Multiprogramming arrangements
    • G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
    • G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
    • G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F2117/00—Details relating to the type or aim of the circuit design
    • G06F2117/08—HW-SW co-design, e.g. HW-SW partitioning

Abstract

디바이스의 DPE(data processing engine) 어레이에서 구현하기 위한 소프트웨어 부분과 디바이스의 PL(programmable logic)에서 구현하기 위한 하드웨어 부분을 가지는 애플리케이션의 경우 하드웨어 컴파일러를 실행하는 프로세서를 사용하여 DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 인터페이스 블록 솔루션에 기반하여 하드웨어 부분에 대해 구현 흐름이 수행된다. 구현 흐름 중에 설계 메트릭을 충족하지 못하는 것에 응답하여 하드웨어 컴파일러로부터 DPE 컴파일러로 인터페이스 블록 제약이 제공된다. 인터페이스 블록 제약을 수신하는 것에 응답하여, DPE 컴파일러를 실행하는 프로세서를 사용하여 업데이트된 인터페이스 블록 솔루션이 생성되고, DPE 컴파일러로부터 하드웨어 컴파일러로 제공된다.

Description

헤테로지니어스 프로그래머블 디바이스를 위한 하드웨어-소프트웨어 설계 동안 흐름 수렴
이 특허 문서의 개시의 부분은 저작권 보호 대상인 자료가 포함되어 있다. 저작권 소유자는 특허상표청 특허 파일 또는 기록에 나타나는 대로, 아무나 특허 문서 또는 특허 개시를 팩스로 복제하는 것에 반대하지 않지만, 그 외에는 무슨 일이 있어도 모든 저작권을 보유한다.
본 개시는 집적 회로(integrated circuit, IC)에 관한 것으로, 보다 구체적으로 헤테로지니어스 프로그래머블 IC 내에 하드웨어 및 소프트웨어 부분을 포함하는 애플리케이션을 구현하는 것에 관한 것이다.
프로그래머블 집적 회로(IC)는 프로그래머블 로직을 포함하는 IC의 타입을 말한다. 프로그래머블 IC의 예는 FPGA(Field Programmable Gate Array)이다. FPGA는 프로그래머블 회로 블록을 포함하는 것이 특징이다. 프로그래머블 회로 블록의 예에는 입력/출력 블록(input/output block, IOB), 구성 가능한 로직 블록(configurable logic block, CLB), 전용 랜덤 액세스 메모리 블록(dedicated random access memory block, BRAM), 디지털 신호 처리 블록(digital signal processing block, DSP), 프로세서, 클록 관리자, 및 지연 잠금 루프(delay lock loop, DLL)를 포함하지만, 이에 한정되는 것은 아니다.
현대의 프로그래머블 IC는 하나 이상의 다른 서브시스템과 조합한 프로그래머블 로직을 포함하도록 진화했다. 예를 들어, 일부 프로그래머블 IC는 프로그래머블 로직과 하드와이어드 프로세서 시스템을 모두 포함하는 시스템 온 칩(System-on-Chip) 또는 "SoC"로 발전했다. 다른 다양한 프로그래머블 IC에는 추가적인 및/또는 상이한 서브시스템이 포함된다. 프로그래머블 IC에 포함된 서브시스템의 이질성이 증가하면서 이러한 디바이스 내에서 애플리케이션을 구현하는 데 어려움이 있다. 하드웨어 및 소프트웨어 기반 서브시스템(예를 들어, 프로그래머블 로직 회로 및 프로세서)을 모두 가지는 IC의 기존 설계 흐름은 먼저 IC용 모놀리식(monolithic) 하드웨어 설계를 생성하는 하드웨어 설계자에 의존했다. 하드웨어 설계는 소프트웨어 설계가 그 후 창작(create), 컴파일 및 실행되는 플랫폼으로서 사용된다. 이 접근 장치는 종종 지나치게 제한적이다.
다른 경우에, 소프트웨어 및 하드웨어 설계 프로세스는 분리될 수 있다. 그러나 하드웨어와 소프트웨어 설계 프로세스를 분리해도 소프트웨어 요구 사항이나 IC의 다양한 서브시스템 사이에 인터페이스 배치(placement)가 표시되지 않는다. 이와 같이, 하드웨어 및 소프트웨어 설계 프로세스는 IC에서 애플리케이션의 작동 가능한 구현에 수렴하지 못할 수 있다.
일 양태에서, 방법은 디바이스의 데이터 처리 엔진(data processing engine, DPE) 어레이 내의 구현을 위한 소프트웨어 부분과 상기 디바이스의 프로그래머블 로직(programmable logic, PL) 내의 구현을 위한 하드웨어 부분을 명시(specify)하는 애플리케이션에 대해, 프로세서를 사용하여 애플리케이션을 위한 논리 아키텍처 및 논리 자원을 DPE 어레이와 프로그래머블 로직 사이의 인터페이스 회로 블록의 하드웨어에 매핑하는 것을 명시하는 제1 인터페이스 솔루션을 생성(generate)하는 단계를 포함할 수 있다. 방법은 논리 아키텍처 및 제1 인터페이스 솔루션에 기반하여 하드웨어 부분의 블록 다이어그램을 구축하는 단계 및 프로세서를 사용하여 블록 다이어그램에 대한 구현 흐름을 수행하는 단계를 포함할 수 있다. 방법은 프로세서를 사용하여 DPE 어레이의 하나 이상의 DPE에서의 구현을 위한 애플리케이션의 소프트웨어 부분을 컴파일하는 단계를 포함할 수 있다.
다른 양태에서, 시스템은 동작들을 개시하도록 구성된 프로세서를 포함한다. 동작들은 디바이스의 DPE 어레이 내에서의 구현을 위한 소프트웨어 부분과 디바이스의 PL 내에서의 구현을 위한 하드웨어 부분을 명시하는 애플리케이션에 대해, 애플리케이션을 위한 논리 아키텍처 및 논리 자원을 DPE 어레이와 프로그래머블 로직(PL) 사이의 인터페이스 회로 블록의 하드웨어에 매핑하는 것을 명시하는 제1 인터페이스 솔루션을 생성하는 동작을 포함할 수 있다. 동작들은 논리 아키텍처 및 제1 인터페이스 솔루션을 기반으로 하드웨어 부분의 블록 다이어그램을 구축하는 단계, 블록 다이어그램에 대한 구현 흐름을 수행하는 단계, DPE 어레이의 하나 이상의 DPE에서의 구현을 위해 애플리케이션의 소프트웨어 부분을 컴파일하는단계를 포함할 수 있다.
다른 양태에서, 컴퓨터 프로그램 제품은 프로그램 코드가 저장된 컴퓨터 판독 가능 저장 매체를 포함한다. 프로그램 코드는 동작들을 개시하기 위해 컴퓨터 하드웨어에 의해 실행 가능하다. 동작들은 디바이스의 DPE 어레이 내에서 구현하기 위한 소프트웨어 부분과 디바이스의 PL 내에서 구현하기 위한 하드웨어 부분을 명시하는 애플리케이션에 대해, 애플리케이션을 위한 논리 아키텍처 및 논리 자원을 DPE 어레이와 프로그래머블 로직(PL) 사이의 인터페이스 회로 블록의 하드웨어에 매핑하는 것을 명시하는 제1 인터페이스 솔루션을 생성하는 동작을 포함할 수 있다. 동작들은 논리 아키텍처 및 제1 인터페이스 솔루션을 기반으로 하드웨어 부분의 블록 다이어그램을 구축하는 동작, 블록 다이어그램에 대한 구현 흐름을 수행하는 동작, DPE 어레이의 하나 이상의 DPE에서의 구현을 위해 애플리케이션의 소프트웨어 부분을 컴파일하는 동작을 포함할 수 있다.
다른 양태에서, 방법은 디바이스의 DPE 어레이에서 구현하기 위한 소프트웨어 부분 및 디바이스의 PL에서 구현하기 위한 하드웨어 부분을 가지는 애플리케이션에 대해, 하드웨어 컴파일러를 실행하는 프로세서를 사용하여 DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 인터페이스 블록 솔루션에 기반하여 하드웨어 부분에 대한 구현 흐름을 수행하는 단계를 포함할 수 있다. 방법은 구현 흐름 동안 설계 메트릭을 충족하지 않는 것에 응답하여, 하드웨어 컴파일러를 실행하는 프로세서를 사용하여 DPE 컴파일러에 인터페이스 블록 제약(interface block constraint)을 제공하는 단계를 포함할 수 있다. 방법은 또한 인터페이스 블록 제약을 수신하는 것에 응답하여 DPE 컴파일러를 실행하는 프로세서를 사용하여 업데이트된 인터페이스 블록 솔루션을 생성하고 업데이트된 인터페이스 블록 솔루션을 DPE 컴파일러로부터 하드웨어 컴파일러로 제공하는 단계를 포함할 수 있다.
다른 양태에서, 시스템은 동작들을 개시하도록 구성된 프로세서를 포함한다. 동작들은 디바이스의 DPE 어레이에서 구현하기 위한 소프트웨어 부분 및 디바이스의 PL에서 구현하기 위한 하드웨어 부분을 가지는 애플리케이션에 대해, 하드웨어 컴파일러를 사용하여 DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 인터페이스 블록 솔루션에 기반하여 하드웨어 부분에 대한 구현 흐름을 수행하는 동작을 포함할 수 있다. 동작들은 구현 흐름 동안 설계 메트릭을 충족하지 않는 것에 응답하여, 하드웨어 컴파일러를 사용하여 DPE 컴파일러에 인터페이스 블록 제약을 제공하는 동작을 포함할 수 있다. 동작들은 또한 인터페이스 블록 제약을 수신하는 것에 응답하여 DPE 컴파일러를 사용하여 업데이트된 인터페이스 블록 솔루션을 생성하고 업데이트된 인터페이스 블록 솔루션을 DPE 컴파일러로부터 하드웨어 컴파일러로 제공하는 동작을 포함할 수 있다.
다른 양태에서, 컴퓨터 프로그램 제품은 프로그램 코드가 저장된 컴퓨터 판독 가능 저장 매체를 포함한다. 프로그램 코드는 동작들을 개시하기 위해 컴퓨터 하드웨어에 의해 실행 가능하다. 동작들은 디바이스의 DPE 어레이에서 구현하기 위한 소프트웨어 부분 및 디바이스의 PL에서 구현하기 위한 하드웨어 부분을 가지는 애플리케이션에 대해, 하드웨어 컴파일러를 사용하여 DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 인터페이스 블록 솔루션에 기반하여 하드웨어 부분에 대한 구현 흐름을 수행하는 동작을 포함할 수 있다. 동작들은 구현 흐름 동안 설계 메트릭을 충족하지 않는 것에 응답하여, 하드웨어 컴파일러를 사용하여 DPE 컴파일러에 인터페이스 블록 제약을 제공하는 동작을 포함할 수 있다. 동작들은 또한 인터페이스 블록 제약을 수신하는 것에 응답하여 DPE 컴파일러를 사용하여 업데이트된 인터페이스 블록 솔루션을 생성하고 업데이트된 인터페이스 블록 솔루션을 DPE 컴파일러로부터 하드웨어 컴파일러로 제공하는 동작을 포함할 수 있다.
다른 양태에서, 방법은 디바이스의 DPE 어레이 내에서의 구현을 위한 소프트웨어 부분 및 디바이스의 PL 내에서의 구현을 위한 HLS 커널을 가지는 하드웨어 부분을 명시하는 애플리케이션에 대해, 프로세서를 사용하여 DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어 자원에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 인터페이스 블록 솔루션을 생성하는 단계를 포함할 수 있다. 방법은 프로세서를 사용하여 DPE 어레이에서 구현될 소프트웨어 부분의 노드 및 HLS 커널 간의 연결을 명시하는 연결 그래프를 생성하는 단계 및 프로세서를 사용하여 연결 그래프 및 HLS 커널에 기반하여 블록 다이어그램을 생성하는 단계를 포함할 수 있고, 블록 다이어그램은 합성 가능하다(synthesizable). 방법은 프로세서를 사용하여 제1 인터페이스 솔루션에 기반하여 블록 다이어그램에 대한 구현 흐름을 수행하는 단계 및 프로세서를 사용하여 DPE 어레이의 하나 이상의 DPE에서의 구현을 위한 애플리케이션의 소프트웨어 부분을 컴파일하는 단계를 더 포함할 수 있다.
다른 양태에서, 시스템은 동작들을 개시하도록 구성된 프로세서를 포함한다. 동작들은 디바이스의 DPE 어레이 내에서의 구현을 위한 소프트웨어 부분 및 디바이스의 PL 내에서의 구현을 위한 HLS 커널을 가지는 하드웨어 부분을 명시하는 애플리케이션에 대해, DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어 자원에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 제1 인터페이스 솔루션을 생성하는 동작을 포함할 수 있다. 동작들은 DPE 어레이에서 구현될 소프트웨어 부분의 노드 및 HLS 커널 간의 연결을 명시하는 연결 그래프를 생성하는 동작 및 연결 그래프 및 HLS 커널에 기반하여 블록 다이어그램을 생성하는 동작을 포함할 수 있고, 블록 다이어그램은 합성 가능하다. 동작들은 제1 인터페이스 솔루션에 기반하여 블록 다이어그램에 대한 구현 흐름을 수행하는 동작 및 DPE 어레이의 하나 이상의 DPE에서의 구현을 위한 애플리케이션의 소프트웨어 부분을 컴파일하는 동작을 더 포함할 수 있다.
다른 양태에서, 컴퓨터 프로그램 제품은 프로그램 코드가 저장된 컴퓨터 판독 가능 저장 매체를 포함한다. 프로그램 코드는 동작들을 개시하기 위해 컴퓨터 하드웨어에 의해 실행 가능하다. 동작들은 디바이스의 DPE 어레이 내에서의 구현을 위한 소프트웨어 부분 및 디바이스의 PL 내에서의 구현을 위한 HLS 커널을 가지는 하드웨어 부분을 명시하는 애플리케이션에 대해, DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어 자원에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 제1 인터페이스 솔루션을 생성하는 동작을 포함할 수 있다. 동작들은 DPE 어레이에서 구현될 소프트웨어 부분의 노드 및 HLS 커널 간의 연결을 명시하는 연결 그래프를 생성하는 동작 및 연결 그래프 및 HLS 커널에 기반하여 블록 다이어그램을 생성하는 동작을 포함할 수 있고, 블록 다이어그램은 합성 가능하다. 동작들은 제1 인터페이스 솔루션에 기반하여 블록 다이어그램에 대한 구현 흐름을 수행하는 동작 및 DPE 어레이의 하나 이상의 DPE에서의 구현을 위한 애플리케이션의 소프트웨어 부분을 컴파일하는 동작을 더 포함할 수 있다.
이 요약 섹션은 단지 특정 개념을 소개하기 위해 제공되며 특허청구된 주제(subject matter)의 어느 핵심 또는 필수 특징도 식별하지 않는다. 본 발명의 장치(arrangement)의 다른 특징은 첨부 도면 및 다음의 상세한 설명으로부터 명백할 것이다.
본 발명의 장치는 첨부 도면에 예로서 도시되어 있다. 그러나, 도면은 본 발명의 장치를 도시된 특정 구현으로만 제한하는 것으로 해석되어서는 안 된다. 다음의 상세한 설명을 검토하고 도면을 참조하면 다양한 양태 및 이점이 명백해질 것이다.
도 1은 본 명세서에 설명된 하나 이상의 실시 예와 함께 사용하기 위한 컴퓨팅 노드의 예를 도시한다.
도 2는 SoC(System-on-Chip) 타입의 집적 회로(integrated circuit, IC)에 대한 예시적인 아키텍처를 도시한다.
도 3은 도 2의 DPE 어레이의 데이터 처리 엔진(data processing engine, DPE)에 대한 예시적인 아키텍처를 도시한다.
도 4는 도 3의 예시적인 아키텍처의 추가 양태를 도시한다.
도 5는 DPE 어레이에 대한 또 다른 예시적인 아키텍처를 도시한다.
도 6은 DPE 어레이의 SoC 인터페이스 블록의 타일에 대한 예시적인 아키텍처를 도시한다.
도 7은 도 1의 네트워크 온 칩(Network-on-Chip, NoC)의 예시적인 구현을 도시한다.
도 8은 NoC를 통해 도 1의 SoC에서 엔드포인트 회로들 사이의 연결을 도시하는 블록 다이어그램이다.
도 9는 다른 예에 따른 NoC를 나타내는 블록 다이어그램이다.
도 10은 NoC를 프로그래밍하는 예시적인 방법을 도시한다.
도 11은 NoC를 프로그래밍하는 다른 예시적인 방법을 도시한다.
도 12는 엔드포인트 회로들 사이의 NoC를 통한 예시적인 데이터 경로를 도시한다.
도 13은 NoC와 관련된 판독(read)/기입(write) 요청 및 응답을 처리하는 예시적인 방법을 도시한다.
도 14는 NoC 마스터 유닛의 예시적인 구현을 도시한다.
도 15는 NoC 슬레이브 유닛의 예시적인 구현을 예시한다.
도 16은 도 1과 관련하여 설명된 시스템에 의해 실행가능한 예시적인 소프트웨어 아키텍처를 도시한다.
도 17a 및 도 17b는 도 1과 관련하여 설명된 것과 같은 시스템을 사용하여 SoC에 매핑된 애플리케이션의 예를 도시한다.
도 18은 SoC에 매핑된 다른 애플리케이션의 예시적인 구현을 도시한다.
도 19는 도 1과 관련하여 설명된 시스템에 의해 실행가능한 다른 예시적인 소프트웨어 아키텍처를 도시한다.
도 20은 SoC에서 애플리케이션을 구현하기 위해 설계 흐름을 수행하는 예시적인 방법을 도시한다.
도 21은 SoC에서 애플리케이션을 구현하기 위해 설계 흐름을 수행하는 다른 예시적인 방법을 도시한다.
도 22는 하드웨어 컴파일러와 DPE 컴파일러 사이의 예시적인 통신 방법을 도시한다.
도 23은 SoC 인터페이스 블록 솔루션을 처리하는 예시적인 방법을 도시한다.
도 24는 SoC에서 구현하기 위한 애플리케이션의 다른 예를 도시한다.
도 25는 DPE 컴파일러에 의해 생성된 SoC 인터페이스 블록 솔루션의 예를 도시한다.
도 26은 DPE 컴파일러에 의해 수신된 라우팅 가능한 SoC 인터페이스 블록 제약의 예를 도시한다.
도 27은 라우팅 불가능한 SoC 인터페이스 블록 제약의 예를 도시한다.
도 28은 DPE 컴파일러가 도 27의 소프트 타입 SoC 인터페이스 블록 제약을 무시하는 예를 도시한다.
도 29는 라우팅 불가능한 SoC 인터페이스 블록 제약의 다른 예를 도시한다.
도 30은 도 29의 DPE 노드들의 예시적인 매핑을 도시한다.
도 31은 라우팅 불가능한 SoC 인터페이스 블록 제약의 다른 예를 도시한다.
도 32는 도 31의 DPE 노드들의 예시적인 매핑을 도시한다.
도 33은 도 1의 시스템에 의해 실행가능한 다른 예시적인 소프트웨어 아키텍처를 도시한다.
도 34는 SoC에서 애플리케이션을 구현하기 위해 설계 흐름을 수행하는 다른 예시적인 방법을 도시한다.
도 35는 SoC에서 애플리케이션을 구현하기 위해 설계 흐름을 수행하는 다른 예시적인 방법을 도시한다.
본 개시는 신규한 특징을 정의하는 청구범위로 마무리되지만, 본 개시 내에 기재된 다양한 특징은 도면과 함께 설명을 고려함으로써 더 잘 이해될 것이라고 믿어진다. 본 명세서에 설명된 프로세스(들), 머신(들), 제조물(들) 및 이들의 모든 변형은 예시의 목적을 위해 제공된다. 본 개시 내에 설명된 특정 구조 및 기능적 세부사항은 제한하는 것으로 해석되어서는 안 되며, 단지 청구범위에 대한 기초로서 그리고 실질적으로 임의의 적절하게 상세한 구조에 설명된 특징을 다양하게 사용하도록 당업자를 교시하기 위한 대표적인 기초로서 해석되어야 한다. 또한, 본 개시 내에서 사용된 용어 및 문구는 제한하려는 것이 아니라 설명된 특징에 대한 이해할 수 있는 설명을 제공하기 위한 것이다.
본 개시는 집적 회로(IC)에 관한 것으로, 보다 구체적으로는 헤테로지니어스 프로그래머블(heterogeneous and programmable) IC 내에 하드웨어 및 소프트웨어 부분을 포함하는 애플리케이션을 구현하는 것에 관한 것이다. 헤테로지니어스 프로그래머블 IC의 예는 디바이스, 예를 들어 본 명세서에서 "프로그래머블 로직" 또는 "PL"로 지칭되는 프로그래머블 회로 및 다수의 하드와이어드 프로그래머블 데이터 처리 엔진(DPE)을 포함하는 집적 회로이다. 복수의 DPE는 SoC(System-on-Chip) 인터페이스 블록을 통해 IC의 PL과 통신 가능하게 링크된 어레이로 배열될 수 있다. 본 개시 내에서 정의된 바와 같이, DPE는 프로그램 코드를 실행할 수 있는 코어 및 코어에 결합된 메모리 모듈을 포함하는 하드와이어드 프로그래머블 회로 블록이다. DPE는 본 개시 내에서 더 상세히 설명된 바와 같이 서로 통신할 수 있다.
설명된 바와 같이 디바이스에서 구현되도록 의도된 애플리케이션은 디바이스의 PL을 사용하여 구현되는 하드웨어 부분 및 디바이스의 DPE 어레이에서 구현되고 이에 의해 실행되는 소프트웨어 부분을 포함한다. 디바이스는 또한 추가 프로그램 코드, 예를 들어 애플리케이션의 다른 소프트웨어 부분을 실행할 수 있는 하드와이어드 프로세서 시스템 또는 "PS"를 포함할 수 있다. 예를 들어, PS는 중앙 처리 장치 또는 "CPU" 또는 프로그램 코드를 실행할 수 있는 기타 하드와이어드 프로세서를 포함한다. 이와 같이, 애플리케이션은 또한 PS의 CPU에 의해 실행되도록 의도된 추가 소프트웨어 부분을 포함할 수 있다.
본 개시 내에 설명된 본 발명의 장치에 따르면, 데이터 처리 시스템에 의해 수행될 수 있는 설계 흐름이 제공된다. 설계 흐름은 PL, DPE 어레이 및/또는 PS를 포함하는 헤테로지니어스 프로그래머블 IC 내에서 애플리케이션의 하드웨어 및 소프트웨어 부분을 모두 구현할 수 있다. IC는 또한 프로그래머블 NoC(Network-on-Chip)를 포함할 수 있다.
일부 구현에서, 애플리케이션은 복수의 상호 연결된 노드를 포함하는 데이터 흐름 그래프로서 명시된다. 데이터 흐름 그래프의 노드는 DPE 어레이 내 또는 PL 내의 구현을 위해 지정된다. 예를 들어, DPE에서 구현된 노드는 궁극적으로 DPE 어레이에서의 특정 DPE에 매핑된다. 애플리케이션에 사용되는 어레이의 각 DPE에 의해 실행되는 오브젝트 코드가 노드(들)를 구현하기 위해 생성된다. 예를 들어, PL에서 구현된 노드는 PL에서 합성 및 구현되거나 사전 구축된 코어(예를 들어, 레지스터 전달 레벨(Register Transfer Level) 또는 "RTL" 코어)를 사용하여 구현될 수 있다.
본 발명의 장치는 IC의 상이한 헤테로지니어스 서브시스템에서의 구현을 위해 애플리케이션의 상이한 부분의 구축 및 통합을 조정(coordinate)할 수 있는 예시적인 설계 흐름을 제공한다. 예시적인 설계 흐름 내의 상이한 단계(stage)들은 특정 서브시스템을 목표(target)로 한다. 예를 들어, 설계 흐름의 하나 이상의 단계는 PL에서 애플리케이션의 하드웨어 부분을 구현하는 것을 목표로 하는 반면, 설계 흐름의 하나 이상의 다른 단계는 DPE 어레이에서 애플리케이션의 소프트웨어 부분을 구현하는 것을 목표로 한다. 그러나 설계 흐름의 하나 이상의 다른 단계는 PS에서 애플리케이션의 다른 소프트웨어 부분을 구현하는 것을 목표로 한다. 여전히 설계 흐름의 또 다른 단계는 NoC를 통해 상이한 서브시스템 및/또는 회로 블록 간에 라우팅(routes) 또는 데이터 이송(data transfer)을 구현하는 것을 목표로 한다.
상이한 서브시스템에 대응하는 예시적인 설계 흐름의 상이한 단계는 서브시스템 특유의 상이한 컴파일러에 의해 수행될 수 있다. 예를 들어, 소프트웨어 부분은 DPE 컴파일러 및/또는 PS 컴파일러를 사용하여 구현될 수 있다. PL에서 구현될 하드웨어 부분은 하드웨어 컴파일러에 의해 구현될 수 있다. NoC에 대한 라우팅은 NoC 컴파일러에 의해 구현될 수 있다. 다양한 컴파일러는 애플리케이션이 IC에서 실행 가능하게 구현되는 솔루션으로 수렴하기 위해 애플리케이션에 의해 명시된 각 서브시스템을 구현하는 동안 서로 통신하고 상호 작용할 수 있다. 예를 들어, 컴파일러는 동작 중에 설계 데이터를 교환하여 애플리케이션에 대해 명시된 설계 메트릭이 충족되는 솔루션으로 수렴할 수 있다. 또한, 달성되는 솔루션(예를 들어, 디바이스에서 애플리케이션의 구현)은 애플리케이션의 다양한 부분이 디바이스의 각 서브시스템에 매핑되고 상이한 서브시스템 간의 인터페이스가 일관되고 상호 합의되는 솔루션이다.
본 개시 내에서 설명된 예시적인 설계 흐름을 사용하여, 시스템은 다른 경우 예를 들어, 애플리케이션의 모든 부분이 디바이스 상에서 공동으로 구현되는 경우보다 더 적은 시간(예를 들어, 더 적은 런타임) 내에 헤테로지니어스 프로그래머블 IC 내에서 애플리케이션을 구현할 수 있다. 또한, 본 개시 내에서 설명된 예시적인 설계 흐름은 애플리케이션의 각 부분이 완전히 독립적으로 매핑된 후 함께 연결(stitch)되거나 결합되는 다른 기존 기법을 사용하여 얻은 결과보다 종종 더 우수한 헤테로지니어스 프로그래머블 IC 내 애플리케이션의 결과적인 구현(예를 들어, 타이밍, 면적, 전력 등과 같은 설계 메트릭의 종결(closure))을 위한 실행 가능성 및 품질을 달성한다. 예시적인 설계 흐름은 적어도 부분적으로 상이한 서브시스템 간의 공유 인터페이스 제약에 의존하는 본 명세서에 설명된 느슨하게 결합된 조인트 수렴 기법을 통해 이러한 결과를 달성한다.
본 발명의 장치의 추가 양태는 도면을 참조하여 아래에서 더 상세히 설명된다. 예시의 단순성과 명료함의 목적을 위해, 도면에 도시된 요소는 반드시 축척대로 그려지지는 않았다. 예를 들어, 일부 요소의 치수는 명확성을 위해 다른 요소에 비해 과장될 수 있다. 또한, 적절하다고 생각되는 경우, 대응하는, 유사한(analogous) 또는 동일한(like) 특징을 나타내기 위해 도면 사이에 참조 번호가 반복된다.
도 1은 컴퓨팅 노드(100)의 예를 도시한다. 컴퓨팅 노드(100)는 호스트 데이터 처리 시스템(호스트 시스템)(102) 및 하드웨어 가속 보드(104)를 포함할 수 있다. 컴퓨팅 노드(100)는 하드웨어 가속 보드와 사용될 수 있는 컴퓨팅 환경의 오직 하나의 예시적인 구현이다. 이와 관련하여, 컴퓨팅 노드(100)는 독립형 용량으로, 베어 메탈 서버로서, 컴퓨팅 클러스터의 일부로서, 또는 클라우드 컴퓨팅 환경 내의 클라우드 컴퓨팅 노드로서 사용될 수 있다. 도 1은 본 명세서에 기술된 예의 사용 또는 기능의 범위에 대한 어떠한 제한도 암시하도록 의도되지 않는다. 컴퓨팅 노드(100)는 SoC(200) 내에서 애플리케이션을 구현하는 것과 관련하여 본 개시 내에서 설명된 다양한 동작을 수행할 수 있는 시스템 및/또는 컴퓨터 하드웨어의 예이다. 예를 들어, 컴퓨팅 노드(100)는 EDA(Electronic Design Automation) 시스템을 구현하는 데 사용될 수 있다.
호스트 시스템(102)은 다수의 다른 범용 또는 특수 목적 컴퓨팅 시스템 환경 또는 구성과 함께 동작한다. 호스트 시스템(102)과 함께 사용하기에 적합할 수 있는 컴퓨팅 시스템, 환경 및/또는 구성의 예는 개인용 컴퓨터 시스템, 서버 컴퓨터 시스템, 씬(thin) 클라이언트, 씩(thick) 클라이언트, 핸드헬드 또는 랩톱 디바이스, 멀티프로세서 시스템, 마이크로프로세서 기반 시스템, 셋톱 박스, 프로그래머블 소비자 전자 제품, 네트워크 PC, 미니컴퓨터 시스템, 메인프레임 컴퓨터 시스템 및 상기 시스템 또는 디바이스 중 임의의 것을 포함하는 분산 클라우드 컴퓨팅 환경 등을 포함하지만 이에 제한되지는 않는다.
도시된 바와 같이, 호스트 시스템(102)은 컴퓨팅 디바이스, 예를 들어 컴퓨터 또는 서버의 형태로 도시된다. 호스트 시스템(102)은 클러스터에서, 또는 통신 네트워크를 통해 링크된 원격 처리 디바이스들에 의해 작업이 수행되는 분산 클라우드 컴퓨팅 환경에서 독립형 디바이스로서 실행될 수 있다. 분산 클라우드 컴퓨팅 환경에서 프로그램 모듈은 메모리 저장 디바이스를 포함하는 로컬 및 원격 컴퓨터 시스템 저장 매체 모두에 위치될 수 있다. 호스트 시스템(102)의 컴포넌트는 하나 이상의 프로세서(106)(예를 들어, 중앙 처리 장치), 메모리(108), 및 메모리(108)를 포함하는 다양한 시스템 컴포넌트를 프로세서(106)에 결합하는 버스(110)를 포함할 수 있지만 이에 국한되지 않는다. 프로세서(들)(106)는 프로그램 코드를 실행할 수 있는 다양한 프로세서 중 임의의 것을 포함할 수 있다. 프로세서 타입의 예는 x86 타입의 아키텍처(IA-32, IA-64 등), 파워 아키텍처(Power Architecture), ARM 프로세서 등을 가지는 프로세서를 포함하지만 이에 국한되지 않는다.
버스(110)는 메모리 버스 또는 메모리 제어기, 주변 버스, 가속 그래픽 포트, 및 다양한 이용 가능한 버스 아키텍처 중 임의의 것을 사용하는 프로세서 또는 로컬 버스를 포함하는 임의의 여러 타입의 통신 버스 구조 중 하나 이상을 나타낸다. 예를 들어, 이러한 아키텍처는 ISA(Industry Standard Architecture) 버스, MCA(Micro Channel Architecture) 버스, EISA(Enhanced ISA) 버스, VESA(Video Electronics Standards Association) 로컬 버스, PCI(Peripheral Component Interconnect) 버스, 및 PCIe(PCI Express) 버스를 포함하지만 이에 국한되지 않는다.
호스트 시스템(102)은 일반적으로 다양한 컴퓨터 판독 가능 매체를 포함한다. 이러한 매체는 호스트 시스템(102)에 의해 액세스 가능한 임의의 이용 가능한 매체일 수 있고, 휘발성 매체, 비휘발성 매체, 이동식 매체, 및/또는 비이동식 매체의 임의의 조합을 포함할 수 있다.
메모리(108)는 랜덤 액세스 메모리(RAM)(112) 및/또는 캐시 메모리(114)와 같은 휘발성 메모리 형태의 컴퓨터 판독 가능 매체를 포함할 수 있다. 호스트 시스템(102)은 또한 다른 이동식/비이동식, 휘발성/비휘발성 컴퓨터 시스템 저장 매체를 포함할 수 있다. 예를 들어, 저장 시스템(116)은 비이동식, 비휘발성 자기 매체(도시되지 않고 일반적으로 "하드 드라이브"라고 불림)로부터 읽고 쓰기 위해 제공될 수 있다. 도시되지는 않았지만 이동식 비휘발성 자기 디스크(예를 들어, "플로피 디스크")에서 읽고 쓰기 위한 자기 디스크 드라이브 및 CD-ROM, DVD-ROM 또는 기타 광학 매체와 같은 이동식 비휘발성 광학 디스크에서 읽거나 쓰기 위한 광학 디스크 드라이브가 제공할 수 있다. 그러한 경우에, 각각은 하나 이상의 데이터 매체 인터페이스에 의해 버스(110)에 연결될 수 있다. 아래에 추가로 도시되고 설명되는 바와 같이, 메모리(108)는 이 개시 내에서 설명되는 기능 및/또는 동작을 수행하도록 구성된 프로그램 모듈(예를 들어, 프로그램 코드)의 세트(예를 들어, 적어도 하나)를 가지는 적어도 하나의 컴퓨터 프로그램 제품을 포함할 수 있다.
운영 체제, 하나 이상의 애플리케이션 프로그램, 기타 프로그램 모듈 및 프로그램 데이터뿐만 아니라 프로그램 모듈(120)의 세트(적어도 하나)를 가지는 프로그램/유틸리티(118)가 예로서 메모리(108)에 저장될 수 있지만, 이에 제한되지는 않는다. 프로그램 모듈(120)은 일반적으로 본 명세서에 기술된 바와 같은 본 발명의 실시 예의 기능 및/또는 방법론을 수행한다. 예를 들어, 프로그램 모듈(120)은 하나 이상의 애플리케이션 및 하드웨어 가속 보드(104) 및/또는 SoC(200)와 통신하기 위한 드라이버 또는 데몬을 포함할 수 있다.
프로그램/유틸리티(118)는 프로세서(106)에 의해 실행 가능하다. 프로그램/유틸리티(118) 및 프로세서(106)에 의해 사용, 생성 및/또는 작동되는 임의의 데이터 항목은 프로세서(106)에 의해 사용될 때 기능을 부여하는 기능적 데이터 구조이다. 본 개시에서 정의되는 바와 같이 "데이터 구조(data structure)"는 물리적 메모리 내에서 데이터의 데이터 모델의 조직(organization)을 물리적으로 구현한 것이다. 이와 같이 데이터 구조는 메모리의 특정 전기 또는 자기 구조 요소로 구성된다. 데이터 구조는 프로세서를 사용하여 실행되는 애플리케이션 프로그램에 의해 사용되는 메모리에 저장된 데이터에 물리적 조직을 부과한다.
호스트 시스템(102)은 버스(110)에 통신 가능하게 링크된 하나 이상의 입/출력(I/O) 인터페이스(128)를 포함할 수 있다. I/O 인터페이스(들)(128)는 호스트 시스템(102)이 외부 디바이스와 통신할 수 있게 하고, 사용자(들)가 호스트 시스템(102)과 상호작용할 수 있도록 하는 외부 디바이스에 결합할 수 있게 하고, 호스트 시스템(102)이 다른 컴퓨팅 디바이스 등과 통신할 수 있도록 하는 외부 디바이스에 결합할 수 있게 한다. 예를 들어, 호스트 시스템(102)은 I/O 인터페이스(들)(128)를 통해 디스플레이(130) 및 하드웨어 가속 보드(104)에 통신 가능하게 링크될 수 있다. 호스트 시스템(102)은 I/O 인터페이스(들)(128)를 통해 키보드(미도시)와 같은 다른 외부 디바이스와 결합될 수 있다. I/O 인터페이스(128)의 예는 네트워크 카드, 모뎀, 네트워크 어댑터, 하드웨어 제어기 등을 포함할 수 있지만, 이에 국한되지 않는다.
예시적인 구현에서 호스트 시스템(102)이 하드웨어 가속 보드(104)와 통신하는 I/O 인터페이스(128)는 PCIe 어댑터이다. 하드웨어 가속 보드(104)는 호스트 시스템(102)에 결합되는 회로 보드, 예를 들어 카드로서 구현될 수 있다. 하드웨어 가속 보드(104)는 예를 들어 카드 슬롯, 예를 들어, 이용 가능한 버스 및/또는 호스트 시스템(102)의 PCIe 슬롯 내에 삽입될 수 있다.
하드웨어 가속 보드(104)는 SoC(200)를 포함한다. SoC(200)는 헤테로지니어스 프로그래머블 IC이고, 그렇게 복수의 헤테로지니어스 서브시스템을 가진다. SoC(200)에 대한 예시적인 아키텍처는 도 2와 관련하여 더 상세히 설명된다. 하드웨어 가속 보드(104)는 또한 SoC(200)에 결합된 휘발성 메모리(134) 및 SoC(200)에도 결합된 비휘발성 메모리(136)를 포함한다. 휘발성 메모리(134)는 RAM으로서 구현될 수 있고 SoC(200)의 "로컬 메모리"로 간주되는 반면, 호스트 시스템(102) 내에 있는 메모리(108)는 SoC(200)에 대해 로컬인 것으로 간주되지 않고 호스트 시스템(102)에 대해 로컬인 것으로 간주된다. 일부 구현에서, 휘발성 메모리(134)는 수 기가바이트의 RAM, 예를 들어 64GB의 RAM을 포함할 수 있다. 비휘발성 메모리(136)의 예는 플래시 메모리를 포함한다.
도 1의 예에서, 컴퓨팅 노드(100)는 SoC(200)를 위한 애플리케이션에서 동작할 수 있고 SoC(200) 내에서 애플리케이션을 구현할 수 있다. 애플리케이션은 SoC(200)에서 이용가능한 상이한 헤테로지니어스 서브시스템에 대응하는 하드웨어 및 소프트웨어 부분을 포함할 수 있다. 일반적으로, 컴퓨팅 노드(100)는 SoC(200)에 의한 실행을 위해 애플리케이션을 SoC(200)에 매핑할 수 있다.
도 2는 SoC(200)에 대한 예시적인 아키텍처를 도시한다. SoC(200)는 프로그래머블 IC 및 통합된 프로그래머블 디바이스 플랫폼의 예이다. 도 2의 예에서, 도시된 SoC(200)의 다양한 상이한 서브시스템 또는 영역(region)은 단일 통합 패키지 내에 제공된 단일 다이 상에서 구현될 수 있다. 다른 예에서, 상이한 서브시스템은 단일의 통합 패키지로서 제공되는 복수의 상호 연결된 다이 상에서 구현될 수 있다.
예에서, SoC(200)는 상이한 기능을 가지는 회로를 가지는 복수의 영역을 포함한다. 이 예에서, SoC(200)는 선택적으로 데이터 처리 엔진(data processing engine, DPE) 어레이(202)를 포함한다. SoC(200)는 프로그래머블 로직(PL) 영역(214)(이하 PL 영역(들) 또는 PL), 처리 시스템(PS)(212), 네트워크-온-칩(NoC)(208), 및 하나 이상의 하드와이어드 회로 블록(210)을 포함한다. DPE 어레이(202)는 SoC(200)의 다른 영역에 대한 인터페이스를 가지는 복수의 상호 연결되고 하드와이어된 프로그래머블 프로세서로서 구현된다.
PL(214)은 명시된 기능을 수행하도록 프로그래밍될 수 있는 회로이다. 예로서, PL(214)은 필드 프로그래머블 게이트 어레이 타입의 회로로서 구현될 수 있다. PL(214)은 프로그래머블 회로 블록의 어레이를 포함할 수 있다. PL(214) 내의 프로그래머블 회로 블록의 예는 구성 가능한 로직 블록(configurable logic block, CLB), 전용 랜덤 액세스 메모리 블록(BRAM 및/또는 UltraRAM 또는 URAM), 디지털 신호 처리 블록(digital signal processing block, DSP), 클록 관리자 및 /또는 지연 잠금 루프(delay lock loop, DLL)를 포함하지만, 이에 국한되지 않는다.
PL(214) 내의 각 프로그래머블 회로 블록은 일반적으로 프로그래머블 인터커넥트 회로 및 프로그래머블 로직 회로 모두를 포함한다. 프로그래머블 인터커넥트 회로는 일반적으로 프로그래머블 PIP(progammable interconnect point)에 의해 상호 연결된 다양한 길이의 많은 수의 인터커넥트 와이어를 포함한다. 전형적으로, 인터커넥트 와이어는 비트 단위로(예를 들어, 각 와이어가 단일 비트의 정보를 전달하는 경우) 연결을 제공하도록 (예를 들어, 와이어 단위로) 구성된다. 프로그래머블 로직 회로는 예를 들어 룩업 테이블, 레지스터, 산술 로직 등을 포함할 수 있는 프로그래머블 요소를 사용하여 사용자 설계의 로직을 구현한다. 프로그래머블 상호 연결 및 프로그래머블 로직 회로는 프로그래머블 요소가 구성되고 작동하는 방법을 정의하는 내부 구성 메모리 셀 내로 구성 데이터를 로딩함으로써 프로그래밍될 수 있다.
PS(212)는 SoC(200)의 일부로서 제조되는 하드와이어드 회로로서 구현된다. PS(212)는 각각 프로그램 코드를 실행할 수 있는 임의의 다양한 상이한 프로세서 타입으로서 구현되거나 이를 포함할 수 있다. 예를 들어, PS(212)는 개별 프로세서, 예를 들어 프로그램 코드를 실행할 수 있는 단일 코어로서 구현될 수 있다. 다른 예에서, PS(212)는 멀티 코어 프로세서로서 구현될 수 있다. 또 다른 예에서, PS(212)는 하나 이상의 코어, 모듈, 코-프로세서, 인터페이스, 및/또는 다른 자원을 포함할 수 있다. PS(212)는 다양한 상이한 타입의 아키텍처 중 임의의 것을 사용하여 구현될 수 있다. PS(212)를 구현하는 데 사용될 수 있는 예시적인 아키텍처는 ARM 프로세서 아키텍처, x86 프로세서 아키텍처, GPU 아키텍처, 모바일 프로세서 아키텍처, DSP 아키텍처, 컴퓨터 판독 가능 명령어들 또는 프로그램 코드를 실행할 수 있는 기타 적절한 아키텍처, 및/또는 상이한 프로세서 및/또는 프로세서 아키텍처의 조합를 포함할 수 있지만 이에 국한되지는 않는다.
NoC(208)는 SoC(200) 내의 엔드포인트 회로 사이에서 데이터를 공유하기 위한 상호 연결 네트워크를 포함한다. 엔드포인트 회로는 DPE 어레이(202), PL 영역(214), PS(212), 및/또는 하드와이어드 회로 블록(210)에 배치될 수 있다. NoC(208)는 전용 스위칭이 있는 고속 데이터 경로를 포함할 수 있다. 예에서, NoC(208)는 수평 경로(path), 수직 경로, 또는 수평 및 수직 경로 모두를 포함한다. 도 1에 도시된 영역의 배열 및 수는 예시일 뿐이다. NoC(208)는 선택된 컴포넌트 및/또는 서브시스템을 연결하기 위해 SoC(200) 내에서 사용할 수 있는 공통 인프라 구조의 예이다.
NoC(208)는 PL(214), PS(212) 및 하드와이어드 회로 블록(210) 중 선택된 것에 대한 연결을 제공한다. NoC(208)는 프로그래밍 가능하다. 다른 프로그래머블 회로와 함께 사용되는 프로그래머블 NoC의 경우, NoC(208)를 통해 라우팅되어야 하는 네트 및/또는 데이터 이송은 SoC(200) 내에서 구현하기 위해 사용자 회로 설계가 생성될 때까지 알 수 없다. NoC(208)는 스위치 및 인터페이스와 같은 NoC(208) 내의 요소들이 어떻게 구성되고 스위치에서 스위치로 NoC 인터페이스 간에 데이터를 전달하기 위해 요소들이 어떻게 작동하는지 정의하는 내부 구성 레지스터(configuration register) 내로 구성 데이터를 로딩함으로써 프로그래밍될 수 있다.
NoC(208)는 SoC(200)의 일부로서 제조되고 물리적으로 수정가능하지 않지만, 사용자 회로 설계의 상이한 마스터 회로와 상이한 슬레이브 회로 사이의 연결을 확립하도록 프로그래밍될 수 있다. 예를 들어, NoC(208)는 사용자 명시(user specified) 마스터 회로와 슬레이브 회로를 연결하는 패킷 교환 네트워크를 확립할 수 있는 복수의 프로그래머블 스위치를 포함할 수 있다. 이와 관련하여, NoC(208)는 상이한 회로 설계에 적응할 수 있으며, 여기서 각각의 상이한 회로 설계는 NoC(208)에 의해 결합될 수 있는 SoC(200)의 상이한 위치에서 구현된 마스터 회로 및 슬레이브 회로의 상이한 조합을 가진다. NoC(208)는 사용자 회로 설계의 마스터 및 슬레이브 회로 간에 데이터, 예를 들어 애플리케이션 데이터 및/또는 구성 데이터를 라우팅하도록 프로그래밍될 수 있다. 예를 들어, NoC(208)는 PL(214) 내에서 구현된 상이한 사용자 명시 회로를 PS(212) 및/또는 DPE 어레이(202)와, 상이한 하드와이어드 회로 블록과 및/또는 SoC(200) 외부의 상이한 회로 및/또는 시스템과 결합하도록 프로그래밍될 수 있다.
하드와이어드 회로 블록(210)은 입력/출력(I/O) 블록, 및/또는 SoC(200) 외부의 회로 및/또는 시스템, 메모리 제어기 등에 신호를 송수신하기 위한 트랜시버를 포함할 수 있다. 상이한 I/O 블록들의 예는 단일 종단(single-ended) 및 의사 차동(pseudo differential) I/O와 고속 차동 클록 트랜시버를 포함할 수 있다. 또한, 하드와이어드 회로 블록(210)은 특정 기능을 수행하도록 구현될 수 있다. 하드와이어드 회로 블록(210)의 추가 예는 암호화 엔진, 디지털-아날로그 변환기, 아날로그-디지털 변환기 등을 포함하지만 이에 국한되지 않는다. SoC(200) 내의 하드와이어드 회로 블록(210)은 본 명세서에서 때때로 애플리케이션-특유의 블록으로 지칭될 수 있다.
도 2의 예에서, PL(214)은 2개의 개별 영역에 도시되어 있다. 다른 예에서, PL(214)은 프로그래머블 회로의 통합 영역으로서 구현될 수 있다. 또 다른 예에서, PL(214)은 프로그래머블 회로의 2개보다 많은 상이한 영역으로서 구현될 수 있다. PL(214)의 특정 조직은 제한하려는 것이 아니다. 이와 관련하여, SoC(200)는 하나 이상의 PL 영역(214), PS(212), 및 NoC(208)를 포함한다.
다른 예시적인 구현에서, SoC(200)는 IC의 상이한 영역에 위치된 2개 이상의 DPE 어레이(202)를 포함할 수 있다. 또 다른 예들에서, SoC(200)는 멀티 다이 IC로서 구현될 수 있다. 이 경우 각 서브시스템은 상이한 다이에서 구현될 수 있다. IC가 다중 칩 모듈(Multi-Chip Module, MCM) 등으로서 구현되는 적층 다이 아키텍처를 사용하여 인터포저에 다이를 나란히 적층하는 것과 같은 임의의 다양한 사용 가능한 멀티 다이 IC 기술을 사용하여 상이한 다이들이 통신 가능하게 링크될 수 있다. 멀티-다이 IC 예에서, 각각의 다이는 단일 서브시스템, 둘 이상의 서브시스템, 서브시스템 및 다른 부분적인 서브시스템, 또는 이들의 임의의 조합을 포함할 수 있음을 이해해야 한다.
DPE 어레이(202)는 SoC 인터페이스 블록(206)을 포함하는 DPE(204)의 2차원 어레이로서 구현된다. DPE 어레이(202)는 본 명세서에서 아래에서 더 상세히 설명될 다양한 상이한 아키텍처 중 임의의 것을 사용하여 구현될 수 있다. 제한이 아닌 예시의 목적으로, 도 2는 정렬된 행 및 정렬된 열로 배열된 DPE(204)를 도시한다. 그러나, 다른 실시 예에서, DPE(204)는 선택된 행 및/또는 열의 DPE가 인접한 행 및/또는 열의 DPE에 대해 수평으로 반전되거나 뒤집힌 곳에 배열될 수 있다. 하나 이상의 다른 실시 예에서, DPE의 행 및/또는 열은 인접한 행 및/또는 열에 대해 오프셋될 수 있다. 하나 이상의 또는 모든 DPE(204)는 각각 프로그램 코드를 실행할 수 있는 하나 이상의 코어를 포함하도록 구현될 수 있다. DPE(204)의 수, DPE(204)의 특정 배열, 및/또는 DPE(204)의 방향은 제한적인 것으로 의도되지 않는다.
SoC 인터페이스 블록(206)은 DPE(204)를 SoC(200)의 하나 이상의 다른 서브시스템에 결합할 수 있다. 하나 이상의 실시 예에서, SoC 인터페이스 블록(206)은 인접한 DPE(204)에 결합된다. 예를 들어, SoC 인터페이스 블록(206)은 DPE 어레이(202)의 DPE의 하단 행에서 각 DPE(204)에 직접 결합될 수 있다. 예시에서, SoC 인터페이스 블록(206)은 DPE(204-1, 204-2, 204-3, 204-4, 204-5, 204-6, 204-7, 204-8, 204-9 및 204-10)에 직접 연결될 수 있다.
도 2는 설명의 목적을 위해 제공된다. 다른 실시 예에서, SoC 인터페이스 블록(206)은 DPE 어레이(202)의 상단에, DPE 어레이(202)의 왼쪽에(예를 들어, 열로서), DPE 어레이(202)의 오른쪽에(예를 들어, 열로서), 또는 DPE 어레이(202) 내부 및 주변의 다수의 위치에(예를 들어, DPE 어레이(202) 내의 하나 이상의 개재 행 및/또는 열로서) 위치될 수 있다. SoC 인터페이스 블록(206)의 레이아웃 및 위치에 따라, SoC 인터페이스 블록(206)에 결합된 특정 DPE는 변할 수 있다.
예시의 목적으로 SoC 인터페이스 블록(206)이 DPE(204)의 왼쪽에 위치되면, SoC 인터페이스 블록(206)은 DPE(204-1), DPE(204-11), DPE(204-21) 및 DPE(204-31)를 포함하는 DPE의 왼쪽 열에 직접 결합될 수 있다. SoC 인터페이스 블록(206)이 DPE(204)의 오른쪽에 위치되면, SoC 인터페이스 블록(206)은 DPE(204-10), DPE(204-20), DPE(204-30), 및 DPE(204-40)를 포함하는 DPE의 오른쪽 열에 직접 결합될 수 있다. SoC 인터페이스 블록(206)이 DPE(204)의 상단에 위치되면, SoC 인터페이스 블록(206)은 DPE(204-31), DPE(204-32), DPE(204-33), DPE(204-34), DPE(204-35), DPE(204-36), DPE(204-37), DPE(204-38), DPE(204-39) 및 DPE(204-40)를 포함하는 DPE의 상단 행에 결합될 수 있다. SoC 인터페이스 블록(206)이 다수의 위치에 위치되는 경우, SoC 인터페이스 블록(206)에 직접 연결된 특정 DPE는 변할 수 있다. 예를 들어, SoC 인터페이스 블록이 DPE 어레이(202) 내에서 행 및/또는 열로서 구현된다면, SoC 인터페이스 블록(206)에 직접 결합된 DPE는 SoC 인터페이스 블록(206)의 하나 이상 또는 각 측면에서 SoC 인터페이스 블록(206)에 인접한 것일 수 있다.
DPE(204)는 집합적으로 취해질 때 DPE 인터커넥트 네트워크를 형성하는 DPE 인터커넥트(미도시)에 의해 상호 접속된다. 이와 같이, SoC 인터페이스 블록(206)은 SoC 인터페이스 블록(206)에 직접 연결된 DPE 어레이(202)의 하나 이상의 선택된 DPE(204)와 통신하고 각각의 DPE(204) 내에서 구현된 DPE 인터커넥트로 형성된 DPE 인터커넥트 네트워크를 이용함으로써, DPE 어레이(202)의 임의의 DPE(204)와 통신할 수 있다.
SoC 인터페이스 블록(206)은 DPE 어레이(202) 내의 각 DPE(204)를 SoC(200)의 하나 이상의 다른 서브시스템과 결합할 수 있다. 예를 들어, SoC 인터페이스 블록(206)은 DPE 어레이(202)를 NoC(208) 및 PL(214)에 결합할 수 있다. 이와 같이, DPE 어레이(202)는 PL(214), PS(212), 및/또는 임의의 하드와이어드 회로 블록(210)에 구현된 회로 블록과 통신할 수 있다. 예를 들어, SoC 인터페이스 블록(206)은 선택된 DPE(204) 및 PL(214) 간의 연결을 확립할 수 있다. SoC 인터페이스 블록(206)은 또한 선택된 DPE(204) 및 NoC(208) 사이의 연결을 확립할 수 있다. NoC(208)를 통해, 선택된 DPE(204)는 PS(212) 및/또는 하드와이어드 회로 블록(210)과 통신할 수 있다. 선택된 DPE(204)는 SoC 인터페이스 블록(206) 및 PL(214)을 통해 하드와이어드 회로 블록(210)과 통신할 수 있다. 특정 실시 예에서, SoC 인터페이스 블록(206)은 SoC(200)의 하나 이상의 서브시스템에 직접 결합될 수 있다. 예를 들어, SoC 인터페이스 블록(206)은 PS(212) 및/또는 하드와이어드 회로 블록(210)에 직접 결합될 수 있다.
하나 이상의 실시 예에서, DPE 어레이(202)는 단일 클록 도메인을 포함한다. NoC(208), PL(214), PS(212), 및 다양한 하드와이어드 회로 블록(210)과 같은 다른 서브시스템은 하나 이상의 개별 또는 상이한 클록 도메인(들)에 있을 수 있다. 여전히, DPE 어레이(202)는 서브시스템들 중 다른 서브시스템과 인터페이스하기 위해 사용될 수 있는 추가 클록을 포함할 수 있다. 특정 실시 예에서, SoC 인터페이스 블록(206)은 DPE 어레이(202)의 DPE(204)에 제공되거나 분배될 수 있는 하나 이상의 클록 신호를 생성할 수 있는 클록 신호 생성기를 포함한다.
DPE 어레이(202)는 DPE(204)와 SoC 인터페이스 블록(206) 사이의 연결성과 DPE(204) 및 SoC 인터페이스 블록(206)이 어떻게 동작하는지를 정의하는 내부 구성 메모리 셀(여기서 "구성 레지스터(configuration register)"로도 지칭됨) 내로 구성 데이터를 로딩함으로써 프로그래밍될 수 있다. 예를 들어, 특정 DPE(204) 또는 DPE(204) 그룹이 서브시스템과 통신하기 위해 DPE(들)(204) 및 SoC 인터페이스 블록(206)은 그렇게 하도록 프로그래밍된다. 유사하게, 하나 이상의 특정 DPE(204)가 하나 이상의 다른 DPE(204)와 통신하기 위해, DPE는 그렇게 하도록 프로그래밍된다. DPE(들)(204) 및 SoC 인터페이스 블록(206)은 DPE(들)(204) 및 SoC 인터페이스 블록(206) 내의 구성 레지스터 내로 구성 데이터를 각각 로딩함으로써 프로그래밍될 수 있다. 다른 예에서, SoC 인터페이스 블록(206)의 일부인 클록 신호 생성기는 DPE 어레이(202)에 제공되는 클록 주파수를 변경하기 위해 구성 데이터를 사용하여 프로그래밍될 수 있다.
도 3은 도 2의 DPE 어레이(202)의 DPE(204)에 대한 예시적인 아키텍처를 도시한다. 도 3의 예에서, DPE(204)는 코어(302), 메모리 모듈(304), 및 DPE 인터커넥트(306)를 포함한다. 각각의 DPE(204)는 SoC(200) 상에 하드와이어드 프로그래머블 회로 블록으로서 구현된다.
코어(302)는 DPE(204)의 데이터 처리 능력을 제공한다. 코어(302)는 임의의 다양한 상이한 처리 회로로서 구현될 수 있다. 도 3의 예에서, 코어(302)는 선택적인 프로그램 메모리(308)를 포함한다. 예시적인 구현에서, 코어(302)는 프로그램 코드, 예를 들어 컴퓨터 판독 가능 명령어들을 실행할 수 있는 프로세서로서 구현된다. 그 경우에, 프로그램 메모리(308)가 포함되고 코어(302)에 의해 실행되는 명령어들을 저장할 수 있다. 코어(302)는 예를 들어 CPU, GPU, DSP, 벡터 프로세서, 또는 명령어들을 실행할 수 있는 다른 타입의 프로세서로서 구현될 수 있다. 코어(302)는 본 명세서에 설명된 다양한 CPU 및/또는 프로세서 아키텍처 중 임의의 것을 사용하여 구현될 수 있다. 다른 예에서, 코어(302)는 VLIW(very long instruction word) 벡터 프로세서 또는 DSP로서 구현된다.
특정 구현에서, 프로그램 메모리(308)는 코어(302)에 대해 사적인(예를 들어, 코어(302)에 의해서 독점적으로 액세스되는) 전용 프로그램 메모리로서 구현된다. 프로그램 메모리(308)는 동일한 DPE(204)의 코어에 의해서만 사용될 수 있다. 따라서, 프로그램 메모리(308)는 코어(302)에 의해서만 액세스될 수 있고 임의의 다른 DPE 또는 다른 DPE의 컴포넌트와 공유되지 않는다. 프로그램 메모리(308)는 판독 및 기입 동작을 위한 단일 포트를 포함할 수 있다. 프로그램 메모리(308)는 프로그램 압축을 지원할 수 있고, 아래에서 더 자세히 설명되는 DPE 인터커넥트(306)의 메모리 매핑된 네트워크 부분을 사용하여 어드레싱 가능하다. 예를 들어, DPE 인터커넥트(306)의 메모리 매핑된 네트워크를 통해, 프로그램 메모리(308)는 코어(302)에 의해 실행될 수 있는 프로그램 코드가 로딩될 수 있다.
코어(302)는 구성 레지스터(324)를 포함할 수 있다. 구성 레지스터(324)는 코어(302)의 동작을 제어하기 위해 구성 데이터와 함께 로딩될 수 있다. 하나 이상의 실시 예에서, 코어(302)는 구성 레지스터(324) 내로 로딩된 구성 데이터에 기반하여 활성화 및/또는 비활성화될 수 있다. 도 3의 예에서, 구성 레지스터(324)는 아래에서 더 자세히 설명되는 DPE 인터커넥트(306)의 메모리 매핑된 네트워크를 통해 어드레싱 가능하다(예를 들어, 판독 및/또는 기입될 수 있다).
하나 이상의 실시 예에서, 메모리 모듈(304)은 코어(302)에 의해 사용 및/또는 생성된 데이터를 저장할 수 있다. 예를 들어, 메모리 모듈(304)은 애플리케이션 데이터를 저장할 수 있다. 메모리 모듈(304)은 RAM(random-access memory)과 같은 판독/기입 메모리를 포함할 수 있다. 따라서, 메모리 모듈(304)은 코어(302)에 의해 판독되고 소비될 수 있는 데이터를 저장할 수 있다. 메모리 모듈(304)은 또한 코어(302)에 의해 기입된 데이터(예를 들어, 결과)를 저장할 수 있다.
하나 이상의 다른 실시 예에서, 메모리 모듈(304)은 DPE 어레이 내의 다른 DPE의 하나 이상의 다른 코어에 의해 사용 및/또는 생성될 수 있는 데이터, 예를 들어 애플리케이션 데이터를 저장할 수 있다. DPE의 하나 이상의 다른 코어는 또한 메모리 모듈(304)로부터 판독 및/또는 기입할 수 있다. 특정 실시 예에서, 메모리 모듈(304)로부터 판독 및/또는 기입할 수 있는 다른 코어는 하나 이상의 이웃 DPE의 코어일 수 있다. DPE(204)와 경계(border) 또는 한계(boundary)를 공유하는(예를 들어, 인접하는) 다른 DPE는 DPE(204)에 대한 "이웃(neighboring)" DPE라고 한다. 코어(302) 및 이웃 DPE로부터의 하나 이상의 다른 코어가 메모리 모듈(304)에 판독 및/또는 기입할 수 있게 함으로써, 메모리 모듈(304)은 메모리 모듈(304)에 액세스할 수 있는 상이한 DPE 및/또는 코어 간의 통신을 지원하는 공유 메모리를 구현한다.
도 2를 참조하면, 예를 들어, DPE(204-14, 204-16, 204-5, 204-25)는 DPE(204-15)의 이웃 DPE로 간주된다. 일 예에서, 각각의 DPE(204-16, 204-5, 204-25) 내의 코어는 DPE(204-15) 내의 메모리 모듈을 판독하고 기입할 수 있다. 특정 실시 예에서, 메모리 모듈에 인접한 이웃 DPE만이 DPE(204-15)의 메모리 모듈에 액세스할 수 있다. 예를 들어, DPE(204-14)는 DPE(204-15)에 인접하지만 DPE(204-15)의 메모리 모듈에 인접하지 않을 수 있는데, 그 이유는 DPE(204-15)의 코어가 DPE(204-14)의 코어와 DPE(204-15)의 메모리 모듈 사이에 위치되기 때문이다. 이와 같이, 특정 실시 예에서, DPE(204-14)의 코어는 DPE(204-15)의 메모리 모듈에 액세스하지 않을 수 있다.
특정 실시 예에서, DPE의 코어가 다른 DPE의 메모리 모듈에 액세스할 수 있는지 여부는 메모리 모듈에 포함된 메모리 인터페이스의 수 및 그러한 코어가 메모리 모듈의 메모리 인터페이스 중 사용 가능한 것에 연결되어 있는지 여부에 달려 있다. 위의 예에서 DPE(204-15)의 메모리 모듈은 4개의 메모리 인터페이스를 포함하며, 여기서 DPE(204-16, 204-5, 204-25) 각각의 코어는 그러한 메모리 인터페이스에 연결된다. DPE(204-15) 자체 내의 코어(302)는 제4 메모리 인터페이스에 연결된다. 각각의 메모리 인터페이스는 하나 이상의 판독 및/또는 기입 채널을 포함할 수 있다. 특정 실시 예에서, 각각의 메모리 인터페이스는 그에 부착된 특정 코어가 메모리 모듈(304) 내의 다수의 뱅크에 동시에 판독 및/또는 기입할 수 있도록 다수의 판독 채널 및 다수의 기입 채널을 포함한다.
다른 예들에서, 4개보다 많은 메모리 인터페이스들이 이용 가능할 수 있다. 이러한 다른 메모리 인터페이스는 DPE(204-15)의 대각선 상의 DPE가 DPE(204-15)의 메모리 모듈에 액세스할 수 있도록 하는 데 사용될 수 있다. 예를 들어, DPE(204-14, 204-24, 204-26, 204-4 및/또는 204-6)과 같은 DPE의 코어가 DPE(204-15)의 메모리 모듈의 사용 가능한 메모리 인터페이스에도 결합되어 있다면, 이러한 다른 DPE도 DPE(204-15)의 메모리 모듈에 또한 액세스할 수 있을 것이다.
메모리 모듈(304)은 구성 레지스터(336)를 포함할 수 있다. 구성 레지스터(336)에는 메모리 모듈(304)의 동작을 제어하기 위한 구성 데이터가 로딩될 수 있다. 도 3의 예에서, 구성 레지스터(336)(및 324)는 아래에서 더 자세히 설명되는 DPE 인터커넥트(306)의 메모리 매핑된 네트워크를 통해 어드레싱 가능하다(예를 들어, 판독 및/또는 기입될 수 있다).
도 3의 예에서, DPE 인터커넥트(306)는 DPE(204)에 고유하다. DPE 인터커넥트(306)는 DPE(204)와 DPE 어레이(202)의 하나 이상의 다른 DPE 간의 통신 및/또는 SoC(200)의 다른 서브시스템과의 통신을 포함하는 다양한 동작을 용이하게 한다. DPE 인터커넥트(306)는 DPE(204)의 구성, 제어 및 디버깅을 추가로 가능하게 한다.
특정 실시 예에서, DPE 인터커넥트(306)는 온-칩 인터커넥트로서 구현된다. 온-칩 인터커넥트의 예는 AMBA(Advanced Microcontroller Bus Architecture) eXtensible Interface(AXI) 버스(예를 들어, 또는 스위치)이다. AMBA AXI 버스는 회로 블록 및/또는 시스템 간에 온-칩 연결을 확립하는 데 사용하기 위한 임베디드 마이크로제어기 버스 인터페이스이다. AXI 버스는 본 개시 내에서 설명된 본 발명의 장치와 함께 사용될 수 있는 인터커넥트 회로의 예로서 본 명세서에서 제공되며, 따라서 제한으로 의도되지 않는다. 인터커넥트 회로의 다른 예는 다른 타입의 버스, 크로스바 및/또는 다른 타입의 스위치를 포함할 수 있다.
하나 이상의 실시 예에서, DPE 인터커넥트(306)는 2개의 상이한 네트워크를 포함한다. 제1 네트워크는 DPE 어레이(202)의 다른 DPE 및/또는 SoC(200)의 다른 서브시스템과 데이터를 교환할 수 있다. 예를 들어, 제1 네트워크는 애플리케이션 데이터를 교환할 수 있다. 제2 네트워크는 DPE(들)에 대한 구성, 제어 및/또는 디버깅 데이터와 같은 데이터를 교환할 수 있다.
도 3의 예에서, DPE 인터커넥트(306)의 제1 네트워크는 스트림 스위치(326) 및 하나 이상의 스트림 인터페이스(미도시)로 형성된다. 예를 들어, 스트림 스위치(326)는 코어(302), 메모리 모듈(304), 메모리 매핑된 스위치(332), 위의 DPE, 왼쪽의 DPE, 오른쪽의 DPE 및 아래의 DPE 각각에 연결하기 위한 스트림 인터페이스를 포함한다. 각 스트림 인터페이스는 하나 이상의 마스터와 하나 이상의 슬레이브를 포함할 수 있다.
스트림 스위치(326)는 메모리 모듈(304)의 메모리 인터페이스에 결합되지 않은 인접하지 않은 DPE 및/또는 DPE가 DPE 어레이(202)의 각 DPE(204)의 DPE 인터커넥트에 의해 형성된 DPE 인터커넥트 네트워크를 통해 코어(302) 및/또는 메모리 모듈(304)과 통신하도록 할 수 있다.
다시 도 2를 참조하고, DPE(204-15)를 기준점으로 사용하여, 스트림 스위치(326)는 DPE(204-14)의 DPE 인터커넥트에 위치된 다른 스트림 스위치에 결합되어 통신할 수 있다. 스트림 스위치(326)는 DPE(204-25)의 DPE 인터커넥트에 위치된 다른 스트림 스위치에 결합되어 통신할 수 있다. 스트림 스위치(326)는 DPE(204-16)의 DPE 인터커넥트에 위치된 다른 스트림 스위치에 결합되어 통신할 수 있다. 스트림 스위치(326)는 DPE(204-5)의 DPE 인터커넥트에 위치된 다른 스트림 스위치에 결합되어 통신할 수 있다. 이와 같이, 코어(302) 및/또는 메모리 모듈(304)은 또한 DPE 내의 DPE 인터커넥트를 통해 DPE 어레이(202) 내의 임의의 DPE와 통신할 수 있다.
스트림 스위치(326)는 또한 PL(214) 및/또는 NoC(208)와 같은 서브시스템에 인터페이스하기 위해 사용될 수 있다. 일반적으로, 스트림 스위치(326)는 회선-교환 스트림 인터커넥트 또는 패킷-교환 스트림 인터커넥트로서 동작하도록 프로그래밍된다. 회선-교환 스트림 인터커넥트는 DPE 간의 고대역폭 통신에 적합한 점대점(point-to-point) 전용 스트림을 구현할 수 있다. 패킷-교환 스트림 인터커넥트는 스트림이 공유될 수 있게 하여 중간 대역폭 통신을 위해 다수의 로직 스트림을 하나의 물리적 스트림으로 시간 다중화(time-multiplex)할 수 있다.
스트림 스위치(326)는 구성 레지스터(도 3에서 "CR"로 약칭됨)(334)를 포함할 수 있다. 구성 데이터는 DPE 인터커넥트(306)의 메모리 매핑된 네트워크를 통해 구성 레지스터(334)에 기입될 수 있다. 구성 레지스터(334) 내로 로딩된 구성 데이터는 DPE(204)가 어느 다른 DPE 및/또는 서브시스템(예를 들어, NoC(208), PL(214) 및/또는 PS(212))와 통신할 것인지 및 그러한 통신이 회선-교환 점대점 연결 또는 패킷-교환 연결로서 확립되는지 여부를 지시한다.
DPE 인터커넥트(306)의 제2 네트워크는 메모리 매핑된 스위치(332)로 형성된다. 메모리 매핑된 스위치(332)는 복수의 메모리 매핑된 인터페이스(미도시)를 포함한다. 각각의 메모리 매핑된 인터페이스는 하나 이상의 마스터와 하나 이상의 슬레이브를 포함할 수 있다. 예를 들어, 메모리 매핑된 스위치(332)는 코어(302), 메모리 모듈(304), DPE(204) 위의 DPE 내의 메모리 매핑된 스위치, 및 DPE(204) 아래의 DPE 내의 메모리 매핑된 스위치 각각에 연결하기 위한 메모리 매핑된 인터페이스를 포함한다.
메모리 매핑된 스위치(332)는 DPE(204)에 대한 구성, 제어 및 디버깅 데이터를 전달하는 데 사용된다. 도 3의 예에서, 메모리 매핑된 스위치(332)는 DPE(204)를 구성하는 데 사용되는 구성 데이터를 수신할 수 있다. 메모리 매핑된 스위치(332)는 DPE(204) 아래에 위치된 DPE로부터 및/또는 SoC 인터페이스 블록(206)으로부터 구성 데이터를 수신할 수 있다. 메모리 매핑된 스위치(332)는 수신된 구성 데이터를 DPE(204) 위의 하나 이상의 다른 DPE로, 코어(302)로(예를 들어, 프로그램 메모리(308) 및/또는 구성 레지스터(324)로), 메모리 모듈(304)로(예를 들어, 메모리 모듈(304) 내의 메모리로 및/또는 구성 레지스터(336)로), 및/또는 스트림 스위치(326) 내의 구성 레지스터(334)로 포워딩할 수 있다.
DPE 인터커넥트(306)는 DPE(204)의 위치에 따라 각각의 이웃 DPE 및/또는 SoC 인터페이스 블록(206)의 DPE 인터커넥트에 결합된다. 종합하면, DPE(204)의 DPE 인터커넥트는 (스트림 네트워크 및/또는 메모리 매핑된 네트워크를 포함할 수 있는) DPE 인터커넥트 네트워크를 형성한다. 각 DPE의 스트림 스위치의 구성 레지스터는 메모리 매핑된 스위치를 통해 구성 데이터를 로딩함으로써 프로그래밍될 수 있다. 구성을 통해 스트림 스위치 및/또는 스트림 인터페이스는 패킷-교환이든 회선-교환이든, 하나 이상의 다른 DPE(204) 내이든 및/또는 SoC 인터페이스 블록(206) 내이든 다른 엔드포인트와의 연결을 확립하도록 프로그래밍된다.
하나 이상의 실시 예에서, DPE 어레이(202)는 PS(212)와 같은 프로세서 시스템의 어드레스 공간에 매핑된다. 따라서, DPE(204) 내의 임의의 구성 레지스터 및/또는 메모리는 메모리 매핑된 인터페이스를 통해 액세스될 수 있다. 예를 들어, 메모리 모듈(304)의 메모리, 프로그램 메모리(308), 코어(302) 내의 구성 레지스터(324), 메모리 모듈(304) 내의 구성 레지스터(336), 및/또는 구성 레지스터(334)는 메모리 매핑된 스위치(332)를 통해 판독 및/또는 기입될 수 있다.
도 3의 예에서, 메모리 매핑된 스위치(332)는 DPE(204)에 대한 구성 데이터를 수신할 수 있다. 구성 데이터는 (만일 포함된다면) 프로그램 메모리(308) 내로 로딩되는 프로그램 코드, 구성 레지스터(324, 334, 및/또는 336) 내로 로딩하기 위한 구성 데이터 및/또는 메모리 모듈(304)의 메모리(예를 들어, 메모리 뱅크) 내로 로딩될 데이터를 포함할 수 있다. 도 3의 예에서, 구성 레지스터(324, 334, 336)는 구성 레지스터가 예를 들어 코어(302), 스트림 스위치(326), 및 메모리 모듈(304)을 제어하도록 의도된 특정 회로 구조 내에 위치되는 것으로 도시되어 있다. 도 3의 예는 단지 예시의 목적을 위한 것으로, 코어(302), 메모리 모듈(304), 및/또는 스트림 스위치(326) 내의 요소가 구성 데이터를 대응하는 구성 레지스터 내로 로딩하는 방식으로 프로그래밍될 수 있다는 것을 도시한다. 다른 실시 예에서, 구성 레지스터는 DPE(204) 전체에 분산된 컴포넌트의 동작을 제어함에도 불구하고 DPE(204)의 특정 영역 내에 통합될 수 있다.
따라서, 스트림 스위치(326)는 구성 데이터를 구성 레지스터(334) 내로 로딩함으로써 프로그래밍될 수 있다. 구성 데이터는 스트림 스위치(326)가 2개의 상이한 DPE 및/또는 다른 서브시스템 사이의 회선-교환 모드로 또는 선택된 DPE 및/또는 다른 서브시스템 간의 패킷-교환 모드로 동작하도록 프로그래밍한다. 따라서, 다른 스트림 인터페이스 및/또는 스위치로 스트림 스위치(326)에 의해 확립된 연결은, DPE(204) 내의 실제 연결 또는 애플리케이션 데이터 경로를 다른 DPE와 및/또는 IC(300)의 다른 서브시스템과 확립하기 위하여 적당한 구성 데이터를 구성 레지스터(334) 내로 로딩함으로써 프로그래밍된다.
도 4는 도 3의 예시적인 아키텍처의 추가 양태를 도시한다. 도 4의 예에서, DPE 인터커넥트(306)에 관한 세부사항은 도시되지 않는다. 도 4는 공유 메모리를 통한 다른 DPE와 코어(302)의 연결을 도시한다. 도 4는 또한 메모리 모듈(304)의 추가적인 양태들을 도시한다. 예시의 목적으로 도 4는 DPE(204-15)를 참조한다.
도시된 바와 같이, 메모리 모듈(304)은 복수의 메모리 인터페이스(402, 404, 406, 408)를 포함한다. 도 4 내에서, 메모리 인터페이스(memory interface)(402, 408)는 "MI"로 약칭된다. 메모리 모듈(304)은 복수의 메모리 뱅크(412-1 내지 412-N)를 더 포함한다. 특정 실시 예에서, 메모리 모듈(304)은 8개의 메모리 뱅크를 포함한다. 다른 실시 예에서, 메모리 모듈(304)은 더 적거나 더 많은 메모리 뱅크(412)를 포함할 수 있다. 하나 이상의 실시 예에서, 각각의 메모리 뱅크(412)는 단일 포트되어 각 클록 사이클마다 각각의 메모리 뱅크에 대한 최대 하나의 액세스를 허용한다. 메모리 모듈(304)이 8개의 메모리 뱅크(412)를 포함하는 경우에, 그러한 구성은 각 클록 사이클마다 8개의 병렬 액세스를 지원한다. 다른 실시 예에서, 각각의 메모리 뱅크(412)는 듀얼 포트 또는 멀티 포트되어 각 클록 사이클마다 더 많은 수의 병렬 액세스를 허용한다.
도 4의 예에서, 메모리 뱅크(412-1 내지 412-N) 각각은 각각의 중재자(arbiter)(414-1 내지 414-N)를 가진다. 각각의 중재자(414)는 충돌 검출에 응답하여 스톨(stall) 신호를 생성할 수 있다. 각각의 중재자(414)는 중재(arbitration) 로직을 포함할 수 있다. 또한, 각각의 중재자(414)는 크로스바를 포함할 수 있다. 따라서, 임의의 마스터는 임의의 특정한 하나 이상의 메모리 뱅크(412)에 기입할 수 있다. 도 3에 관련하여 언급된 바와 같이, 메모리 모듈(304)은 메모리 매핑된 스위치(332)에 연결되어, 메모리 뱅크(412)에 대한 데이터의 판독 및 기입을 용이하게 한다. 이와 같이 메모리 모듈(304)에 저장된 특정 데이터는 메모리 매핑된 스위치(332)를 통한 구성, 제어, 및/또는 디버깅 프로세스의 일부로서 제어, 예를 들어 기입될 수 있다.
메모리 모듈(304)은 직접 메모리 액세스(direct memory access, DMA) 엔진(416)을 더 포함한다. 하나 이상의 실시 예에서, DMA 엔진(416)은 적어도 2개의 인터페이스를 포함한다. 예를 들어, 하나 이상의 인터페이스는 DPE 인터커넥트(306)로부터 입력 데이터 스트림을 수신하고 수신된 데이터를 메모리 뱅크(412)에 기입할 수 있다. 하나 이상의 다른 인터페이스는 메모리 뱅크(412)로부터 데이터를 판독하고 DPE 인터커넥트(306)의 스트림 인터페이스(예를 들어 스트림 스위치)를 통해 데이터를 내보낼 수 있다. 예를 들어, DMA 엔진(416)은 도 3의 스트림 스위치(326)에 액세스하기 위한 스트림 인터페이스를 포함할 수 있다.
메모리 모듈(304)은 복수의 상이한 DPE에 의해 액세스될 수 있는 공유 메모리로서 동작할 수 있다. 도 4의 예에서, 메모리 인터페이스(402)는 코어(302)에 포함된 코어 인터페이스(428)를 통해 코어(302)에 결합된다. 메모리 인터페이스(402)는 중재자(414)를 통해 메모리 뱅크(412)에 대한 액세스를 코어(302)에 제공한다. 메모리 인터페이스(404)는 DPE(204-25)의 코어에 결합된다. 메모리 인터페이스(404)는 DPE(204-25)의 코어에 메모리 뱅크(412)에 대한 액세스를 제공한다. 메모리 인터페이스(406)는 DPE(204-16)의 코어에 결합된다. 메모리 인터페이스(406)는 DPE(204-16)의 코어에 메모리 뱅크(412)에 대한 액세스를 제공한다. 메모리 인터페이스(408)는 DPE(204-5)의 코어에 결합된다. 메모리 인터페이스(408)는 DPE(204-5)의 코어에 메모리 뱅크(412)에 대한 액세스를 제공한다. 따라서, 도 4의 예에서, DPE(204-15)의 메모리 모듈(304)과 공유 경계를 가지는 각 DPE는 메모리 뱅크(412)를 판독하고 기입할 수 있다. 도 4의 예에서, DPE(204-14)의 코어는 DPE(204-15)의 메모리 모듈(304)에 대한 직접 액세스를 갖지 않는다.
코어(302)는 코어 인터페이스(430, 432, 434)를 통해 다른 이웃 DPE의 메모리 모듈에 액세스할 수 있다. 도 4의 예에서, 코어 인터페이스(434)는 DPE(204-25)의 메모리 인터페이스에 결합된다. 따라서, 코어(302)는 코어 인터페이스(434) 및 DPE(204-25)의 메모리 모듈 내에 포함된 메모리 인터페이스를 통해 DPE(204-25)의 메모리 모듈에 액세스할 수 있다. 코어 인터페이스(432)는 DPE(204-14)의 메모리 인터페이스에 결합된다. 따라서, 코어(302)는 코어 인터페이스(432) 및 DPE(204-14)의 메모리 모듈 내에 포함된 메모리 인터페이스를 통해 DPE(204-14)의 메모리 모듈에 액세스할 수 있다. 코어 인터페이스(430)는 DPE(204-5) 내의 메모리 인터페이스에 결합된다. 따라서, 코어(302)는 코어 인터페이스(430) 및 DPE(204-5)의 메모리 모듈 내에 포함된 메모리 인터페이스를 통해 DPE(204-5)의 메모리 모듈에 액세스할 수 있다. 논의된 바와 같이, 코어(302)는 코어 인터페이스(428) 및 메모리 인터페이스(402)를 통해 DPE(204-15) 내의 메모리 모듈(304)에 액세스할 수 있다.
도 4의 예에서, 코어(302)는 DPE(204-15)에서 코어(302)와 경계를 공유하는 DPE(예를 들어, DPE(204-25, 204-14, 204-5))의 임의의 메모리 모듈을 판독하고 기입할 수 있다. 하나 이상의 실시 예에서, 코어(302)는 DPE(204-25, 204-15, 204-14, 204-5) 내의 메모리 모듈을 단일 연속(contiguous) 메모리로서(예를 들어, 단일 어드레스 공간으로서) 볼 수 있다. 이와 같이, 코어(302)가 이러한 DPE의 메모리 모듈을 판독 및/또는 기입하는 프로세스는 코어(302)가 메모리 모듈(304)을 판독 및/또는 기입하는 것과 동일하다. 코어(302)는 이 연속 메모리 모델을 가정하여 판독 및/또는 기입을 위한 어드레스를 생성할 수 있다. 코어(302)는 생성된 어드레스에 기반하여 판독 및/또는 기입 요청을 적절한 코어 인터페이스(428, 430, 432, 및/또는 434)로 보낼 수 있다.
언급된 바와 같이, 코어(302)는 이러한 동작의 어드레스에 기반하여 코어 인터페이스(428, 430, 432, 및/또는 434)를 통해 정확한 방향으로 판독 및/또는 기입 동작을 매핑할 수 있다. 코어(302)가 메모리 액세스를 위한 어드레스를 생성할 때, 코어(302)는 방향(예를 들어, 액세스될 특정 DPE)을 결정하기 위해 어드레스를 디코딩할 수 있고 결정된 방향으로 정확한 코어 인터페이스에 메모리 동작을 포워딩한다.
따라서, 코어(302)는 DPE(204-25) 내의 메모리 모듈 및/또는 DPE(204-15)의 메모리 모듈(304)일 수 있는 공유 메모리를 통해 DPE(204-25)의 코어와 통신할 수 있다. 코어(302)는 DPE(204-14) 내의 메모리 모듈인 공유 메모리를 통해 DPE(204-14)의 코어와 통신할 수 있다. 코어(302)는 DPE(204-5) 내의 메모리 모듈 및/또는 DPE(204-15)의 메모리 모듈(304)일 수 있는 공유 메모리를 통해 DPE(204-5)의 코어와 통신할 수 있다. 또한, 코어(302)는 DPE(204-15) 내의 메모리 모듈(304)인 공유 메모리를 통해 DPE(204-16)의 코어와 통신할 수 있다.
논의된 바와 같이, DMA 엔진(416)은 하나 이상의 스트림-메모리 인터페이스를 포함할 수 있다. DMA 엔진(416)을 통해, 애플리케이션 데이터는 SoC(200) 내의 다른 소스로부터 수신되어 메모리 모듈(304)에 저장될 수 있다. 예를 들어, 데이터는 스트림 스위치(326)를 통해 DPE(204-15)와 경계를 공유하고/공유하거나 공유하지 않는 다른 DPE로부터 수신될 수 있다. 데이터는 또한 DPE의 스트림 스위치를 통해 SoC 인터페이스 블록(206)을 통해 SoC의 다른 서브시스템(예를 들어, NoC(208), 하드와이어드 회로 블록(210), PL(214), 및/또는 PS(212))으로부터 수신될 수 있다. DMA 엔진(416)은 스트림 스위치로부터 이러한 데이터를 수신하고 메모리 모듈(304) 내의 적절한 메모리 뱅크 또는 메모리 뱅크(412)에 데이터를 기입할 수 있다.
DMA 엔진(416)은 하나 이상의 메모리-스트림 인터페이스를 포함할 수 있다. DMA 엔진(416)을 통해, 데이터는 메모리 모듈(304)의 메모리 뱅크 또는 메모리 뱅크들(412)로부터 판독될 수 있고 스트림 인터페이스를 통해 다른 목적지로 전송될 수 있다. 예를 들어, DMA 엔진(416)은 메모리 모듈(304)로부터 데이터를 판독하고 그러한 데이터를 스트림 스위치를 통해 DPE(204-15)와 경계를 공유하고/공유하거나 공유하지 않는 다른 DPE에 전송할 수 있다. DMA 엔진(416)은 또한 스트림 스위치 및 SoC 인터페이스 블록(206)을 통해 다른 서브시스템(예를 들어, NoC(208), 하드와이어드 회로 블록(210), PL(214), 및/또는 PS(212))에 이러한 데이터를 전송할 수 있다.
하나 이상의 실시 예에서, DMA 엔진(416)은 DPE(204-15) 내의 메모리 매핑된 스위치(332)에 의해 프로그래밍된다. 예를 들어, DMA 엔진(416)은 구성 레지스터(336)에 의해 제어될 수 있다. 구성 레지스터(336)는 DPE 인터커넥트(306)의 메모리 매핑된 스위치(332)를 사용하여 기입될 수 있다. 특정 실시 예에서, DMA 엔진(416)은 DPE(204-15) 내의 스트림 스위치(326)에 의해 제어될 수 있다. 예를 들어, DMA 엔진(416)은 그것에 연결된 스트림 스위치(326)에 의해 기입될 수 있는 제어 레지스터를 포함할 수 있다. DPE 인터커넥트(306) 내의 스트림 스위치(326)를 통해 수신된 스트림은 구성 레지스터(324, 334, 및/또는 336) 내로 로딩된 구성 데이터에 따라 메모리 모듈(304) 내의 DMA 엔진(416)에 및/또는 직접 코어(302)에 연결될 수 있다. 구성 레지스터(324, 334, 및/또는 336) 내에 로딩된 구성 데이터에 따라 DMA 엔진(416)(예를 들어, 메모리 모듈(304)) 및/또는 코어(302)로부터 스트림이 전송될 수 있다.
메모리 모듈(304)은 하드웨어 동기화 회로(hardware synchronization circuitry)(420)(도 4에서 "HSC"로 약칭됨)를 더 포함할 수 있다. 일반적으로, 하드웨어 동기화 회로(420)는 상이한 코어들(예를 들어, 이웃 DPE의 코어들), 도 4의 코어(302), DMA 엔진(416), 및 DPE 인터커넥트(306)를 통해 통신할 수 있는 다른 외부 마스터(예를 들어, PS(212))의 동작을 동기화할 수 있다. 예시적이고 비제한적인 예로서, 하드웨어 동기화 회로(420)는 2개의 상이한 코어, 스트림 스위치, 메모리 매핑된 인터페이스, 및/또는 DPE(204-15) 내의 DMA 및/또는 메모리 모듈(304) 내의 동일한, 예를 들어 공유된 버퍼에 액세스하는 상이한 DPE를 동기화할 수 있다.
2개의 DPE가 이웃이 아닌 경우, 2개의 DPE는 공통 메모리 모듈에 액세스할 수 없다. 그 경우에, 애플리케이션 데이터는 데이터 스트림을 통해 이송(transfer)될 수 있다("데이터 스트림" 및 "스트림"이라는 용어는 본 개시 내에서 때때로 상호교환적으로 사용될 수 있다). 이와 같이 로컬 DMA 엔진은 로컬 메모리 기반 이송으로부터 스트림 기반 이송으로 이송을 변환할 수 있다. 그 경우에, 코어(302) 및 DMA 엔진(416)은 하드웨어 동기화 회로(420)를 사용하여 동기화할 수 있다.
PS(212)는 메모리 매핑된 스위치(332)를 통해 코어(302)와 통신할 수 있다. 예를 들어, PS(212)는 메모리 판독 및 기입을 개시함으로써 메모리 모듈(304) 및 하드웨어 동기화 회로(420)에 액세스할 수 있다. 다른 실시 예에서, 하드웨어 동기화 회로(420)는 또한 잠금 상태가 하드웨어 동기화 회로(420)의 PS(212)에 의한 폴링을 피하기 위해 변경될 때 PS(212)에 인터럽트를 보낼 수 있다. PS(212)는 또한 스트림 인터페이스를 통해 DPE(204-15)와 통신할 수 있다.
공유 메모리 모듈을 통한 이웃 DPE 및 DPE 인터커넥트(306)를 통한 이웃 및/또는 비-이웃 DPE와 통신하는 것 외에도, 코어(302)는 캐스케이드 인터페이스(cascade interface)를 포함할 수 있다. 도 4의 예에서, 코어(302)는 캐스케이드 인터페이스(422, 424)(도 4에서 "CI"로 약칭됨)를 포함한다. 캐스케이드 인터페이스(422 및 424)는 다른 코어와의 직접 통신을 제공할 수 있다. 도시된 바와 같이, 코어(302)의 캐스케이드 인터페이스(422)는 DPE(204-14)의 코어로부터 입력 데이터 스트림을 직접 수신한다. 캐스케이드 인터페이스(422)를 통해 수신된 데이터 스트림은 코어(302) 내의 데이터 처리 회로에 제공될 수 있다. 코어(302)의 캐스케이드 인터페이스(424)는 출력 데이터 스트림을 DPE(204-16)의 코어에 직접 보낼 수 있다.
도 4의 예에서, 캐스케이드 인터페이스(422) 및 캐스케이드 인터페이스(424) 각각은 버퍼링을 위한 FIFO(first-in-first-out) 인터페이스를 포함할 수 있다. 특정 실시 예에서, 캐스케이드 인터페이스(422, 424)는 폭이 수백 비트일 수 있는 데이터 스트림을 전달(convey)할 수 있다. 캐스케이드 인터페이스(422 및 424)의 특정 비트 폭은 제한하려는 의도가 아니다. 도 4의 예에서, 캐스케이드 인터페이스(424)는 코어(302) 내의 누산기 레지스터(accumulator register)(436)(도 4 내에서 "AC"로 약칭됨)에 결합된다. 캐스케이드 인터페이스(424)는 누산기 레지스터(436)의 내용을 출력할 수 있고 매 클록 사이클마다 그렇게 할 수 있다. 누산기 레지스터(436)는 코어(302) 내의 데이터 처리 회로에 의해 생성 및/또는 작동되는 데이터를 저장할 수 있다.
도 4의 예에서, 캐스케이드 인터페이스(422 및 424)는 구성 레지스터(324) 내로 로딩된 구성 데이터에 기반하여 프로그래밍될 수 있다. 예를 들어, 구성 레지스터(324)에 기반하여, 캐스케이드 인터페이스(422)는 활성화 또는 비활성화될 수 있다. 유사하게, 구성 레지스터(324)에 기반하여, 캐스케이드 인터페이스(424)는 활성화 또는 비활성화될 수 있다. 캐스케이드 인터페이스(422)는 캐스케이드 인터페이스(424)와 독립적으로 활성화 및/또는 비활성화될 수 있다.
하나 이상의 다른 실시 예에서, 캐스케이드 인터페이스(422 및 424)는 코어(302)에 의해 제어된다. 예를 들어, 코어(302)는 캐스케이드 인터페이스(422 및/또는 424)에 대한 판독/기입 명령어들을 포함할 수 있다. 다른 예에서, 코어(302)는 캐스케이드 인터페이스(422 및/또는 424)에 대한 판독 및/또는 기입이 가능한 하드와이어드 회로를 포함할 수 있다. 특정 실시 예에서, 캐스케이드 인터페이스(422 및 424)는 코어(302) 외부의 엔티티에 의해 제어될 수 있다.
본 개시 내에서 설명된 실시 예들 내에서, DPE(204)는 캐시 메모리를 포함하지 않는다. 캐시 메모리를 생략함으로써, DPE 어레이(202)는 예측 가능한, 예를 들어, 결정론적인 성능을 달성할 수 있다. 또한, 상이한 DPE에 위치된 캐시 메모리 간의 일관성을 유지할 필요가 없기 때문에 상당한 처리 오버헤드를 피한다.
하나 이상의 실시 예에 따르면, DPE(204)의 코어(302)는 입력 인터럽트를 갖지 않는다. 따라서, DPE(204)의 코어(302)는 인터럽트 없이 동작할 수 있다. DPE(204)의 코어(302)에 대한 입력 인터럽트를 생략하는 것은 또한 DPE 어레이(202)가 예측 가능한, 예를 들어, 결정론적인 성능을 달성하도록 허용한다.
도 5는 DPE 어레이에 대한 또 다른 예시적인 아키텍처를 도시한다. 도 5의 예에서, SoC 인터페이스 블록(206)은 DPE(204)와 SoC(200)의 다른 서브시스템 사이의 인터페이스를 제공한다. SoC 인터페이스 블록(206)은 DPE를 디바이스 내로 통합한다. SoC 인터페이스 블록(206)은 DPE(204)에 구성 데이터를 전달(convey)하고, DPE(204)로부터 다른 서브시스템으로 이벤트를 전달하고, 다른 서브시스템으로부터 DPE(204)로 이벤트를 전달하고, DPE 어레이(202) 외부의 엔티티에 인터럽트를 생성 및 전달하고, 다른 서브시스템 및 DPE(204) 간에 애플리케이션 데이터를 전달할 수 있고/있거나, 다른 서브시스템과 DPE(204) 사이의 트레이스 및/또는 디버그 데이터를 전달할 수 있다.
도 5의 예에서, SoC 인터페이스 블록(206)은 복수의 상호 연결된 타일을 포함한다. 예를 들어, SoC 인터페이스 블록(206)은 타일(502, 504, 506, 508, 510, 512, 514, 516, 518, 520)을 포함한다. 도 5의 예에서, 타일(502-520)은 행으로 조직화된다. 다른 실시 예에서, 타일은 열, 그리드 또는 다른 레이아웃으로 배열될 수 있다. 예를 들어, SoC 인터페이스 블록(206)은 DPE(204)의 왼쪽, DPE(204)의 오른쪽, DPE(204)의 열 사이 등의 타일 열로서 구현될 수 있다. 다른 실시 예에서, SoC 인터페이스 블록(206)은 DPE 어레이(202) 위에 위치될 수 있다. SoC 인터페이스 블록(206)은 타일이 DPE 어레이(202)의 아래, DPE 어레이(202)의 왼쪽, DPE 어레이(202)의 오른쪽 및/또는 DPE 어레이(202) 위의 임의의 조합으로 위치하도록 구현될 수 있다. 이와 관련하여, 도 5는 제한이 아니라 예시의 목적을 위해 제공된 것이다.
하나 이상의 실시 예에서, 타일(502-520)은 동일한 아키텍처를 가진다. 하나 이상의 다른 실시 예에서, 타일(502-520)은 둘 이상의 상이한 아키텍처로 구현될 수 있다. 특정 실시 예에서, 각각의 상이한 타일 아키텍처가 상이한 타입의 서브시스템 또는 SoC(200)의 서브시스템의 조합과의 통신을 지원하는 SoC 인터페이스 블록(206) 내의 타일을 구현하기 위해 상이한 아키텍처가 사용될 수 있다.
도 5의 예에서, 타일(502-520)은 데이터가 하나의 타일에서 다른 타일로 전파될 수 있도록 결합된다. 예를 들어, 데이터는 타일(502)로부터 타일(504, 506)을 통해, 그리고 타일 라인을 따라 타일(520)로 전파될 수 있다. 유사하게, 데이터는 타일(520)에서 타일(502)로 역방향으로 전파될 수 있다. 하나 이상의 실시 예에서, 타일(502-520) 각각은 복수의 DPE에 대한 인터페이스로서 동작할 수 있다. 예를 들어, 타일(502-520) 각각은 DPE 어레이(202)의 DPE(204)의 서브세트에 대한 인터페이스로서 동작할 수 있다. 각 타일이 인터페이스를 제공하는 DPE의 서브세트는 SoC 인터페이스 블록(206)의 둘 이상의 타일에 의한 인터페이스가 DPE에 제공되지 않도록 상호 배타적일 수 있다.
일 예에서, 타일(502-520) 각각은 DPE(204)의 열에 대한 인터페이스를 제공한다. 예시의 목적을 위해 타일(502)은 열 A의 DPE에 대한 인터페이스를 제공한다. 타일(504)은 열 B 등의 DPE에 대한 인터페이스를 제공한다. 각 경우에 타일은 DPE 열에 있는 인접 DPE에 대한 직접 연결을 포함하며, 이는 이 예에서 하단 DPE이다. 열 A를 참조하면, 예를 들어 타일(502)은 DPE(204-1)에 직접 연결된다. 열 A 내의 다른 DPE는 타일(502)과 통신할 수 있지만 동일한 열에 있는 개재 DPE의 DPE 인터커넥트를 통해 그렇게 한다.
예를 들어, 타일(502)은 PS(212), PL(214), 및/또는 애플리케이션 특유의 회로 블록과 같은 다른 하드와이어드 회로 블록(210)과 같은 다른 소스로부터 데이터를 수신할 수 있다. 타일(502)은 다른 열의 DPE(예를 들어, 타일(502)이 인터페이스가 아닌 DPE)로 어드레싱된 데이터를 타일(504)에 보내는 한편, 열 A의 DPE로 어드레싱된 데이터의 그 부분을 그러한 DPE에 제공할 수 있다. 타일(504)은 열 B의 DPE로 어드레싱된 타일(502)로부터 수신된 데이터가 그러한 DPE에 제공되는 경우 동일하거나 유사한 처리를 수행하는 한편, 다른 열의 DPE로 어드레싱된 데이터를 타일(506) 등으로 보낼 수 있다.
이러한 방식으로, 데이터는 데이터가 어드레싱되는 DPE(예를 들어, "목표 DPE(들)")에 대한 인터페이스로서 동작하는 타일에 도달할 때까지 SoC 인터페이스 블록(206)의 타일에서 타일로 전파될 수 있다. 목표 DPE(들)에 대한 인터페이스로 작동하는 타일은 DPE의 메모리 매핑된 스위치 및/또는 DPE의 스트림 스위치를 사용하여 데이터를 목표 DPE(들)로 지향시킬 수 있다.
언급된 바와 같이, 열의 사용은 예시적인 구현이다. 다른 실시 예에서, SoC 인터페이스 블록(206)의 각 타일은 DPE 어레이(202)의 DPE의 행에 대한 인터페이스를 제공할 수 있다. 이러한 구성은 SoC 인터페이스 블록(206)이 DPE(204)의 왼쪽에 있든, 오른쪽에 있든, DPE(204)의 열 사이에 있든, 타일의 열로서 구현되는 경우에 사용될 수 있다. 다른 실시 예에서, 각 타일이 인터페이스를 제공하는 DPE의 서브세트는 DPE 어레이(202)의 모든 DPE보다 적은 임의의 조합일 수 있다. 예를 들어, DPE(204)는 SoC 인터페이스 블록(206)의 타일에 할당(apportion)될 수 있다. 그러한 DPE의 특정 물리적 레이아웃은 DPE 인터커넥트에 의해 확립된 DPE의 연결에 기반하여 변할 수 있다. 예를 들어, 타일(502)은 DPE(204-1, 204-2, 204-11, 204-12)에 대한 인터페이스를 제공할 수 있다. SoC 인터페이스 블록(206)의 다른 타일은 4개의 다른 DPE 등에 대한 인터페이스를 제공할 수 있다.
도 6은 SoC 인터페이스 블록(206)의 타일에 대한 예시적인 아키텍처를 도시한다. 도 6의 예에서, SoC 인터페이스 블록(206)에 대한 2개의 상이한 타입의 타일이 도시되어 있다. 타일(602)은 DPE와 단지 PL(214) 사이의 인터페이스 역할을 하도록 구성된다. 타일(610)은 DPE와 NoC(208) 사이 및 DPE와 PL(214) 사이의 인터페이스 역할을 하도록 구성된다. SoC 인터페이스 블록(206)은 타일(602) 및 타일(610)에 대해 도시된 바와 같이, 두 아키텍처를 모두 사용하는 타일의 조합 또는 다른 예에서, 타일(610)에 대해 예시된 바와 같은 아키텍처를 가지는 타일들만을 포함할 수 있다.
도 6의 예에서, 타일(602)은 PL 인터페이스(606) 및 바로 위의 DPE(204-1)와 같은 DPE에 연결된 스트림 스위치(604)를 포함한다. PL 인터페이스(606)는 PL(214)에 각각 위치된 BLI(Boundary Logic Interface) 회로(620) 및 BLI 회로(622)에 연결된다. 타일(610)은 NoC와 PL 인터페이스(614) 및 바로 위의 DPE(204-5)와 같은 DPE에 연결된 스트림 스위치(612)를 포함한다. NoC와 PL 인터페이스(614)는 PL(214) 내의 BLI 회로(624 및 626)에 연결되고 또한 NoC(208)의 NoC 마스터 유닛(NoC Master Unit, NMU)(630) 및 NoC 슬레이브 유닛(NoC Slave Unit, NSU)(632)에 연결된다.
도 6의 예에서, 각 스트림 인터페이스(604)는 6 개의 상이한 32 비트 데이터 스트림을 그에 연결된 DPE로 출력할 수 있고 그로부터 4 개의 상이한 32 비트 데이터 스트림을 수신할 수 있다. PL 인터페이스(606) 및 NoC와 PL 인터페이스(614) 각각은 BLI(620) 및 BLI(624)를 통해 PL(214)에 6 개의 상이한 64 비트 데이터 스트림을 각각 제공할 수 있다. 일반적으로, BLI(620, 622, 624, 626) 각각은 PL 인터페이스(606) 및/또는 NoC와 PL 인터페이스(614)가 연결되는 PL(214) 내의 인터페이스 또는 연결 포인트를 제공한다. PL 인터페이스(606), NoC와 PL 인터페이스(614) 각각은 BLI(622) 및 BLI(624)를 통해 각각 PL(214)로부터 8 개의 상이한 64 비트 데이터 스트림을 수신할 수 있다.
NoC와 PL 인터페이스(614)는 또한 NoC(208)에 연결된다. 도 6의 예에서, NoC와 PL 인터페이스(614)는 하나 이상의 NMU(630) 및 하나 이상의 NSU(632)에 연결된다. 일 예에서, NoC와 PL 인터페이스(614)는 2개의 상이한 128 비트 데이터 스트림을 NoC(208)에 제공할 수 있으며, 여기서 각각의 데이터 스트림은 상이한 NMU(630)에 제공된다. NoC와 PL 인터페이스(614)는 NoC(208)로부터 2개의 상이한 128 비트 데이터 스트림을 수신할 수 있으며, 여기서 각 데이터 스트림은 상이한 NSU(632)로부터 수신된다.
인접한 타일의 스트림 스위치(604)가 연결된다. 예에서, 인접한 타일의 스트림 스위치(604)는 (예를 들어, 타일이 경우에 따라 오른쪽 또는 왼쪽에 있는 한) 왼쪽 및 오른쪽 방향 각각에서 4 개의 상이한 32 비트 데이터 스트림을 통해 통신할 수 있다.
타일(602 및 610) 각각은 구성 데이터를 전달하기 위해 하나 이상의 메모리 매핑된 스위치를 포함할 수 있다. 예시의 목적을 위해 메모리 매핑된 스위치는 도시되지 않는다. 예를 들어, 메모리 매핑된 스위치는 바로 위의 DPE의 메모리 매핑된 스위치에, 스트림 스위치(604)와 동일하거나 유사한 방식으로 SoC 인터페이스 블록(206)의 다른 인접 타일에 있는 메모리 매핑된 스위치에, 타일(602 및 610)(도시되지 않음)의 구성 레지스터에, 및/또는 경우에 따라 PL 인터페이스(608) 또는 NoC와 PL 인터페이스(614)에 수직으로 연결될 수 있다.
DPE(204) 및/또는 SoC 인터페이스 블록(206)의 타일(602 및/또는 610)에 포함된 다양한 스위치와 관련하여 설명된 다양한 비트 폭 및 데이터 스트림 수는 예시의 목적으로 제공되며 본 개시 내에서 설명된 본 발명의 장치를 제한하려는 것이 아니다.
도 7은 NoC(208)의 예시적인 구현을 도시한다. NoC(208)는 NMU(702), NSU(704), 네트워크(714), NPI(NoC peripheral interconnect)(710), 및 레지스터(712)를 포함한다. 각 NMU(702)는 엔드포인트 회로를 NoC(208)에 연결하는 인그레스(ingress) 회로이다. 각 NSU(704)는 NoC(208)를 엔드포인트 회로에 연결하는 이그레스(egress) 회로이다. NMU(702)는 네트워크(714)를 통해 NSU(704)에 연결된다. 예에서, 네트워크(714)는 NPS(NoC packet switch)(706) 및 NPS(706) 사이의 라우팅(708)을 포함한다. 각각의 NPS(706)는 NoC 패킷의 스위칭을 수행한다. NPS(706)는 복수의 물리 채널을 구현하기 위해 라우팅(708)을 통해 서로 그리고 NMU(702) 및 NSU(704)에 연결된다. NPS(706)는 또한 물리 채널당 다수의 가상 채널을 지원한다.
NPI(710)는 NMU(702), NSU(704), 및 NPS(706)를 프로그래밍하기 위한 회로를 포함한다. 예를 들어, NMU(702), NSU(704), 및 NPS(706)는 그 기능을 결정하는 레지스터(712)를 포함할 수 있다. NPI(710)는 기능을 설정하기 위해 그 프로그래밍을 위해 레지스터(712)에 결합된 주변 인터커넥트를 포함한다. NoC(208) 내의 레지스터(712)는 인터럽트, QoS(Quality of Service), 오류 처리 및 보고, 트랜잭션 제어, 전력 관리, 어드레스 매핑 제어를 지원한다. 레지스터(712)는 예를 들어 기입 요청을 사용하여 레지스터(712)에 기입함으로써 재프로그래밍되기 전에 사용 가능한 상태로 초기화될 수 있다. NoC(208)에 대한 구성 데이터는 예를 들어 프로그래밍 디바이스 이미지(programming device image, PDI)의 일부로서 비휘발성 메모리(non-volatile memory, NVM)에 저장될 수 있고, NoC(208) 및/또는 다른 엔드포인트 회로를 프로그래밍하기 위해 NPI(710)에 제공될 수 있다.
NMU(702)는 트래픽 인그레스 지점이다. NSU(704)는 트래픽 이그레스 지점이다. NMU(702) 및 NSU(704)에 결합된 엔드포인트 회로는 강화된(hardened) 회로(예를 들어, 하드와이어드 회로 블록(210)) 또는 PL(214)에서 구현된 회로일 수 있다. 주어진 엔드포인트 회로는 하나보다 많은 NMU(702) 또는 하나보다 많은 NSU(704)에 결합될 수 있다.
도 8은 예에 따라 NoC(208)를 통한 SoC(200) 내의 엔드포인트 회로들 사이의 연결을 도시하는 블록 다이어그램이다. 예에서, 엔드포인트 회로(802)는 NoC(208)를 통해 엔드포인트 회로(804)에 연결된다. 엔드포인트 회로(802)는 NoC(208)의 NMU(702)에 결합되는 마스터 회로이다. 엔드포인트 회로(804)는 NoC(208)의 NSU(704)에 결합된 슬레이브 회로이다. 각각의 엔드포인트 회로(802, 804)는 PS(212) 내의 회로, PL 영역(214) 내의 회로, 또는 다른 서브시스템 내의 회로(예를 들어, 하드와이어드 회로 블록(210))일 수 있다.
네트워크(714)는 복수의 물리 채널(806)을 포함한다. 물리 채널(806)은 NoC(208)를 프로그래밍함으로써 구현된다. 각각의 물리 채널(806)은 하나 이상의 NPS(706) 및 관련 라우팅(708)을 포함한다. NMU(702)는 적어도 하나의 물리 채널(806)을 통해 NSU(704)와 연결된다. 물리 채널(806)은 또한 하나 이상의 가상 채널(808)을 가질 수 있다.
네트워크(714)를 통한 연결은 마스터-슬레이브 배열을 사용한다. 예에서, 네트워크(714)를 통한 가장 기본적인 연결은 단일 슬레이브에 연결된 단일 마스터를 포함한다. 그러나 다른 예에서는 더 복잡한 구조가 구현될 수 있다.
도 9는 다른 예에 따라 NoC(208)를 도시하는 블록 다이어그램이다. 예에서, NoC(208)는 수직 부분(vertical portion)(902)(VNoC) 및 수평 부분(horizontal portion)(904)(HNoC)을 포함한다. 각각의 VNoC(902)는 PL 영역(214) 사이에 배치된다. HNoC(904)는 PL 영역(214)과 I/O 뱅크(910)(예를 들어, I/O 블록 및/또는 하드와이어드 회로 블록(210)에 대응하는 트랜시버) 사이에 배치된다. NoC(208)는 메모리 인터페이스(908)(예를 들어, 하드와이어드 회로 블록(210))에 연결된다. PS(212)는 HNoC(904)에 결합된다.
예에서, PS(212)는 HNoC(904)에 결합된 복수의 NMU(702)를 포함한다. VNoC(902)는 PL 영역(214) 내에 배치되는 NMU(702) 및 NSU(704) 둘 다를 포함한다. 메모리 인터페이스(908)는 HNoC(904)에 결합된 NSU(704)를 포함한다. HNoC(904) 및 VNoC(902) 모두 라우팅(708)에 의해 연결된 NPS(706)를 포함한다. VNoC(902)에서 라우팅(708)은 수직으로 연장된다. HNoC(904)에서 라우팅은 수평으로 연장된다. 각각의 VNoC(902)에서, 각각의 NMU(702)는 NPS(706)에 결합된다. 마찬가지로, 각각의 NSU(704)는 NPS(706)에 결합된다. NPS(706)는 스위치 매트릭스를 형성하기 위해 서로 결합된다. 각 VNoC(902) 내의 일부 NPS(706)는 HNoC(904) 내의 다른 NPS(706)에 결합된다.
단일 HNoC(904)만이 도시되어 있지만, 다른 예에서, NoC(208)는 하나가 넘는 HNoC(904)를 포함할 수 있다. 또한, 2개의 VNoC(902)가 도시되어 있지만, NoC(208)는 2개가 넘는 VNoC(902)를 포함할 수 있다. 메모리 인터페이스(908)가 예로서 도시되어 있지만, 하드와이어드 회로 블록(210) 다른 하드와이어드 회로 블록(210)이 메모리 인터페이스(908) 대신에 또는 이에 추가하여 사용될 수 있음을 이해해야 한다.
도 10은 NoC(208)를 프로그래밍하는 예시적인 방법(1000)을 도시한다. SoC(200)의 다른 서브시스템과 독립적으로 설명되지만, 방법(1000)은 SoC(200)에 대한 더 큰 부팅 또는 프로그래밍 프로세스의 일부로서 포함 및/또는 사용될 수 있다.
블록(1002)에서, SoC(200)에 구현된 플랫폼 관리 제어기(Platform Management Controller, PMC)는 부팅 시에 NoC 프로그래밍 데이터를 수신한다. NoC 프로그래밍 데이터는 PDI의 일부일 수 있다. PMC는 SoC(200)을 관리하는 역할을 한다. PMC는 정상 작동 중에 안전한 보안 환경을 유지하고 SoC(200)을 부팅하고 SoC(200)을 관리할 수 있다.
블록(1004)에서, PMC는 물리 채널(806)을 생성하기 위해 NPI(710)를 통해 레지스터(712)에 NoC 프로그래밍 데이터를 로딩한다. 예에서, 프로그래밍 데이터는 또한 NPS(706)에서 라우팅 테이블을 구성하기 위한 정보를 포함할 수 있다. 블록(1006)에서, PMC는 SoC(200)를 부팅한다. 이러한 방식으로, NoC(208)는 적어도 NMU(702)와 NSU(704) 사이의 물리 채널(806)에 대한 구성 정보를 포함한다. NoC(208)에 대한 나머지 구성 정보는 아래에서 더 설명되는 바와 같이 런타임 동안 수신될 수 있다. 다른 예에서, 런타임 동안 수신되는 것으로 아래에서 설명되는 구성 정보의 전부 또는 일부는 부팅 시에 수신될 수 있다.
도 11은 NoC(208)를 프로그래밍하는 예시적인 방법(1100)을 도시한다. 블록(1102)에서, PMC는 런타임 동안 NoC 프로그래밍 데이터를 수신한다. 블록(1104)에서, PMC는 NPI(710)를 통해 NoC 레지스터(712)에 프로그래밍 데이터를 로딩한다. 예에서, 블록(1106)에서, PMC는 NPS(706)에서 라우팅 테이블을 구성한다. 블록(1108)에서, PMC는 물리 채널(806)을 통해 QoS 경로를 구성한다. 블록(1110)에서, PMC는 어드레스 공간 매핑을 구성한다. 블록(1112)에서, PMC는 인그레스/이그레스 인터페이스 프로토콜, 폭 및 주파수를 구성한다. QoS 경로, 어드레스 공간 매핑, 라우팅 테이블 및 인그레스/이그레스 구성은 아래에서 더 논의된다.
도 12는 엔드포인트 회로들 사이의 NoC(208)를 통한 예시적인 데이터 경로(1200)를 도시한다. 데이터 경로(1200)는 엔드포인트 회로(1202), AXI 마스터 회로(1204), NMU(1206), NPS(1208), NSU(1210), AXI 슬레이브 회로(1212), 및 엔드포인트 회로(1214)를 포함한다. 엔드포인트 회로(1202)는 AXI 마스터 회로(1204)에 결합된다. AXI 마스터 회로(1204)는 NMU(1206)에 결합된다. 다른 예에서, AXI 마스터 회로(1204)는 NMU(1206)의 일부이다.
NMU(1206)는 NPS(1208)에 결합된다. NPS(1208)는 NPS(1208)의 체인(예를 들어, 본 예에서 5 개의 NPS(1208)의 체인)을 형성하기 위해 서로 결합된다. 일반적으로, NMU(1206)와 NSU(1210) 사이에는 적어도 하나의 NPS(1208)가 있다. NSU(1210)는 NPS(1208) 중 하나에 결합된다. AXI 슬레이브 회로(1212)는 NSU(1210)에 결합된다. 다른 예에서, AXI 슬레이브 회로(1212)는 NSU(1210)의 일부이다. 엔드포인트 회로(1214)는 AXI 슬레이브 회로(1212)에 결합된다.
엔드포인트 회로(1202 및 1214)는 각각 강화된 회로(예를 들어, PS 회로, 하드와이어드 회로(210), 하나 이상의 DPE(204)) 또는 PL(214) 내에 구성된 회로일 수 있다. 엔드포인트 회로(1202)는 마스터 회로로서 기능하고 NMU(1206)에 판독/기입 요청을 전송한다. 예에서 엔드포인트 회로(1202 및 1214)는 AXI 프로토콜을 사용하여 NoC(208)와 통신한다. AXI가 예에서 설명되지만, NoC(208)는 당업계에 공지된 다른 타입의 프로토콜을 사용하여 엔드포인트 회로로부터 통신을 수신하도록 구성될 수 있다는 것을 이해해야 한다. 예를 들어 명확성의 목적을 위해 NoC(208)는 본 명세서에서 AXI 프로토콜을 지원하는 것으로 설명된다. NMU(1206)는 목적지 NSU(1210)에 도달하기 위해 NPS(1208) 세트를 통해 요청을 중계(relay)한다. NSU(1210)는 데이터를 처리하고 엔드포인트 회로(1214)로 분배하기 위해 부착된 AXI 슬레이브 회로(1212)에 요청을 전달(pass)한다. AXI 슬레이브 회로(1212)는 판독/기입 응답을 NSU(1210)로 다시 보낸다. NSU(1210)는 NPS(1208) 세트를 통해 응답을 NMU(1206)에 포워딩할 수 있다. NMU(1206)는 AXI 마스터 회로(1204)에 응답을 전달하고, AXI 마스터 회로(1204)는 엔드포인트 회로(1202)에 데이터를 분배한다.
도 13은 판독/기입 요청 및 응답을 처리하는 예시적인 방법(1300)을 도시한다. 방법(1300)은 엔드포인트 회로(1202)가 AXI 마스터(1204)를 통해 NMU(1206)에 요청(예를 들어, 판독 요청 또는 기입 요청)을 전송하는 블록(1302)에서 시작한다. 블록(1304)에서, NMU(1206)는 응답을 처리한다. 예에서, NMU(1206)는 엔드포인트 회로(1202)의 클록 도메인과 NoC(208) 사이의 비동기식 크로싱(crossing) 및 레이트 매칭을 수행한다. NMU(1206)는 요청에 기반하여 NSU(1210)의 목적지 어드레스를 결정한다. NMU(1206)는 가상화가 사용되는 경우 어드레스 재매핑을 수행할 수 있다. NMU(1206)는 또한 요청의 AXI 변환을 수행한다. NMU(1206)는 또한 요청을 패킷 스트림으로 패킷화한다.
블록(1306)에서, NMU(1206)는 요청에 대한 패킷을 NPS(1208)로 전송한다. 각각의 NPS(1208)는 목적지 어드레스 및 라우팅 정보에 기반하여 목표 출력 포트에 대한 테이블 룩업을 수행한다. 블록(1308)에서, NSU(1210)는 요청의 패킷을 처리한다. 예에서, NSU(1210)는 요청을 역패킷화(de-packetize)하고, AXI 변환을 수행하고, NoC 클록 도메인으로부터 엔드포인트 회로(1214)의 클록 도메인으로 비동기식 크로싱 및 레이트 매칭을 수행한다. 블록(1310)에서 NSU(1210)는 요청을 AXI 슬레이브 회로(1212)를 통해 엔드포인트 회로(1214)로 전송한다. NSU(1210)는 또한 AXI 슬레이브 회로(1212)를 통해 엔드포인트 회로(1214)로부터 응답을 수신할 수 있다.
블록(1312)에서, NSU(1210)는 응답을 처리한다. 예에서, NSU(1210)는 엔드포인트 회로(1214)의 클록 도메인과 NoC(208)의 클록 도메인으로부터 비동기식 크로싱 및 레이트 매칭을 수행한다. NSU(1210)는 또한 응답을 패킷 스트림으로 패킷화한다. 블록(1314)에서, NSU(1210)는 NPS(1208)를 통해 패킷을 전송한다. 각각의 NPS(1208)는 목적지 어드레스 및 라우팅 정보에 기반하여 목표 출력 포트에 대한 테이블 룩업을 수행한다. 블록(1316)에서, NMU(1206)는 패킷을 처리한다. 예에서, NMU(1206)는 응답을 역패킷화하고, AXI 변환을 수행하고, NoC 클록 도메인으로부터 엔드포인트 회로(1202)의 클록 도메인으로 비동기식 크로싱 및 레이트 매칭을 수행한다. 블록(1318)에서 NMU(1206)는 AXI 마스터 회로(1204)를 통해 엔드포인트 회로(1202)로 응답을 전송한다.
도 14는 NMU(702)의 예시적인 구현을 도시한다. NMU(702)는 AXI 마스터 인터페이스(1402), 패킷화 회로(1404), 어드레스 맵(1406), 역패킷화 회로(1408), QoS 회로(1410), VC 매핑 회로(1412), 및 클록 관리 회로(1414)를 포함한다. AXI 마스터 인터페이스(1402)는 엔드포인트 회로를 위해 NMU(702)에 AXI 인터페이스를 제공한다. 다른 예들에서, 상이한 프로토콜이 사용될 수 있고, 따라서 NMU(702)는 선택된 프로토콜을 준수하는 상이한 마스터 인터페이스를 가질 수 있다. NMU(702)는 인바운드 트래픽을 패킷화 회로(1404)로 라우팅하고, 패킷화 회로(1404)는 인바운드 데이터로부터 패킷을 생성한다. 패킷화 회로(1404)는 어드레스 맵(1406)으로부터 목적지 ID를 결정하고, 이는 패킷을 라우팅하는데 사용된다. QoS 회로(1410)는 NoC(208) 내로의 패킷 주입(injection) 속도를 제어하기 위해 인그레스 레이트 제어를 제공할 수 있다. VC 매핑 회로(1412)는 각각의 물리 채널에서 QoS 가상 채널을 관리한다. NMU(702)는 패킷이 매핑되는 가상 채널을 선택하도록 구성될 수 있다. 클록 관리 회로(1414)는 레이트 매칭 및 비동기 데이터 크로싱을 수행하여 AXI 클록 도메인과 NoC 클록 도메인 사이의 인터페이스를 제공한다. 역패킷화 회로(1408)는 NoC(208)로부터 리턴 패킷을 수신하고 AXI 마스터 인터페이스(1402)에 의한 출력을 위해 패킷을 역패킷화하도록 구성된다.
도 15는 NSU(704)의 예시적인 구현을 도시한다. NSU(704)는 AXI 슬레이브 인터페이스(1502), 클록 관리 회로(1504), 패킷화 회로(1508), 역패킷화 회로(1506), 및 QoS 회로(1510)를 포함한다. AXI 슬레이브 인터페이스(1502)는 엔드포인트 회로를 위해 NSU(704)에 AXI 인터페이스를 제공한다. 다른 예들에서, 상이한 프로토콜이 사용될 수 있고, 따라서 NSU(704)는 선택된 프로토콜을 준수하는 상이한 슬레이브 인터페이스를 가질 수 있다. NSU(704)는 NoC(208)로부터의 인바운드 트래픽을 역패킷화 회로(1506)로 라우팅하고, 역패킷화 회로(1506)는 역패킷화 데이터를 생성한다. 클록 관리 회로(1504)는 AXI 클록 도메인과 NoC 클록 도메인 사이의 인터페이스를 제공하기 위해 레이트 매칭 및 비동기 데이터 크로싱을 수행한다. 패킷화 회로(1508)는 슬레이브 인터페이스(1502)로부터 리턴 데이터를 수신하고 NoC(208)를 통한 전송을 위해 리턴 데이터를 패킷화하도록 구성된다. QoS 회로(1510)는 NoC(208)로의 패킷 주입 속도를 제어하기 위해 인그레스 속도 제어를 제공할 수 있다.
도 16은 도 1과 관련하여 설명된 시스템에 의해 실행가능한 예시적인 소프트웨어 아키텍처를 도시한다. 예를 들어, 도 16의 아키텍처는 도 1의 프로그램 모듈(120) 중 하나 이상으로서 구현될 수 있다. 도 16의 소프트웨어 아키텍처는 DPE 컴파일러(1602), NoC 컴파일러(1604) 및 하드웨어 컴파일러(1606)를 포함한다. 도 16은 (예를 들어, SoC(200)에서 애플리케이션을 구현하기 위해 설계 흐름을 수행하는) 동작 동안 컴파일러들 사이에서 교환될 수 있는 다양한 타입의 설계 데이터의 예를 도시한다.
DPE 컴파일러(1602)는 애플리케이션으로부터 하나 이상의 DPE 및/또는 DPE 어레이(202)의 DPE(204)의 서브세트 내로 로딩될 수 있는 하나 이상의 바이너리를 생성할 수 있다. 각 바이너리는 DPE(들)의 코어(들), 선택적으로 애플리케이션 데이터 및 DPE에 대한 구성 데이터에 의해 실행 가능한 오브젝트 코드를 포함할 수 있다. NoC 컴파일러(1604)는 애플리케이션을 위한 데이터 경로를 창작하기 위해 NoC(208) 내로 로딩되는 구성 데이터를 포함하는 바이너리를 생성할 수 있다. 하드웨어 컴파일러(1606)는 PL(214)에서 구현하기 위한 구성 비트스트림을 생성하기 위해 애플리케이션의 하드웨어 부분을 컴파일할 수 있다.
도 16은 DPE 컴파일러(1602), NoC 컴파일러(1604), 및 하드웨어 컴파일러(1606)가 동작 동안 서로 통신하는 방법의 예를 도시한다. 각 컴파일러는 설계 데이터를 교환하여 솔루션으로 수렴함으로써 조정된(coordinated) 방식으로 통신한다. 솔루션은 설계 메트릭 및 제약을 충족하고 SoC(200)의 다양한 헤테로지니어스 서브시스템이 통신하는 공통 인터페이스를 포함하는 SoC(200) 내의 애플리케이션의 구현이다.
본 개시 내에서 정의된 바와 같이, 용어 "설계 메트릭(design metric)"은 SoC(200)에서 구현될 애플리케이션의 목적 또는 요건을 정의한다. 설계 메트릭의 예는 전력 소비 요구 사항, 데이터 처리량 요구 사항, 타이밍 요구 사항 등을 포함하지만 이에 국한되지 않는다. 설계 메트릭은 사용자 입력, 파일 또는 애플리케이션의 상위(higher) 또는 시스템 수준 요구 사항을 정의하는 다른 방식을 통해 제공될 수 있다. 본 개시 내에서 정의된 바와 같이, "설계 제약(design constraint)"은 EDA 도구가 설계 메트릭 또는 요구 사항을 달성하기 위해 따를 수도 있고 따르지 않을 수도 있는 요구 사항이다. 설계 제약은 컴파일러 지시문(compiler directive)으로서 명시될 수 있으며 일반적으로 EDA 도구(예를 들어, 컴파일러(들))가 따라야 하는 하위(lower) 수준 요구 사항 또는 제안을 명시한다. 설계 제약은 사용자 입력(들), 하나 이상의 설계 제약을 포함하는 파일, 커맨드 라인 입력 등을 통해 명시될 수 있다.
일 양태에서, DPE 컴파일러(1602)는 애플리케이션을 위한 논리 아키텍처 및 SoC 인터페이스 블록 솔루션을 생성할 수 있다. 예를 들어, DPE 컴파일러(1602)는 DPE 어레이(202)에서 구현될 애플리케이션의 소프트웨어 부분에 대한 높은 수준의 사용자 정의 메트릭에 기반하여 논리 아키텍처를 생성할 수 있다. 메트릭의 예는 데이터 처리량, 레이턴시, 자원 사용률 및 전력 소비를 포함할 수 있지만, 이에 국한되지 않는다. 메트릭 및 애플리케이션(예를 들어, DPE 어레이(202)에서 구현될 특정 노드)에 기반하여, DPE 컴파일러(1602)는 논리 아키텍처를 생성할 수 있다.
논리 아키텍처는 애플리케이션의 다양한 부분에 필요한 하드웨어 자원 블록 정보를 명시할 수 있는 파일 또는 데이터 구조이다. 예를 들어, 논리 아키텍처는 애플리케이션의 소프트웨어 부분, DPE 어레이(202)와 통신하기 위해 PL(214)에서 필요한 임의의 IP(Intellectual Property) 코어, NoC(208)를 통해 라우팅될 필요가 있는 임의의 연결 및 DPE 어레이(202), NoC(208) 및 PL(214) 내의 IP 코어에 대한 포트 정보를 구현하는 데 필요한 DPE(204)의 수를 명시할 수 있다. IP 코어는 재사용 가능한 블록, 또는 특정 기능이나 동작을 수행할 수 있는 재사용 가능한 회로 블록으로서 회로 설계에서 사용될 수 있는 로직, 셀 또는 IC 레이아웃 설계의 부분이다. IP 코어는 PL(214) 내에서 구현하기 위해 회로 설계 내로 통합될 수 있는 포맷으로 명시될 수 있다. 본 개시는 다양한 타입의 코어를 언급하지만, 다른 수식어가 없는 "코어"라는 용어는 일반적으로 그러한 상이한 타입의 코어를 지칭하기 위한 것이다.
상세한 설명의 끝에 위치한 본 개시 내의 예 1은 애플리케이션에 대한 논리 아키텍처를 명시하는 데 사용될 수 있는 예시적인 스키마를 보여준다. 예 1은 애플리케이션에 대한 논리 아키텍처에 포함된 다양한 타입의 정보를 보여준다. 일 양태에서, 하드웨어 컴파일러(1606)는 애플리케이션 자체를 사용하는 것과 대조적으로 논리 아키텍처 및 SoC 인터페이스 블록 솔루션에 기초하거나 이를 사용하여 애플리케이션의 하드웨어 부분을 구현할 수 있다.
DPE 어레이(202)에 대한 포트 정보 및 NoC(208)와 PL(214) 내의 IP 코어에 대한 포트 정보는 예를 들어, 각 포트가 스트림 데이터 포트인지, 메모리 매핑된 포트인지 또는 파라미터 포트인지 여부, 및 포트가 마스터인지 슬레이브인지 여부와 같은 포트의 논리적 구성을 포함할 수 있다. IP 코어에 대한 포트 정보의 다른 예는 포트의 데이터 너비 및 작동 빈도를 포함한다. DPE 어레이(202), NoC(208) 및 PL(214) 내의 IP 코어 간의 연결은 논리 아키텍처에 명시된 각 하드웨어 자원 블록의 포트 간의 논리적 연결로서 명시될 수 있다.
SoC 인터페이스 블록 솔루션은 DPE 어레이(202) 안팎의 연결의 SoC 인터페이스 블록(206)의 물리적 데이터 경로(예를 들어, 물리적 자원)로의 매핑을 명시하는 데이터 구조 또는 파일이다. 예를 들어, SoC 인터페이스 블록 솔루션은 DPE 어레이(202) 안팎의 데이터 이송에 사용되는 특정 논리적 연결을 SoC 인터페이스 블록(206)의 특정 스트림 채널, 예를 들어 SoC 인터페이스 블록(206)의 특정 타일, 스트림 스위치 및/또는 스트림 스위치 인터페이스(예를 들어, 포트)로 매핑한다. 상세한 설명의 끝 쪽에 예 1에 이어 위치된 예 2는 애플리케이션을 위한 SoC 인터페이스 블록 솔루션에 대한 예시적인 스키마를 도시한다.
일 양태에서, DPE 컴파일러(1602)는 애플리케이션 및 논리 아키텍처에 기반하여 NoC(208)를 통한 데이터 트래픽을 분석하거나 시뮬레이션할 수 있다. DPE 컴파일러(1602)는 애플리케이션의 소프트웨어 부분, 예를 들어 "NoC 트래픽"의 데이터 이송 요구 사항을 NoC 컴파일러(1604)에 제공할 수 있다. NoC 컴파일러(1604)는 DPE 컴파일러(1602)로부터 수신된 NoC 트래픽에 기반하여 NoC(208)를 통한 데이터 경로에 대한 라우팅을 생성할 수 있다. "NoC 솔루션"으로 도시된 NoC 컴파일러(1604)로부터의 결과는 DPE 컴파일러(1602)에 제공될 수 있다.
일 양태에서, NoC 솔루션은 NoC(208)에 연결되는 애플리케이션의 노드들이 연결될 NoC(208)의 인그레스 및/또는 이그레스 지점만을 명시하는 초기 NoC 솔루션일 수 있다. 예를 들어, NoC(208) 내의 (예를 들어, 인그레스 지점과 이그레스 지점 사이의) 데이터 경로에 대한 보다 상세한 라우팅 및/또는 구성 데이터는 컴파일러의 수렴의 목적을 위해 NoC 솔루션으로부터 제외될 수 있다. 상세한 설명 끝 쪽에 예 2를 이어 위치된 예 3은 애플리케이션에 대한 NoC 솔루션에 대한 예제 스키마를 보여준다.
하드웨어 컴파일러(1606)는 PL(214)에서 애플리케이션의 하드웨어 부분을 구현하기 위해 논리 아키텍처 상에서 동작할 수 있다. 하드웨어 컴파일러(1606)가 (예를 들어, 타이밍, 전력, 데이터 처리량 등에 대한) 확립된 설계 제약을 충족하는 애플리케이션의 하드웨어 부분의 구현을 (예를 들어, 논리 아키텍처를 사용하여) 생성할 수 없는 경우, 하드웨어 컴파일러(1606)는 하나 이상의 SoC 인터페이스 블록 제약을 생성할 수 있고/있거나 하나 이상의 사용자 명시된(user-specified) SoC 인터페이스 블록 제약을 수신할 수 있다. 하드웨어 컴파일러(1606)는 요청으로서 DPE 컴파일러(1602)에 SoC 인터페이스 블록 제약을 제공할 수 있다. SoC 인터페이스 블록 제약은 논리 아키텍처의 하나 이상의 부분을 SoC 인터페이스 블록(206)의 상이한 스트림 채널에 효과적으로 재매핑한다. 하드웨어 컴파일러(1606)로부터 제공되는 SoC 인터페이스 블록 제약은 하드웨어 컴파일러(1606)가 설계 메트릭을 충족하는 PL(214)에서의 애플리케이션의 하드웨어 부분의 구현을 생성하는데 더 유리하다. 상세한 설명의 끝 쪽에 예 3에 이어 위치된 예 4는 SoC 인터페이스 블록 및/또는 애플리케이션에 대한 NoC에 대한 예시적인 제약을 도시한다.
다른 양태에서, 하드웨어 컴파일러(1606)는 또한 애플리케이션 및 논리 아키텍처에 기반하여 NoC 트래픽을 생성하고 NoC 컴파일러(1604)에 제공할 수 있다. 하드웨어 컴파일러(1606)는 예를 들어 애플리케이션의 하드웨어 부분을 분석 또는 시뮬레이션하여, NoC(208)를 통해 PS(212), DPE 어레이(202), 및/또는 SoC(200)의 다른 부분에 전달될 설계의 하드웨어 부분에 의해 생성되는 데이터 트래픽을 결정할 수 있다. NoC 컴파일러(1604)는 하드웨어 컴파일러(1606)로부터 수신된 정보에 기반하여 NoC 솔루션을 생성 및/또는 업데이트할 수 있다. NoC 컴파일러(1604)는 NoC 솔루션 또는 그 업데이트된 버전을 하드웨어 컴파일러(1606)로 그리고 또한 DPE 컴파일러(1602)로 제공할 수 있다. 이와 관련하여, DPE 컴파일러(1602)는 SoC 인터페이스 블록 솔루션을 업데이트할 수 있고, NoC 컴파일러(1604)로부터 NoC 솔루션 또는 업데이트된 NoC 솔루션을 수신하는 것에 응답하여, 및/또는 하드웨어 컴파일러(1606)로부터 하나 이상의 SoC 인터페이스 블록 제약을 수신하는 것에 응답하여 업데이트된 솔루션을 하드웨어 컴파일러(1606)에 제공할 수 있다. DPE 컴파일러(1602)는 하드웨어 컴파일러(1606)로부터 및/또는 NoC 컴파일러(1604)로부터의 업데이트된 NoC 솔루션으로부터 수신된 SoC 인터페이스 블록 제약(들)에 기반하여, 업데이트된 SoC 인터페이스 블록 솔루션을 생성한다.
도 16의 예에 도시된 컴파일러들 사이의 데이터 흐름은 단지 예시 목적이라는 것을 이해해야 한다. 이와 관련하여, 컴파일러들 간의 정보 교환은 본 개시 내에서 설명된 예시적인 설계 흐름의 다양한 단계에서 수행될 수 있다. 다른 양태에서, 컴파일러 사이의 설계 데이터의 교환은 반복적인 방식으로 수행될 수 있으므로 각 컴파일러는 다른 컴파일러로부터 수신된 정보를 기반으로 해당 컴파일러가 처리하는 애플리케이션의 부분의 구현을 지속적으로 정제하여 솔루션에 수렴할 수 있다.
하나의 특정 예에서, 하드웨어 컴파일러(1606)는 DPE 컴파일러(1602)로부터 논리 아키텍처 및 SoC 인터페이스 블록 솔루션을 수신하고 NoC 컴파일러(1604)로부터 NoC 솔루션을 수신한 후, 확립된 설계 메트릭을 충족하는 애플리케이션의 하드웨어 부분의 구현을 생성하는 것은 불가능하다고 결정할 수 있다. DPE 컴파일러(1602)에 의해 생성된 초기 SoC 인터페이스 블록 솔루션은 DPE 어레이(202)에서 구현될 애플리케이션 부분에 대한 DPE 컴파일러(1602)의 지식에 기반하여 생성된다. 마찬가지로, NoC 컴파일러(1604)에 의해 생성된 초기 NoC 솔루션은 DPE 컴파일러(1602)에 의해 NoC 컴파일러(1604)에 제공되는 초기 NoC 트래픽에 기반하여 생성된다. 상세한 설명의 끝 쪽에 예 4에 이어 위치된 예 5는 애플리케이션에 대한 NoC 트래픽에 대한 예시적인 스키마를 도시한다. 스키마가 예 1-5에서 사용되는 한편, 다른 포맷화 및/또는 데이터 구조가 예시된 정보를 명시하기 위해 사용될 수 있음을 이해해야 한다.
하드웨어 컴파일러(1606)는 합성(필요한 경우), 배치, 및 하드웨어 부분 라우팅을 포함하는 애플리케이션의 하드웨어 부분에 대한 구현 흐름을 수행하려고 시도한다. 이와 같이, 초기 SoC 인터페이스 블록 솔루션 및 초기 NoC 솔루션은 확립된 타이밍 제약을 충족하지 않는 PL(214) 내의 배치 및/또는 라우팅을 초래할 수 있다. 다른 경우에, SoC 인터페이스 블록 솔루션 및 NoC 솔루션은 전달되어야 하는 데이터를 수용하기 위해 와이어와 같은 충분한 수의 물리적 자원을 갖지 않을 수 있어서 PL(214)에서 혼잡을 초래한다. 이러한 경우, 하드웨어 컴파일러(1606)는 하나 이상의 상이한 SoC 인터페이스 블록 제약을 생성하고/하거나, 하나 이상의 사용자 명시 SoC 인터페이스 블록 제약을 수신하고, SoC 인터페이스 블록 솔루션을 재생성하기 위한 요청으로서 DPE 컴파일러(1602)에 SoC 인터페이스 블록 제약을 제공할 수 있다. 마찬가지로, 하드웨어 컴파일러(1606)는 하나 이상의 상이한 NoC 제약을 생성하고/하거나, 하나 이상의 사용자 명시된 NoC 제약을 수신하고, NoC 솔루션을 재생성하기 위한 요청으로서 NoC 컴파일러(1604)에 NoC 제약을 제공할 수 있다. 이러한 방식으로, 하드웨어 컴파일러(1606)는 DPE 컴파일러(1602) 및/또는 NoC 컴파일러(1604)를 호출(invoke)한다.
DPE 컴파일러(1602)는 하드웨어 컴파일러(1606)로부터 수신된 SoC 인터페이스 블록 제약을 취하고, 가능하다면 수신된 SoC 인터페이스 블록 제약을 사용하여 SoC 인터페이스 블록 솔루션을 업데이트하고, 업데이트된 SoC 인터페이스 블록 솔루션을 하드웨어 컴파일러(1606)에 다시 제공할 수 있다. 유사하게, NoC 컴파일러(1604)는 하드웨어 컴파일러(1606)로부터 수신된 NoC 제약을 취하고, 가능하다면 수신된 NoC 제약을 사용하여 NoC 솔루션을 업데이트하고, 업데이트된 NoC 솔루션을 하드웨어 컴파일러(1606)에 다시 제공할 수 있다. 그 다음, 하드웨어 컴파일러(1606)는 DPE 컴파일러(1602)로부터 수신된 업데이트된 SoC 인터페이스 블록 솔루션 및 NoC 컴파일러(1604)로부터 수신된 업데이트된 NoC 솔루션을 사용하여 PL(214) 내에서의 구현을 위한 애플리케이션의 하드웨어 부분을 생성하기 위해 구현 흐름을 계속할 수 있다.
일 양태에서, 하드웨어 컴파일러(1606)가 하나 이상의 SoC 인터페이스 블록 제약 및 하나 이상의 NoC 제약을 각각 제공함으로써 DPE 컴파일러(1602) 및/또는 NoC 컴파일러(1604)를 호출하는 것은 확인(validation) 프로세스의 일부일 수 있다. 예를 들어, 하드웨어 컴파일러(1606)는 하드웨어 컴파일러(1606)로부터 제공되는 SoC 인터페이스 블록 제약 및 NoC 제약이 라우팅 가능한 SoC 인터페이스 블록 솔루션 및/또는 NoC 솔루션에 사용되거나 통합될 수 있다는 확인을 DPE 컴파일러(1602) 및/또는 NoC 컴파일러(1604)로부터 청하고 있다.
도 17a는 도 1과 관련하여 설명된 시스템을 사용하여 SoC(200)에 매핑된 애플리케이션(1700)의 예를 도시한다. 예시의 목적을 위해 SoC(200)의 상이한 서브시스템의 서브세트만 도시된다. 애플리케이션(1700)은 도시된 연결을 가지는 노드 A, B, C, D, E 및 F를 포함한다. 아래 예 6은 애플리케이션(1700)을 명시하는 데 사용할 수 있는 예제 소스 코드를 보여준다.
예 6
using namespace cardano; // class library with graph building primitives
class radio : cardano::graph { // an example graph class
public:
input_port in;
output_port out;
kernel a,b,c,d,e,f;
radio() { // graph constructor
a = kernel::create(polarclip);
b = kernel::create(feedback);
c = kernel::create(equalizer);
d = kernel::create(fir_tap11);
e = kernel::create(fir_tap7);
f = kernel::create(scale);
fabric<fpga>(a); fabric<fpga>(f);
runtime<ratio>(b) = 0.6; runtime<ratio>(c) = 0.2;
runtime<ratio>(d) = 0.8; runtime<ratio>(e) = 0.1;
connect<stream, window<64,8> > ( a.out[0], b.in[0] );
connect<window<32> > ( b.out[0], c.in[0] );
connect<window<32, 24> > ( c.out[0], d.in[0] );
connect<window<32, 16> > ( d.out[1], e.in[0] );
connect<window<32, 8> > ( e.out[0], async(b.in[1]) );
connect<window<16>, stream > ( d.out[0], f.in[0] );
connect<stream> ( in, a.in[0] );
connect<stream> ( f.out[0], out );
}
}
radio mygraph; //top level testbench
simulation::platform<1,1> platform(“in.txt”, “out.txt”);
connect<> net0(platform.src[0], mygraph.in);
connect<> net1(platform.sink[0], mygraph.out);
int main(void) { //control program for PS
mygraph.init();
mygraph.run();
mygraph.end();
return 0;
}
일 양태에서, 애플리케이션(1700)은 복수의 노드를 포함하는 데이터 흐름 그래프로서 명시된다. 각 노드는 계산을 나타내고, 계산은 단일 명령어와 대조적으로, 함수(function)에 대응한다. 노드는 데이터 흐름을 나타내는 에지(edge)에 의해 상호 연결된다. 노드의 하드웨어 구현은 해당 노드에 대한 각각의 입력으로부터 데이터를 수신하는 것에 대한 응답으로만 실행할 수 있다. 노드는 일반적으로 비차단(non-blocking) 방식으로 실행된다. 애플리케이션(1700)에 의해 명시된 데이터 흐름 그래프는 순차(sequential) 프로그램과 대조적으로 SoC(200)에서 구현될 병렬 사양(parallel specification)을 나타낸다. 시스템은 애플리케이션(1700)에 (예를 들어, 예 1에 예시된 바와 같은 그래프 형태로) 동작하여 다양한 노드를 그 안에서의 구현을 위한 SoC(200)의 적절한 서브시스템에 매핑할 수 있다.
일 예에서, 애플리케이션(1700)은 C 및/또는 C++와 같은 고급 프로그래밍 언어(high-level programming language, HLL)로 명시된다. 언급한 바와 같이, 순차 프로그램을 생성하기 위해 통상적으로 사용되는 HLL에 명시되어 있지만, 데이터 흐름 그래프인 애플리케이션(1700)은 병렬 사양이다. 시스템은 데이터 흐름 그래프 및 그런 애플리케이션(1700)을 구축하는 데 사용되는 클래스 라이브러리를 제공할 수 있다. 데이터 흐름 그래프는 사용자에 의해 정의되고 SoC(200)의 아키텍처에 컴파일된다. 클래스 라이브러리는 애플리케이션(1700)을 구축하는 데 사용할 수 있는 그래프, 노드 및 에지에 대한 미리 정의된 클래스 및 생성자(constructor)가 있는 헬퍼 라이브러리로서 구현될 수 있다. 애플리케이션(1700)은 SoC(200)에서 효과적으로 실행되며, SoC(200)의 PS(212)에서 실행되는 위임된(delegated) 오브젝트를 포함한다. PS(212)에서 실행되는 애플리케이션(1700)의 오브젝트는 SoC(200)에서, 예를 들어, PL(214), DPE 어레이(202), 및/또는 하드와이어드 회로 블록(210)에서 실행되고 있는 실제 계산을 지시하고 모니터링하는 데 사용될 수 있다.
본 개시 내에서 설명된 본 발명의 장치에 따르면, 가속기(예를 들어, PL 노드)는 데이터 흐름 그래프(예를 들어, 애플리케이션)에서 오브젝트로서 표현될 수 있다. 시스템은 PL 노드를 자동으로 합성하고, 합성된 PL 노드를 PL(214)에서 구현하기 위해 연결할 수 있다. 그에 비해 기존 EDA 시스템에서 사용자는 순차 시맨틱스를 활용하는 하드웨어 가속을 위한 애플리케이션을 명시한다. 하드웨어 가속 함수는 함수 호출을 통해 명시된다. 하드웨어 가속 함수에 대한 인터페이스(예를 들어, 이 예에서 PL 노드)는 데이터 흐름 그래프의 연결과 대조적으로 함수 호출과 함수 호출에서 제공되는 다양한 인수(argument)에 의해 정의된다.
예 6의 소스 코드에 도시된 바와 같이, 노드 A 및 F는 PL(214)에서의 구현을 위해 지정(designate)되는 반면, 노드 B, C, D 및 E는 DPE 어레이(202) 내에서의 구현을 위해 지정된다. 노드의 연결은 소스 코드의 데이터 이송 에지에 의해 명시된다. 예 6의 소스 코드는 또한 탑 레벨 테스트 벤치와 PS(212)에서 실행되는 제어 프로그램을 명시한다.
도 17a로 돌아가서, 애플리케이션(1700)은 SoC(200)에 맵핑된다. SoC(200). 도시된 바와 같이, 노드 A 및 F는 PL(214)에 맵핑된다. 음영 처리된 DPE(204-13 및 204-14)는 노드 B, C, D 및 E가 매핑되는 DPE(204)를 나타낸다. 예를 들어 노드 B와 C는 DPE(204-13)에 매핑되는 반면, 노드 D와 E는 DPE(204-4)에 매핑된다. 노드 A 및 F는 PL(214), SoC 인터페이스 블록(206)의 특정 타일 및 스위치, 개재 DPE(204)의 DPE 인터커넥트 내의 스위치를 통한 라우팅을 통해 그리고 선택된 이웃 DPE(204)의 특정 메모리를 사용하여 PL(214)에서 구현되고 DPE(204-13 및 204-44)에 연결된다.
DPE(204-13)에 대해 생성된 바이너리는 DPE(204-13)가 노드 B와 C에 대응하는 계산을 구현하기 위하여 필요한 오브젝트 코드, 및 DPE(204-13)와 DPE(204-14) 사이, 그리고 DPE(204-13)와 DPE(204-3) 사이의 데이터 경로를 확립하기 위한 구성 데이터를 포함한다. DPE(204-4)에 대해 생성된 바이너리는 DPE(204-4)가 노드 D 및 E에 해당하는 계산을 구현하기 위하여 필요한 오브젝트 코드, 및 DPE(204-14) 및 DPE(204-5)와의 데이터 경로를 확립하기 위한 구성 데이터를 포함한다.
DPE(204-13) 및 DPE(204-4)를 SoC 인터페이스 블록(206)에 연결하기 위해 DPE(204-3, 204-5, 204-6, 204-7, 204-8, 204-9)와 같은 다른 DPE(204)에 대해 다른 바이너리가 생성된다. 분명히, 그러한 바이너리는 그러한 다른 DPE(204)가 다른 계산을 구현할 경우, 임의의 오브젝트 코드를 포함할 것이다(애플리케이션의 노드가 할당된다).
이 예에서, 하드웨어 컴파일러(1606)는 DPE(204-14)와 노드 F를 연결하는 긴 라우팅으로 인해 타이밍 제약을 충족하는 하드웨어 부분의 구현을 생성할 수 없다. 본 개시 내에서 애플리케이션의 하드웨어 부분의 구현의 특정 상태는 하드웨어 설계의 상태로 지칭될 수 있으며, 여기서 하드웨어 설계는 구현 흐름 전반에 걸쳐 생성 및/또는 업데이트된다. 예를 들어, SoC 인터페이스 블록 솔루션은 노드 F에 대한 신호 크로싱을 DPE(204-9) 아래의 SoC 인터페이스 블록의 타일에 할당할 수 있다. 그 경우에, 하드웨어 컴파일러(1606)는 노드 F에 대한 SoC 인터페이스 블록(206)을 통한 크로싱이 DPE(204-4)에 더 가깝게 이동되도록 요청하는, 요청된 SoC 인터페이스 블록 제약을 DPE 컴파일러(1602)에 제공할 수 있다. 예를 들어, 하드웨어 컴파일러(1606)로부터의 요청된 SoC 인터페이스 블록 제약은 DPE(204-4)에 대한 논리적 연결이 SoC 인터페이스 블록(206) 내에서 DPE(204-4) 바로 아래의 타일에 매핑되도록 요청할 수 있다. 이 재매핑은 하드웨어 컴파일러가 타이밍을 개선하기 위해 노드 F를 DPE(204-4)에 훨씬 더 가깝게 배치할 수 있게 할 것이다.
도 17b는 애플리케이션(1700)의 SoC(200)로의 다른 예시적인 매핑을 도시한다. 도 17b는 도 17a에 도시된 것보다 대안적이고 보다 상세한 예를 도시한다. 예를 들어, 도 17b는 DPE 컴파일러(1602)에 의해 수행되는 바와 같이, 애플리케이션(1700)의 노드의 DPE 어레이(202)의 특정 DPE(204)로의 매핑, 애플리케이션(1700)의 노드가 매핑되는 DPE(204) 사이에 확립된 연결, DPE(204)의 메모리 모듈 내의 메모리의 애플리케이션(1700)의 노드로의 할당, 데이터 이송의 DPE(204)(이중 방향 화살표로 표시)의 메모리와 코어 인터페이스(예를 들어, 428, 430, 432, 434, 402, 404, 406 및 408) 및/또는 DPE 인터커넥트(306) 내의 스트림 스위치로의 매핑을 도시한다.
도 17b의 예에서, 메모리 모듈(1702, 1706, 1710, 1714, 및 1718)은 코어(1704, 1708, 1712, 1716 및 1720)와 함께 도시되어 있다. 코어(1704, 1708, 1712, 1716, 및 1720)는 각각 프로그램 메모리(1722, 1724, 1726, 1728 및 1730)를 포함한다. 상부(upper) 행에서 코어(1704) 및 메모리 모듈(1706)은 DPE(204)를 형성하는 반면, 코어(1708) 및 메모리 모듈(1710)은 또 다른 DPE(204)를 형성한다. 하부(lower) 행에서 메모리 모듈(1714) 및 코어(1716)는 DPE(204)를 형성하는 반면, 메모리(1718) 및 코어(1720)는 또 다른 DPE(204)를 형성한다.
도시된 바와 같이, 노드 A 및 F는 PL(214)에 매핑된다. 노드 A는 메모리 모듈(1702) 내의 스트림 스위치 및 중재자(arbiter)를 통해 메모리 모듈(1702) 내의 메모리 뱅크(예를 들어, 메모리 뱅크의 음영 부분)에 연결된다. 노드 B 및 C는 코어(1704)에 매핑된다. 노드 B 및 C를 구현하기 위한 명령어들은 프로그램 메모리(1722)에 저장된다. 노드 D 및 E는 프로그램 메모리(1728)에 저장된 노드 D 및 E를 구현하기 위한 명령어들과 함께 코어(1716)에 매핑된다. 노드 B는 할당되어 코어-메모리 인터페이스를 통해 메모리 모듈(1706) 내의 메모리 뱅크의 음영 부분에 액세스하는 반면, 노드 C는 할당되어 코어-메모리 인터페이스를 통해 메모리 모듈(1702) 내의 메모리 뱅크의 음영 부분에 액세스한다. 노드 B, C 및 E는 할당되어 코어-메모리 인터페이스를 통해 메모리 모듈(1714) 내의 메모리 뱅크의 음영 부분에 액세스할 수 있다. 노드 D는 코어-메모리 인터페이스를 통해 메모리 모듈(1718) 내의 메모리 뱅크의 음영 부분에 액세스할 수 있다. 노드 F는 중재자 및 스트림 스위치를 통해 메모리 모듈(1718)에 연결된다.
도 17b는 애플리케이션의 노드들 사이의 연결이 메모리 및/또는 코어 사이에서 메모리를 공유하는 코어 인터페이스를 사용하고 DPE 인터커넥트(306)를 사용하여 구현될 수 있음을 도시한다.
도 18은 SoC(200) 상에 매핑된 다른 애플리케이션의 예시적인 구현을 도시한다. 예시의 목적을 위해, SoC(200)의 상이한 서브시스템의 서브세트만이 도시된다. 이 예에서, PL(214)에서 각각 구현되는 노드 A 및 F로의 연결은 NoC(208)를 통해 라우팅된다. NoC(208)는 인그레스/이그레스 지점(1802, 1804, 1806, 1808, 1810, 1812, 1814, 1816)(예를 들어, NMU/NSU)을 포함한다. 도 18의 예는 노드 A가 인그레스/이그레스 지점(1802)에 비교적 가깝게 배치되는 경우를 예시하는 반면, 휘발성 메모리(134)에 액세스하는 노드 F는 인그레스/이그레스 지점(1816)에 도달하기 위해 PL(214)을 통한 긴 라우팅을 가진다. 하드웨어 컴파일러(1606)가 노드 F를 인그레스/이그레스 지점(1816)에 더 가깝게 배치할 수 없으면 하드웨어 컴파일러(1606)는 NoC 컴파일러(1604)로부터 업데이트된 NoC 솔루션을 요청할 수 있다. 그 경우 하드웨어 컴파일러(1606)는 노드 F에 대해 상이한 인그레스/이그레스 지점, 예를 들어, 인그레스/이그레스 지점(1812)을 명시하는 업데이트된 NoC 솔루션을 생성하기 위하여 NoC 제약과 함께 NoC 컴파일러(1604)를 호출할 수 있다. 노드 F에 대한 상이한 인그레스/이그레스 지점은 하드웨어 컴파일러(1606)가 노드 F를 업데이트된 NoC 솔루션에 명시된 새로 지정된 인그레스/이그레스 지점에 더 가깝게 배치하고 NoC(208)에서 이용 가능한 더 빠른 데이터 경로를 이용할 수 있게 할 것이다.
도 19는 도 1과 관련하여 설명된 시스템에 의해 실행 가능한 다른 예시적인 소프트웨어 아키텍처(1900)를 도시한다. 예를 들어, 아키텍처(1900)는 도 1의 프로그램 모듈(120) 중 하나 이상으로서 구현될 수 있다. 도 19의 예에서, 애플리케이션(1902)은 SoC(200) 내에서 구현하기 위한 것이다.
도 19의 예에서, 사용자는 시스템에 의해 제공되는 사용자 인터페이스(1906)와 상호 작용할 수 있다. 사용자 인터페이스(1906)와 상호 작용할 때, 사용자는 애플리케이션(1902), 애플리케이션(1902)에 대한 성능 및 파티셔닝 제약(1904), 및 베이스 플랫폼(1908)을 명시하거나 제공할 수 있다.
애플리케이션(1902)은 SoC(200)에서 이용 가능한 상이한 서브시스템에 각각 대응하는 복수의 상이한 부분을 포함할 수 있다. 애플리케이션(1902)은 예를 들어 예 6과 관련하여 설명된 바와 같이 명시될 수 있다. 애플리케이션(1902)은 DPE 어레이(202)에서 구현될 소프트웨어 부분 및 PL(214)에서 구현될 하드웨어 부분을 포함한다. 애플리케이션(1902)은 선택적으로 PS(212)에서 구현될 추가 소프트웨어 부분 및 NoC(208)에서 구현될 부분을 포함할 수 있다.
파티셔닝 제약(성능 및 파티셔닝 제약(1904))은 애플리케이션(1902)의 다양한 노드가 구현될 위치 또는 서브시스템을 선택적으로 명시한다. 예를 들어, 파티셔닝 제약은 애플리케이션(1902)에 대한 노드 단위로, 노드가 DPE 어레이(202) 또는 PL(214)에서 구현되어야 하는지 여부를 나타낼 수 있다. 다른 예에서, 위치 제약은 보다 구체적이거나 상세한 정보를 DPE 컴파일러(1602)에 제공하여 커널 대 DPE, 네트워크 또는 데이터 흐름 대 스트림 스위치, 그리고 버퍼 대 DPE의 메모리 모듈 및/또는 메모리 모듈의 뱅크의 매핑을 수행할 수 있다.
예시적인 예로서, 애플리케이션의 구현은 특정 매핑을 요구할 수 있다. 예를 들어, 커널의 여러 복사본이 DPE 어레이에 구현되어야 하고 커널의 각 복사본이 상이한 데이터 세트에서 동시에 작동하는 애플리케이션에서, DPE 어레이의 상이한 DPE에서 실행되는 커널의 모든 복사본에 대해 데이터 세트가 동일한 상대 어드레스(메모리 내의 위치)에 위치되게 하는 것이 바람직하다. 이는 위치 제약을 사용하여 달성될 수 있다. 이 조건이 DPE 컴파일러(1602)에 의해 유지되지 않는 경우, 커널의 각 사본은 DPE 어레이의 복수의 상이한 DPE에 걸쳐 동일한 프로그래밍을 복제하기보다는 개별적으로 또는 독립적으로 프로그래밍되어야 한다.
다른 예시적인 예는 DPE 간의 캐스케이드 인터페이스를 활용하는 애플리케이션에 위치 제약을 두는 것이다. 캐스케이드 인터페이스는 각 행에서 한 방향으로 흐르기 때문에, 캐스케이드 인터페이스를 사용하여 결합된 DPE 체인의 시작을 캐스케이드 인터페이스가 누락된 DPE(예를 들어, 모서리 DPE)에서 또는 DPE 어레이의 다른 곳에서 쉽게 복제할 수 없는 위치(예를 들어, 행의 마지막 DPE)에서 시작되게 하지 않는 것이 바람직할 수 있다. 위치 제약은 애플리케이션의 DPE의 체인의 시작이 특정 DPE에서 시작하도록 강제할 수 있다.
성능 제약(성능 및 파티셔닝 제약(1904))은 DPE 어레이(202)에 있든 또는 PL(214)에 있든 노드의 구현에 의해 달성될 전력 요구 사항, 레이턴시 요구 사항, 타이밍 및/또는 데이터 처리량과 같은 다양한 메트릭을 명시할 수 있다.
베이스 플랫폼(1908)은 SoC(200)가 결합되는 회로 기판 상의 회로와 상호 작용하고/하거나 연결되는 SoC(200)에서 구현될 인프라 구조 회로에 대한 설명이다. 베이스 플랫폼(1908)은 합성 가능할 수 있다. 예를 들어, 베이스 플랫폼(1908)은 SoC(200) 밖(예를 들어, SoC(200) 외부)으로부터 신호를 수신하고 SoC 밖의 시스템 및/또는 회로에 신호를 제공하는 SoC(200) 내에서 구현될 회로를 명시한다. 예로서, 베이스 플랫폼(1908)은 호스트 시스템(102) 및/또는 도 1의 컴퓨팅 노드(100)와 통신하기 위한 PCIe(Peripheral Component Interconnect Express) 노드와 같은 회로 자원, 휘발성 메모리(134) 및/또는 비휘발성 메모리(136)에 액세스하기 위한 메모리 제어기 또는 제어기들, 및/또는 DPE 어레이(202) 및/또는 PL(214)을 PCIe 노드와 결합하는 내부 인터페이스와 같은 다른 자원을 명시할 수 있다. 베이스 플랫폼(1908)에 의해 명시된 회로는 특정 타입의 회로 기판이 주어지면 SoC(200)에서 구현될 수 있는 임의의 애플리케이션에 사용할 수 있다. 이와 관련하여, 베이스 플랫폼(1908)은 SoC(200)가 결합되는 특정 회로 기판에 고유하다.
일 예에서, 파티셔너(1910)는 애플리케이션(1902)의 각 부분이 구현될 SoC(200)의 서브시스템에 기반하여 애플리케이션(1902)의 상이한 부분들을 분리할 수 있다. 예시적인 구현에서, 파티셔너(1910)는 사용자가 애플리케이션(1902)의 상이한 부분(예를 들어, 노드) 중 어느 것이 SoC(200)의 상이한 서브시스템 각각에 대응하는지를 표시하는 입력을 제공하는 사용자 지시(user directed) 도구로서 구현된다. 예를 들어, 제공되는 입력은 성능 및 파티셔닝 제약(1904)일 수 있다. 예시의 목적을 위해, 파티셔너(1910)는 애플리케이션(1902)을 PS(212) 상에서 실행될 PS 부분(1912), DPE 어레이(202) 상에서 실행될 DPE 어레이 부분(1914), PL(214)에서 구현될 PL 부분(1916), 및 NoC(208)에서 구현되는 NoC 부분(1936)으로 파티셔닝한다. 일 양태에서, 파티셔너(1910)는 PS 부분(1912), DPE 어레이 부분(1914), PL 부분(1916), 및 NoC 부분(1936) 각각을 별도의 파일 또는 별도의 데이터 구조로서 생성할 수 있다.
도시된 바와 같이, 상이한 서브시스템에 대응하는 상이한 부분 각각은 서브시스템에 특유한 상이한 컴파일러에 의해 처리된다. 예를 들어, PS 컴파일러(1918)는 PS 부분(1912)을 컴파일하여 PS(212)에 의해 실행 가능한 오브젝트 코드를 포함하는 하나 이상의 바이너리를 생성할 수 있다. DPE 컴파일러(1602)는 DPE 어레이 부분(1914)을 컴파일하여, 상이한 DPE(204), 애플리케이션 데이터 및/또는 구성 데이터에 의해 실행 가능한 오브젝트 코드를 포함하는 하나 이상의 바이너리를 생성할 수 있다. 하드웨어 컴파일러(1606)는 PL 부분(1916)에 대한 구현 흐름을 수행하여, PL(214)에서 PL 부분(1916)을 구현하기 위해 SoC(200) 내에 로딩될 수 있는 구성 비트스트림을 생성할 수 있다. 본 명세서에서 정의된 바와 같이, "구현 흐름(implementation flow)"이라는 용어는 배치(place) 및 라우팅(route) 및 선택적으로 합성이 수행되는 프로세스를 의미한다. NoC 컴파일러(1604)는 NoC(208)에 로딩될 때 애플리케이션(1902)의 다양한 마스터 및 슬레이브를 연결하는 그 안의 데이터 경로를 생성하는 NoC(208)에 대한 구성 데이터를 명시하는 바이너리를 생성할 수 있다. 컴파일러(1918, 1602, 1604, 및/또는 1606)에 의해 생성된 이러한 상이한 출력은 바이너리 및 구성 비트스트림(1924)으로서 도시된다.
특정 구현에서, 컴파일러(1918, 1602, 1604, 및/또는 1606) 중 특정 컴파일러는 작동 중에 서로 통신할 수 있다. 애플리케이션(1902)에서 작동하는 설계 흐름 동안 다양한 단계에서 통신함으로써 컴파일러(1918, 1602, 1604 및/또는 1606)는 솔루션으로 수렴할 수 있다. 도 19의 예에서, DPE 컴파일러(1602) 및 하드웨어 컴파일러(1606)는 각각 애플리케이션(1902)의 부분(1914 및 1916)을 컴파일하는 동안, 작동 중에 통신할 수 있다. 하드웨어 컴파일러(1606) 및 NoC 컴파일러(1604)는 각각 애플리케이션(1902)의 부분(1916 및 1936)을 컴파일하는 동안 작동 중에 통신할 수 있다. DPE 컴파일러(1602)는 또한 NoC 라우팅 솔루션 및/또는 업데이트된 NoC 라우팅 솔루션을 얻기 위해 NoC 컴파일러(1604)를 호출할 수 있다.
결과 바이너리 및 구성 비트스트림(1924)은 다양한 상이한 목표 중 임의의 것에 제공될 수 있다. 예를 들어, 결과 바이너리 및 구성 비트스트림(들)(1924)은 시뮬레이션 플랫폼(1926), 하드웨어 에뮬레이션 플랫폼(1928), RTL 시뮬레이션 플랫폼(1930), 및/또는 목표 IC(1932)에 제공될 수 있다. RTL 시뮬레이션 플랫폼(1930)의 경우에, 하드웨어 컴파일러(1922)는 RTL 시뮬레이션 플랫폼(1930)에서 시뮬레이션될 수 있는 PL 부분(1916)에 대한 RTL을 출력하도록 구성될 수 있다.
시뮬레이션 플랫폼(1926), 에뮬레이션 플랫폼(1928), RTL 시뮬레이션 플랫폼(1930)으로부터, 및/또는 목표 IC(1932) 내의 애플리케이션(1902)의 구현으로부터 얻어진 결과는 성능 프로파일러 및 디버거(1934)에 제공될 수 있다. 성능 프로파일러 및 디버거(1934)로부터의 결과는 사용자 인터페이스(1906)에 제공될 수 있고, 여기서 사용자는 애플리케이션(1902)을 실행 및/또는 시뮬레이션한 결과를 볼 수 있다.
도 20은 SoC(200)에서 애플리케이션을 구현하기 위해 설계 흐름을 수행하는 예시적인 방법(2000)을 도시한다. 방법(2000)은 도 1과 관련하여 설명된 바와 같은 시스템에 의해 수행될 수 있다. 시스템은 도 16 또는 도 19와 관련하여 설명된 바와 같이 소프트웨어 아키텍처를 실행할 수 있다.
블록(2002)에서, 시스템은 애플리케이션을 수신한다. 애플리케이션은 SoC(200)의 DPE 어레이(202) 내 구현을 위한 소프트웨어 부분과 SoC(200)의 PL(214) 내 구현을 위한 하드웨어 부분을 명시할 수 있다.
블록(2004)에서, 시스템은 애플리케이션에 대한 논리 아키텍처를 생성할 수 있다. 예를 들어, 시스템에 의해 실행되는 DPE 컴파일러(1602)는 DPE 어레이(202)에서 구현될 애플리케이션의 소프트웨어 부분 및 임의의 높은 수준의 사용자 명시 메트릭에 기반하여 논리 아키텍처를 생성할 수 있다. DPE 컴파일러(1602)는 또한 DPE 어레이(202) 안팎의 연결 대 SoC 인터페이스 블록(206)의 물리적 데이터 경로의 매핑을 명시하는 SoC 인터페이스 블록 솔루션을 생성할 수 있다.
다른 양태에서, 논리 아키텍처 및 SoC 인터페이스 블록 솔루션을 생성할 때, DPE 컴파일러(1602)는 DPE 어레이(202)에서 구현될 애플리케이션의 노드("DPE 노드"로 지칭됨) 대 특정 DPE(204)의 초기 매핑을 생성할 수 있다. DPE 컴파일러(1602)는 선택적으로 글로벌 메모리에 대한 NoC 트래픽을 NoC 컴파일러(1604)에 제공함으로써 애플리케이션의 글로벌 메모리 데이터 구조 대 글로벌 메모리(예를 들어, 휘발성 메모리(134))의 초기 매핑 및 라우팅을 생성한다. 논의된 바와 같이, NoC 컴파일러(1604)는 수신된 NoC 트래픽으로부터 NoC 솔루션을 생성할 수 있다. 초기 매핑 및 라우팅을 사용하여 DPE 컴파일러(1602)는 DPE 부분의 초기 구현을 확인하기 위해 DPE 부분을 시뮬레이션할 수 있다. DPE 컴파일러(1602)는 시뮬레이션에 의해 생성된 데이터를 SoC 인터페이스 블록 솔루션에서 사용되는 각 스트림 채널에 대응하는 하드웨어 컴파일러(1606)로 출력할 수 있다.
일 양태에서, DPE 컴파일러(1602)에 의해 수행되는 바와 같이 논리 아키텍처를 생성하는 것은 도 19와 관련하여 이전에 설명된 파티셔닝을 구현한다. 다양한 예시적인 스키마는 각 컴파일러에 할당된 애플리케이션의 부분을 컴파일하는 동안 도 19의 상이한 컴파일러(DPE 컴파일러(1602), 하드웨어 컴파일러(1606), 및 NoC 컴파일러(1604))가 어떻게 결정과 제약을 교환하는지를 도시한다. 다양한 예시 스키마는 결정 및/또는 제약이 어떻게 논리적으로 SoC(200)의 상이한 서브시스템에 걸쳐 있는지를 추가로 보여준다.
블록(2006)에서, 시스템은 하드웨어 부분의 블록 다이어그램을 구축할 수 있다. 예를 들어, 시스템에 의해 실행되는 하드웨어 컴파일러(1606)는 블록 다이어그램을 생성할 수 있다. 블록 다이어그램은 논리 아키텍처에 의해 명시된 대로 애플리케이션의 하드웨어 부분을 SoC(200)용 베이스 플랫폼과 통합한다. 예를 들어, 하드웨어 컴파일러(1606)는 블록 다이어그램을 생성할 때 하드웨어 부분과 베이스 플랫폼을 연결할 수 있다. 또한, 하드웨어 컴파일러(1606)는 애플리케이션의 하드웨어 부분에 대응하는 IP 코어를 SoC 인터페이스 블록 솔루션에 기반하여 SoC 인터페이스 블록에 연결하기 위한 블록 다이어그램을 생성할 수 있다.
예를 들어, 논리 아키텍처에 의해 명시된 바와 같이 애플리케이션의 하드웨어 부분의 각 노드는 특정 RTL 코어(예를 들어, 커스텀 RTL의 사용자 제공 또는 명시 부분) 또는 사용 가능한 IP 코어에 매핑될 수 있다. 사용자가 명시하는 코어로 노드를 매핑함으로써, 하드웨어 컴파일러(1606)는 베이스 플랫폼의 다양한 회로 블록, 논리 아키텍처마다 DPE 어레이(202)와 인터페이스하는 데 필요한 PL(214)의 임의의 IP 코어, 및/또는 PL(214)에서 구현될 추가 사용자 명시 IP 코어 및/또는 RTL 코어를 명시하기 위한 블록 다이어그램을 구축할 수 있다. 사용자가 수동으로 삽입할 수 있는 추가 IP 코어 및/또는 RTL 코어의 예는 데이터 폭 변환 블록, 하드웨어 버퍼 및/또는 클록 도메인 로직을 포함하지만, 이에 국한되지는 않는다. 일 양태에서, 블록 다이어그램의 각 블록은 PL(214)에서 구현될 특정 코어(예를 들어, 회로 블록)에 대응할 수 있다. 블록 다이어그램은 PL에서 구현될 코어들의 연결 및 SoC 인터페이스 블록 솔루션 및 논리 아키텍처로부터 결정된 바와 같이 NoC(208) 및/또는 SoC 인터페이스 블록(206)의 물리적 자원과 코어의 연결을 명시한다.
일 양태에서, 하드웨어 컴파일러(1606)는 또한 NoC 솔루션을 구하기 위하여 논리 아키텍처에 따라 NoC 트래픽을 야기하고 NoC 컴파일러(1604)를 실행함으로써 PL(214)의 코어와 글로벌 메모리(예를 들어, 휘발성 메모리(134)) 사이에 논리적 연결을 생성할 수 있다. 일 예에서, 하드웨어 컴파일러(1606)는 블록 다이어그램 및 논리적 연결을 구현하기 위해 PL(214)의 용량을 확인하기 위해 논리적 연결을 라우팅할 수 있다. 다른 양태에서, 하드웨어 컴파일러(1606)는 실제 데이터 트래픽으로 블록 다이어그램의 기능을 확인하기 위한 시뮬레이션의 일부로서 하나 이상의 데이터 트래픽 생성기와 함께 SoC 인터페이스 블록 트레이스(예를 들어, 아래에서 더 자세히 설명됨)를 사용할 수 있다.
블록(2008)에서, 시스템은 블록 다이어그램에 대한 구현 흐름을 수행한다. 예를 들어, 하드웨어 컴파일러는 PL(214)에서 애플리케이션의 하드웨어 부분을 구현하기 위해 SoC(200) 내로 로딩될 수 있는 구성 비트스트림을 생성하기 위해 필요한 경우 블록 다이어그램에 대한 합성, 배치 및 라우팅을 포함하는 구현 흐름을 수행할 수 있다.
하드웨어 컴파일러(1606)는 SoC 인터페이스 블록 솔루션 및 NoC 솔루션을 사용하여 블록 다이어그램에 대한 구현 흐름을 수행할 수 있다. 예를 들어, SoC 인터페이스 블록 솔루션은 특정 DPE(204)가 PL(214)과 통신하는 SoC 인터페이스 블록(206)의 특정 스트림 채널을 명시하기 때문에, 배치자(placer)는 블록들이 연결될 SoC 인터페이스 블록(206)의 특정 스트림 채널에 가까운(예를 들어, 특정 거리 내의) SoC 인터페이스 블록(206)을 통하여 DPE(204)와 연결을 가진 블록 다이어그램의 블록들을 배치할 수 있다. 예를 들어, 블록의 포트는 SoC 인터페이스 블록 솔루션에 의해 명시된 스트림 채널과 상관될 수 있다. 하드웨어 컴파일러(1606)는 또한 포트로부터의 입력 및/또는 출력되는 신호를 SoC 인터페이스 블록 솔루션으로부터 결정된 포트에 결합된 특정 스트림 채널(들)에 연결된 PL(214)의 BLI로 라우팅함으로써, SoC 인터페이스 블록(206)에 연결되는 블록 다이어그램의 블록의 포트들 사이의 연결을 라우팅할 수 있다.
유사하게, NoC 솔루션은 PL(214)의 회로 블록이 연결될 특정 인그레스/이그레스 지점을 명시하기 때문에, 배치자는 NoC(208)와 연결을 가진 블록 다이어그램의 블록을 블록이 연결될 특정 인그레스/이그레스 지점에 가까이(예를 들어, 특정 거리 내) 배치할 수 있다. 예를 들어, 블록의 포트는 NoC 솔루션의 인그레스/이그레스 지점과 상관될 수 있다. 하드웨어 컴파일러(1606)는 또한 포트로부터의 입력 및/또는 출력되는 신호를 NoC 솔루션으로부터 결정된 포트에 논리적으로 결합된 NoC(208)의 인그레스/이그레스 지점으로 라우팅함으로써, NoC(208)의 인그레스/이그레스 지점에 연결된 블록 다이어그램의 블록의 포트들 사이의 연결을 라우팅할 수 있다. 하드웨어 컴파일러(1606)는 또한 PL(214) 내의 블록의 포트를 서로 연결하는 임의의 신호를 라우팅할 수 있다. 그러나 일부 애플리케이션에서 NoC(208)는 DPE 어레이(202)와 PL(214) 사이에서 데이터를 전달하는 데 사용되지 않을 수 있다.
블록(2010)에서, 구현 흐름 동안, 하드웨어 컴파일러는 선택적으로 DPE 컴파일러(1602) 및/또는 NoC 컴파일러(1604)와 설계 데이터를 교환한다. 예를 들어, 하드웨어 컴파일러(1606), DPE 컴파일러(1602), 및 NoC 컴파일러(1604)는 필요에 따라 일회성(one-time basis) 또는 반복적(iterative) 또는 반복적(repeated)으로 도 16과 관련하여 설명된 바와 같이 설계 데이터를 교환할 수 있다. 블록(2010)은 선택적으로 수행될 수 있다. 하드웨어 컴파일러(1606)는 예를 들어 블록 다이어그램의 구축 전 또는 구축 동안, 배치 전 및/또는 배치 동안, 및/또는 라우딩 전 및/또는 라우팅 동안, DPE 컴파일러(1602) 및/또는 NoC 컴파일러(1604)와 설계 데이터를 교환할 수 있다.
블록(2012)에서, 시스템은 하드웨어 컴파일러(1606)에 의해 생성된 최종 하드웨어 설계를 하드웨어 패키지로서 엑스포트(export)한다. 하드웨어 패키지에는 PL(214)를 프로그래밍하는 데 사용되는 구성 비트스트림이 포함되어 있다. 하드웨어 패키지는 애플리케이션의 하드웨어 부분에 따라 생성된다.
블록(2014)에서, 사용자는 하드웨어 패키지를 사용하여 새로운 플랫폼을 구성한다. 사용자는 사용자가 제공한 구성을 기반으로 새 플랫폼 생성을 시작한다. 하드웨어 패키지를 사용하여 시스템에 의해 생성된 플랫폼은 애플리케이션의 소프트웨어 부분을 컴파일하는 데 사용된다.
블록(2016)에서, 시스템은 DPE 어레이(202)에서의 구현을 위해 애플리케이션의 소프트웨어 부분을 컴파일한다. 예를 들어, 시스템은 DPE 컴파일러(1602)를 실행하여 DPE 어레이(202)의 다양한 DPE(204) 내로 로딩될 수 있는 하나 이상의 바이너리를 생성한다. DPE(204)에 대한 바이너리는 DPE(204)에 대한 오브젝트 코드, 애플리케이션 데이터 및 구성 데이터를 포함할 수 있다. 구성 비트스트림 및 바이너리가 생성되면, 시스템은 구성 비트스트림 및 바이너리를 SoC(200) 내로 로딩하여 그 안의 애플리케이션을 구현할 수 있다.
다른 양태에서, 하드웨어 컴파일러(1606)는 하드웨어 구현을 DPE 컴파일러(1602)에 제공할 수 있다. DPE 컴파일러(1602)는 구현 흐름을 수행하는 데 있어서, 하드웨어 컴파일러(1606)가 의존한 최종 SoC 인터페이스 블록 솔루션을 추출할 수 있다. DPE 컴파일러(1602)는 하드웨어 컴파일러(1606)에 의해 사용되는 동일한 SoC 인터페이스 블록 솔루션을 사용하여 컴파일을 수행한다.
도 20의 예에서, 애플리케이션의 각 부분은 서브시스템 특유의 컴파일러에 의해 해결된다. 컴파일러는 애플리케이션에 대해 구현된 대로 다양한 서브시스템(예를 들어, SoC 인터페이스 블록) 간의 인터페이스가 규정을 준수하고 일관성을 유지하도록 보장하기 위해 설계 데이터(예를 들어, 제약 및/또는 제안된 솔루션)를 전달할 수 있다. 도 20에 구체적으로 도시되지는 않았지만, NoC 컴파일러(1604)는 또한 애플리케이션에서 사용되는 경우 NoC(208)를 프로그래밍하기 위한 바이너리를 생성하기 위해 호출될 수 있다.
도 21은 SoC(200)에서 애플리케이션을 구현하기 위해 설계 흐름을 수행하는 다른 예시적인 방법(2100)을 도시한다. 방법(2100)은 도 1과 관련하여 설명된 시스템에 의해 수행될 수 있다. 시스템은 도 16 또는 도 19와 관련하여 설명된 바와 같이 소프트웨어 아키텍처를 실행할 수 있다. 방법(2100)은 시스템이 애플리케이션을 수신하는 블록(2102)에서 시작할 수 있다. 애플리케이션은 SoC(200)에서 구현될 데이터 흐름 그래프로서 명시될 수 있다. 애플리케이션은 DPE 어레이(202)에서의 구현을 위한 소프트웨어 부분, PL(214)에서의 구현을 위한 하드웨어 부분, 및 SoC(200)의 NoC(208)에서의 구현을 위한 데이터 이송을 포함할 수 있다. 애플리케이션은 또한 PS(212)에서의 구현을 위한 추가 소프트웨어 부분을 포함할 수 있다.
블록(2104)에서, DPE 컴파일러(1602)는 애플리케이션으로부터 논리 아키텍처, SoC 인터페이스 블록 솔루션, 및 SoC 인터페이스 블록 트레이스를 생성할 수 있다. 논리 아키텍처는 DPE 어레이(202) 내에서 구현하도록 지정된 애플리케이션의 소프트웨어 부분을 구현하는 데 필요한 DPE(204) 및 DPE(204)와 인터페이스하는 데 필요한 PL(214)에서 구현될 임의의 IP 코어를 기반으로 할 수 있다. 언급된 바와 같이, DPE 컴파일러(1602)는 DPE 컴파일러(1602)가 (애플리케이션의 소프트웨어 부분의) 노드 대 DPE 어레이(202)의 초기 매핑을 수행하는 초기 DPE 솔루션을 생성할 수 있다. DPE 컴파일러(1602)는 논리 자원을 SoC 인터페이스 블록(206)의 물리 자원(예를 들어, 스트림 채널)에 매핑하는 초기 SoC 인터페이스 블록 솔루션을 생성할 수 있다. 일 양태에서, SoC 인터페이스 블록 솔루션은 데이터 이송으로부터 NoC 컴파일러(1604)에 의해 생성된 초기 NoC 솔루션을 사용하여 생성될 수 있다. DPE 컴파일러(1602)는 SoC 인터페이스 블록(206)을 통한 데이터 흐름을 시뮬레이션하기 위해 SoC 인터페이스 블록 솔루션으로 초기 DPE 솔루션을 시뮬레이션할 수 있다. DPE 컴파일러(1602)는 도 21에 예시된 설계 흐름 동안 후속 사용을 위한 "SoC 인터페이스 블록 트레이스"로서, 시뮬레이션 동안 SoC 인터페이스 블록을 통한 데이터 이송을 캡처할 수 있다.
블록(2104)에서, 하드웨어 컴파일러(1606)는 PL(214)에서 구현될 애플리케이션의 하드웨어 부분의 블록 다이어그램을 생성한다. 하드웨어 컴파일러(1606)는 논리 아키텍처 및 SoC 인터페이스 블록 솔루션 및 선택적으로 논리 아키텍처에 의해 명시된 회로 블록과 함께 블록 다이어그램에 포함될 사용자에 의해 명시된 추가 IP 코어에 기반하여 블록 다이어그램을 생성한다. 일 양태에서, 사용자는 이러한 추가 IP 코어를 수동으로 삽입하고 IP 코어를 논리 아키텍처에 명시된 하드웨어 설명의 다른 회로 블록에 연결한다.
블록(2106)에서, 하드웨어 컴파일러(1606)는 선택적으로 하나 이상의 사용자 명시 SoC 인터페이스 블록 제약을 수신하고 SoC 인터페이스 블록 제약을 DPE 컴파일러(1602)에 제공한다.
일 양태에서, 애플리케이션의 하드웨어 부분을 구현하기 전에, 하드웨어 컴파일러(1606)는 블록 다이어그램 및 논리 아키텍처에 기반하여 NoC(208), DPE 어레이(202) 및 PL(214) 사이에 정의된 물리 연결을 평가할 수 있다. 하드웨어 컴파일러(1606)는 블록 다이어그램(예를 들어, 설계의 PL 부분)과 DPE 어레이(202) 및/또는 NoC(208) 사이의 연결을 평가하기 위해 블록 다이어그램의 아키텍처 시뮬레이션을 수행할 수 있다. 예를 들어, 하드웨어 컴파일러(1606)는 DPE 컴파일러(1602)에 의해 생성된 SoC 인터페이스 블록 트레이스를 사용하여 시뮬레이션을 수행할 수 있다. 예시적이고 비제한적인 예로서, 하드웨어 컴파일러(1606)는 블록 다이어그램의 SystemC 시뮬레이션을 수행할 수 있다. 시뮬레이션에서, 데이터 트래픽이 SoC 인터페이스 블록 트레이스를 사용하여 블록 다이어그램에 대하여, 그리고 PL(214)과 DPE 어레이(202)(SoC 인터페이스 블록(206)를 통해) 및/또는 NoC(208) 사이의 스트림 채널(예를 들어, 물리적 연결)에 대하여 생성된다. 시뮬레이션은 하드웨어 컴파일러(1606)에 제공되는 시스템 성능 및/또는 디버깅 정보를 생성한다.
하드웨어 컴파일러(1606)는 시스템 성능 데이터를 평가할 수 있다. 예를 들어, 하드웨어 컴파일러(1606)가 시스템 성능 데이터로부터 애플리케이션의 하드웨어 부분에 대한 하나 이상의 설계 메트릭이 충족되지 않는다고 결정하면, 하드웨어 컴파일러(1606)는 사용자의 지시(direction) 하에 하나 이상의 SoC 인터페이스 블록 제약을 생성할 수 있다. 하드웨어 컴파일러(1606)는 요청에 따라 SoC 인터페이스 블록 제약을 DPE 컴파일러(1602)에 제공한다.
DPE 컴파일러(1602)는 애플리케이션의 DPE 부분 대 하드웨어 컴파일러(1606)에 의해 제공되는 SoC 인터페이스 블록 제약을 이용하는 DPE 어레이(202)의 DPE(204)의 업데이트된 매핑을 수행할 수 있다. 예를 들어 PL(214) 내의 하드웨어 부분이 SoC 인터페이스 블록(206)을 통해 직접 (예를 들어, NoC(208)를 트래버스하지 않고) DPE 어레이(202)에 연결되는 애플리케이션이 구현된다면, DPE 컴파일러(1602)는 NoC 컴파일러(1604)를 관여시키지 않고 하드웨어 컴파일러(1606)에 대한 업데이트된 SoC 인터페이스 블록 솔루션을 생성할 수 있다.
블록(2108)에서, 하드웨어 컴파일러(1606)는 선택적으로 하나 이상의 사용자 명시 NoC 제약을 수신하고 확인(validation)을 위해 NoC 컴파일러에 NoC 제약을 제공한다. 하드웨어 컴파일러(1606)는 또한 NoC 트래픽을 NoC 컴파일러(1606)에 제공할 수 있다. NoC 컴파일러(1604)는 수신된 NoC 제약 및/또는 NoC 트래픽을 사용하여 업데이트된 NoC 솔루션을 생성할 수 있다. 예를 들어, PL(214)의 하드웨어 부분이 NoC(208)를 통해 DPE 어레이(202), PS(212), 하드와이어드 회로 블록(210), 또는 휘발성 메모리(134)에 연결되는 애플리케이션이 구현된다면, 하드웨어 컴파일러(1606)는 NoC 컴파일러(1604)에 NoC 제약 및/또는 NoC 트래픽을 제공함으로써 NoC 컴파일러(1604)를 호출할 수 있다. NoC 컴파일러(1604)는 업데이트된 NoC 솔루션으로서 NoC(208)를 통해 데이터 경로에 대한 라우팅 정보를 업데이트할 수 있다. 업데이트된 라우팅 정보는 업데이트된 라우팅 및 라우팅에 대한 특정 인그레스/이그레스 지점을 명시할 수 있다. 하드웨어 컴파일러(1606)는 업데이트된 NoC 솔루션을 획득할 수 있고 응답으로 DPE 컴파일러(1602)에 제공되는 업데이트된 SoC 인터페이스 블록 제약을 생성할 수 있다. 프로세스는 본질적으로 반복적(iterative)일 수 있다. DPE 컴파일러(1602) 및 NoC 컴파일러(1604)는 블록(2106 및 2108)에 의해 도시된 바와 같이 동시에 동작할 수 있다.
블록(2110)에서, 하드웨어 컴파일러(1606)는 블록 다이어그램에 대한 합성을 수행할 수 있다. 블록(2112)에서, 하드웨어 컴파일러(1606)는 블록 다이어그램에 대한 배치 및 라우팅을 수행한다. 블록(2114)에서, 배치 및/또는 라우팅을 수행하는 동안, 하드웨어 컴파일러는 블록 다이어그램의 구현, 예를 들어 구현 흐름의 이들 상이한 단계 중 임의의 단계에서 하드웨어 부분의 구현(예를 들어, 하드웨어 설계)의 현재 상태가 애플리케이션의 하드웨어 부분에 대한 설계 메트릭을 충족하는지 여부를 결정할 수 있다. 예를 들어, 하드웨어 컴파일러(1606)는 현재 구현이 배치 전, 배치 동안, 라우팅 전 또는 라우팅 동안 설계 메트릭을 충족하는지 여부를 결정할 수 있다. 애플리케이션의 하드웨어 부분의 현재 구현이 설계 메트릭을 충족하지 않는다는 결정에 응답하여, 방법(2100)은 블록(2116)으로 계속된다. 그렇지 않으면, 방법(2100)은 블록(2120)으로 계속된다.
블록(2116)에서, 하드웨어 컴파일러는 DPE 컴파일러(1602)에 하나 이상의 사용자 명시 SoC 인터페이스 블록 제약을 제공할 수 있다. 하드웨어 컴파일러(1606)는 선택적으로 하나 이상의 NoC 제약을 NoC 컴파일러(1604)에 제공할 수 있다. 논의된 바와 같이, DPE 컴파일러(1602)는 하드웨어 컴파일러(1606)로부터 수신된 SoC 인터페이스 블록 제약(들)을 사용하여 업데이트된 SoC 인터페이스 블록 솔루션을 생성한다. NoC 컴파일러(1604)는 업데이트된 NoC 솔루션을 선택적으로 생성한다. 예를 들어, NoC 컴파일러(1604)는 DPE 어레이(202)와 PL(214) 사이의 하나 이상의 데이터 경로가 NoC(208)를 통해 흐르는 경우 호출될 수 있다. 블록(2118)에서, 하드웨어 컴파일러(1606)는 업데이트된 SoC 인터페이스 블록 솔루션 및 선택적으로 업데이트된 NoC 솔루션을 수신한다. 블록(2118) 후에, 방법(2100)은 하드웨어 컴파일러(1606)가 업데이트된 SoC 인터페이스 블록 솔루션 및 선택적으로 업데이트된 NoC 솔루션을 사용하여 배치 및/또는 라우팅을 계속 수행하는 블록(2112)으로 계속된다.
도 21은 컴파일러 간의 설계 데이터의 교환이 반복적으로 수행될 수 있음을 도시한다. 예를 들어, 배치 및/또는 라우팅 단계 동안 복수의 상이한 지점 중 임의의 지점에서, 하드웨어 컴파일러(1606)는 애플리케이션의 하드웨어 부분의 구현의 현재 상태가 확립된 설계 메트릭을 충족하는지 여부를 결정할 수 있다. 그렇지 않다면, 하드웨어 컴파일러(1606)는 하드웨어 컴파일러(1606)가 배치 및 라우팅의 목적을 위해 사용하는 업데이트된 SoC 인터페이스 블록 솔루션 및 업데이트된 NoC 솔루션을 획득하기 위해 설명된 바와 같이 설계 데이터의 교환을 개시할 수 있다. 하드웨어 컴파일러(1606)는 NoC(208)의 구성이 업데이트되어야 하는 경우(예를 들어, PL(214)로부터의 데이터가 NoC(208)를 통해 다른 회로 블록으로 제공되고/되거나 다른 회로 블록으로부터 수신되는 경우) NoC 컴파일러(1604)를 호출하기만 할 필요가 있다는 것을 이해해야 한다.
블록(2120)에서, 애플리케이션의 하드웨어 부분이 설계 메트릭을 충족하는 경우, 하드웨어 컴파일러(1606)는 PL(214) 내의 하드웨어 부분의 구현을 명시하는 구성 비트스트림을 생성한다. 하드웨어 컴파일러(1606)는 최종 SoC 인터페이스 블록 솔루션(예를 들어, 배치 및 라우팅에 사용되는 SoC 인터페이스 블록 솔루션)을 DPE 컴파일러(1602)에 제공하고 배치 및 라우팅에 사용되었을 수 있는 최종 NoC 솔루션을 NoC 컴파일러(1604)에 제공할 수 있다.
블록(2122)에서, DPE 컴파일러(1602)는 DPE 어레이(204)의 DPE(202)를 프로그래밍하기 위한 바이너리를 생성한다. NoC 컴파일러(1604)는 NoC(208)를 프로그래밍하기 위한 바이너리를 생성한다. 예를 들어, 블록(2106, 2108, 2116) 전반에 걸쳐, DPE 컴파일러(1602) 및 NoC 컴파일러(1604)는 증분 유효성 함수(incremental validation function)를 수행할 수 있고, 여기서는 SoC 인터페이스 블록 및 NoC에 대한 완전한 솔루션이 결정된 경우보다 더 짧은 런타임에 수행될 수 있는 확인 절차에 기반하여 사용되는 SoC 인터페이스 블록 솔루션 및 NoC 솔루션이 생성된다. 블록(2122)에서, DPE 컴파일러(1602) 및 NoC 컴파일러(1604)는 각각 DPE 어레이(202) 및 NoC(208)를 프로그래밍하는데 사용되는 최종 바이너리를 생성할 수 있다.
블록(2124)에서, PS 컴파일러(1918)는 PS 바이너리를 생성한다. PS 바이너리는 PS(212)에 의해 실행되는 오브젝트 코드를 포함한다. PS 바이너리는 예를 들어 PS(212)에 의해 실행되는 제어 프로그램을 구현하여, 그 안에 구현된 애플리케이션으로 SoC(200)의 동작을 모니터링한다. DPE 컴파일러(1602)는 또한 PS 컴파일러(1918)에 의해 컴파일될 수 있고 DPE 어레이(202)의 DPE(204)에 대한 판독 및/또는 기입을 위해 PS(212)에 의해 실행될 수 있는 DPE 어레이 드라이버를 생성할 수 있다.
블록(2126)에서, 시스템은 SoC(200)에서 구성 비트스트림 및 바이너리를 사용(deploy)할 수 있다. 예를 들어, 시스템은 다양한 바이너리 및 구성 비트스트림을 SoC(200)로 제공되어 SoC(200) 내로 로딩될 수 있는 PDI로 결합하여, 그 안의 애플리케이션을 구현할 수 있다.
도 22는 하드웨어 컴파일러(1606)와 DPE 컴파일러(1602) 사이의 통신의 예시적인 방법(2200)을 도시한다. 방법(2200)은 도 16, 19, 20, 21와 관련하여 설명된 바와 같이 하드웨어 컴파일러(1606)와 DPE 컴파일러(1602) 사이의 통신이 어떻게 다루어질 수 있는지의 예를 제시한다. 방법(2200)은 하드웨어 컴파일러(1606)와 DPE 컴파일러(1602) 사이에서 수행되는 확인 호출(예를 들어, 확인 절차)의 예시적인 구현을 도시한다. 방법(2200)의 예는 하드웨어 컴파일러(1606)로부터 제공된 SoC 인터페이스 블록 제약에 응답하여 업데이트된 SoC 인터페이스 블록 솔루션을 생성하기 위하여, DPE 어레이(202) 및/또는 NoC(208)에 대한 전체(full) 배치 및 라우팅을 수행하는 것의 대안을 제공한다. 방법(2200)은 애플리케이션의 소프트웨어 부분의 매핑 및 라우팅을 개시하기 전에 재라우팅이 시도되는 증분 접근법을 도시한다.
방법(2200)은 하드웨어 컴파일러(1606)가 DPE 컴파일러(1602)에 하나 이상의 SoC 인터페이스 블록 제약을 제공하는 블록(2202)에서 시작할 수 있다. 구현 흐름 동안 그리고 애플리케이션의 하드웨어 부분에 대한 설계 메트릭이 충족되지 않거나 충족되지 않을 것이라고 결정하는 것에 응답하여 하드웨어 컴파일러(1606)는 하나 이상의 사용자 명시 SoC 인터페이스 블록 제약을 수신하고/하거나 하나 이상의 SoC 인터페이스 블록 제약을 생성할 수 있다. SoC 인터페이스 블록 제약은 논리 자원(들) 대 애플리케이션의 하드웨어 부분에 대한 개선된 QoS(Quality of Result)를 초래할 것으로 예상되는 SoC 인터페이스 블록(206)의 물리적 스트림 채널의 선호되는 매핑을 명시할 수 있다.
하드웨어 컴파일러(1606)는 DPE 컴파일러(1602)에 SoC 인터페이스 블록 제약을 제공한다. 하드웨어 컴파일러(1606)로부터 제공되는 SoC 인터페이스 블록 제약은 2개의 상이한 카테고리에 속할 수 있다. SoC 인터페이스 블록 제약의 제1 카테고리는 하드 제약(hard constraint)이다. SoC 인터페이스 블록 제약의 제2 카테고리는 소프트 제약(soft constraint)이다. 하드 제약은 SoC(200) 내에서 애플리케이션을 구현하기 위해 만족되어야 하는 설계 제약이다. 소프트 제약은 SoC(200)에 대한 애플리케이션 구현에서 위반될 수 있는 설계 제약이다.
한 예에서, 하드 제약은 PL(214)에서 구현될 애플리케이션의 하드웨어 부분에 대한 사용자 명시 제약이다. 하드 제약은 사용자 명시 제약인 위치, 전력, 타이밍 등과 같은 임의의 이용 가능한 제약 타입을 포함할 수 있다. 소프트 제약은 설명된 대로 논리 자원(들) 대 SoC 인터페이스 블록(206)의 스트림 채널의 특정 매핑을 명시하는 제약과 같은 구현 흐름 전반에 걸쳐 하드웨어 컴파일러(1606) 및/또는 DPE 컴파일러(1602)에 의해 생성되는 임의의 이용 가능한 제약을 포함할 수 있다.
블록(2204)에서, DPE 컴파일러(1602)는 SoC 인터페이스 블록 제약(들)을 수신하는 것에 응답하여 업데이트된 SoC 인터페이스 블록 솔루션을 생성하는데 있어서, 수신된 SoC 인터페이스 블록 제약을 통합하기 위한 확인 프로세스를 개시한다. 블록(2206)에서, DPE 컴파일러(1602)는 애플리케이션의 하드웨어 부분과 관련하여 하드웨어 컴파일러(1606)로부터 수신된 하드 제약(들)과 소프트 제약(들)을 구별할 수 있다.
블록(2208)에서, DPE 컴파일러(1602)는 하드웨어 컴파일러로부터 제공된 하드 제약(들) 및 소프트 제약(들) 모두를 따르는 동안 애플리케이션의 소프트웨어 부분을 라우팅한다. 예를 들어, DPE 컴파일러(1602)는 DPE 어레이(202)의 DPE(204) 사이의 연결 및 DPE(204)와 SoC 인터페이스 블록(206) 사이의 데이터 경로를 라우팅하여, SoC 인터페이스 블록(206)의 어느 스트림 채널(예를 들어, 타일, 스트림 스위치 및 포트)이 DPE 어레이(202)와 PL(214) 및/또는 NoC(208) 사이의 데이터 경로 크로싱에 사용되는지 결정한다. DPE 컴파일러(1602)가 하드 제약(들) 및 소프트 제약(들) 모두를 따르면서 DPE 어레이(202)에서의 구현을 위해 애플리케이션의 소프트웨어 부분을 성공적으로 라우팅한다면, 방법(2200)은 블록(2218)으로 계속 진행된다. DPE 컴파일러(1602)가 하드 제약(들) 및 소프트 제약(들) 모두를 따르면서 DPE 어레이에서 애플리케이션의 소프트웨어 부분에 대한 라우팅을 생성할 수 없다면 예를 들어 제약이 라우팅 불가능하다면, 방법(2200)은 블록(2210)으로 계속된다.
블록(2210)에서, DPE 컴파일러(1602)는 하드 제약(들)만을 따르면서 애플리케이션의 소프트웨어 부분을 라우팅한다. 블록(2210)에서, DPE 컴파일러(1602)는 라우팅 동작의 목적을 위해 소프트 제약(들)을 무시한다. DPE 컴파일러(1602)가 하드 제약(들)만을 따르면서 DPE 어레이(202)에서 구현을 위해 애플리케이션의 소프트웨어 부분을 성공적으로 라우팅한다면, 방법(2200)은 블록(2218)으로 계속된다. DPE 컴파일러(1602)가 하드 제약(들)만을 따르면서 DPE 어레이(202)에서 애플리케이션의 소프트웨어 부분에 대한 라우팅을 생성할 수 없다면, 방법(2200)은 블록(2212)으로 계속된다.
블록(2208 및 2210)은 DPE 노드의 전체 맵(예를 들어, 배치) 및 라우팅이 수행되는 것보다 더 적은 시간에 업데이트된 SoC 인터페이스 블록 솔루션을 생성하기 위하여 하드웨어 컴파일러(1606)로부터 제공된 SoC 인터페이스 블록 제약(들)을 사용하려고 하는 확인 동작에 대한 접근법을 도시한다. 이와 같이, 블록(2208 및 2210)은 DPE 노드 대 DPE 어레이(202)의 DPE(204)를 매핑(예를 들어, 재매핑)하거나 "배치(place)"하려고 시도하지 않고 라우팅만 포함한다.
방법(2200)은 라우팅만으로는 하드웨어 컴파일러로부터의 SoC 인터페이스 블록 제약(들)을 사용하여 업데이트된 SoC 인터페이스 블록 솔루션에 도달할 수 없는 경우 블록(2212)으로 계속된다. 블록(2212)에서, DPE 컴파일러(1602)는 하드 제약(들) 및 소프트 제약(들) 모두를 사용하여 DPE 어레이(202)의 DPE에 애플리케이션의 소프트웨어 부분을 매핑할 수 있다. DPE 컴파일러(1602)는 또한 SoC(200)의 아키텍처(예를 들어, 연결)로 프로그래밍된다. DPE 컴파일러(1602)는 SoC 인터페이스 블록(206)의 물리 채널에 대한(예를 들어, 스트림 채널에 대한) 논리 자원의 실제 할당을 수행하고 또한 SoC(200)의 아키텍처 연결을 모델링할 수 있다.
예로서, PL 노드 B와 통신하는 DPE 노드 A를 고려하자. 블록 다이어그램의 각 블록은 PL(214)에서 구현될 특정 코어(예를 들어, 회로 블록)에 대응할 수 있다. PL 노드 B는 SoC 인터페이스 블록(206) 내의 물리 채널 X를 통하여 DPE 노드 A와 통신한다. 물리 채널 X는 DPE 노드 A와 PL 노드 B 사이에서 데이터 스트림(들)을 나른다. DPE 컴파일러(1602)는 DPE Y와 물리 채널 X 사이의 거리가 최소화되도록 DPE 노드 A를 특정 DPE Y에 매핑할 수 있다.
SoC 인터페이스 블록(206)의 일부 구현에서, 그 안에 포함된 타일 중 하나 이상은 PL(214)에 연결되지 않는다. 연결되지 않은 타일은 PL(214) 내부 및/또는 주변에 특정 하드와이어드 회로 블록(210)을 배치한 결과일 수 있다. 예를 들어, SoC 인터페이스 블록(206) 내에 연결되지 않은 타일이 있는 이 아키텍처는 SoC 인터페이스 블록(206)과 PL(214) 사이의 라우팅을 복잡하게 한다. 연결되지 않은 타일에 관한 연결 정보는 DPE 컴파일러(1602)에서 모델링된다. DPE 컴파일러(1602)는 매핑 수행의 일부로서 PL(214)과 연결되어 있는 DPE 노드를 선택할 수 있다. DPE 컴파일러(1602)는 매핑 수행의 일부로서 SoC 인터페이스 블록(206)의 연결되지 않은 타일 바로 위에 DPE 어레이(202)의 열에서 DPE(204)에 매핑되는 선택된 DPE 노드의 수를 최소화할 수 있다. DPE 컴파일러(1602)는 PL(214)(예를 들어, 다른 DPE(204)에 대신 연결되는 노드)과 연결(예를 들어, 직접 연결)이 없는 DPE 노드를 SoC 인터페이스 블록(206)의 연결되지 않은 타일 위에 위치된 DPE 어레이(202)의 열에 매핑한다.
블록(2214)에서, DPE 컴파일러(1602)는 하드 제약(들)만을 따르면서 애플리케이션의 재매핑된 소프트웨어 부분을 라우팅한다. DPE 컴파일러(1602)가 하드 제약(들)만을 따르면서 DPE 어레이(202)에서 구현을 위해 애플리케이션의 재매핑된 소프트웨어 부분을 성공적으로 라우팅하는 경우, 방법(2200)은 블록(2218)으로 계속된다. DPE 컴파일러(1602)가 하드 제약(들)만을 따르면서 DPE 어레이(202) 내의 애플리케이션의 소프트웨어 부분에 대한 라우팅을 생성할 수 없다면, 방법(2200)은 블록(2216)으로 계속된다. 블록(2216)에서, DPE 컴파일러(1602)는 확인 동작이 실패했음을 표시한다. DPE 컴파일러(1602)는 알림(notification)을 출력할 수 있고 하드웨어 컴파일러(1606)에 알림을 제공할 수 있다.
블록(2218)에서, DPE 컴파일러(1602)는 업데이트된 SoC 인터페이스 블록 솔루션 및 업데이트된 SoC 인터페이스 블록 솔루션에 대한 스코어를 생성한다. DPE 컴파일러(1602)는 블록(2208), 블록(2210), 또는 블록(2212 및 2214)에서 결정된 업데이트된 라우팅 또는 업데이트된 매핑 및 라우팅에 기반하여 업데이트된 SoC 인터페이스 블록 솔루션을 생성한다.
DPE 컴파일러(1602)에 의해 생성된 스코어는 수행된 매핑 및/또는 라우팅 동작에 기반하여 SoC 인터페이스 블록 솔루션의 품질을 표시한다. 하나의 예시적인 구현에서, DPE 컴파일러(1602)는 얼마나 많은 소프트 제약이 충족되지 않았는지, 그리고 소프트 제약에서 요청된 스트림 채널과 업데이트된 SoC 인터페이스 블록 솔루션에서 할당된 실제 채널 사이의 거리에 기반하여 스코어를 결정한다. 예를 들어 충족되지 않은 소프트 제약의 수와 거리는 모두 스코어에 반비례할 수 있다.
다른 예시적인 구현에서, DPE 컴파일러(1602)는 하나 이상의 설계 비용 메트릭을 사용하여 업데이트된 SoC 인터페이스 블록 솔루션의 품질에 기반하여 스코어를 결정한다. 이러한 설계 비용 메트릭에는 SoC 인터페이스 블록 솔루션이 지원하는 데이터 이동(data movement)의 수, 메모리 충돌 비용 및 라우팅의 레이턴시가 포함될 수 있다. 일 양태에서, DPE 어레이(202)에서의 데이터 이동의 수는 SoC 인터페이스 블록(206)에 걸쳐 데이터를 이송하는 데 필요한 것에 더하여 DPE 어레이(202)에서 사용되는 DMA 이송의 수에 의해 정량화될 수 있다. 메모리 충돌 비용은 각 메모리 뱅크에 대한 동시 액세스 회로(예를 들어, DPE 또는 DMA)의 수에 기반하여 결정될 수 있다. 라우팅의 레이턴시는 SoC 인터페이스 블록(206) 포트와 개별 소스 또는 목적지 DPE(204) 사이에서 데이터를 이송하는 데 필요한 최소 사이클 수에 의해 정량화될 수 있다. DPE 컴파일러(1602)는 설계 비용 메트릭이 더 낮을 때(예를 들어, 설계 비용 메트릭의 합계가 더 낮을 때) 더 높은 스코어를 결정한다.
다른 예시적인 구현에서, 업데이트된 SoC 인터페이스 블록 솔루션의 총 스코어는 분수(예를 들어, 80/100)로 계산되며, 여기서 분자는 100에서 추가 DMA 이송 수, 2를 초과하는 각 메모리 뱅크에 대한 동시 액세스 회로 수 및 SoC 인터페이스 블록(206) 포트와 DPE(204) 코어 사이의 라우팅에 필요한 홉의 수의 합만큼 줄어든다.
블록(2220)에서, DPE 컴파일러(1602)는 업데이트된 SoC 인터페이스 블록 솔루션 및 스코어를 하드웨어 컴파일러(1606)에 제공한다. 하드웨어 컴파일러(1606)는 각각의 SoC 인터페이스 블록 솔루션의 스코어를 기반으로 DPE 컴파일러(1602)로부터 수신된 다양한 SoC 인터페이스 블록 솔루션을 평가할 수 있다. 일 양태에서, 예를 들어 하드웨어 컴파일러(1606)는 이전 SoC 인터페이스 블록 솔루션을 유지할 수 있다. 하드웨어 컴파일러(1606)는 업데이트된 SoC 인터페이스 블록 솔루션의 스코어를 이전(예를 들어, 직전 SoC 인터페이스 블록 솔루션)의 스코어와 비교할 수 있고, 업데이트된 SoC 인터페이스 블록 솔루션의 스코어가 이전 SoC 인터페이스 블록 솔루션의 스코어를 초과한다면, 업데이트된 SoC 인터페이스 블록 솔루션을 사용할 수 있다.
다른 예시적인 구현에서, 하드웨어 컴파일러(1606)는 80/100의 스코어를 가진 SoC 인터페이스 블록 솔루션을 DPE 컴파일러(1602)로부터 수신한다. 하드웨어 컴파일러(1606)는 PL(214) 내의 애플리케이션의 하드웨어 부분의 구현에 도달할 수 없고 DPE 컴파일러(1602)에 하나 이상의 SoC 인터페이스 블록 제약을 제공한다. DPE 컴파일러(1602)로부터 하드웨어 컴파일러(1606)에 의해 수신된 업데이트된 SoC 인터페이스 블록 솔루션은 20/100의 스코어를 가진다. 그 경우에, 새로 수신된 SoC 인터페이스 블록 솔루션의 스코어가 이전 SoC 인터페이스 블록 솔루션의 스코어보다 초과하지 않는다고(예를 들어, 더 낮다고) 결정하는 것에 응답하여, 하드웨어 컴파일러(1606)는 하나 이상의 SoC 인터페이스 블록 제약(예를 들어, 소프트 제약)을 완화하고, 완화된 제약(들)을 포함하는 SoC 인터페이스 블록 제약을 DPE 컴파일러(1602)에 제공한다. DPE 컴파일러(1602)는 완화된 설계 제약(들)에 비추어, 20/100 및/또는 80/100보다 높은 스코어를 가지는 또 다른 SoC 인터페이스 블록 솔루션을 생성하려고 시도한다.
다른 예에서, 하드웨어 컴파일러(1606)는 더 높거나 가장 높은 스코어를 가진 이전 SoC 인터페이스 블록 솔루션을 사용하도록 선택할 수 있다. 하드웨어 컴파일러(1606)는 예를 들어 직전 SoC 인터페이스 블록 솔루션보다 낮은 스코어를 가지는 SoC 인터페이스 블록 솔루션을 수신하는 것에 응답하여 또는 하나 이상의 SoC 인터페이스 블록 제약이 완화된 후 이전 SoC 인터페이스 블록 솔루션보다 낮은 스코어를 가지는 SoC 인터페이스 블록 솔루션을 수신하는 것에 응답하여, 임의의 시점에서 앞선(earlier) SoC 인터페이스 블록 솔루션으로 복귀할 수 있다.
도 23은 SoC 인터페이스 블록 솔루션을 처리하는 예시적인 방법(2300)을 도시한다. 방법(2300)은 수신된 SoC 인터페이스 블록 솔루션(들)을 평가하고 애플리케이션의 하드웨어 부분에 대한 구현 흐름을 수행하는 데 사용하기 위해 현재 최상의 SoC 인터페이스 블록 솔루션이라고 불리는 SoC 인터페이스 블록 솔루션을 선택하도록 하드웨어 컴파일러(1606)에 의해 수행될 수 있다.
블록(2302)에서, 하드웨어 컴파일러(1606)는 DPE 컴파일러(1602)로부터 SoC 인터페이스 블록 솔루션을 수신한다. 블록(2302)에서 수신된 SoC 인터페이스 블록 솔루션은 DPE 컴파일러(1602)로부터 제공되는 초기 또는 제1 SoC 인터페이스 블록 솔루션일 수 있다. SoC 인터페이스 블록 솔루션을 하드웨어 컴파일러(1606)에 제공하는데 있어서, DPE 컴파일러(1602)는 SoC 인터페이스 블록 솔루션에 대한 스코어를 더 제공한다. 적어도 초기에, 하드웨어 컴파일러(1606)는 제1 SoC 인터페이스 블록 솔루션을 현재 최상의 SoC 인터페이스 블록 솔루션으로 선택한다.
블록(2304)에서, 하드웨어 컴파일러(1606)는 선택적으로 사용자로부터 하나 이상의 하드 SoC 인터페이스 블록 제약을 수신한다. 블록(2306)에서, 하드웨어 컴파일러는 애플리케이션의 하드웨어 부분을 구현하기 위한 하나 이상의 소프트 SoC 인터페이스 블록 제약을 생성할 수 있다. 하드웨어 컴파일러는 하드웨어 설계 메트릭을 충족하기 위한 노력으로 소프트 SoC 인터페이스 블록 제약을 생성한다.
블록(2308)에서, 하드웨어 컴파일러(1606)는 확인을 위해 SoC 인터페이스 블록 제약(예를 들어, 하드 및 소프트 둘 다)을 DPE 컴파일러(1602)에 보낸다. SoC 인터페이스 블록 제약을 수신하는 것에 응답하여, DPE 컴파일러는 하드웨어 컴파일러(1606)로부터 수신된 SoC 인터페이스 블록 제약에 기반하여 업데이트된 SoC 인터페이스 블록 솔루션을 생성할 수 있다. DPE 컴파일러(1602)는 업데이트된 SoC 인터페이스 블록 솔루션을 하드웨어 컴파일러(1606)에 제공한다. 따라서, 블록(2310)에서, 하드웨어 컴파일러는 업데이트된 SoC 인터페이스 블록 솔루션을 수신한다.
블록(2312)에서, 하드웨어 컴파일러(1606)는 업데이트된 SoC 인터페이스 블록 솔루션(예를 들어, 가장 최근에 수신된 SoC 인터페이스 블록 솔루션)의 스코어를 제1(예를 들어, 이전에 수신된) SoC 인터페이스 블록 솔루션의 스코어와 비교한다.
블록(2314)에서, 하드웨어 컴파일러(1606)는 업데이트된(예를 들어, 가장 최근에 수신된) SoC 인터페이스 블록 솔루션의 스코어가 이전에 수신된(예를 들어, 제1) SoC 인터페이스 블록 솔루션의 스코어를 초과하는지 여부를 결정한다. 블록(2316)에서, 하드웨어 컴파일러(1606)는 가장 최근에 수신된(예를 들어, 업데이트된) SoC 인터페이스 블록 솔루션을 현재 최상의 SoC 인터페이스 블록 솔루션으로서 선택한다.
블록(2318)에서, 하드웨어 컴파일러(1606)는 개선 목표가 달성되었는지 또는 시간 예산이 초과되었는지 여부를 결정한다. 예를 들어, 하드웨어 컴파일러(1606)는 애플리케이션의 하드웨어 부분의 현재 구현 상태가 더 많은 수의 설계 메트릭을 충족하고 있는지 및/또는 하나 이상의 설계 메트릭을 거의 충족하게 되었는지 여부를 결정할 수 있다. 하드웨어 컴파일러(1606)는 또한 배치 및/또는 라우팅에 소요된 처리 시간의 양과 해당 시간이 최대 배치 시간, 최대 라우팅 시간 또는 배치와 라우팅 모두에 대한 최대 시간 양을 초과하는지에 기반하여 시간 예산이 초과되었는지 여부를 결정한다. 개선 목표에 도달했거나 시간 예산이 초과되었다는 결정에 응답하여, 방법(2300)은 블록(2324)으로 계속된다. 그렇지 않다면, 방법(2300)은 블록(2320)으로 계속된다.
블록(2324)에서, 하드웨어 컴파일러(1606)는 애플리케이션의 하드웨어 부분을 구현하기 위해 현재 최상의 SoC 인터페이스 블록 솔루션을 사용한다.
블록(2320)으로 계속해서, 하드웨어 컴파일러(1606)는 SoC 인터페이스 블록 제약들 중 하나 이상을 완화한다. 하드웨어 컴파일러(1606)는 예를 들어 하나 이상의 소프트 제약을 완화하거나 변경할 수 있다. 소프트 SoC 인터페이스 블록 제약을 완화하거나 변경하는 예는 소프트 SoC 인터페이스 블록 제약을 제거(remove)(예를 들어, 삭제(delete))하는 것을 포함한다. 소프트 SoC 인터페이스 블록 제약을 완화하거나 변경하는 또 다른 예는 소프트 SoC 인터페이스 블록 제약을 상이한 SoC 인터페이스 블록 제약으로 대체하는 것을 포함한다. 대체 소프트 SoC 인터페이스 블록 제약은 대체되는 원본보다 덜 엄격할 수 있다.
블록(2322)에서, 하드웨어 컴파일러(1606)는 완화된 SoC 인터페이스 블록 제약(들)을 포함하는 SoC 인터페이스 블록 제약(들)을 DPE 컴파일러(1602)로 보낼 수 있다. 블록(2322) 후에, 방법(2300)은 블록(2310)으로 다시 되돌아가서 설명된 바와 같이 처리를 계속한다. 예를 들어, DPE 컴파일러는 블록(2322)에서 하드웨어 컴파일러로부터 수신된 SoC 인터페이스 블록 제약에 기반하여 더 업데이트된 SoC 인터페이스 블록 솔루션을 생성한다. 블록(2310)에서, 하드웨어 컴파일러는 더 업데이트된 SoC 인터페이스 블록 솔루션을 수신한다.
방법(2300)은 구현 흐름 및 SoC 인터페이스 블록 제약(들)이 완화될 수 있는 상황을 수행하는 데 사용할 SoC 인터페이스 블록 솔루션을 DPE 컴파일러(1602)로부터 선택하는 예시적인 프로세스를 도시한다. 하드웨어 컴파일러(1606)는 조정(reconciliation) 및/또는 확인(validation) 프로세스의 일부로서 업데이트된 SoC 인터페이스 블록 솔루션을 획득하기 위해 구현 흐름 동안 다양한 상이한 지점 중 임의의 지점에서 DPE 컴파일러(1602)에 SoC 인터페이스 블록 제약을 제공할 수 있음을 이해해야 한다. 예를 들어, 하드웨어 컴파일러(1606)가 (예를 들어, 타이밍, 전력, 또는 다른 검사 또는 분석에 기반하여) 현재 상태에서 애플리케이션의 하드웨어 부분의 구현이 애플리케이션의 설계 메트릭을 충족하지 않거나 충족하지 않을 것이라고 결정하는 임의의 지점에서, 하드웨어 컴파일러(1606)는 업데이트된 SoC 인터페이스 블록 제약(들)을 DPE 컴파일러(1602)에 제공함으로써 업데이트된 SoC 인터페이스 블록 솔루션을 요청할 수 있다.
도 24는 SoC(200)에서의 구현을 위한 애플리케이션(2400)의 다른 예를 도시한다. 애플리케이션(2400)은 방향성 흐름 그래프로서 명시된다. 노드는 PL 노드, DPE 노드 및 I/O 노드를 구별하기 위해 음영 처리되고 모양이 상이하다. 도시된 예에서, I/O 노드는 SoC 인터페이스 블록(206)에 매핑될 수 있다. PL 노드는 PL에서 구현된다. DPE 노드는 특정 DPE에 매핑된다. 전체가 도시되지는 않았지만, 애플리케이션(2400)은 DPE(204)에 매핑될 36개의 커널(예를 들어, 노드), DPE 어레이 데이터 스트림에 매핑될 72개의 PL, PL 데이터 스트림에 매핑될 36개의 DPE 어레이를 포함한다.
도 25는 DPE 컴파일러(1602)에 의해 생성된 SoC 인터페이스 블록 솔루션의 예시적인 도시이다. 도 25의 SoC 인터페이스 블록 솔루션은 DPE 컴파일러(1602)에 의해 생성되어 하드웨어 컴파일러(1606)에 제공될 수 있다. 도 25의 예는 DPE 컴파일러(1602)가 DPE 노드 대 DPE 어레이(202)의 DPE(204)의 초기 매핑을 생성하는 시나리오를 도시한다. 또한, DPE 컴파일러(1602)는 DPE 노드의 초기 매핑을 성공적으로 라우팅한다. 도 25의 예에서, DPE 어레이(202)의 열 6-17만이 도시된다. 또한, 각 열은 4개의 DPE(204)를 포함한다.
도 25는 DPE 노드 대 DPE 어레이(202)의 DPE(204)의 매핑 및 데이터 스트림의 SoC 인터페이스 블록(206) 하드웨어로의 라우팅을 도시한다. DPE 컴파일러(1602)에 의해 결정된 바와 같은 애플리케이션(2400)의 DPE 노드(0-35) 대 DPE(204)의 매핑은 DPE 어레이(202)를 참조하여 도시된다. DPE와 SoC 인터페이스 블록(206)의 특정 타일 사이의 데이터 스트림의 라우팅은 화살표 모음으로 도시된다. 도 25-30를 설명할 때 예시의 목적으로, 도 25에 디스플레이된 키는 소프트 제약, 하드 제약에 의해 제어되는 데이터 스트림 및 적용 가능한 제약이 없는 데이터 스트림 사이에 구별하는 데 사용된다.
도 25-30을 참조하면, 소프트 제약은 DPE 컴파일러(1602) 및/또는 하드웨어 컴파일러(1606)에 의해 결정된 라우팅에 대응하는 반면, 하드 제약은 사용자 명시 SoC 인터페이스 블록 제약을 포함할 수 있다. 도 25에 도시된 모든 제약은 소프트 제약이다. 도 25의 예는 DPE 컴파일러(1602)가 초기 SoC 인터페이스 블록 솔루션을 성공적으로 결정하는 경우를 도시한다. 일 양태에서, DPE 컴파일러(1602)는 한 열에서 다른 열로 행 DPE(204)를 따라 (예를 들어, 왼쪽에서 오른쪽으로) 트래버스하는 다른 라우팅을 사용하려고 시도하기 전에 도시된 바와 같이 SoC 인터페이스 블록 솔루션에 대한 수직 라우팅을 사용하는 것을 적어도 처음에 시도하도록 구성될 수 있다.
도 26은 DPE 컴파일러(1602)에 의해 수신된 라우팅 가능한 SoC 인터페이스 블록 제약의 예를 예시한다. DPE 컴파일러(1602)는 업데이트된 SoC 인터페이스 블록 제약의 형태로 업데이트된 라우팅을 명시하는 업데이트된 SoC 인터페이스 블록 솔루션을 생성할 수 있다. 도 26의 예에서, 더 많은 수의 SoC 인터페이스 블록 제약이 하드 제약이다. 이 예에서, DPE 컴파일러(1602)는 도시된 각각의 타입의 제약을 관찰하면서 DPE 어레이(202)의 데이터 스트림을 성공적으로 라우팅한다.
도 27은 DPE 컴파일러(1602)에 의해 관찰되어야 하는 라우팅 불가능한 SoC 인터페이스 블록 제약의 예를 도시한다. DPE 컴파일러(1602)는 도 27에 예시된 제약을 관찰하는 SoC 인터페이스 블록 솔루션을 생성할 수 없다.
도 28은 DPE 컴파일러(1602)가 도 27로부터의 소프트 타입 SoC 인터페이스 블록 제약을 무시하는 예를 도시한다. 도 28의 예에서, DPE 컴파일러(1602)는 하드 제약만을 사용하여 DPE 어레이(202)에서의 구현을 위해 애플리케이션의 소프트웨어 부분을 성공적으로 라우팅한다. 제약에 의해 제어되지 않는 그러한 데이터 스트림은 DPE 컴파일러(1602)가 적합하다고 보거나 그렇게 할 수 있는 임의의 방식으로 라우팅될 수 있다.
도 29는 라우팅 불가능한 SoC 인터페이스 블록 제약의 다른 예를 도시한다. 도 29의 예는 하드 제약만을 가진다. 이와 같이, DPE 컴파일러(1602)는 하드 제약을 무시할 수 없이 매핑(또는 재매핑) 동작을 개시한다.
도 30은 도 29의 DPE 노드들의 예시적인 매핑을 도시한다. 이 예에서, 재매핑에 후속하여, DPE 컴파일러(1602)는 업데이트된 SoC 인터페이스 블록 솔루션을 생성하기 위해 DPE 노드를 성공적으로 라우팅할 수 있다.
도 31은 라우팅 불가능한 SoC 인터페이스 블록 제약의 다른 예를 도시한다. 도 31의 예는 하드 제약만을 가진다. 이와 같이, DPE 컴파일러(1602)는 하드 제약을 무시할 수 없이 매핑 동작을 개시한다. 예시의 목적을 위해, DPE 어레이(202)는 DPE의 3개의 행(예를 들어, 각 열에 3개의 DPE)만을 포함한다.
도 32는 도 31의 DPE 노드들의 예시적인 매핑을 도시한다. 도 32는 도 31와 관련하여 설명된 바와 같이 개시되는 재매핑 동작으로부터 획득된 결과를 도시한다. 이 예에서, 재매핑에 후속하여, DPE 컴파일러(1602)는 업데이트된 SoC 인터페이스 블록 솔루션을 생성하기 위해 애플리케이션의 소프트웨어 솔루션을 성공적으로 라우팅할 수 있다.
일 양태에서, 시스템은 매핑 문제의 정수 선형 계획법(integer linear programming, ILP) 공식을 생성함으로써 도 25-32에 도시된 매핑을 수행할 수 있다. ILP 공식은 맵핑 문제를 정의하는 복수의 상이한 변수 및 제약을 포함할 수 있다. 시스템은 비용(들)을 또한 최소화하면서 ILP 공식을 풀 수 있다. 비용은 사용된 DMA 엔진의 수에 따라 적어도 부분적으로 결정될 수 있다. 이러한 방식으로 시스템은 DFG를 DPE 어레이에 매핑할 수 있다.
다른 양태에서, 시스템은 DFG의 노드를 우선순위의 내림차순으로 정렬할 수 있다. 시스템은 하나 이상의 요인(factor)를 기반으로 우선 순위를 결정할 수 있다. 요인의 예에는 DFG 그래프에서 노드의 높이, 노드의 총 차수(degree)(예를 들어, 노드에 들어오고 나가는 모든 에지의 합) 및/또는 메모리, 스트림 및 캐스케이드와 같은 노드에 연결된 에지의 타입이 포함될 수 있지만 이에 국한되지 않는다. 시스템은 친화도(affinity) 및 유효성(validity)에 기반하여 사용 가능한 최상의 DPE에 노드를 배치할 수 있다. 시스템은 이 노드의 모든 자원 요구 사항이 주어진 DPE(예를 들어, 컴퓨팅 자원, 메모리 버퍼, 스트림 자원)에서 충족될 수 있는지 여부를 기반으로 유효성을 결정할 수 있다. 시스템은 하나 이상의 다른 요인을 기반으로 친화도를 결정할 수 있다. 친화도 요인의 예는 DMA 통신을 최소화하기 위해 이 노드의 이웃이 이미 배치된 동일한 DPE 또는 인접 DPE에 노드를 배치하는 것, 이 노드가 캐스케이드 체인의 일부인지 여부와 같은 아키텍처 제약 및/또는 최대 여유(free) 자원을 가진 DPE를 찾는 것을 포함할 수 있다. 모든 제약이 충족된 상태에서 노드가 배치되면 시스템은 배치된 노드의 이웃 노드의 우선 순위를 증가시켜서 해당 노드가 다음에 처리되도록 할 수 있다. 사용 가능한 배치가 현재 노드에 유효하지 않다면, 시스템은 이 노드를 위한 공간을 만들기 위해 최상의 후보 DPE(들)로부터 일부 다른 노드의 배치를 취소하려고 시도할 수 있다. 시스템은 배치되지 않은 노드를 다시 배치될 우선 순위 대기열(queue)에 다시 넣을 수 있다. 시스템은 수행된 배치 및 배치 해제의 총 수를 추적함으로써, 좋은 솔루션을 찾는 데 드는 총 노력을 제한할 수 있다. 그러나, 다른 맵핑 기법이 사용될 수 있고 본 명세서에 제공된 예가 제한하려는 의도가 아님을 이해해야 한다.
도 33은 도 1과 관련하여 설명된 시스템에 의해 실행가능한 다른 예시적인 소프트웨어 아키텍처(3300)를 도시한다. 예를 들어, 도 33의 아키텍처(3300)는 도 1의 프로그램 모듈(120) 중 하나 이상으로서 구현될 수 있다. 도 33의 예시적인 소프트웨어 아키텍처(3300)는 데이터 흐름 그래프와 같은 애플리케이션이 PL(214)에서 구현하기 위해 하나 이상의 HLS(High-Level Synthesis) 커널을 명시하는 경우에 사용될 수 있다. 예를 들어, 애플리케이션의 PL 노드는 HLS 처리를 필요로 하는 HLS 커널을 참조한다. 일 양태에서, HLS 커널은 C 및/또는 C++와 같은 고급 언어(high-level language, HLL)로 명시된다.
도 33의 예에서, 소프트웨어 아키텍처(3300)는 DPE 컴파일러(1602), 하드웨어 컴파일러(1606), HLS 컴파일러(3302), 및 시스템 링커(system linker)(3304)를 포함한다. NoC 컴파일러(1604)는 DPE 컴파일러(1602)와 함께 포함되어 사용되어, 본 개시 내에서 이전에 설명된 바와 같이 유효성 검사(3306)를 수행할 수 있다.
도시된 바와 같이, DPE 컴파일러(1602)는 애플리케이션(3312), SoC 아키텍처 설명(3310), 및 선택적으로 테스트 벤치(3314)를 수신한다. 논의된 바와 같이, 애플리케이션(3312)은 병렬 실행 시맨틱스를 포함하는 데이터 흐름 그래프로서 명시될 수 있다. 애플리케이션(3312)은 상호 연결된 PL 노드 및 DPE 노드를 포함할 수 있고 런타임 파라미터를 명시할 수 있다. 이 예에서 PL 노드는 HLS 커널을 참조한다. SoC 아키텍처 설명(3310)은 DPE 어레이(202)의 크기 및 치수, PL(214)의 크기 및 그 안에서 이용 가능한 다양한 프로그래머블 회로 블록, PS(212)에 포함된 프로세서 및 기타 디바이스의 타입과 같은 PS(212)의 타입, 및 애플리케이션(3312)이 구현될 SoC(200)에 있는 회로의 기타 물리적 특성과 같은 정보를 명시하는 데이터 구조 또는 파일일 수 있다. SoC 아키텍처 설명(3310)은 또한 거기에 포함된 서브시스템 간의 연결(예를 들어, 인터페이스)을 명시할 수 있다.
DPE 컴파일러(1602)는 HLS 커널을 HLS 컴파일러(3302)로 출력할 수 있다. HLS 컴파일러(3302)는 HLL에 명시된 HLS 커널을 하드웨어 컴파일러에 의해 합성될 수 있는 HLS IP로 변환한다. 예를 들어, HLS IP는 레지스터 전달 레벨(RTL) 블록으로서 명시될 수 있다. 예를 들어, HLS 컴파일러(3302)는 각 HLS 커널에 대한 RTL 블록을 생성한다. 도시된 바와 같이, HLS 컴파일러(3302)는 HLS IP를 시스템 링커(3304)로 출력한다.
DPE 컴파일러(1602)는 초기 SoC 인터페이스 블록 솔루션 및 연결 그래프와 같은 추가 출력을 생성한다. DPE 컴파일러(1602)는 시스템 링커(3304)에 연결 그래프를 출력하고 하드웨어 컴파일러(1606)에 SoC 인터페이스 블록 솔루션을 출력한다. 연결 그래프는 PL(214)에서 구현(이제 HLS IP로 전환)될 HLS 커널에 대응하는 노드와 DPE 어레이(202)에서 구현될 노드 사이에 연결을 명시한다.
도시된 바와 같이, 시스템 링커(3304)는 SoC 아키텍처 설명(3310)을 수신한다. 시스템 링커(3304)는 또한 DPE 컴파일러(1602)를 통해 처리되지 않는 애플리케이션(3312)으로부터 직접 하나 이상의 HLS 및/또는 RTL 블록을 수신할 수 있다. 시스템 링커(3304)는 수신된 HLS 및/또는 RTL 블록, HLS IP 및 IP 커널들 간의 연결과 IP 커널과 DPE 노드 간의 연결을 명시하는 연결 그래프를 사용하여 애플리케이션의 하드웨어 부분에 해당하는 블록 다이어그램을 자동으로 생성할 수 있다. 일 양태에서, 시스템 링커(3304)는 블록 다이어그램을 SoC(200)에 대한 베이스 플랫폼(도시되지 않음)과 통합할 수 있다. 예를 들어, 시스템 링커(3304)는 블록 다이어그램을 베이스 플랫폼에 연결할 수 있어 그 결과 통합 블록 다이어그램이 된다. 블록 다이어그램 및 연결된 베이스 플랫폼은 합성 가능한 블록 다이어그램이라고 지칭될 수 있다.
다른 양태에서, SDF 그래프(예를 들어, 애플리케이션(3312)) 내에서 커널로서 참조되는 HLS IP 및 RTL IP는 DPE 컴파일러(1602) 외부의 IP로 컴파일될 수 있다. 컴파일된 IP는 시스템 링커(3304)에 직접 제공될 수 있다. 시스템 링커(3304)는 제공된 IP를 사용하여 애플리케이션의 하드웨어 부분에 해당하는 블록 다이어그램을 자동으로 생성할 수 있다.
일 양태에서, 시스템 링커(3304)는 블록 다이어그램 내에 원래 SDF(예를 들어, 애플리케이션(3312)) 및 생성된 연결 그래프로부터 유도된 추가적인 하드웨어 특유의 세부사항을 포함할 수 있다. 예를 들어, 애플리케이션(3312)은 일부 메커니즘을 사용하여 (예를 들어, 이름 또는 다른 매칭/상관 기법에 의해) 이러한 IP의 데이터베이스에서 IP로 변환(translate)되거나 상관(예를 들어, 매칭)될 수 있는 실제 HLS 모델인 소프트웨어 모델을 포함하기 때문에, 시스템 링커(3304)는 (예를 들어, 사용자 개입 없이) 블록 다이어그램을 자동으로 생성할 수 있다. 이 예에서는 커스텀 IP가 사용될 수 없다. 블록 다이어그램을 자동으로 생성할 때, 시스템 링커(3304)는 데이터 폭 변환 블록, 하드웨어 버퍼 및/또는 본 명세서에 설명된 다른 경우에 사용자에 의해 수동으로 삽입되고 연결되었던 클록 도메인 크로싱 로직과 같은 하나 이상의 추가 회로 블록을 자동으로 삽입할 수 있다. 예를 들어, 시스템 링커(3304)는 데이터 타입 및 소프트웨어 모델을 분석하여, 설명된 바와 같이 연결 그래프에 의해 명시된 연결을 생성하는 데 하나 이상의 추가 회로 블록이 필요하다고 결정할 수 있다.
시스템 링커(3304)는 블록 다이어그램을 하드웨어 컴파일러(1606)에 출력한다. 하드웨어 컴파일러(1606)는 블록 다이어그램 및 DPE 컴파일러(1602)에 의해 생성된 초기 SoC 인터페이스 블록 솔루션을 수신한다. 하드웨어 컴파일러(1606)는 도 20의 블록(2010), 도 21, 22, 23의 블록(2106, 2108, 2112, 2114, 2116, 2118)과 관련하여 이전에 설명된 바와 같이 DPE 컴파일러(1602) 및 선택적으로 NoC 컴파일러(1604)로 유효성(validation) 검사(3306)를 개시할 수 있다. 유효성은 하드웨어 컴파일러가 DPE 컴파일러(1602) 및 선택적으로 NoC 컴파일러(1604)에 다양한 타입의 제약(반복적 접근법에서 완화/수정된 제약을 포함할 수 있음)과 같은 설계 데이터를 제공하는 반복 프로세스일 수 있으며, 그 대가로, DPE 컴파일러(1602)로부터 업데이트된 SoC 인터페이스 블록 솔루션을 그리고 선택적으로 NoC 컴파일러(1604)로부터 업데이트된 NoC 솔루션을 수신한다.
하드웨어 컴파일러(1606)는 PL(214)에서 애플리케이션(3312)의 하드웨어 부분을 구현하는 구성 비트스트림을 포함하는 하드웨어 패키지를 생성할 수 있다. 하드웨어 컴파일러(1606)는 하드웨어 패키지를 DPE 컴파일러(1602)로 출력할 수 있다. DPE 컴파일러(1602)는 내부의 DPE 어레이(202)에서 구현하도록 의도된 애플리케이션(3312)의 소프트웨어 부분을 프로그래밍하는 DPE 어레이 구성 데이터(예를 들어, 하나 이상의 바이너리)를 생성할 수 있다.
도 34는 SoC(200)에서 애플리케이션을 구현하기 위해 설계 흐름을 수행하는 다른 예시적인 방법(3400)을 도시한다. 방법(3400)은 도 1과 관련하여 설명된 바와 같은 시스템에 의해 수행될 수 있다. 시스템은 도 33과 관련하여 설명된 바와 같이 소프트웨어 아키텍처를 실행할 수 있다. 도 34의 예에서, 처리 중인 애플리케이션은 PL(214)에서 구현하기 위해 HLS 커널을 명시하는 노드를 포함한다.
블록(3402)에서, DPE 컴파일러(1602)는 애플리케이션, SoC(200)의 SoC 아키텍처 설명, 및 선택적으로 테스트 벤치를 수신한다. 블록(3404)에서, DPE 컴파일러(1602)는 연결 그래프를 생성하고 연결 그래프를 시스템 링커에 제공할 수 있다. 블록(3406)에서, DPE 컴파일러(1602)는 초기 SoC 인터페이스 블록 솔루션을 생성하고 하드웨어 컴파일러(1606)에 초기 SoC 인터페이스 블록 솔루션을 제공한다. 초기 SoC 인터페이스 블록 솔루션은 애플리케이션의 DPE 노드 대 DPE 어레이(202)의 DPE(204)의 초기 매핑 및 DPE 어레이(202) 안팎의 연결 대 SoC 인터페이스 블록(206)의 물리적 데이터 경로의 매핑을 명시할 수 있다.
블록(3408)에서, HLS 컴파일러(3302)는 합성 가능한 IP 코어를 생성하기 위해 HLS 커널에 대해 HLS를 수행할 수 있다. 예를 들어, DPE 컴파일러(1602)는 애플리케이션의 노드에 의해 명시된 HLS 커널을 HLS 컴파일러(3302)에 제공한다. HLS 컴파일러(3302)는 수신된 HLS 커널 각각에 대한 HLS IP를 생성한다. HLS 컴파일러(3302)는 HLS IP를 시스템 링커로 출력한다.
블록(3410)에서, 시스템 링커는 연결 그래프, SoC 아키텍처 설명 및 HLS IP를 사용하여 애플리케이션의 하드웨어 부분에 대응하는 블록 다이어그램을 자동으로 생성할 수 있다. 블록(3412)에서, 시스템 링커는 SoC(200)에 대한 블록 다이어그램과 베이스 플랫폼을 통합할 수 있다. 예를 들어, 하드웨어 컴파일러(1606)는 블록 다이어그램을 베이스 플랫폼에 연결하여 통합 블록 다이어그램을 생성할 수 있다. 일 양태에서, 블록 다이어그램 및 연결된 베이스 플랫폼은 합성 가능한 블록 다이어그램라고 지칭된다.
블록(3414)에서, 하드웨어 컴파일러(1606)는 통합 블록 다이어그램에 대한 구현 흐름을 수행할 수 있다. 구현 흐름 동안, 하드웨어 컴파일러(1606)는 DPE 컴파일러(1602) 및 선택적으로 NoC 컴파일러(1604)와 협력하여 본 명세서에 설명된 바와 같이 확인을 수행하여 PL에서의 구현을 위한 애플리케이션의 하드웨어 부분의 구현으로 수렴할 수 있다. 예를 들어, 논의된 바와 같이, 하드웨어 컴파일러(1606)는 애플리케이션의 하드웨어 부분의 현재 구현 상태가 하나 이상의 설계 메트릭을 충족하지 않는다는 결정에 응답하여 DPE 컴파일러(1602) 및 선택적으로 NoC 컴파일러(1604)를 호출할 수 있다. 하드웨어 컴파일러(1606)는 배치 전, 배치 동안, 라우팅 전, 및/또는 라우팅 동안 DPE 컴파일러(1602) 및 선택적으로 NoC 컴파일러(1604)를 호출할 수 있다.
블록(3416)에서, 하드웨어 컴파일러(1606)는 하드웨어 구현을 DPE 컴파일러(1602)로 엑스포트한다. 일 양태에서, 하드웨어 구현은 DSA(device support archive) 파일로서 출력될 수 있다. DSA 파일은 구현 흐름으로부터 플랫폼 메타데이터, 에뮬레이션 데이터, 하드웨어 컴파일러(1606)에 의해 생성된 하나 이상의 구성 비트스트림 등을 포함할 수 있다. 하드웨어 구현은 또한 애플리케이션의 하드웨어 부분의 구현을 생성하기 위해 하드웨어 컴파일러(1606)에 의해 사용되는 최종 SoC 인터페이스 블록 솔루션 및 선택적으로 최종 NoC 솔루션을 포함할 수 있다.
블록(3418)에서, DPE 컴파일러(1602)는 DPE 어레이에 대한 소프트웨어 생성을 완료한다. 예를 들어, DPE 컴파일러(1602)는 애플리케이션에서 사용되는 DPE를 프로그래밍하는 데 사용되는 바이너리를 생성한다. 바이너리를 생성할 때, DPE 컴파일러(1602)는 구현 흐름을 수행하기 위해 하드웨어 컴파일러(1606)에 의해 사용되는 최종 SoC 인터페이스 블록 솔루션 및 선택적으로 최종 NoC 솔루션을 사용할 수 있다. 일 양태에서, DPE 컴파일러는 DSA에 포함된 구성 비트스트림 및/또는 메타데이터의 검사를 통해 하드웨어 컴파일러에 의해 사용되는 SoC 인터페이스 블록 솔루션을 결정할 수 있다.
블록(3420)에서, NoC 컴파일러(1604)는 NoC(208)를 프로그래밍하기 위한 바이너리 또는 바이너리들을 생성한다. 블록(3422)에서, PS 컴파일러(1918)는 PS 바이너리를 생성한다. 블록(3424)에서, 시스템은 SoC(200)에서 구성 비트스트림 및 바이너리를 사용(deploy)할 수 있다.
도 35는 SoC(200)에서 애플리케이션을 구현하기 위한 설계 흐름을 수행하는 다른 예시적인 방법(3500)을 도시한다. 방법(3500)은 도 1과 관련하여 설명된 바와 같은 시스템에 의해 수행될 수 있다. 애플리케이션은 본 명세서에 설명된 데이터 흐름 그래프로서 명시될 수 있으며 DPE 어레이(202) 내에서 구현하기 위한 소프트웨어 부분과 PL(214) 내에서 구현하기 위한 하드웨어 부분을 포함할 수 있다.
블록(3502)에서, 시스템은 DPE 어레이(202)와 PL(214)을 결합하는 인터페이스 블록의 하드웨어 자원에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 제1 인터페이스 솔루션을 생성할 수 있다. 예를 들어, DPE 컴파일러(1602)는 초기 또는 제1 SoC 인터페이스 블록 솔루션을 생성할 수 있다.
블록(3504)에서, 시스템은 DPE 어레이에서 구현될 소프트웨어 부분의 노드와 HLS 커널 사이의 연결을 명시하는 연결 그래프를 생성할 수 있다. 일 양태에서, DPE 컴파일러(1602)는 연결 그래프를 생성할 수 있다.
블록(3506)에서, 시스템은 연결 그래프 및 HLS 커널에 기반하여 블록 다이어그램을 생성할 수 있다. 블록 다이어그램은 합성 가능하다. 예를 들어, 시스템 링커는 합성 가능한 블록 다이어그램을 생성할 수 있다.
블록(3508)에서, 시스템은 제1 인터페이스 솔루션을 사용하여 블록 다이어그램에 대한 구현 흐름을 수행할 수 있다. 논의된 바와 같이, 하드웨어 컴파일러(1606)는 구현 흐름 동안 DPE 컴파일러(1602) 및 선택적으로 NoC 컴파일러(1604)와 설계 데이터를 교환할 수 있다. 하드웨어 컴파일러(1606) 및 DPE 컴파일러(1602)는 DPE 컴파일러(1602)가 하드웨어 컴파일러(1606)에 의해 호출되는 것에 응답하여 업데이트된 SoC 인터페이스 블록 솔루션을 하드웨어 컴파일러(1606)에 제공하는 경우 데이터를 반복적으로 교환할 수 있다. 하드웨어 컴파일러(1606)는 SoC 인터페이스 블록에 하나 이상의 제약을 제공함으로써 DPE 컴파일러를 호출할 수 있다. 하드웨어 컴파일러(1606) 및 NoC 컴파일러(1604)는 NoC 컴파일러(1604)가 하드웨어 컴파일러(1606)에 의해 호출되는 것에 응답하여 업데이트된 NoC 솔루션을 하드웨어 컴파일러(1606)에 제공하는 경우 데이터를 반복적으로 교환할 수 있다. 하드웨어 컴파일러(1606)는 NoC(208)에 대한 하나 이상의 제약을 제공함으로써 NoC 컴파일러(1604)를 호출할 수 있다.
블록(3510)에서, 시스템은 DPE 컴파일러(1602)를 사용하여 DPE 어레이(202)의 하나 이상의 DPE(204)에서의 구현을 위한 애플리케이션의 소프트웨어 부분을 컴파일할 수 있다. DPE 컴파일러(1602)는 DPE 어레이(202)와 PL(214) 사이의 일관된 인터페이스(예를 들어, 하드웨어 컴파일러(1606)에 의한 구현 흐름 동안 사용되는 동일한 SoC 인터페이스 블록 솔루션)를 사용하기 위하여 구현 흐름의 결과를 수신할 수 있다.
설명의 목적을 위해, 본 명세서에 개시된 다양한 본 발명의 개념에 대한 철저한 이해를 제공하기 위해 특정 명명법(nomenclature)이 제시된다. 그러나, 본 명세서에 사용된 용어는 본 발명의 구성의 특정 측면을 설명하기 위한 목적으로만 사용되며 제한하려는 의도가 아니다.
본 명세서에 정의된 바와 같이, 단수 형태 "a", "an" 및 "the"는 문맥이 명백하게 달리 나타내지 않는 한 복수 형태도 포함하도록 의도된다.
본 명세서에 정의된 바와 같이, "적어도 하나(at least one)", "하나 이상(one or more)" 및 "및/또는(and/or)"이라는 용어는 달리 명시적으로 언급되지 않는 한, 동작에 있어서 연접(conjunctive) 및 이접(disjunctive) 모두인 개방형 표현이다. 예를 들어, "A, B, 및 C 중 적어도 하나", "A, B 또는 C 중 적어도 하나", "A, B 및 C 중 하나 이상", "A, B 또는 C 중 하나 이상", "A, B 및/또는 C"의 각각의 표현은 A 단독, B 단독, C 단독, A와 B 함께, A와 C 함께, B와 C 함께, 또는 A, B 및 C 함께를 의미한다.
본 명세서에 정의된 바와 같이, "자동으로(automatically)"라는 용어는 사용자 개입이 없음을 의미한다. 본 명세서에 정의된 바와 같이, "사용자(user)"라는 용어는 인간을 의미한다.
본 명세서에 정의된 바와 같이, "컴퓨터 판독 가능 저장 매체(computer readable storage medium)"라는 용어는 명령어 실행 시스템, 장치 또는 디바이스에 의해 또는 이와 연관하여 사용하기 위한 프로그램 코드를 포함하거나 저장하는 저장 매체를 의미한다. 본 명세서에 정의된 바와 같이, "컴퓨터 판독 가능 저장 매체"는 일시적인 전파 신호 자체가 아니다. 컴퓨터 판독 가능 저장 매체는 전자 저장 디바이스, 자기 저장 디바이스, 광학 저장 디바이스, 전자기 저장 디바이스, 반도체 저장 디바이스, 또는 이들의 임의의 적절한 조합일 수 있지만 이에 제한되지는 않는다. 본 명세서에 기술된 바와 같은 다양한 형태의 메모리는 컴퓨터 판독 가능 저장 매체의 예이다. 컴퓨터 판독 가능 저장 매체의 보다 구체적인 예의 불완전한 목록은 휴대용 컴퓨터 디스켓, 하드 디스크, RAM, ROM(read-only memory), EPROM(erasable programmable read-only memory) 또는 플래시 메모리, EEPROM(electronically erasable programmable read-only memory), SRAM(static random access memory), 휴대용 CD-ROM(compact disc read-only memory), DVD(digital versatile disk), 메모리 스틱, 플로피 디스크 등을 포함할 수 있다.
본 명세서에 정의된 바와 같이, "만약 ~라면(if)"이라는 용어는 문맥에 따라 "~할 때(when)" 또는 "~할 때(upon)" 또는 "~에 응답하여(in response to)" 또는 "~에 응답하여(responsive to)"를 의미한다. 따라서 "라고 결정된다면(if it is determined)" 또는 "[명시된 조건 또는 이벤트가] 검출된다면(if [a stated condition or event] is detected)"이라는 문구는 문맥에 따라 "~라고 결정할 때(upon determining)" 또는 "~라고 결정하는 것에 응답하여(in response to determining)" 또는 "[명시된 조건 또는 이벤트]를 검출할 때(upon detecting [the stated condition or event])" 또는 "[명시된 조건 또는 이벤트를] 검출하는 것에 응답하여(in response to detecting [the stated condition or event])" 또는 "[명시된 조건 또는 이벤트를] 검출하는 것에 응답하여(responsive to detecting [the stated condition or event])"를 의미하는 것으로 해석될 수 있다.
본 명세서에 정의된 바와 같이, "고급 언어(high-level language)" 또는 "HLL"이라는 용어는 명령어들이 데이터 처리 시스템의 세부 사항(예를 들어, 머신어)으로부터 강한 추상화(strong abstraction)를 가지는 데이터 처리 시스템을 프로그래밍하는 데 사용되는 프로그래밍 언어 또는 명령어들의 집합을 의미한다. 예를 들어, HLL은 메모리 관리와 같은 데이터 처리 시스템의 동작 측면을 자동화하거나 숨길 수 있다. HLL이라고 하지만 이러한 언어는 일반적으로 "효율성 수준 언어(efficiency-level languages)"로 분류된다. HLL은 하드웨어 지원 프로그래밍 모델을 직접 노출한다. HLL의 예에는 C, C++ 및 기타 적절한 언어가 포함되지만 이에 국한되지는 않는다.
HLL은 디지털 회로를 설명하는 데 사용되는 Verilog, System Verilog 및 VHDL과 같은 하드웨어 설명 언어(a hardware description language, HDL)와 대조될 수 있다. HDL을 사용하면 설계자는 일반적으로 기술에 독립적인 RTL(register transfer level) 넷리스트로 컴파일될 수 있는 디지털 회로 설계의 정의를 생성할 수 있다.
본 명세서에 정의된 바와 같이, 용어 "~에 응답하여(responsive to)" 및 상기 기재된 바와 유사한 언어, 예를 들어 "만약 ~라면(if)", "~할 때(when)" 또는 "~할 때(upon)"는 행동(action) 또는 이벤트에 쉽게 응답하거나 반응하는 것을 의미한다. 응답 또는 반응이 자동으로 수행된다. 따라서, 제2 행동이 제1 행동에 "반응하여" 수행된다면, 제1 행동의 발생과 제2 행동의 발생 사이에는 인과 관계가 있다. "~에 응답하여(responsive to)"라는 용어는 인과 관계를 나타낸다.
본 명세서에 정의된 바와 같이, 용어 "일 실시 예(one embodiment)", "실시 예(an embodiment)", "하나 이상의 실시 예(one or more embodiments)", "특정 실시 예(particular embodiments)" 또는 유사한 언어는 실시 예와 관련하여 설명된 특정 특징, 구조 또는 특성이 본 개시 내에서 설명된 적어도 하나의 실시 예에 포함된다는 것을 의미한다. 따라서, 본 개시 전체에 걸쳐 문구 "일 실시 예에서", "실시 예에서", "하나 이상의 실시 예에서", "특정 실시 예에서" 및 유사한 언어의 등장은 모두 동일한 실시 예를 지칭할 수 있지만 반드시 그런 것은 아니다. "실시 예" 및 "장치(arrangement)"라는 용어는 본 개시 내에서 상호 교환 가능하게 사용된다.
본 명세서에 정의된 바와 같이, "출력(output)"이라는 용어는 물리적 메모리 요소, 예를 들어 디바이스에 저장하기, 디스플레이 또는 기타 주변 출력 디바이스에 기입하기, 다른 시스템으로 보내기(sending) 또는 전송하기(transmitting), 엑스포트하기 등을 의미한다.
본 명세서에 정의된 바와 같이, "실질적으로(substantially)"라는 용어는 열거된 특성, 파라미터 또는 값이 정확하게 달성될 필요는 없지만, 예를 들어 허용 오차, 측정 오류, 측정 정확도 제한 및 당업자에게 알려진 다른 요인을 포함하는 편차 또는 변동이 특성이 제공하고자 하는 효과를 배제하지 않는 양으로 발생할 수 있다는 것을 의미한다.
제1, 제2 등의 용어는 다양한 요소를 설명하기 위해 본 명세서에서 사용될 수 있다. 이러한 요소는 이러한 용어에 의해 제한되어서는 안 되는데, 이러한 용어는 달리 명시되거나 문맥이 달리 명확하게 나타내지 않는 한, 한 요소를 다른 요소와 구별하는 데만 사용되기 때문이다.
컴퓨터 프로그램 제품은 프로세서가 본 명세서에 설명된 본 발명의 장치의 측면을 수행하도록 하기 위한 컴퓨터 판독 가능 프로그램 명령어들이 있는 컴퓨터 판독 가능 저장 매체(또는 매체들)를 포함할 수 있다. 본 개시 내에서 "프로그램 코드"라는 용어는 "컴퓨터 판독 가능 프로그램 명령어들"이라는 용어와 상호 교환적으로 사용된다. 본 명세서에 기술된 컴퓨터 판독 가능 프로그램 명령어들은 컴퓨터 판독 가능 저장 매체로부터 각각의 컴퓨팅/처리 디바이스로 다운로드되거나, 네트워크 예를 들어 인터넷, LAN, WAN 및/또는 무선 네트워크를 통해 외부 컴퓨터 또는 외부 저장 디바이스로 다운로드될 수 있다. 네트워크는 구리 전송 케이블, 광 전송 섬유, 무선 전송, 라우터, 방화벽, 스위치, 게이트웨이 컴퓨터 및/또는 에지 서버를 포함하는 에지 디바이스를 포함할 수 있다. 각 컴퓨팅/처리 디바이스 내의 네트워크 어댑터 카드 또는 네트워크 인터페이스는 네트워크로부터 컴퓨터 판독 가능 프로그램 명령어들을 수신하고 컴퓨터 판독 가능 프로그램 명령어들을 각 컴퓨팅/처리 디바이스 내의 컴퓨터 판독 가능 저장 매체에 저장하기 위해 포워딩한다.
본 명세서에 설명된 본 발명의 장치에 대한 동작들을 수행하기 위한 컴퓨터 판독 가능 프로그램 명령어들은 객체 지향 프로그래밍 언어 및/또는 절차적 프로그래밍 언어를 포함하는 하나 이상의 프로그래밍 언어의 임의의 조합으로 작성된 어셈블러 명령어들, ISA(instruction-set-architecture) 명령어들, 머신 명령어들, 머신 종속 명령어들, 마이크로코드, 펌웨어 명령어들, 또는 소스 코드 또는 오브젝트 코드일 수 있다. 컴퓨터 판독 가능 프로그램 명령어들은 상태 설정(state-setting) 데이터를 포함할 수 있다. 컴퓨터 판독 가능한 프로그램 명령어들은 전적으로 사용자의 컴퓨터에서, 부분적으로 사용자의 컴퓨터에서, 독립 실행형 소프트웨어 패키지로서, 부분적으로 사용자의 컴퓨터, 부분적으로 원격 컴퓨터에서, 또는 전적으로 원격 컴퓨터 또는 서버에서 실행될 수 있다. 후자의 시나리오에서 원격 컴퓨터는 LAN 또는 WAN을 포함한 임의의 타입의 네트워크를 통해 사용자의 컴퓨터에 연결되거나, 연결은 (예를 들어, 인터넷 서비스 공급자를 사용하여 인터넷을 통해) 외부 컴퓨터에 이루어질 수 있다. 일부 경우에, 예를 들어 프로그래머블 로직 회로, FPGA 또는 PLA를 포함하는 전자 회로는 본 명세서에 설명된 본 발명의 장치의 측면을 수행하기 위하여, 전자 회로를 개인화하기 위해 컴퓨터 판독 가능 프로그램 명령어들의 상태 정보를 이용함으로써 컴퓨터 판독 가능 프로그램 명령어들을 실행할 수 있다.
본 발명의 장치의 특정 측면은 방법, 장치(시스템) 및 컴퓨터 프로그램 제품의 흐름도 예시 및/또는 블록 다이어그램을 참조하여 여기서 설명된다. 흐름도 예시 및/또는 블록 다이어그램의 각 블록, 및 흐름도 예시 및/또는 블록 다이어그램의 블록의 조합은 컴퓨터 판독 가능 프로그램 명령어들, 예를 들어 프로그램 코드에 의해 구현될 수 있음을 이해할 것이다.
이러한 컴퓨터 판독 가능 프로그램 명령어들은 범용 컴퓨터, 특수 목적 컴퓨터 또는 기타 프로그래머블 데이터 처리 장치의 프로세서에 제공되어 머신을 생성하여, 컴퓨터의 프로세서 또는 다른 프로그래머블 데이터 처리 장치를 통해 실행되는 명령어들이 흐름도 및/또는 블록 다이어그램 블록 또는 블록들에 명시된 기능/동작(act)을 구현하기 위한 수단을 생성한다. 이러한 컴퓨터 판독 가능 프로그램 명령어들은 또한 컴퓨터, 프로그래머블 데이터 처리 장치, 및/또는 다른 디바이스가 특정 방식으로 기능하도록 지시할 수 있는 컴퓨터 판독 가능 저장 매체에 저장될 수 있어서, 명령어들이 저장된 컴퓨터 판독 가능 저장 매체는 흐름도 및/또는 블록 다이어그램 블록 또는 블록들에 명시된 동작의 측면을 구현하는 명령어들을 포함하는 제조 물품을 포함한다.
컴퓨터 판독 가능 프로그램 명령어들은 또한 컴퓨터, 다른 프로그래머블 데이터 처리 장치, 또는 다른 디바이스에 로딩되어, 일련의 동작이 컴퓨터, 다른 프로그래머블 장치 또는 다른 디바이스에서 수행되게 하여 컴퓨터 구현 프로세스를 생성할 수 있어서, 컴퓨터, 다른 프로그래머블 장치 또는 다른 디바이스에서 실행되는 명령어들이 흐름도 및/또는 블록 다이어그램 블록 또는 블록들에 명시된 기능/동작을 구현할 수 있다.
도면의 흐름도 및 블록 다이어그램은 본 발명 장치의 다양한 측면에 따른 시스템, 방법 및 컴퓨터 프로그램 제품의 가능한 구현의 아키텍처, 기능 및 동작을 도시한다. 이와 관련하여, 흐름도 또는 블록 다이어그램의 각 블록은 모듈, 세그먼트 또는 명시된 동작을 구현하기 위한 하나 이상의 실행 가능한 명령어를 포함하는 명령어들의 일부를 나타낼 수 있다.
일부 대안적인 구현에서, 블록에 언급된 동작은 도면에 언급된 순서와 다르게 발생할 수 있다. 예를 들어, 연속적으로 도시된 두 개의 블록은 실질적으로 동시에 실행될 수 있거나 관련된 기능에 따라 블록이 때때로 역순으로 실행될 수 있다. 다른 예들에서, 블록들은 일반적으로 증가하는 숫자 순서로 수행될 수 있는 반면, 또 다른 예에서, 하나 이상의 블록은 결과가 저장되고 바로 뒤따르지 않는 후속 또는 다른 블록에서 이용되는 변화하는 순서로 수행될 수 있다. 또한 블록 다이어그램 및/또는 순서도 예시의 각 블록, 블록 다이어그램 및/또는 순서도 예시의 블록의 조합은 명시된 기능 또는 동작을 수행하거나 특수 목적 하드웨어와 컴퓨터 명령어들의 조합을 수행하는 특수 목적 하드웨어 기반 시스템에 의해 구현될 수 있다는 것을 주목할 것이다.
아래 청구범위에서 찾을 수 있는 모든 기능식 청구항(means or step plus function) 요소의 해당 구조, 재료, 동작(act) 및 등가물은 구체적으로 청구된 다른 청구된 요소와 조합하여 기능을 수행하기 위한 임의의 구조, 재료 또는 동작을 포함하도록 의도된다.
방법은 디바이스의 DPE 어레이 내의 구현을 위한 소프트웨어 부분과 디바이스의 PL 내의 구현을 위한 하드웨어 부분을 명시하는 애플리케이션에 대해, 프로세서를 사용하여 애플리케이션을 위한 논리 아키텍처 및 논리 자원을 DPE 어레이와 프로그래머블 로직 사이의 인터페이스 회로 블록의 하드웨어에 매핑하는 것을 명시하는 제1 인터페이스 솔루션을 생성하는 단계를 포함한다. 방법은 논리 아키텍처 및 제1 인터페이스 솔루션에 기반하여 하드웨어 부분의 블록 다이어그램을 구축하는 단계 및 프로세서를 사용하여 블록 다이어그램에 대한 구현 흐름을 수행하는 단계를 포함한다. 방법은 프로세서를 사용하여 DPE 어레이의 하나 이상의 DPE에서의 구현을 위한 애플리케이션의 소프트웨어 부분을 컴파일하는 단계를 포함한다.
다른 양태에서, 블록 다이어그램을 구축하는 것은 프로그래머블 로직 내에서 구현하기 위한 적어도 하나의 IP 코어를 블록 다이어그램에 추가하는 것을 포함한다.
다른 양태에서, 구현 흐름 동안, 하드웨어 컴파일러는 소프트웨어 부분을 컴파일하도록 구성된 DPE 컴파일러와 설계 데이터를 교환함으로써 블록 다이어그램을 구축하고 구현 흐름을 수행한다.
다른 양태에서, 하드웨어 컴파일러는 NoC 컴파일러와 추가 설계 데이터를 교환한다. 하드웨어 컴파일러는 DPE 어레이를 디바이스의 PL에 결합하는 디바이스의 NoC를 통해 라우팅을 구현하도록 구성된 제1 NoC 솔루션을 수신한다.
다른 양태에서, 구현 흐름을 수행하는 것은 교환된 설계 데이터에 기반하여 수행된다.
다른 양태에서, 소프트웨어 부분의 컴파일은 구현 흐름으로부터 생성된 PL에서의 구현을 위한 애플리케이션의 하드웨어 부분의 구현에 기반하여 수행된다.
다른 양태에서, 블록 다이어그램을 구축하고 구현 흐름을 수행하도록 구성된 하드웨어 컴파일러가 블록 다이어그램의 구현이 하드웨어 부분에 대한 설계 메트릭을 충족하지 않는다고 결정하는 것에 응답하여, 인터페이스 회로 블록에 대한 제약을 소프트웨어 부분을 컴파일하도록 구성된 DPE 컴파일러에 제공한다. 하드웨어 컴파일러는 제약에 기반하여 DPE 컴파일러에 의해 생성된 제2 인터페이스 솔루션을 DPE 컴파일러로부터 수신한다.
다른 양태에서, 구현 흐름을 수행하는 것은 제2 인터페이스 솔루션에 기반하여 수행된다.
다른 양태에서, 하드웨어 컴파일러는 블록 다이어그램의 구현이 NoC에 대한 제1 NoC 솔루션을 사용하는 설계 메트릭을 충족하지 않는다는 결정에 응답하여 NoC에 대한 제약을 NoC 컴파일러에 제공한다. 하드웨어 컴파일러는 NoC에 대한 제약을 기반으로 NoC 컴파일러에 의해 생성된 제2 NoC 솔루션을 NoC 컴파일러로부터 수신한다.
시스템은 동작들을 개시하도록 구성된 프로세서를 포함한다. 동작들은 디바이스의 DPE 어레이 내의 구현을 위한 소프트웨어 부분과 디바이스의 PL 내의 구현을 위한 하드웨어 부분을 명시하는 애플리케이션에 대해, 애플리케이션을 위한 논리 아키텍처 및 논리 자원을 DPE 어레이와 PL 사이의 인터페이스 회로 블록의 하드웨어에 매핑하는 것을 명시하는 제1 인터페이스 솔루션을 생성하는 동작을 포함한다. 동작들은 논리 아키텍처 및 제1 인터페이스 솔루션에 기반하여 하드웨어 부분의 블록 다이어그램을 구축하는 동작, 블록 다이어그램에 대한 구현 흐름을 수행하는 동작, 및 DPE 어레이의 하나 이상의 DPE에서의 구현을 위한 애플리케이션의 소프트웨어 부분을 컴파일하는 동작을 포함한다.
다른 양태에서, 블록 다이어그램을 구축하는 것은 PL 내의 구현을 위해 블록 다이어그램에 적어도 하나의 IP 코어를 추가하는 것을 포함한다.
다른 양태에서, 동작들은 구현 흐름 동안, 블록 다이어그램을 구축하고 소프트웨어 부분을 컴파일하도록 구성된 DPE 컴파일러와 설계 데이터를 교환함으로써 구현 흐름을 수행하는 하드웨어 컴파일러를 실행하는 것을 포함한다.
다른 양태에서, 동작들은 하드웨어 컴파일러가 NoC 컴파일러와 추가 설계 데이터를 교환하고 하드웨어 컴파일러가 DPE 어레이를 디바이스의 PL에 결합하는 디바이스의 NoC를 통해 라우팅을 구현하도록 구성된 제1 NoC 솔루션을 수신하는 것을 포함한다.
다른 양태에서, 구현 흐름을 수행하는 것은 교환된 설계 데이터에 기반하여 수행된다.
다른 양태에서, 소프트웨어 부분의 컴파일은 구현 흐름으로부터 생성된 PL에서의 구현을 위한 애플리케이션의 하드웨어 부분에 대한 하드웨어 설계에 기반하여 수행된다.
다른 양태에서, 동작들은 블록 다이어그램을 구축하고 구현 흐름을 수행하도록 구성된 하드웨어 컴파일러가 블록 다이어그램의 구현이 하드웨어 부분에 대한 설계 제약을 충족하지 않는다고 결정하는 것에 응답하여 소프트웨어 부분을 컴파일하도록 구성된 DPE 컴파일러에 인터페이스 회로 블록에 대한 제약을 제공하는 것을 포함한다. 하드웨어 컴파일러는 DPE 컴파일러로부터 제약에 기반하여 DPE 컴파일러에 의해 생성된 제2 인터페이스 솔루션을 수신한다.
다른 양태에서, 구현 흐름을 수행하는 것은 제2 인터페이스 솔루션에 기반하여 수행된다.
다른 양태에서, 하드웨어 컴파일러는 블록 다이어그램의 구현이 NoC에 대한 제1 NoC 솔루션을 사용하는 설계 메트릭을 충족하지 않는다는 결정에 응답하여 NoC에 대한 제약을 NoC 컴파일러에 제공한다. 하드웨어 컴파일러는 NoC에 대한 제약을 기반으로 NoC 컴파일러에 의해 생성된 제2 NoC 솔루션을 NoC 컴파일러로부터 수신한다.
방법은 디바이스의 DPE 어레이에서 구현하기 위한 소프트웨어 부분과 디바이스의 PL에서 구현하기 위한 하드웨어 부분을 가지는 애플리케이션에 대해 하드웨어 컴파일러를 실행하는 프로세서를 사용하여 DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 인터페이스 블록 솔루션에 기반하여 하드웨어 부분에 대한 구현 흐름을 수행하는 단계를 포함한다. 방법은 구현 흐름 동안 설계 메트릭을 충족하지 못하는 것에 대한 응답하여 하드웨어 컴파일러를 실행하는 프로세서를 사용하여 DPE 컴파일러에 인터페이스 블록 제약을 제공하는 단계를 포함한다. 방법은 또한 인터페이스 블록 제약을 수신하는 것에 응답하여 DPE 컴파일러를 실행하는 프로세서를 사용하여 업데이트된 인터페이스 블록 솔루션을 생성하고 DPE 컴파일러로부터 하드웨어 컴파일러로 업데이트된 인터페이스 블록 솔루션을 제공하는 단계를 포함한다.
다른 양태에서, 인터페이스 블록 제약은 소프트웨어 부분에 의해 사용되는 논리 자원을 인터페이스 블록의 물리 자원에 매핑한다.
다른 양태에서, 하드웨어 컴파일러는 업데이트된 인터페이스 블록 솔루션을 사용하여 구현 흐름을 계속한다.
다른 양태에서, 하드웨어 컴파일러는 하드웨어 부분에 대한 설계 제약을 충족하지 않는 것에 응답하여 DPE 컴파일러에 인터페이스 블록 제약을 반복적으로 제공한다.
다른 양태에서, 인터페이스 블록 제약은 하드 제약과 소프트 제약을 포함한다. 그 경우, 방법은 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 DPE 컴파일러가 하드 제약과 소프트 제약을 둘다 사용하여 애플리케이션의 소프트웨어 부분을 라우팅하는 단계를 포함한다.
다른 양태에서, 방법은 하드 제약과 소프트 제약을 둘다 사용하여 업데이트된 인터페이스 블록 솔루션을 생성하는 데 실패한 것에 응답하여 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 하드 제약만을 사용하여 애플리케이션의 소프트웨어 부분을 라우팅하는 단계를 포함한다.
다른 양태에서, 방법은 하드 제약만을 사용하여 업데이트된 매핑을 생성하는 데 실패한 것에 응답하여, 업데이트된 인터페이스 블록 솔루션을 생성하기 위하여, 하드 제약과 소프트 제약을 둘다 사용하여 소프트웨어 부분을 매핑하고, 하드 제약만을 사용하여 소프트웨어 부분을 라우팅하는 단계를 포함한다.
다른 양태에서, 인터페이스 블록 솔루션 및 업데이트된 인터페이스 블록 솔루션 각각이 스코어를 갖고, 방법은 더 업데이트된 인터페이스 블록 솔루션을 얻기 위하여 스코어를 비교하는 단계, 인터페이스 블록 솔루션에 대한 스코어가 업데이트된 인터페이스 블록 솔루션에 대한 스코어를 초과한다고 결정한 것에 응답하여 인터페이스 블록 제약을 완화하는 단계, 및 완화된 인터페이스 블록 제약을 DPE 컴파일러에 제출하는 단계를 포함한다.
다른 양태에서, 인터페이스 블록 솔루션 및 업데이트된 인터페이스 블록 솔루션은 각각 스코어를 가진다. 방법은 스코어를 비교하는 단계, 및 업데이트된 인터페이스 블록 솔루션에 대한 스코어가 인터페이스 블록 솔루션에 대한 스코어를 초과한다고 결정한 것에 응답하여 구현 흐름을 수행하기 위해 업데이트된 인터페이스 블록 솔루션을 사용하는 단계를 포함한다.
시스템은 동작들을 개시하도록 구성된 프로세서를 포함한다. 동작들은 디바이스의 DPE 어레이에서 구현하기 위한 소프트웨어 부분과 디바이스의 PL에서 구현하기 위한 하드웨어 부분을 가지는 애플리케이션에 대해 하드웨어 컴파일러를 사용하여 DPE 어레이를 PL에 결합하는 인터페이스 블록의 하드웨어에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 인터페이스 블록 솔루션에 기반하여 하드웨어 부분에 대한 구현 흐름을 수행하는 동작을 포함한다. 동작들은 구현 흐름 동안 설계 메트릭을 충족하지 못하는 것에 응답하여 하드웨어 컴파일러를 사용하여 DPE 컴파일러에 인터페이스 블록 제약을 제공하는 동작을 포함한다. 동작들은 인터페이스 블록 제약을 수신하는 것에 응답하여, DPE 컴파일러를 사용하여 업데이트된 인터페이스 블록 솔루션을 생성하고 DPE 컴파일러로부터 하드웨어 컴파일러로 업데이트된 인터페이스 블록 솔루션을 제공하는 동작을 더 포함한다.
다른 양태에서, 인터페이스 블록 제약은 소프트웨어 부분에 의해 사용되는 논리 자원을 인터페이스 블록의 물리적 자원에 매핑한다.
다른 양태에서, 하드웨어 컴파일러는 업데이트된 인터페이스 블록 솔루션을 사용하여 구현 흐름을 계속한다.
다른 양태에서, 하드웨어 컴파일러는 하드웨어 부분에 대한 설계 제약을 충족하지 않는 것에 응답하여 DPE 컴파일러에 인터페이스 블록 제약을 반복적으로 제공한다.
다른 양태에서, 인터페이스 블록 제약은 하드 제약과 소프트 제약을 포함한다. 그 경우, 프로세서는 DPE 컴파일러가 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 하드 제약과 소프트 제약을 둘다 사용하여 애플리케이션의 소프트웨어 부분을 라우팅하는 것을 포함하는 동작들을 개시하도록 구성된다.
다른 양태에서, 동작들은 하드 제약과 소프트 제약을 둘다 사용하여 업데이트된 매핑을 생성하는 데 실패한 것에 응답하여, 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 하드 제약만을 사용하여 애플리케이션의 소프트웨어 부분을 라우팅하는 동작을 포함한다.
다른 양태에서, 동작들은 하드 제약만을 사용하여 업데이트된 매핑을 생성하는 데 실패한 것에 응답하여, 업데이트된 인터페이스 블록 솔루션을 생성하기 위하여 하드 제약과 소프트 제약을 둘다 사용하여 소프트웨어 부분을 매핑하고, 하드 제약만을 사용하여 소프트웨어 부분을 라우팅하는 동작을 포함한다.
다른 양태에서, 인터페이스 블록 솔루션 및 업데이트된 인터페이스 블록 솔루션은 각각 스코어를 가진다. 프로세서는 더 업데이트된 인터페이스 블록 솔루션을 얻기 위하여 스코어를 비교하고 인터페이스 블록 솔루션에 대한 스코어가 업데이트된 인터페이스 블록 솔루션에 대한 스코어를 초과한다고 결정하는 것에 응답하여 인터페이스 블록 제약을 완화하고 완화된 인터페이스 블록 제약을 DPE 컴파일러에 제출하는 것을 포함하는 동작을 개시하도록 구성된다.
다른 양태에서, 인터페이스 블록 솔루션 및 업데이트된 인터페이스 블록 솔루션은 각각 스코어를 가진다. 프로세서는, 스코어를 비교하고, 업데이트된 인터페이스 블록 솔루션에 대한 스코어가 인터페이스 블록 솔루션에 대한 스코어를 초과한다고 결정하는 것에 응답하여, 구현 흐름을 수행하기 위해 업데이트된 인터페이스 블록 솔루션을 사용하는 것을 포함하는 동작을 개시하도록 구성된다.
방법은 디바이스의 DPE 어레이 내에서 구현하기 위한 소프트웨어 부분과 디바이스의 PL 내에서 구현하기 위한 HLS 커널을 가지는 하드웨어 부분을 명시하는 애플리케이션에 대해 프로세서를 사용하여 DPE 어레이와 PL을 결합하는 인터페이스 블록의 하드웨어 자원에 소프트웨어 부분에 의해 사용되는 논리 자원을 매핑하는 제1 인터페이스 솔루션을 생성하는 단계를 포함한다. 방법은 프로세서를 사용하여 DPE 어레이에서 구현될 소프트웨어 부분의 노드와 HLS 커널 간의 연결을 명시하는 연결 그래프를 생성하는 단계 및 프로세서를 사용하여 연결 그래프 및 HLS 커널에 기반하여 블록 다이어그램을 생성하는 단계를 포함하고, 여기서 블록 다이어그램은 합성 가능하다. 방법은 프로세서를 사용하여 제1 인터페이스 솔루션에 기반하여 블록 다이어그램에 대한 구현 흐름을 수행하는 단계 및 프로세서를 사용하여 DPE 어레이의 하나 이상의 DPE에서 구현하기 위한 애플리케이션의 소프트웨어 부분을 컴파일하는 단계를 더 포함한다.
다른 양태에서, 블록 다이어그램을 생성하는 단계는 HLS 커널에 대해 HLS를 수행하여 HLS 커널의 합성 가능한 버전을 생성하는 단계 및 HLS 커널의 합성 가능한 버전을 사용하여 블록 다이어그램을 구성하는 단계를 포함한다.
다른 양태에서, HLS 커널의 합성 가능한 버전은 RTL 블록으로서 명시된다.
다른 양태에서, 블록 다이어그램을 생성하는 것은 애플리케이션이 구현될 SoC의 아키텍처의 설명에 기반하여 수행된다.
다른 양태에서, 블록 다이어그램을 생성하는 것은 블록 다이어그램을 베이스 플랫폼과 연결하는 것을 포함한다.
다른 양태에서, 구현 흐름을 수행하는 것은 PL에서의 구현을 위한 블록 다이어그램을 합성하는 것, 및 제1 인터페이스 솔루션에 기반하여 합성된 블록 다이어그램을 배치 및 라우팅하는 것을 포함한다.
다른 양태에서, 방법은 구현 흐름 동안, 블록 다이어그램을 구축하고 소프트웨어 부분을 컴파일하도록 구성된 DPE 컴파일러와 설계 데이터를 교환함으로써 구현 흐름을 수행하는 하드웨어 컴파일러를 실행하는 단계를 포함한다.
다른 양태에서, 방법은 하드웨어 컴파일러가 NoC 컴파일러와 추가 설계 데이터를 교환하고 하드웨어 컴파일러가 DPE 어레이를 디바이스의 PL에 결합하는 디바이스의 NoC를 통해 라우팅을 구현하도록 구성된 제1 NoC 솔루션을 수신하는 단계를 포함한다.
다른 양태에서, 방법은 블록 다이어그램을 구축하고 구현 흐름을 수행하도록 구성된 하드웨어 컴파일러가 블록 다이어그램의 구현이 하드웨어 부분에 대한 설계 메트릭을 충족하지 않는다고 결정하는 것에 응답하여 소프트웨어 부분을 컴파일하도록 구성된 DPE 컴파일러에 인터페이스 회로 블록에 대한 제약을 제공하는 단계를 포함한다. 방법은 또한 하드웨어 컴파일러가 제약에 기반하여 DPE 컴파일러에 의해 생성된 제2 인터페이스 솔루션을 DPE 컴파일러로부터 수신하는 단계를 포함한다.
다른 양태에서, 구현 흐름을 수행하는 것은 제2 인터페이스 솔루션에 기반하여 수행된다.
시스템은 동작들을 개시하도록 구성된 프로세서를 포함한다. 동작들은 디바이스의 DPE 어레이 내에서 구현하기 위한 소프트웨어 부분과 디바이스의 PL 내에서 구현하기 위한 HLS 커널을 가지는 하드웨어 부분을 명시하는 애플리케이션에 대해 소프트웨어 부분에 의해 사용되는 논리 자원을 DPE 어레이와 PL을 결합하는 인터페이스 블록의 하드웨어 자원에 매핑하는 제1 인터페이스 솔루션을 생성하는 동작을 포함한다. 동작들은 DPE 어레이에서 구현될 소프트웨어 부분의 노드 및 HLS 커널 사이의 연결을 명시하는 연결 그래프를 생성하고, 연결 그래프와 HLS 커널에 기반하여 블록 다이어그램을 생성하는 동작을 포함하며, 여기서 블록 다이어그램은 합성 가능하다. 동작들은 제1 인터페이스 솔루션에 기반하여 블록 다이어그램에 대한 구현 흐름을 수행하고 DPE 어레이의 하나 이상의 DPE에서 구현하기 위해 애플리케이션의 소프트웨어 부분을 컴파일하는 동작을 더 포함한다.
다른 양태에서, 블록 다이어그램을 생성하는 것은 HLS 커널에 대해 HLS를 수행하여 HLS 커널의 합성 가능한 버전을 생성하고 HLS 커널의 합성 가능한 버전을 사용하여 블록 다이어그램을 구성하는 것을 포함한다.
다른 양태에서, HLS 커널의 합성 가능한 버전은 RTL 블록으로서 명시된다.
다른 양태에서, 블록 다이어그램을 생성하는 것은 애플리케이션이 구현될 SoC의 아키텍처의 설명에 기반하여 수행된다.
다른 양태에서, 블록 다이어그램을 생성하는 것은 블록 다이어그램을 베이스 플랫폼과 연결하는 것을 포함한다.
다른 양태에서, 구현 흐름을 수행하는 것은 PL에서의 구현을 위한 블록 다이어그램을 합성하고, 제1 인터페이스 솔루션에 기반하여 합성된 블록 다이어그램을 배치 및 라우팅하는 것을 포함한다.
다른 양태에서, 동작들은 구현 흐름 동안, 소프트웨어 부분을 컴파일하도록 구성된 DPE 컴파일러와 설계 데이터를 교환함으로써 블록 다이어그램을 구축하고 구현 흐름을 수행하는 하드웨어 컴파일러를 실행하는 동작을 포함한다.
다른 양태에서, 동작들은 하드웨어 컴파일러가 NoC 컴파일러와 추가 설계 데이터를 교환하고 하드웨어 컴파일러가 DPE 어레이를 디바이스의 PL에 결합하는 디바이스의 NoC를 통해 경로를 구현하도록 구성된 제1 NoC 솔루션을 수신하는 동작을 포함한다.
다른 양태에서, 동작들은 블록 다이어그램을 구축하고 구현 흐름을 수행하도록 구성된 하드웨어 컴파일러가 블록 다이어그램의 구현이 하드웨어 부분에 대한 설계 메트릭을 충족하지 않는다고 결정하는 것에 응답하여 소프트웨어 부분을 컴파일하도록 구성된 DPE 컴파일러에 인터페이스 회로 블록에 대한 제약을 제공하는 것을 포함한다. 방법은 또한 하드웨어 컴파일러가 제약에 기반하여 DPE 컴파일러에 의해 생성된 제2 인터페이스 솔루션을 DPE 컴파일러로부터 수신하는 것을 포함한다.
다른 양태에서, 구현 흐름을 수행하는 것은 제2 인터페이스 솔루션에 기반하여 수행된다.
본 명세서에는 프로그램 코드가 저장된 컴퓨터 판독 가능 저장 매체를 포함하는 하나 이상의 컴퓨터 프로그램 제품이 개시되어 있다. 프로그램 코드는 본 개시 내에서 설명된 다양한 동작을 개시하기 위해 컴퓨터 하드웨어에 의해 실행가능하다.
본 명세서에 제공된 본 발명의 장치에 대한 설명은 예시를 위한 것이며, 개시된 형태 및 예를 완전하게 하거나 제한하도록 의도되지 않는다. 본 명세서에 사용된 용어는 본 발명의 장치의 원리, 실질적인 적용 또는 시장에서 발견되는 기술에 비하여 기술적 개선을 설명하고/하거나 당업자가 본 명세서에 개시된 발명의 장치를 이해할 수 있게 하기 위해 선택되었다. 수정 및 변형은 기술된 발명의 장치의 범위 및 정신을 벗어나지 않고 당업자에게 명백할 수 있다. 따라서, 이러한 특징 및 구현의 범위를 나타내는 것으로서, 전술한 개시보다 다음 청구범위를 참조해야 한다.
예 1은 애플리케이션에서 파생된 논리 아키텍처에 대한 예시적인 스키마를 보여준다.
예 1
{
"$schema": "http://json-schema.org/draft-4/schema#",
"description": "DPE/IPI Logical Architecture Specification",
"id": "LogicalArchSchema-0.1",
"compatible": [ "LogicalArchSchema-0.1" ],
"definitions": {
"ArrayString": {
"type": "array",
"items": { "type": "string" }
},
"LogicalConnection": {
"type": "object",
"properties": {
"type" : { "type" : "string", "enum": [ "stream", "mem", "event" ] },
"direction" : { "type" : "string", "enum": [ "me_to_pl", "pl_to_me", "me_to_noc", "noc_to_me", "noc_to_pl", "pl_to_noc", "noc_to_noc", "pl_to_pl"] },
"srcPort" : {
"type" : "object",
"properties": {
"instName" : { "type" : "string" },
"portName" : { "type" : "string" }
},
"additionalProperties": false,
"required": [ "instName", "portName" ]
},
"dstPorts" : {
"type" : "array",
"items" : {
"type": "object",
"properties": {
"instName" : { "type" : "string" },
"portName" : { "type" : "string" }
},
"additionalProperties": false,
"required": [ "instName", "portName" ]
}
},
"memMode" : { "type" : "string", "enum": [ "read-only", "write-only", "read-write" ] },
"addrType" : { "type" : "string", "enum": [ "virtual", "physical" ] }
},
"additionalProperties": false,
"required": [ "type", "direction", "srcPort", "dstPorts" ]
},
"LogicalPort": {
"type": "object",
"properties": {
"type" : { "type" : "string", "enum": [ "stream", "mem", "event" ] },
"direction" : { "type" : "string", "enum": [ "master", "slave" ] },
"dataWidth" : { "type" : "integer", "minimum" : 1 },
"clkFreq" : { "type" : "double" },
"traceFile" : { "type" : "string" },
"annotation": { "$ref": "#/definitions/ArrayString" },
"hw_annotation": { "type" : "string" },
"sdfioName": { "$ref": "#/definitions/ArrayString" },
"vlnvName" : { "type" : "string" },
"mechannel" : { "type" : "string" }
},
"additionalProperties": false,
"required": [ "type", "direction", "dataWidth", "clkFreq" ]
},
"DPEIP": {
"type": "object",
"properties": {
"vlnvName" : { "type" : "string" },
"annotation": { "type" : "string" },
"hw_annotation": { "type" : "string" },
"meshimPorts" : {
"type" : "object",
"properties" : { "$ref": "#/definitions/LogicalPort" }
}
},
"additionalProperties": false,
"required": [ "meshimPorts", "annotation" ]
},
"NoCIP": {
"type": "object",
"properties": {
"type" : { "type" : "string", "enum": [ "stream", "mem"] },
"vlnvName" : { "type": "string" },
"annotation": { "type" : "string" },
"hw_annotation": { "type" : "string" },
"nocPorts" : {
"type" : "object",
"properties" : { "$ref": "#/definitions/LogicalPort" }
}
},
"additionalProperties": false,
"required": [ "nocPorts", "annotation" ]
},
"PLIP": {
"type": "object",
"properties": {
"ckernelName" : { "type" : "string" },
"sdfinstName" : { "type" : "string" },
"vlnvName" : { "type" : "string" },
"annotation": { "type" : "string" },
"hw_annotation": { "type" : "string" },
"plPorts" : {
"type" : "object",
"properties" : { "$ref": "#/definitions/LogicalPort" }
}
},
"additionalProperties": false,
"required": [ "plPorts", "annotation" ]
}
},
"type": "object",
"properties": {
"appId" : { "type": "string" },
"schema" : { "type": "string" },
"device" : { "type": "string" },
"platform" : { "type": "string" },
"connections" : {
"type": "object",
"properties": { "$ref": "#/definitions/LogicalConnection" },
"minProperties": 0
},
"DPE": {
"type": "object",
"properties": { "$ref": "#/definitions/DPEIP" },
"minProperties": 0
},
"PL": {
"type": "object",
"properties": { "$ref": "#/definitions/PLIP" },
"minProperties": 0
},
"NoC": {
"type": "object",
"properties": { "$ref": "#/definitions/NoCIP" },
"minProperties": 0
}
},
"required": [
"appId"
]
}
예 2는 DPE 어레이(202)에서 구현될 애플리케이션에 대한 SoC 인터페이스 블록 솔루션에 대한 예시적인 스키마를 보여준다.
예 2
{
"$schema": "http://json-schema.org/draft-3/schema#",
"description": "DPE Solution schema",
"id": "DPESolutionSpecification",
"definitions": {},
"type" : "object",
"properties" : {
"version" : { "type" : "string" },
"Placement" : { "type" : "array",
"items" : {
"properties" : {
"LogicalInstance" : {
"type" : "object",
"properties" : {
"InstanceName" : { "type" : "string" },
"PortName" : { "type" : "string" }
}
},
"PhysicalInstance" : {
"type" : "array",
"items" : { "type" : "string" }
},
"IsSoft" : {"type" : "boolean" }
}
}
}
}
}
}
예 3은 NoC(208)에서 구현될 애플리케이션에 대한 NoC 솔루션에 대한 예시적인 스키마를 보여준다.
예 3
{
"$schema": "http://json-schema.org/draft-3/schema#",
"description": "NOC Solution schema",
"id": "SolutionsSchema",
"definitions": {},
"type" : "object",
"properties" : {
"SolutionType" : { "type" : "string" },
"Paths" : {
"type" : "array",
"items" : {
"properties" : {
"Phase" : { "type" : "integer" },
"From" : { "type" : "string" },
"FromLocked" : { "type" : "boolean" },
"To" : { "type" : "string" },
"ToLocked" : { "type" : "boolean" },
"Port" : {"type" : "string"},
"ReadTC" : { "type" : "string", "enum" : ["LL", "BE", "ISOC"] },
"WriteTC" : { "type" : "string", "enum" : ["LL", "BE", "ISOC"] },
"ReadBW" : { "type" : "integer", "minimum" : 0, "maximum" : 19200},
"WriteBW" : { "type" : "integer", "minimum" : 0, "maximum" : 19200},
"ReadAchievedBW" : {"type" : "integer"},
"WriteAchievedBW" : {"type" : "integer"},
"ReadLatency" : { "type" : "integer", "minimum" : 4},
"WriteLatency" : {"type" : "integer", "minimum" : 4},
"ReadBestPossibleLatency" : {"type" : "integer", "minimum" : 4},
"WriteBestPossibleLatency" : {"type" : "integer", "minimum" : 4},
"PathLocked" : { "type" : "boolean" },
"Nets" : {
"type" : "array",
"items" : {
"properties" : {
"PhyInstanceStart": {"type" : "string"},
"PhyInstanceEnd" : {"type" : "string"},
"VC" : {"type" : "integer", "minimum" : 0, "maximum" : 7},
"Connections" : {"type" : "array", "items" : { "type" : "string" } },
"RequiredBW" : {"type" : "integer"},
"AchievedBW" : {"type" : "integer"},
"AchievedLatency" : {"type" : "integer"},
"CommType" : { "type" : "string", "enum" : ["READ", "WRITE", "READ_REQ", "WRITE_RESP"] }
}
}
}
}
}
},
"Components" : {
"type" : "array",
"items" : {
"properties" : {
"Name" : { "type" : "string" },
"TrafficLInst" : { "type" : "string" },
"PortIndex" : { "type" : "integer" },
"DestId" : { "type" : "integer" },
"required" : ["Name", "DestId" ],
"additionalProperties" : false
}
}
}
}
}
}
예 4는 SoC 인터페이스 블록 제약 및/또는 NoC 제약을 명시하기 위한 예시적인 스키마를 보여준다.
예 4
{
"$schema": "http://json-schema.org/draft-3/schema#",
"description": "NOC Constraints schema",
"id": "ConstraintsSpecification",
"definitions": {},
"type" : "object",
"properties" : {
"version" : { "type" : "string" },
"Placement" : { "type" : "array",
"items" : {
"properties" : {
"LogicalInstance" : {"type" : "string"},
"PhysicalInstance" : {"type" : "array", "items" : { "type" : "string" } },
"IsSoft" : {"type" : "boolean" }
}
}
}
}
}
}
예 5는 NoC 트래픽을 명시하기 위한 예시적인 스키마를 보여준다.
예 5
{
"$schema": "http://json-schema.org/draft-7/schema#",
"description": "NOC Traffic Specification Schema",
"id": "TrafficSpecification",
"type": "object",
"definitions": {},
"additionalProperties": false,
"properties" : {
"LogicalInstances" : {
"type" : "array",
"items" : {
"type": "object",
"additionalProperties": false,
"properties" : {
"Name" : { "type" : "string"},
"IsMaster" : { "type" : "boolean"},
"CompType" : { "type" : "string" },
"Ports" : { "type" : "array", "items" : {"type" : "string"}},
"Protocol" : { "type" : "string", "enum" : ["AXI_MM", "AXI_STRM"] },
"SysAddress" : { "type" : "integer" },
"SysAddressSize" : { "type" : "integer" },
"SysAddresses" : {
"type" : "array",
"items" : {
"type":"object",
"additionalProperties": false,
"properties" : {
"Base" : { "type" : "integer" },
"Size" : { "type" : "integer" }
},
"required" : ["Base", "Size" ]
}
},
"AxiDataWidth" : { "type" : "integer" },
"NumReadOutstanding" : { "type" : "integer", "minimum" : 0, "maximum" : 64 },
"NumWriteOutstanding" : { "type" : "integer", "minimum" : 0, "maximum" : 64 },
"ReadRateLimiter" : { "type" : "integer" },
"WriteRateLimiter" : { "type" : "integer" },
"InterleaveSize" : { "type" : "integer" },
"ExternalConn" : { "type" : "string" },
"IsVirtual" : { "type" : "boolean", "default" : false }
},
"required" : ["Name", "CompType", "Protocol"]
}
},
"Paths" : {
"type" : "array",
"items" : {
"type": "object",
"additionalProperties": false,
"properties" : {
"Phase" : { "type" : "integer" },
"From" : { "type" : "string" },
"To" : { "type" : "string" },
"Port" : {"type" : "string"},
"CommType" : { "type" : "string", "enum" : ["MM_ReadWrite", "STRM", "MM_ReadOnly", "MM_WriteOnly"] },
"ReadTC" : { "type" : "string", "enum" : ["LL", "BE", "ISOC"] },
"WriteTC" : { "type" : "string", "enum" : ["LL", "BE", "ISOC"] },
"WriteBurstSize" : { "type" : "integer", "minimum" : 1, "maximum" : 256 },
"ReadBurstSize" : { "type" : "integer", "minimum" : 1, "maximum" : 256 },
"ReadBW" : { "type" : "integer", "minimum" : 0, "maximum" : 19200},
"WriteBW" : { "type" : "integer", "minimum" : 0, "maximum" : 19200},
"ReadLatency" : { "type" : "integer", "minimum" : 0},
"WriteLatency" : {"type" : "integer", "minimum" : 0},
"ReadAvgBurst" : { "type" : "integer", "minimum" : 0},
"WriteAvgBurst" : { "type" : "integer", "minimum" : 0},
"ExclusiveGroup" : {"type" : "string"}
}
}
}
}
}

Claims (15)

  1. 방법에 있어서,
    디바이스의 데이터 처리 엔진(data processing engine, DPE) 어레이에서의 구현을 위한 소프트웨어 부분과 상기 디바이스의 프로그래머블 로직에서의 구현을 위한 하드웨어 부분을 가지는 애플리케이션에 대해, 상기 소프트웨어 부분에 의해 사용되는 논리 자원을 상기 DPE 어레이를 상기 프로그래머블 로직에 결합하는 인터페이스 블록의 하드웨어에 매핑하는 인터페이스 블록 솔루션에 기반하여, 하드웨어 컴파일러를 실행하는 프로세서를 사용하여 상기 하드웨어 부분에 대한 구현 흐름을 수행하는 단계;
    상기 구현 흐름 동안 설계 메트릭을 충족하지 못한 것에 응답하여, 상기 하드웨어 컴파일러를 실행하는 프로세서를 사용하여 DPE 컴파일러에 인터페이스 블록 제약을 제공하는 단계;
    상기 인터페이스 블록 제약을 수신하는 것에 응답하여, 상기 DPE 컴파일러를 실행하는 프로세서를 사용하여 업데이트된 인터페이스 블록 솔루션을 생성하는 단계; 및
    상기 DPE 컴파일러로부터 상기 업데이트된 인터페이스 블록 솔루션을 상기 하드웨어 컴파일러로 제공하는 단계
    를 포함하는 것인, 방법.
  2. 제1항에 있어서,
    상기 하드웨어 컴파일러는 상기 하드웨어 부분에 대한 설계 제약을 충족하지 않는 것에 응답하여 인터페이스 블록 제약을 상기 DPE 컴파일러에 반복적으로 제공하는 것인, 방법.
  3. 제1항에 있어서,
    상기 인터페이스 블록 제약은 하드 제약과 소프트 제약을 포함하고, 상기 방법은:
    상기 DPE 컴파일러가 상기 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 상기 하드 제약과 상기 소프트 제약을 둘다 사용하여 상기 애플리케이션의 소프트웨어 부분을 라우팅하는 단계를 더 포함하는 것인, 방법.
  4. 제3항에 있어서,
    상기 하드 제약과 상기 소프트 제약을 둘다 사용하여 상기 업데이트된 인터페이스 블록 솔루션을 생성하는 데 실패한 것에 응답하여, 상기 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 상기 하드 제약만을 사용하여 상기 애플리케이션의 소프트웨어 부분을 라우팅하는 단계를 더 포함하는 것인, 방법.
  5. 제4항에 있어서,
    상기 하드 제약만을 사용하여 업데이트된 매핑을 생성하는 데 실패한 것에 응답하여, 상기 하드 제약과 상기 소프트 제약을 둘다 사용하여 상기 소프트웨어 부분을 매핑하고, 상기 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 상기 하드 제약만을 사용하여 상기 소프트웨어 부분을 라우팅하는 단계를 더 포함하는 것인, 방법.
  6. 제1항에 있어서,
    상기 인터페이스 블록 솔루션 및 상기 업데이트된 인터페이스 블록 솔루션은 각각 스코어를 가지고, 상기 방법은:
    상기 스코어를 비교하는 단계; 및
    상기 인터페이스 블록 솔루션에 대한 스코어가 상기 업데이트된 인터페이스 블록 솔루션에 대한 스코어를 초과한다고 결정하는 것에 응답하여, 상기 인터페이스 블록 제약을 완화(relax)하고 상기 완화된 인터페이스 블록 제약을 상기 DPE 컴파일러에 제출하여 더 업데이트된 인터페이스 블록 솔루션을 획득하는 단계
    를 더 포함하는 것인, 방법.
  7. 제1항에 있어서,
    상기 인터페이스 블록 솔루션 및 상기 업데이트된 인터페이스 블록 솔루션은 각각 스코어를 가지고, 상기 방법은:
    상기 스코어를 비교하는 단계; 및
    상기 업데이트된 인터페이스 블록 솔루션에 대한 스코어가 상기 인터페이스 블록 솔루션에 대한 스코어를 초과한다고 결정하는 것에 응답하여, 상기 구현 흐름을 수행하기 위해 상기 업데이트된 인터페이스 블록 솔루션을 사용하는 단계
    를 더 포함하는 것인, 방법.
  8. 시스템에 있어서,
    동작들을 개시하도록 구성된 프로세서를 포함하고, 상기 동작들은:
    디바이스의 데이터 처리 엔진(data processing engine, DPE) 어레이에서의 구현을 위한 소프트웨어 부분과 디바이스의 프로그래머블 로직에서의 구현을 위한 하드웨어 부분을 가지는 애플리케이션에 대해, 상기 소프트웨어 부분에 의해 사용되는 논리 자원을 상기 DPE 어레이를 상기 프로그래머블 로직에 결합하는 인터페이스 블록의 하드웨어에 매핑하는 인터페이스 블록 솔루션에 기반하여, 하드웨어 컴파일러를 사용하여 상기 하드웨어 부분에 대한 구현 흐름을 수행하는 동작;
    상기 구현 흐름 동안 설계 메트릭을 충족하지 못한 것에 응답하여, 상기 하드웨어 컴파일러를 사용하여 DPE 컴파일러에 인터페이스 블록 제약을 제공하는 동작;
    상기 인터페이스 블록 제약을 수신하는 것에 응답하여, 상기 DPE 컴파일러를 사용하여 업데이트된 인터페이스 블록 솔루션을 생성하는 동작; 및
    상기 DPE 컴파일러로부터 상기 하드웨어 컴파일러로 상기 업데이트된 인터페이스 블록 솔루션을 제공하는 동작
    을 포함하는 것인, 시스템.
  9. 제8항에 있어서,
    상기 하드웨어 컴파일러는 상기 업데이트된 인터페이스 블록 솔루션을 사용하여 상기 구현 흐름을 계속하는 것인, 시스템.
  10. 제8항에 있어서,
    상기 하드웨어 컴파일러는 상기 하드웨어 부분에 대한 설계 제약을 충족하지 않는 것에 응답하여 인터페이스 블록 제약을 상기 DPE 컴파일러에 반복적으로 제공하는 것인, 시스템.
  11. 제8항에 있어서,
    상기 인터페이스 블록 제약은 하드 제약과 소프트 제약을 포함하고, 상기 프로세서는:
    상기 DPE 컴파일러가 상기 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 상기 하드 제약과 상기 소프트 제약을 둘다 사용하여 상기 애플리케이션의 소프트웨어 부분을 라우팅하는 동작을 포함하는 동작들을 개시하도록 구성되는 것인, 시스템.
  12. 제11항에 있어서,
    상기 프로세서는:
    상기 하드 제약과 상기 소프트 제약을 둘다 사용하여 업데이트된 매핑을 생성하는 데 실패한 것에 응답하여, 상기 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 상기 하드 제약만을 사용하여 상기 애플리케이션의 소프트웨어 부분을 라우팅하는 동작을 더 포함하는 동작들을 개시하도록 구성되는 것인, 시스템.
  13. 제12항에 있어서,
    상기 프로세서는:
    상기 하드 제약만을 사용하여 업데이트된 매핑을 생성하는 데 실패한 것에 응답하여, 상기 하드 제약과 상기 소프트 제약을 둘다 사용하여 상기 소프트웨어 부분을 매핑하고, 상기 업데이트된 인터페이스 블록 솔루션을 생성하기 위해 상기 하드 제약만을 사용하여 상기 소프트웨어 부분을 라우팅하는 동작을 더 포함하는 동작들을 개시하도록 구성되는 것인, 시스템.
  14. 제8항에 있어서,
    상기 인터페이스 블록 솔루션 및 상기 업데이트된 인터페이스 블록 솔루션은 각각 스코어를 가지며, 상기 프로세서는:
    상기 스코어를 비교하는 동작; 및
    상기 인터페이스 블록 솔루션에 대한 스코어가 상기 업데이트된 인터페이스 블록 솔루션에 대한 스코어를 초과한다고 결정하는 것에 응답하여, 상기 인터페이스 블록 제약을 완화하고 상기 완화된 인터페이스 블록 제약을 상기 DPE 컴파일러에 제출하여 더 업데이트된 인터페이스 블록 솔루션을 획득하는 동작
    을 포함하는 동작들을 개시하도록 구성되는 것인, 시스템.
  15. 제8항에 있어서,
    상기 인터페이스 블록 솔루션 및 상기 업데이트된 인터페이스 블록 솔루션은 각각 스코어를 가지며, 상기 프로세서는:
    상기 스코어를 비교하는 동작; 및
    상기 업데이트된 인터페이스 블록 솔루션에 대한 스코어가 상기 인터페이스 블록 솔루션에 대한 스코어를 초과한다고 결정하는 것에 응답하여, 상기 구현 흐름을 수행하기 위해 상기 업데이트된 인터페이스 블록 솔루션을 사용하는 동작
    을 포함하는 동작들을 개시하도록 구성되는 것인, 시스템.
KR1020217034941A 2019-05-23 2020-05-12 헤테로지니어스 프로그래머블 디바이스를 위한 하드웨어-소프트웨어 설계 동안 흐름 수렴 KR20220008809A (ko)

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
US16/421,439 2019-05-23
US16/421,439 US10891132B2 (en) 2019-05-23 2019-05-23 Flow convergence during hardware-software design for heterogeneous and programmable devices
PCT/US2020/032520 WO2020236462A1 (en) 2019-05-23 2020-05-12 Flow convergence during hardware-software design for heterogeneous and programmable devices

Publications (1)

Publication Number Publication Date
KR20220008809A true KR20220008809A (ko) 2022-01-21

Family

ID=70919181

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020217034941A KR20220008809A (ko) 2019-05-23 2020-05-12 헤테로지니어스 프로그래머블 디바이스를 위한 하드웨어-소프트웨어 설계 동안 흐름 수렴

Country Status (6)

Country Link
US (1) US10891132B2 (ko)
EP (1) EP3973380A1 (ko)
JP (1) JP7461380B2 (ko)
KR (1) KR20220008809A (ko)
CN (1) CN113874834A (ko)
WO (1) WO2020236462A1 (ko)

Families Citing this family (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US10802807B1 (en) 2019-05-23 2020-10-13 Xilinx, Inc. Control and reconfiguration of data flow graphs on heterogeneous computing platform
WO2021100122A1 (ja) * 2019-11-19 2021-05-27 三菱電機株式会社 設計支援システムおよび設計支援プログラム
CN111985181B (zh) * 2020-08-25 2023-09-22 北京灵汐科技有限公司 一种节点布局方法、装置、计算机设备及存储介质
US11270051B1 (en) 2020-11-09 2022-03-08 Xilinx, Inc. Model-based design and partitioning for heterogeneous integrated circuits
US11803681B1 (en) * 2021-03-22 2023-10-31 Xilinx, Inc. Wafer-scale large programmable device
US11733980B2 (en) * 2021-12-10 2023-08-22 Xilinx, Inc. Application implementation and buffer allocation for a data processing engine array
CN115081363B (zh) * 2022-08-16 2022-10-25 中国电子科技集团公司信息科学研究院 一种协同公共服务平台

Family Cites Families (117)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US3776137A (en) 1971-09-24 1973-12-04 Aai Corp Projectile and cartridge arrangement
GB8618943D0 (en) 1986-08-02 1986-09-10 Int Computers Ltd Data processing apparatus
US5752035A (en) 1995-04-05 1998-05-12 Xilinx, Inc. Method for compiling and executing programs for reprogrammable instruction set accelerator
US5848264A (en) 1996-10-25 1998-12-08 S3 Incorporated Debug and video queue for multi-processor chip
CA2205797C (en) 1997-05-22 2001-04-24 Andrew Wilfred Macleod A system for local context spilling for graph colouring register allocators
US5966534A (en) 1997-06-27 1999-10-12 Cooke; Laurence H. Method for compiling high level programming languages into an integrated processor with reconfigurable logic
US6195788B1 (en) * 1997-10-17 2001-02-27 Altera Corporation Mapping heterogeneous logic elements in a programmable logic device
US6080204A (en) * 1997-10-27 2000-06-27 Altera Corporation Method and apparatus for contemporaneously compiling an electronic circuit design by contemporaneously bipartitioning the electronic circuit design using parallel processing
US6075935A (en) * 1997-12-01 2000-06-13 Improv Systems, Inc. Method of generating application specific integrated circuits using a programmable hardware architecture
US6091263A (en) 1997-12-12 2000-07-18 Xilinx, Inc. Rapidly reconfigurable FPGA having a multiple region architecture with reconfiguration caches useable as data RAM
EP1138001B1 (en) 1998-11-20 2003-08-27 Altera Corporation Reconfigurable programmable logic device computer system
US6204687B1 (en) 1999-08-13 2001-03-20 Xilinx, Inc. Method and structure for configuring FPGAS
US6526557B1 (en) 2000-07-25 2003-02-25 Xilinx, Inc. Architecture and method for partially reconfiguring an FPGA
US20020159466A1 (en) 2001-02-14 2002-10-31 John Rhoades Lookup engine
US6836842B1 (en) 2001-04-24 2004-12-28 Xilinx, Inc. Method of partial reconfiguration of a PLD in which only updated portions of configuration data are selected for reconfiguring the PLD
US6462579B1 (en) 2001-04-26 2002-10-08 Xilinx, Inc. Partial reconfiguration of a programmable gate array using a bus macro
US7996827B2 (en) 2001-08-16 2011-08-09 Martin Vorbach Method for the translation of programs for reconfigurable architectures
US7420392B2 (en) 2001-09-28 2008-09-02 Xilinx, Inc. Programmable gate array and embedded circuitry initialization and processing
US6781407B2 (en) 2002-01-09 2004-08-24 Xilinx, Inc. FPGA and embedded circuitry initialization and processing
US6759869B1 (en) 2002-06-05 2004-07-06 Xilinx, Inc. Large crossbar switch implemented in FPGA
US6810514B1 (en) 2002-07-03 2004-10-26 Xilinx, Inc. Controller arrangement for partial reconfiguration of a programmable logic device
US7080283B1 (en) 2002-10-15 2006-07-18 Tensilica, Inc. Simultaneous real-time trace and debug for multiple processing core systems on a chip
US6907595B2 (en) 2002-12-13 2005-06-14 Xilinx, Inc. Partial reconfiguration of a programmable logic device using an on-chip processor
US7149829B2 (en) 2003-04-18 2006-12-12 Sonics, Inc. Various methods and apparatuses for arbitration among blocks of functionality
US8020163B2 (en) 2003-06-02 2011-09-13 Interuniversitair Microelektronica Centrum (Imec) Heterogeneous multiprocessor network on chip devices, methods and operating systems for control thereof
US7124338B1 (en) 2003-10-10 2006-10-17 Xilinx, Inc. Methods of testing interconnect lines in programmable logic devices using partial reconfiguration
US7653820B1 (en) 2003-10-31 2010-01-26 Xilinx, Inc. System and method for securing using decryption keys during FPGA configuration using a microcontroller
US7185309B1 (en) 2004-01-30 2007-02-27 Xilinx, Inc. Method and apparatus for application-specific programmable memory architecture and interconnection network on a chip
US7328335B1 (en) 2004-10-01 2008-02-05 Xilinx, Inc. Bootable programmable logic device for internal decoding of encoded configuration data
US7689726B1 (en) 2004-10-01 2010-03-30 Xilinx, Inc. Bootable integrated circuit device for readback encoding of configuration data
US7224184B1 (en) 2004-11-05 2007-05-29 Xilinx, Inc. High bandwidth reconfigurable on-chip network for reconfigurable systems
US7394288B1 (en) 2004-12-13 2008-07-01 Massachusetts Institute Of Technology Transferring data in a parallel processing environment
US7281093B1 (en) 2004-12-21 2007-10-09 Xilinx, Inc. Memory apparatus for a message processing system and method of providing same
US7199608B1 (en) 2005-02-17 2007-04-03 Xilinx, Inc. Programmable logic device and method of configuration
US7380035B1 (en) 2005-03-24 2008-05-27 Xilinx, Inc. Soft injection rate control for buses or network-on-chip with TDMA capability
US7788625B1 (en) 2005-04-14 2010-08-31 Xilinx, Inc. Method and apparatus for precharacterizing systems for use in system level design of integrated circuits
US7418690B1 (en) * 2005-04-29 2008-08-26 Altera Corporation Local searching techniques for technology mapping
US7301822B1 (en) 2005-05-18 2007-11-27 Xilinx, Inc. Multi-boot configuration of programmable devices
US7587612B2 (en) 2005-06-30 2009-09-08 Intel Corporation Generating and communicating information on locations of program sections in memory
US7509617B1 (en) 2005-09-12 2009-03-24 Xilinx, Inc. Design methodology to support relocatable bit streams for dynamic partial reconfiguration of FPGAs to reduce bit stream memory requirements
US7546572B1 (en) 2005-09-20 2009-06-09 Xilinx, Inc. Shared memory interface in a programmable logic device using partial reconfiguration
US7302625B1 (en) 2005-11-21 2007-11-27 Xilinx, Inc. Built-in self test (BIST) technology for testing field programmable gate arrays (FPGAs) using partial reconfiguration
US7477072B1 (en) 2006-01-17 2009-01-13 Xilinx, Inc. Circuit for and method of enabling partial reconfiguration of a device having programmable logic
US7454658B1 (en) 2006-02-10 2008-11-18 Xilinx, Inc. In-system signal analysis using a programmable logic device
US7650248B1 (en) 2006-02-10 2010-01-19 Xilinx, Inc. Integrated circuit for in-system signal monitoring
JP2007286671A (ja) 2006-04-12 2007-11-01 Fujitsu Ltd ソフトウェア／ハードウェア分割プログラム、および分割方法。
US7640527B1 (en) 2006-06-29 2009-12-29 Xilinx, Inc. Method and apparatus for partial reconfiguration circuit design for a programmable device
US7478357B1 (en) 2006-08-14 2009-01-13 Xilinx, Inc. Versatile bus interface macro for dynamically reconfigurable designs
US7831801B1 (en) 2006-08-30 2010-11-09 Xilinx, Inc. Direct memory access-based multi-processor array
US7636816B2 (en) 2006-09-29 2009-12-22 Broadcom Corporation Global address space management
US7506298B1 (en) * 2006-12-19 2009-03-17 Xilinx, Inc. Methods of mapping a logical memory representation to physical memory in a programmable logic device
US7521961B1 (en) 2007-01-23 2009-04-21 Xilinx, Inc. Method and system for partially reconfigurable switch
US7724815B1 (en) 2007-02-27 2010-05-25 Xilinx, Inc. Method and apparatus for a programmably terminated receiver
US7500060B1 (en) 2007-03-16 2009-03-03 Xilinx, Inc. Hardware stack structure using programmable logic
US7518396B1 (en) 2007-06-25 2009-04-14 Xilinx, Inc. Apparatus and method for reconfiguring a programmable logic device
US9495290B2 (en) 2007-06-25 2016-11-15 Sonics, Inc. Various methods and apparatus to support outstanding requests to multiple targets while maintaining transaction ordering
US7576561B1 (en) 2007-11-13 2009-08-18 Xilinx, Inc. Device and method of configuring a device having programmable logic
US8250342B1 (en) 2008-01-09 2012-08-21 Xilinx, Inc. Digital signal processing engine
US7746099B1 (en) 2008-01-11 2010-06-29 Xilinx, Inc. Method of and system for implementing a circuit in a device having programmable logic
US8006021B1 (en) 2008-03-27 2011-08-23 Xilinx, Inc. Processor local bus bridge for an embedded processor block core in an integrated circuit
US8370776B1 (en) * 2008-06-13 2013-02-05 Altera Corporation Method and apparatus for compiling intellectual property systems design cores using an incremental compile design flow
US8045546B1 (en) 2008-07-08 2011-10-25 Tilera Corporation Configuring routing in mesh networks
US8214694B1 (en) 2009-03-12 2012-07-03 Xilinx, Inc. Lightweight probe and data collection within an integrated circuit
CN102369601B (zh) 2009-03-30 2015-04-29 三洋电机株式会社 太阳能电池
US8289960B2 (en) 2009-06-22 2012-10-16 Citrix Systems, Inc. Systems and methods for N-core tracing
US8359448B1 (en) 2009-07-17 2013-01-22 Xilinx, Inc. Specific memory controller implemented using reconfiguration
WO2011079942A1 (en) 2009-12-28 2011-07-07 Hyperion Core, Inc. Optimisation of loops and data flow sections
US8719808B1 (en) 2010-01-27 2014-05-06 Altera Corporation Method and apparatus for using object files to provide reliable program operation
WO2011099972A1 (en) 2010-02-11 2011-08-18 Hewlett-Packard Company, L. P. Executable identity based file access
US9134976B1 (en) 2010-12-13 2015-09-15 Reservoir Labs, Inc. Cross-format analysis of software systems
US8415974B1 (en) 2011-03-09 2013-04-09 Xilinx, Inc. Methods and circuits enabling dynamic reconfiguration
US9081896B1 (en) 2012-03-21 2015-07-14 Amazon Technologies, Inc. Generating a replacement binary for emulation of an application
US9286221B1 (en) 2012-06-06 2016-03-15 Reniac, Inc. Heterogeneous memory system
US9134981B2 (en) * 2012-06-22 2015-09-15 Altera Corporation OpenCL compilation
US9479456B2 (en) 2012-11-02 2016-10-25 Altera Corporation Programmable logic device with integrated network-on-chip
US9081634B1 (en) 2012-11-09 2015-07-14 Xilinx, Inc. Digital signal processing block
US8719750B1 (en) 2012-11-12 2014-05-06 Xilinx, Inc. Placement and routing of a circuit design
US10558437B1 (en) 2013-01-22 2020-02-11 Altera Corporation Method and apparatus for performing profile guided optimization for high-level synthesis
US9230112B1 (en) 2013-02-23 2016-01-05 Xilinx, Inc. Secured booting of a field programmable system-on-chip including authentication of a first stage boot loader to mitigate against differential power analysis
US8928351B1 (en) 2013-03-13 2015-01-06 Xilinx, Inc. Emulating power domains in an integrated circuit using partial reconfiguration
US9336010B2 (en) 2013-03-15 2016-05-10 Xilinx, Inc. Multi-boot or fallback boot of a system-on-chip using a file-based boot device
US9165143B1 (en) 2013-03-15 2015-10-20 Xilinx, Inc. Image file generation and loading
US9304986B1 (en) 2013-06-18 2016-04-05 Altera Corporation Methods and systems to automatically connect with interfaces
US9152794B1 (en) 2013-09-05 2015-10-06 Xilinx, Inc. Secure key handling for authentication of software for a system-on-chip
US20150109024A1 (en) 2013-10-22 2015-04-23 Vaughn Timothy Betz Field Programmable Gate-Array with Embedded Network-on-Chip Hardware and Design Flow
US9411688B1 (en) 2013-12-11 2016-08-09 Xilinx, Inc. System and method for searching multiple boot devices for boot images
US9686358B2 (en) 2014-01-22 2017-06-20 Alcatel Lucent Devices and methods for network-coded and caching-aided content distribution
US9652410B1 (en) 2014-05-15 2017-05-16 Xilinx, Inc. Automated modification of configuration settings of an integrated circuit
US9436785B1 (en) 2014-09-19 2016-09-06 Xilinx, Inc. Hierarchical preset and rule based configuration of a system-on-chip
US9652252B1 (en) 2014-10-29 2017-05-16 Xilinx, Inc. System and method for power based selection of boot images
US9147024B1 (en) 2014-11-06 2015-09-29 Xilinx, Inc. Hardware and software cosynthesis performance estimation
WO2016077393A1 (en) 2014-11-12 2016-05-19 Xilinx, Inc. Heterogeneous multiprocessor program compilation targeting programmable integrated circuits
US9218443B1 (en) 2014-11-12 2015-12-22 Xilinx, Inc. Heterogeneous multiprocessor program compilation targeting programmable integrated circuits
US9223921B1 (en) 2014-11-13 2015-12-29 Xilinx, Inc. Compilation of HLL code with hardware accelerated functions
US9323876B1 (en) 2014-11-24 2016-04-26 Xilinx, Inc. Integrated circuit pre-boot metadata transfer
US10089259B2 (en) 2015-07-21 2018-10-02 BigStream Solutions, Inc. Precise, efficient, and transparent transfer of execution between an auto-generated in-line accelerator and processor(s)
US9864828B1 (en) 2015-09-17 2018-01-09 Xilinx, Inc. Hardware acceleration device handoff for using programmable integrated circuits as hardware accelerators
US10180850B1 (en) 2015-11-03 2019-01-15 Xilinx, Inc. Emulating applications that use hardware acceleration
CN105429909B (zh) 2015-12-31 2018-11-20 上海交通大学 一种基于复色的并行交换调度方法
US20170220499A1 (en) 2016-01-04 2017-08-03 Gray Research LLC Massively parallel computer, accelerated computing clusters, and two-dimensional router and interconnection network for field programmable gate arrays, and applications
US9946674B2 (en) 2016-04-28 2018-04-17 Infineon Technologies Ag Scalable multi-core system-on-chip architecture on multiple dice for high end microcontroller
US9977663B2 (en) 2016-07-01 2018-05-22 Intel Corporation Technologies for optimizing sparse matrix code with field-programmable gate arrays
US10243882B1 (en) 2017-04-13 2019-03-26 Xilinx, Inc. Network on chip switch interconnect
US10402176B2 (en) 2017-12-27 2019-09-03 Intel Corporation Methods and apparatus to compile code to generate data flow code
US11003471B2 (en) 2018-01-26 2021-05-11 Vmware, Inc. Just-in-time hardware for field programmable gate arrays
US10673745B2 (en) 2018-02-01 2020-06-02 Xilinx, Inc. End-to-end quality-of-service in a network-on-chip
US10503690B2 (en) 2018-02-23 2019-12-10 Xilinx, Inc. Programmable NOC compatible with multiple interface communication protocol
US10621129B2 (en) 2018-03-27 2020-04-14 Xilinx, Inc. Peripheral interconnect for configurable slave endpoint circuits
US10866753B2 (en) 2018-04-03 2020-12-15 Xilinx, Inc. Data processing engine arrangement in a device
US10747690B2 (en) 2018-04-03 2020-08-18 Xilinx, Inc. Device with data processing engine array
US10635622B2 (en) 2018-04-03 2020-04-28 Xilinx, Inc. System-on-chip interface architecture
US11500674B2 (en) 2018-06-26 2022-11-15 Intel Corporation Circuitry with adaptive memory assistance capabilities
US10635419B2 (en) 2018-07-13 2020-04-28 Fungible, Inc. Incremental compilation of finite automata for a regular expression accelerator
US10833679B2 (en) 2018-12-28 2020-11-10 Intel Corporation Multi-purpose interface for configuration data and user fabric data
US10642946B2 (en) 2018-12-28 2020-05-05 Intel Corporation Modular periphery tile for integrated circuit device
US11036660B2 (en) 2019-03-28 2021-06-15 Intel Corporation Network-on-chip for inter-die and intra-die communication in modularized integrated circuit devices
US11062070B2 (en) 2019-03-28 2021-07-13 Intel Corporation Die to die interconnect structure for modularized integrated circuit devices

Also Published As

Publication number Publication date
JP2022533828A (ja) 2022-07-26
CN113874834A (zh) 2021-12-31
US10891132B2 (en) 2021-01-12
JP7461380B2 (ja) 2024-04-03
US20200371787A1 (en) 2020-11-26
WO2020236462A1 (en) 2020-11-26
EP3973380A1 (en) 2022-03-30

Similar Documents

Publication Publication Date Title
JP7465895B2 (ja) ヘテロジニアスプログラマブルデバイスのための高位合成を有するハードウェアソフトウェア設計フロー
US10891132B2 (en) Flow convergence during hardware-software design for heterogeneous and programmable devices
US10891414B2 (en) Hardware-software design flow for heterogeneous and programmable devices
US7987086B2 (en) Software entity for the creation of a hybrid cycle simulation model
US10628622B1 (en) Stream FIFO insertion in a compilation flow for a heterogeneous multi-core architecture
US7849441B2 (en) Method for specifying stateful, transaction-oriented systems for flexible mapping to structurally configurable, in-memory processing semiconductor device
US10289785B1 (en) Platform architecture creation for a system-on-chip
US10977018B1 (en) Development environment for heterogeneous devices
US10783295B1 (en) Netlist partitioning for designs targeting a data processing engine array
CN113906428A (zh) 异构多核心架构的编译流程
US10853541B1 (en) Data processing engine (DPE) array global mapping
Saldana et al. MPI as an abstraction for software-hardware interaction for HPRCs
US11301295B1 (en) Implementing an application specified as a data flow graph in an array of data processing engines
US10963615B1 (en) Data processing engine (DPE) array routing
US10839121B1 (en) Data processing engine (DPE) array detailed mapping
US11474826B1 (en) Boot image file having a global partition for data processing engines of a programmable device
Shin et al. Automatic network generation for system-on-chip communication design
Li High-Performance FPGA-accelerated Chiplet Modeling
Masing Prototyping Methodologies and Design of Communication-centric Heterogeneous Many-core Architectures
Aylward et al. Reconfigurable systems and flexible programming for hardware design, verification and software enablement for system-on-a-chip architectures
Chang et al. Exploring Field-Programmable Gate Array (FPGA)-Based Emulation Technologies for Accelerating Computer Architecture Development and Evaluation
Kim Computation Model Based Automatic Design Space Exploration
Ariño Alegre Design and implementation of an ARMv4 tightly coupled multicore in VHDL and validation on a FPGA