KR102204282B1 - 다수의 기능 유닛을 가지는 프로세서를 위한 루프 스케쥴링 방법 - Google Patents

다수의 기능 유닛을 가지는 프로세서를 위한 루프 스케쥴링 방법 Download PDF

Info

Publication number
KR102204282B1
KR102204282B1 KR1020130143552A KR20130143552A KR102204282B1 KR 102204282 B1 KR102204282 B1 KR 102204282B1 KR 1020130143552 A KR1020130143552 A KR 1020130143552A KR 20130143552 A KR20130143552 A KR 20130143552A KR 102204282 B1 KR102204282 B1 KR 102204282B1
Authority
KR
South Korea
Prior art keywords
loop
scheduling
priority
instructions
execution units
Prior art date
Application number
KR1020130143552A
Other languages
English (en)
Other versions
KR20150059894A (ko
Inventor
이연복
박영환
양호
케샤바 프라사드
Original Assignee
삼성전자주식회사
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 삼성전자주식회사 filed Critical 삼성전자주식회사
Priority to KR1020130143552A priority Critical patent/KR102204282B1/ko
Priority to US14/330,675 priority patent/US9292287B2/en
Priority to EP14193967.8A priority patent/EP2876555B1/en
Priority to CN201410678024.2A priority patent/CN104657210B/zh
Publication of KR20150059894A publication Critical patent/KR20150059894A/ko
Application granted granted Critical
Publication of KR102204282B1 publication Critical patent/KR102204282B1/ko

Links

Images

Classifications

    • 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/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • 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
    • G06F9/30065—Loop control instructions; iterative instructions, e.g. LOOP, REPEAT
    • 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
    • G06F8/44—Encoding
    • G06F8/445—Exploiting fine grain parallelism, i.e. parallelism at instruction level
    • G06F8/4452—Software pipelining
    • 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
    • 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/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • 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/38—Concurrent instruction execution, e.g. pipeline or look ahead
    • G06F9/3836—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution
    • G06F9/3851—Instruction issuing, e.g. dynamic instruction scheduling or out of order instruction execution from multiple instruction streams, e.g. multistreaming
    • 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
    • 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/48—Program initiating; Program switching, e.g. by interrupt
    • G06F9/4806—Task transfer initiation or dispatching
    • G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
    • G06F9/4881—Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues
    • Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
    • Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
    • Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
    • Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management

Landscapes

  • Engineering & Computer Science (AREA)
  • Software Systems (AREA)
  • Theoretical Computer Science (AREA)
  • General Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Multimedia (AREA)
  • Devices For Executing Special Programs (AREA)
  • Data Exchanges In Wide-Area Networks (AREA)

Abstract

루프 스케쥴링 방법이 개시된다. 실시예들은 복수의 실행 유닛들을 이용하여 제1 루프를 스케쥴하고, 제1 루프의 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 제2 루프를 스케쥴할 수 있다. 제 n 루프 (n>2) 이하의 경우도 n-1번째 루프의 결과를 이용하여 n-1 번째 루프와 동일한 방법으로 스케쥴할 수 있다.

Description

다수의 기능 유닛을 가지는 프로세서를 위한 루프 스케쥴링 방법{METHOD OF SCHEDULING LOOPS FOR PROCESSOR HAVING A PLURALITY OF FUNTIONAL UNITS}
아래 실시예들은 루프 스케쥴링 방법에 관한 것이다.
매우 긴 명령어 워드(Very Long Instruction Word; VLIW) 구조 또는 코어스-그레인드 리컨피규어블 어레이(Coarse-Grained Reconfigurable Array; CGRA) 구조의 프로세서는 다수의 기능성 유닛(Functional Unit; FU)들을 사용한다. FU들은 데이터-패스(data-path)에 의해 연결된다.
프로세서 내의 FU들 및 데이터-패스들의 구성 있어서, 무수히 많은 조합이 가능하다. 최대의 성능을 위한 디자인으로서, 모든 FU가 모든 명령어들을 처리할 수 있게 구성될 수 있고, 데이터-패스들이 모든 FU들을 서로 간에 연결하게 구성될 수 있다. 데이터-패스의 비트-넓이(bit-width) 프로세서가 지원하는 벡터(data) 데이터 타입(type) 중 가장 큰 비트-넓이일 수 있다.
일 측에 따른 루프 스케쥴링 방법은 복수의 실행 유닛들을 이용하여 적어도 하나의 선순위 루프를 스케쥴하는 단계; 및 상기 적어도 하나의 선순위 루프의 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 후순위 루프를 스케쥴하는 단계를 포함한다.
이 때, 상기 적어도 하나의 선순위 루프를 스케쥴하는 단계는 상기 복수의 실행 유닛들을 이용하여 최우선순위 루프를 스케쥴하는 단계를 포함할 수 있다.
또한, 상기 후순위 루프를 스케쥴하는 단계는 상기 적어도 하나의 선순위 루프가 스케쥴된 복수의 사이클들에서, 상기 적어도 하나의 선순위 루프를 위해 할당되지 않은 실행 유닛들을 이용하여 상기 후순위 루프의 적어도 일부를 스케쥴하는 단계를 포함할 수 있다.
또한, 상기 적어도 하나의 선순위 루프를 스케쥴하는 단계는 소스 코드에 포함된 복수의 루프들 중 서로 독립적인 적어도 두 개의 루프들을 선택하는 단계; 및 상기 적어도 두 개의 루프들의 우선순위들을 결정하는 단계를 포함할 수 있다.
또한, 상기 적어도 하나의 선순위 루프의 우선순위는 상기 후순위 루프의 우선순위보다 높고, 루프의 우선순위는 루프의 반복 횟수 및 루프의 단일 반복을 위한 사이클 수 중 적어도 하나에 기초하여 계산될 수 있다.
또한, 상기 후순위 루프를 스케쥴하는 단계는 상기 후순위 루프에 포함된 복수의 명령어들 사이의 데이터 의존 관계에 기초하여 상기 복수의 명령어들을 상기 적어도 하나의 선순위 루프가 스케쥴된 복수의 사이클들에서 상기 이용 가능한 실행 유닛들에 할당하는 단계를 포함할 수 있다.
또한, 상기 후순위 루프를 스케쥴하는 단계는 상기 후순위 루프를 스케쥴하기 위한 실행 유닛을 결정하는 단계; 및 상기 적어도 하나의 선순위 루프가 스케쥴된 사이클에서 상기 결정된 실행 유닛이 이용 가능한지 여부를 판단하는 단계를 포함할 수 있다.
또한, 상기 적어도 하나의 선순위 루프를 스케쥴하는 단계는 최우선순위 루프에 포함된 복수의 명령어들 사이의 데이터 의존 관계에 기초하여 상기 복수의 명령어들을 복수의 사이클들에서 상기 복수의 실행 유닛들에 할당하는 단계를 포함할 수 있다.
또한, 상기 루프 스케쥴링 방법은 상기 후순위 루프가 상기 이용 가능한 실행 유닛들을 이용하여 스케쥴되지 않는 경우, 상기 적어도 하나의 선순위 루프의 스케쥴 결과를 언롤링하는 단계; 및 상기 언롤링된 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 상기 후순위 루프를 스케쥴하는 단계를 더 포함할 수 있다.
또한, 상기 언롤링하는 단계는 언롤링 횟수에 대한 임계값 및 상기 언롤링된 스케쥴 결과의 사이클수에 대한 임계값 중 적어도 하나에 기초하여, 상기 적어도 하나의 선순위 루프의 스케쥴 결과를 언롤링할지 여부를 결정하는 단계를 포함할 수 있다.
또한, 상기 후순위 루프를 스케쥴하는 단계는 상기 적어도 하나의 선순위 루프의 반복 횟수가 상기 후순위 루프의 반복 횟수보다 큰 경우, 프레디케이션 가딩을 이용하여 상기 후순위 루프의 반복이 완료된 이후 상기 후순위 루프가 실행되는 것을 제한하는 단계를 포함할 수 있다.
또한, 상기 루프 스케쥴링 방법은 상기 적어도 하나의 선순위 루프의 반복 횟수가 상기 후순위 루프의 반복 횟수보다 작은 경우, 상기 적어도 하나의 선순위 루프의 반복이 완료된 이후 상기 후순위 루프의 나머지 반복이 수행되도록 상기 후순위 루프를 추가로 스케쥴하는 단계를 더 포함할 수 있다.
또한, 상기 루프 스케쥴링 방법은 상기 적어도 하나의 선순위 루프의 반복이 완료된 이후 상기 후순위 루프의 중간 데이터를 저장하는 명령어를 추가로 스케쥴하는 단계를 더 포함할 수 있다.
또한, 상기 복수의 실행 유닛들은 코어스-그레인드 리콘피규어블 어레이(Coarse-Grained Reconfigurable Array; CGRA) 혹은 VLIW(Very Long Instruction Word) 프로세서에 포함될 수 있다.
또한, 상기 복수의 실행 유닛들은 스칼라 데이터 연산을 처리하는 스칼라 기능성 유닛(Functional Unit; FU); 스칼라 데이터와 벡터 데이터 사이의 변환을 처리하는 팩/언팩 FU; 벡터 데이터의 로드 및 스토어를 처리하는 벡터 로드/스토어 FU; 및 벡터 데이터의 연산을 처리하는 벡터 FU를 포함할 수 있다.
다른 일 측에 따른 루프 스케쥴링 방법은 복수의 실행 유닛들을 이용하여 제1 루프(loop)를 스케쥴하는 단계; 및 상기 제1 루프의 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 제2 루프를 스케쥴하는 단계를 포함한다.
또 다른 일 측에 따른 컴파일링 장치는 하나 또는 그 이상의 프로그램을 실행하는 하나 또는 그 이상의 프로세서들; 및 상기 하나 또는 그 이상의 프로그램들을 컴파일 혹은 스케쥴링 하는 컴파일러 혹은 스케쥴러; 및 상기 하나 또는 그 이상의 프로그램의 컴파일 혹은 스케쥴된 결과를 포함하는 목적코드가 저장되는 메모리를 포함하고, 상기 컴파일러 혹은 스케쥴러는 소스코드에 포함된 복수의 루프들 중 서로 독립적인 두 개의 루프들을 선택하는 명령어들, 상기 두 개의 루프들 중 우선순위가 높은 제 1 루프와 우선순위가 낮은 제 2 루프를 결정하는 명령어들; 복수의 실행 유닛들을 이용하여 상기 제 1 루프를 스케쥴하는 명령어들; 제 1 루프의 스케쥴 결과에 따른 이용가능한 실행 유닛들을 이용하여 제 2 루프를 스케쥴하는 명령어들; 및 상기 제 1 루프의 스케쥴 결과 및 상기 제 2 루프의 스케쥴 결과를 포함하는 목적 코드를 생성하는 명령어들을 포함한다.
또 다른 일 측에 따른 컴파일링 장치는 하나 또는 그 이상의 프로그램들을 실행하는 하나 또는 그 이상의 프로세서들; 및 상기 하나 또는 그 이상의 프로그램들이 저장된 메모리를 포함한다. 여기서, 상기 하나 또는 그 이상의 프로그램들은 소스 코드에 포함된 복수의 루프들 중 서로 독립적인 두 개, 혹은 그 이상의 루프들을 선택하는 명령어들; 상기 두 개의 루프들 중 우선순위가 높은 제1 루프와 우선순위가 낮은 제2 루프 혹은 그 이하의 우선순위의 루프를 결정하는 명령어들; 복수의 실행 유닛들을 이용하여 상기 제1 루프를 스케쥴하는 명령어들; 제1 루프의 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 제2 루프 혹은 그 이하의 우선순위의 루프를 스케쥴하는 명령어들; 및 상기 제1 루프의 스케쥴 결과 및 상기 제2 루프 혹은 그 이하의 우선순위의 루프의 스케쥴 결과를 포함하는 목적 코드를 생성하는 명령어들을 포함한다.
도 1은 일 실시예에 따른 루프 스케쥴링 방법을 나타낸 동작 흐름도.
도 2a 및 도 2b는 일 실시예에 따른 제1 루프와 제2 루프가 스케쥴된 결과를 설명하는 도면.
도 3a 및 도 3b는 단일 루프를 스케쥴하는 실시예를 설명하는 도면.
도 4a 내지 도 4f는 제1 루프와 제2 루프를 스케쥴하는 실시예를 설명하는 도면.
도 5 및 도 6은 제1 루프의 스케쥴 결과를 언롤링하여 제2 루프를 스케쥴하는 실시예들을 나타낸 동작 흐름도.
도 7 내지 도 12는 실시예들에 따른 최적화 대상 아키텍처(architecture)를 설명하는 도면.
이하, 실시예들을 첨부된 도면을 참조하여 상세하게 설명한다.
도 1은 일 실시예에 따른 루프 스케쥴링 방법을 나타낸 동작 흐름도이다. 도 1을 참조하면, 일 실시예에 따른 루프 스케쥴링 방법은 제1 루프(loop)를 스케쥴하는 단계(110)와 제2 루프를 스케쥴하는 단계(120)를 포함한다. 단계(110)에서 제1 루프는 복수의 실행 유닛들을 이용하여 스케쥴될 수 있다. 각각의 실행 유닛은 명령어(instruction)를 실행하는 유닛으로, 예를 들어 VLIW 구조 또는 CGRA 구조의 프로세서에 포함된 기능성 유닛일 수 있다. 단계(110)에서 제1 루프에 포함된 복수의 명령어들은 복수의 실행 유닛들에 할당될 수 있다. 복수의 실행 유닛들에 관한 보다 상세한 사항들은 도 7 내지 도 12를 참조하여 후술한다. 단계(120)에서 제2 루프는 제1 루프의 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 스케쥴될 수 있다. 단계(120)에서 제2 루프에 포함된 복수의 명령어들은 제1 루프의 스케쥴 결과 이용되지 않은 실행 유닛들을 이용하여 스케쥴될 수 있다.
실시예들은 두 개의 루프들을 스케쥴하는 경우뿐 아니라 셋 이상의 루프들을 스케쥴하는 경우에도 적용될 수 있다. 예를 들어, 실시예들은 제1 루프를 우선적으로 스케쥴한 뒤, 남는 HW 자원을 이용하여 제2 루프를 스케쥴할 수 있다. 나아가, 실시예들은 제1 루프 및 제2 루프의 스케쥴 결과 남는 HW 자원을 이용하여 제3 루프를 스케쥴할 수 있다. 뿐만 아니라, 실시예들은 넷 이상의 루프들이 동시에 실행되도록 스케쥴하는 경우에도 적용될 수 있다. 이하, 설명의 편의를 위하여 제1 루프와 제2 루프를 스케쥴하는 경우를 예로 들어 설명한다.
일 예로, 표 1을 참조하면, 라디오 커널(radio kernel)에 사용되는 소스 코드는 복수의 루프들(loop1, loop2)을 포함할 수 있다. 소스 코드의 루프(loop1)이 단계(110)에서 스케쥴되는 제1 루프이고, 소스 코드의 루프(loop2)가 단계(120)에서 스케쥴되는 제2 루프일 수 있다.
source code
for(n=0; n<3; n++) {
for(m=0; m<6; m++){
Func1 (..){
for( i=0; i<2 ; i++) {
for( j=0; j<2; j++) {
loop1
loop2
...
}
}
}
}
}
표 2를 참조하면, 루프(loop1)은 루프 바디(loop body)에 복수의 명령어들을 포함할 수 있다. 단계(110)에서 루프(loop1)은 복수의 실행 유닛들을 이용하여 스케쥴될 수 있다. 예를 들어, 도 2a를 참조하면, 매 사이클(220)마다 루프(loop1)에 포함된 복수의 명령어들이 복수의 실행 유닛들(210)에 할당될 수 있다. 하드웨어 자원의 제약 및 루프(loop1) 내 명령어들 사이의 의존 관계(dependency) 등으로 인하여, 루프(loop1) 내 모든 명령어들이 병렬적으로 스케쥴되기 어렵다. 이 경우, 이용되지 않는 실행 유닛(nop)이 발생될 수 있다. 도 2a에서 채워진 블록(230)에 대응하는 실행 유닛(FU03)은 해당 사이클(cycle 3)에 할당된 명령어(S32_SAT_CMUL)를 처리할 수 있다. 반면, 도 2a에서 비어있는 블록(240)에 대응하는 실행 유닛(FU04)은 해당 사이클(cycle 3)에 아무런 명령어도 처리하지 않고, 동작 사이클을 낭비할 수 있다.
loop1
for(k=0; k < 22; k++) {
cir=S32_LD_1(in, i);
cir_power = S32_SAT_CCMUL (cir, cir, 4);
power_th = S32_INSERT_ALL((npow*nc_thre));
mask_high = S32_COMP_HIGH(cir_power, power_th);
mask_low = S32_COMP_LOW(cir_power, power_th);
cir_high = S32_SAT_CMUL(cir, mask_high, 0);
cir_low = S32_SAT_CMUL(cir, mask_low, 0);
noise_reduce_coef = S32_INSERT_ALL(nr_coef);
cir_low_reduce = S32_SAT_CMUL(cir_low, noise_reduce_coef, shift_bit);
cir_nr = S32_SAT_ADD(cir_high, cir_low_reduce);
S32_ST_0 (out, k, cir_nr);
}
표 2에서, S32_LD_1()은 벡터 로드 연산을 위한 명령어이고, S32_SAT_CCMUL()은 벡터 곱셈 연산을 위한 명령어이다. S32_INSERT_ALL()은 벡터 대입 연산을 위한 명령어이며, S32_COMP_HIGH(), S32_COMP_LOW()는 각각 벡터 상위 비트 비교 연산을 위한 명령어 및 벡터 하위 비트 비교 연산을 위한 명령어이다. S32_SAT_CMUL()은 벡터 곱셈 연산을 위한 명령어이고, S32_SAT_ADD()는 벡터 덧셈 연산을 위한 명령어이며, S32_ST_0()은 벡터 스토어 연산을 위한 명령어이다.
표 3을 참조하면, 루프(loop2)는 루프 바디에 복수의 명령어들을 포함할 수 있다. 단계(120)에서 루프(loop2)는 루프(loop1)의 스케쥴 결과 이용되지 않은 실행 유닛들을 이용하여 스케쥴될 수 있다. 예를 들어, 도 2b를 참조하면, 루프(loop2)에 포함된 복수의 명령어들이 루프(loop1)의 스케쥴 결과 비어있는 블록들에 할당될 수 있다. 루프(loop2)의 스케쥴에 의하여, 루프(loop1)의 스케쥴 결과 비어있는 블록(240)에 루프(loop2)를 위한 명령어(cga_add, 250)가 할당될 수 있다. 이로 인하여, 명령어 레벨 병렬화(Instruction Level Parallelism, ILP)가 향상되고, 이용되지 않는 실행 유닛들이 감소될 수 있다. 또한, 낭비되는 동작 사이클이 감소되고, 프로세서의 전력 소모량이 감소될 수 있다.
loop2
for(m=0; m < 5 ; m++) {
cir = I_S32_LD_1( (unsigned int)in, m);
cir_power = S32_SAT_CCMUL(cir, cir, 4);
power_th = S32_INSERT_ALL( (npow * nc_thre) >> 4);
mask_high = S32_COMP_HIGH(cir_power, power_th);
mask_low = S32_COMP_LOW(cir_power, power_th);
cir_high = S32_SAT_CMUL(cir, mask_high, 0);
cir_low = S32_SAT_CMUL(cir, mask_low, 0);
noise_reduce_coef = S32_INSERT_ALL(nr_coef);
cir_low_reduce = S32_SAT_CMUL(cir_low, noise_reduce_coef, shift_bit);
cir_nr = S32_SAT_ADD(cir_high, cir_low_reduce);
I_S32_ST_0 (out, i, cir_nr );
}
표 3에서, I_S32_LD_1()은 벡터 로드 연산을 위한 명령어이고, S32_SAT_CCMUL()은 벡터 곱셈 연산을 위한 명령어이다. S32_INSERT_ALL()은 벡터 대입 연산을 위한 명령어이며, S32_COMP_HIGH(), S32_COMP_LOW()는 각각 벡터 상위 비트 비교 연산을 위한 명령어 및 벡터 하위 비트 비교 연산을 위한 명령어이다. S32_SAT_CMUL()은 벡터 곱셈 연산을 위한 명령어이고, S32_SAT_ADD()는 벡터 덧셈 연산을 위한 명령어이며, I_S32_ST_0()은 벡터 스토어 연산을 위한 명령어이다.
이하, 도 3a 및 도 3b를 참조하여 단일 루프를 스케쥴하는 실시예를 설명하고, 도 4a 내지 도 4b를 참조하여 제1 루프의 스케쥴 결과를 이용하여 제2 루프를 스케쥴하는 실시예를 상세히 설명한다.
도 3a 및 도 3b는 단일 루프를 스케쥴하는 실시예를 설명하는 도면이다. 도 3a 및 도 3b를 설명하기에 앞서, 일 실시예에 따른 스케쥴러가 이용하는 스케쥴링 기법을 간략히 설명한다. 스케쥴러는 루프 바디에 포함된 명령어들이 병렬적으로 실행되도록 루프를 스케쥴할 수 있다. 예를 들어, 스케쥴러는 가장 안쪽 루프(inner most loop)의 반복(iteration)들이 병렬적으로 실행되도록 루프를 스케쥴할 수 있다. 이하, '반복' 또는 '이터레이션'은 임의의 반복 시점에서 루프 바디가 1회 수행되는 동작을 지칭할 수 있다. 스케쥴러는 실시예들에 따른 루프 스케쥴 또는 컴파일을 수행할 수 있다. 스케쥴러는 구현에 따라 루프 스케쥴링 장치, 또는 컴파일일 장치로 지칭될 수 있다. 스케쥴러는 프로세서에 의해 수행되는 소프트웨어 모듈로 구성되어 되거나, HWA(Hardware Accelerator) 등 하드웨어 모듈로 구성될 수 있다.
스케쥴러는 소프트웨어 파이프라인 기법을 이용하여 루프를 스케쥴할 수 있다. 예를 들어, 스케쥴러는 모듈로 스케쥴링(modulo scheduling) 기법을 이용하여 루프를 스케쥴할 수 있다. 모듈로 스케쥴링 기법은 루프 바디가 일정한 인터벌(interval)로 반복적으로 실행되도록 루프를 스케쥴하는 기법이다. 여기서, 일정한 인터벌은 복수의 사이클들로 구성될 수 있다. 일정한 인터벌은 루프 내 연속된 두 이터레이션들이 개시(initiation)되는 시점들 사이의 차이라는 의미로, 개시 인터벌(initiation interval, II)이라고 지칭될 수 있다. 예를 들어, 도 2a의 스케쥴 결과 및 도 2b의 스케쥴 결과에서 개시 인터벌은 5 (cycles)일 수 있다.
도 3a를 참조하면, 일 실시예에 따른 스케쥴러는 루프의 데이터 흐름 그래프(Data Flow Graph, DFG) (310)를 대상 아키텍처(target architecture) (320)에 맵핑할 수 있다. 스케쥴러는 루프에 포함된 복수의 명령어들이 실행될 사이클 및 실행 유닛을 결정하고, 실행 결과 도출된 데이터가 이동될 데이터 경로를 결정할 수 있다. 스케쥴러는 이터레이션 내부의 데이터 연관 관계, 이터레이션들 사이의 데이터 연관 관계, 하드웨어 자원 등 제약조건(constraint)을 고려한다. 스케쥴러는 데이터 연관 관계를 나타내는 데이터 흐름 그래프(310)와 대상 아키텍처(320)를 이용할 수 있다.
데이터 흐름 그래프(310)를 참조하면, 명령어(n1)이 수행된 이후에 명령어(n2)와 명령어(n3)가 수행될 수 있다. 또한, 명령어(n2)와 명령어(n3)가 모두 수행된 이후에 명령어(n4)가 수행될 수 있다. 대상 아키텍처(320)를 참조하면, 실행 유닛(fu1)은 실행 유닛(fu2) 및 실행 유닛(fu3)과 데이터를 주고 받을 수 있다. 또한, 실행 유닛(fu2)는 실행 유닛(fu1) 및 실행 유닛(fu4)와 데이터를 주고 받을 수 있다. 실행 유닛(fu3)은 실행 유닛(fu1) 및 실행 유닛(fu4)와 데이터를 주고 받을 수 있으며, 실행 유닛(fu4)는 실행 유닛(fu2) 및 실행 유닛(fu3)과 데이터를 주고 받을 수 있다. 다만, 실행 유닛(fu1)과 실행 유닛(fu4)는 직접 데이터를 주고 받을 수 없다.
도 3b를 참조하면, 스케쥴러는 첫 번째 사이클(t=1)에서 명령어(n1)을 실행 유닛(fu2)에 할당할 수 있다. 데이터 흐름 그래프(310)에 따르면, 명령어(n1)이 수행되어야 나머지 명령어들이 수행될 수 있으므로, 첫 번째 사이클(t=1)에는 다른 명령어들을 할당할 수 없다. 두 번째 사이클(t=2)에서 명령어(n2) 및 명령어(n3)가 수행될 수 있다. 명령어(n1)이 할당된 실행 유닛(fu2)는 실행 유닛(fu1) 및 실행 유닛(fu4)와 데이터를 주고 받을 수 있으므로, 명령어(n2)는 실행 유닛(fu1)에 할당되고 명령어(n3)는 실행 유닛(fu4)에 할당될 수 있다. 세 번째 사이클(t=3)에서 명령어(n4)가 수행될 수 있고, 명령어(n4)는 실행 유닛(fu1) 및 실행 유닛(fu4)와 데이터를 주고 받을 수 있는 실행 유닛(fu3)에 할당될 수 있다.
여기서, 이터레이션들 사이의 데이터 의존 관계가 없다고 가정하면, 첫 번째 이터레이션(i1)이 완료되기 전 두 번째 이터레이션(i2)이 개시될 수 있다. 하드웨어 자원의 제약으로 인하여 두 번째 이터레이션(i2)이 첫 번째 이터레이션(i1)과 동시에 시작되는 것은 어렵고, 두 번째 이터레이션(i2)은 두 번째 사이클(t=2)에서 개시될 수 있다. 스케쥴러는 첫 번째 이터레이션(i1)을 스케쥴한 것과 유사하게, 두 번째 이터레이션(i2)을 스케쥴할 수 있다. 이하, n#(i##)는 ## 번째 이터레이션을 위한 명령어(n#)을 지칭한다.
스케쥴러는 두 번째 사이클(t=2)에서 n1(i2)을 실행 유닛(fu2)에 할당할 수 있다. 데이터 흐름 그래프(310)에 따르면, 명령어(n1)이 수행되어야 나머지 명령어들이 수행될 수 있으므로, 두 번째 사이클(t=2)에는 두 번째 이터레이션을 위한 다른 명령어들을 할당할 수 없다. 세 번째 사이클(t=3)에서 n2(i2) 및 n3(i2)가 수행될 수 있다. n1(i2)가 할당된 실행 유닛(fu2)는 실행 유닛(fu1) 및 실행 유닛(fu4)와 데이터를 주고 받을 수 있으므로, n2(i2)는 실행 유닛(fu1)에 할당되고 n3(i2)는 실행 유닛(fu4)에 할당될 수 있다. 네 번째 사이클(t=4)에서 n4(i2)가 수행될 수 있고, n4(i2)는 실행 유닛(fu1) 및 실행 유닛(fu4)와 데이터를 주고 받을 수 있는 실행 유닛(fu3)에 할당될 수 있다.
스케쥴러는 루프의 반복 횟수(N)만큼 루프를 스케쥴함으로써, 도 3b의 결과를 얻을 수 있다. 도 3b의 결과는 크게 세 구간들로 분류될 수 있다. 첫 번째 구간(310)은 프롤로그(prolog)로, 루프의 초반 이터레이션이 수행되는 구간이다. 두 번째 구간(320)은 커널(kernel, 341)이 안정화 상태에 있는 구간이다. 두 번째 구간(320)에서 복수의 실행 유닛들에 할당되는 명령어들은 동일하다. 예를 들어, 세 번째 사이클(t=3)에서 실행 유닛(fu1)에는 명령어(n2)가 할당되고, 실행 유닛(fu2)에는 명령어(n1)이 할당되며, 실행 유닛(fu3)에는 명령어(n4)가 할당되고, 실행 유닛(fu4)에는 명령어(n3)가 할당된다. 마찬가지로, 네 번째 사이클(t=4)에서도 실행 유닛(fu1)에는 명령어(n2)가 할당되고, 실행 유닛(fu2)에는 명령어(n1)이 할당되며, 실행 유닛(fu3)에는 명령어(n4)가 할당되고, 실행 유닛(fu4)에는 명령어(n3)가 할당된다. 두 번째 구간(320)이 끝나는 N 번째 사이클(t=N)까지 복수의 실행 유닛들에 할당되는 명령어들은 동일하다. 커널은 두 번째 구간(320) 내에서 반복되는 할당 결과를 지칭할 수 있다. 세 번째 구간(330)은 에필로그(epilog)로, 루프의 후반 이터레이션이 수행되는 구간이다.
커널이 형성되는 사이클 수는 전술한 개시 인터벌과 실질적으로 동일할 수 있다. 예를 들어, 도 3b의 두 번째 구간(320)에서 세 번째 이터레이션(i3)이 개시되는 시점과 네 번째 이터레이션(i4)이 개시되는 시점 사이의 사이클 차이는 1 (cycle)이므로, 개시 인터벌은 1 (cycle)이다. 또한, 도 3b의 두 번째 구간(320)에서 커널(341)은 한 개의 사이클로 형성된다.
도 3b의 실시예에서는 커널(341)에서 모든 실행 유닛들이 이용되고 있으나, 소스 코드 내부의 연상들 사이의 데이터 의존 관계 및 하드웨어 자원의 제약 등으로 인하여 매 사이클마다 모든 실행 유닛들이 활용되도록 스케쥴하는 것은 현실적으로 매우 어렵다. 실시예들에 따른 스케쥴러는 하나의 루프를 스케쥴한 결과 각 사이클에서 사용되지 않는 하드웨어 자원을 이용하여 다른 루프의 이터레이션 전부 또는 적어도 다른 루프의 일부 이터레이션을 스케쥴할 수 있다. 이로 인하여, 스케쥴러는 총 실행 사이클을 감소시키고, 전력 소모를 감소시키는 기술을 제공할 수 있다. 또한, 아래에서 상세히 설명하겠으나, 스케쥴러는 제 1 루프의 스케쥴 결과에 따른 이용 가능한 하드웨어 자원을 이용 하여도 제 2 루프를 스케쥴할 수 없는 경우, 제 1 루프의 스케쥴링 결과를 언롤링(unrolling) 하여 스케쥴링 피리오드(scheduling period) (=II, 개시 인터벌과 실질적으로 동일)를 확장 함으로써 이용 가능한 HW 자원을 추가 확보 하여 제 2 루프의 스케쥴링을 시도 할 수 있다. 실시예들에 따른 스케쥴링 기법에 따르면, 컴파일 타임에 스케쥴이 결정되므로 추가적인 하드웨어 오버헤드가 발생되지 않을 수 있다.
도 4a 내지 도 4f는 제1 루프와 제2 루프를 스케쥴하는 실시예를 설명하는 도면이다. 도 4a를 참조하면, 일 실시예에 따른 제1 루프의 데이터 의존 관계는 데이터 흐름 그래프(410)로 표현될 수 있다. 명령어(s1)은 명령어(s2) 및 명령어(s3)에 선행되어야 하고, 명령어(s2)은 명령어(p1)에 선행되어야 하며, 명령어(s3)는 명령어(p2)에 선행되어야 한다. 명령어(p1)은 명령어(m1) 및 명령어(m2)에 선행되어야 하고, 명령어(p2)는 명령어(m4) 및 명령어(m5)에 선행되어야 한다. 명령어(m1), 명령어(m2), 명령어(m4), 및 명령어(m5)는 각각 명령어(v2), 명령어(v3), 명령어(v4), 및 명령어(v5)에 선행되어야 한다. 명령어(v2)와 명령어(v3)는 명령어(m3)에 선행되어야 하고, 명령어(v4)와 명령어(v5)는 명령어(m6)에 선행되어야 한다. 도 4b를 참조하면, 일 실시예에 따른 대상 아키텍처(415)는 복수의 실행 유닛들로 SC1, SC2, SC3, PU1, PU2, PU3, MM1, MM2, VEC1, VEC2, VEC3, 및 VEC4를 포함할 수 있다. 복수의 실행 유닛들은 메시(mesh) 형태로 서로 데이터를 주고 받을 수 있다. 도 4c를 참조하면, 일 실시예에 따른 스케쥴러는 도 4a의 데이터 흐름 그래프(410)를 도 4b의 대상 아키텍처(415)에 맵핑함으로써, 제1 루프의 스케쥴 결과(420)를 도출할 수 있다. 제1 루프의 스케쥴 결과(420)는 프롤로그와 에필로그는 포함하지 않고 커널만을 포함할 수 있다. 스케쥴러가 도 4a의 데이터 흐름 그래프(410)를 도 4b의 대상 아키텍처(415)에 맵핑하는 동작에는 도 3a 및 도 3b를 통하여 기술된 사항들이 그대로 적용될 수 있으므로 보다 상세한 설명은 생략한다.
도 4d를 참조하면, 일 실시예에 따른 제2 루프의 데이터 의존 관계는 데이터 흐름 그래프(430)로 표현될 수 있다. 명령어(s1)은 명령어(s2)에 선행하고, 명령어(s2)는 명령어(s3)에 선행하며, 명령어(s3)는 명령어(s4)에 선행한다. 도 4e를 참조하면, 제2 루프가 제1 루프와 별도로 스케쥴되는 경우, 제2 루프의 스케쥴 결과(440)가 도출될 수 있다.
루프의 실행에 소비되는 총 사이클 수는 II*(SC+(N-1))로 계산될 수 있다. 여기서, II는 개시 인터벌이고, SC는 스테이지 카운트(stage count)이며, N은 반복 횟수(iteration count)이다. 루프의 매 이터레이션은 II(cyles)로 구성되는 SC 개의 스테이지들로 분할될 수 있다. 도 4c를 참조하면, 제1 루프의 II는 4(cycles)이고, 2 번의 스테이지들에 의하여 단일 이터레이션이 수행될 수 있으므로 제1 루프의 SC는 2이다. 도 4e를 참조하면, 제2 루프의 II는 2(cycles)이고, 2번의 스테이지들에 의하여 단일 이터레이션이 수행될 수 있으므로 제2 루프의 SC는 2이다.
제1 루프의 반복 횟수(iteration count)가 100이고, 제2 루프의 반복 횟수가 200이라고 가정하면, 제1 루프 및 제2 루프의 실행에 소비되는 총 사이클 수는 다음과 같이 계산될 수 있다.
loop 1 = II * (SC + (N-1)) = 4 * (2 + (100-1)) = 404 cycles
loop 2 = II * (SC + (N-1)) = 2 * (2 + (200-1)) = 402 cycles
이 경우, 제1 루프와 제2 루프를 모두 실행하는데 걸리는 총 사이클 수는 806cycle이다.
도 4f를 참조하면, 스케쥴러는 제1 루프의 스케쥴 결과 이용되지 않은 실행 유닛들을 이용하여 제2 루프를 스케쥴할 수 있다. 스케쥴러는 도 4c의 제1 루프의 스케쥴 결과(420)에서 두 번째 사이클의 SC1와 SC3 및 네 번째 사이클의 SC2와 SC3를 이용하여 제2 루프를 스케쥴할 수 있다. 스케쥴러는 제1 루프가 실행되는 동안 각 사이클에서 이용되지 않는 실행 유닛을 이용하여 제2 루프가 실행되도록, 제2 루프를 스케쥴할 수 있다. 예를 들어, 스케쥴러는 각각의 실행 유닛에 할당되는 플래그 비트(flag bit)를 이용하여, 실행 유닛이 이용가능한지 여부를 판단할 수 있다. 혹은, 스케쥴러는 HW 자원의 이용도를 테이블 상에서 관리 함으로써 실행 유닛이 이용가능한지 여부를 판단할 수도 있다. 스케쥴러는 제2 루프의 데이터 흐름 그래프를 대상 아키텍처에 맵핑할 수 있다. 맵핑 결과, 스케쥴러는 제2 루프를 스케쥴하기 위한 실행 유닛을 결정할 수 있다. 스케쥴러는 결정된 실행 유닛의 플래그 비트를 확인함으로써, 혹은 테이블 상에서 제 1 루프에의 이용 여부를 확인 함으로써, 결정된 실행 유닛을 제2 루프의 스케쥴에 이용할 수 있는지 여부를 판단할 수 있다. 만약 결정된 실행 유닛이 이용 가능한 경우, 스케쥴러는 결정된 실행 유닛을 이용하여 제2 루프를 스케쥴한다. 만약 결정된 실행 유닛이 이미 제1 루프의 스케쥴링에 이용되었다면, 스케쥴러는 다른 실행 유닛을 검출한다. 제2 루프의 스케쥴이 성공적으로 완료되는 경우, 스케쥴러는 스케쥴 결과(450)을 도출할 수 있다. 여기서, 제1 루프와 제2 루프는 서로 독립적일 수 있다. 다시 말해, 제1 루프와 제2 루프는 서로 의존 관계가 없을 수 있다. 스케쥴 결과(450)에서 괄호 안의 숫자는 각각의 루프를 지시한다.
제1 루프의 반복 횟수가 100이고 제2 루프의 반복 횟수가 200인 경우, 제1 루프가 100회 반복되는 동안 제2 루프의 100번의 이터레이션이 수행된다. 이후, 도 4e의 스케쥴 결과(440)에 따라 제2 루프의 나머지 100번의 이터레이션이 수행될 수 있다. 제1 루프 및 제2 루프의 실행에 소비되는 총 사이클 수는 다음과 같이 감소될 수 있다.
(1) loop 1 (100 iterations) + loop 2 (100 iterations) = 404 cycles
(2) loop2 (100 iterations) = 2 * (2 + (100-1)) = 202 cycles
이 경우, 제1 루프와 제2 루프를 모두 실행하는데 걸리는 총 사이클 수는 404 + 202 = 606 cycles로 감소된다.
일 실시예에 따른 스케쥴러는 소스 코드에 포함된 복수의 루프들 중 서로 독립적인 두 개의 루프들을 선택한 이후, 두 개의 루프들의 우선순위를 결정할 수 있다. 스케쥴러는 다양한 기준에 따라 두 루프들의 우선순위를 정할 수 있다. 예를 들어, 스케쥴러는 스케쥴 결과에 이용 가능한 하드웨어 자원을 더 많이 포함하는 루프를 제1 루프로 정하고, 나머지 루프를 제2 루프로 정할 수 있다. 이하, 제1 루프는 우선순위가 더 높은 루프를 지칭하고, 제2 루프는 우선순위가 더 낮은 루프를 지칭한다. 또는, 스케쥴러는 반복 횟수가 많은 루프를 제1 루프로 정하고, 비교적 규모가 작은 루프를 제2 루프로 정할 수 있다. 스케쥴러는 표 4와 같은 기준을 이용하여 제1 루프와 제2 루프를 결정할 수 있다.
우선순위 제1 루프 제2 루프
(a) Iteration(LoopA)
>
Iteration(LoopB)		 II(LoopB) - II(LoopA) > M LoopB LoopA
(b) Otherwise LoopA LoopB
(c) Otherwise II(LoopA) -II(LoopB) > M LoopA LoopB
(d) Otherwise LoopB LoopA
여기서, M은 사용자 지정 문턱값이다. 표 4의 기준에 따르면, 스케쥴러는 II의 차이가 M보다 큰 경우, 더 큰 II를 가지는 루프를 제1 루프로 결정한다(케이스 a 및 케이스 c). II의 차이가 M보다 작거나 같은 경우, 스케쥴러는 많은 반복 횟수를 가지는 루프를 제1 루프로 결정한다(케이스 b 및 케이스 d).
스케쥴러는 제1 루프의 스케쥴 결과로부터 각 사이클에서 맵핑된 하드웨어 자원을 제약조건으로 하여, 제2 루프를 스케쥴할 수 있다. 스케쥴러는 CGRA 구조의 대상 아키텍처를 위한 모듈러 스케쥴링 기법을 이용할 수 있다. 예를 들어, 스케쥴러는 빙 메이 알고리즘(Bing Mei's algorithm)을 이용 할 수 있다. 빙 메이 알고리즘은 최소 II로부터 시작하여 스케쥴이 완료 될 때까지, DFG 상의 명령어들을 실행 유닛들에 랜덤하게 할당할 수 있다.
만약 제1 루프의 II (cycles) 내에 제2 루프를 스케쥴하지 못하는 경우, 스케쥴러는 제1 루프의 스케쥴 결과를 언롤링(unrolling)할 수 있다. 제1 루프의 스케쥴 결과를 언롤링하는 경우 더 많은 이용 가능한 실행 유닛들을 제2 루프의 스케쥴에 이용할 수 있으므로, 제2 루프의 스케쥴링이 성공할 가능성이 높아진다. 예를 들어, 도 4c의 스케쥴 결과(420)를 언롤링하는 경우, 스케쥴 결과(420)를 그대로 복사하여 스케쥴 결과(420)의 아래에 이어 붙인 것과 같은 스케쥴 결과가 도출될 수 있다. 언롤링된 스케쥴 결과에는 원래의 스케쥴 결과(420)에 비하여 2배로 많은 이용 가능한 하드웨어 자원들이 존재하므로, 제2 루프의 스케쥴링이 성공할 가능성이 높아질 수 있다. 제1 루프의 언롤링과 관련된 보다 상세한 사항들은 도 5 및 도 6을 참조하여 후술한다.
케이스 b 및 케이스 d에서, 제1 루프의 반복 횟수는 제2 루프의 반복 횟수보다 많다. 스케쥴러는 제1 루프의 실행 도중 제2 루프의 이터레이션이 모두 완료되는 경우, 이후 사이클에서 제2 루프가 실행되는 것을 방지할 수 있다. 스케쥴러는 프레디케이션 가딩(predication guarding)을 이용하여 제2 루프의 이터레이션이 완료된 이후 사이클에서 제2 루프가 실행되는 것을 방지할 수 있다. 예를 들어, 스케쥴러는 매 사이클마다 제2 루프의 사이클이 완료되었는지 여부를 지시하는 프레디케이션 비트가 설정되도록 할 수 있다. 제2 루프를 위한 실행 유닛들은 프레디케이션 비트의 값에 따라 할당된 명령어를 수행할지 여부를 결정할 수 있다.
케이스 a 및 케이스 c에서, 제1 루프의 반복 횟수는 제2 루프의 반복 횟수보다 적다. 스케쥴러는 제2 루프의 일부 이터레이션은 제1 루프의 실행 기간 동안 실행되고, 제2 루프의 나머지 이터레이션은 제1 루프의 실행이 종료된 이후 새로이 실행되도록, 제2 루프를 스케쥴할 수 있다. 스케쥴러는 제1 루프를 스케쥴하는 것과 유사하게 제2 루프의 나머지 이터레이션을 스케줄할 수 있다. 스케쥴러는 제2 루프의 나머지 이터레이션을 스케쥴할 때에는 제1 루프를 고려하지 않는다. 이 경우, 제1 루프의 실행이 종료된 후, 제2 루프만 포함되는 스케쥴 정보에 따라 제2 루프의 나머지 이터레이션이 실행될 수 있다. 만약 제2 루프의 나머지 이터레이션에 이전 이터레이션에서 사용된 데이터가 필요한 경우, 스케쥴러는 해당 데이터가 버퍼에 저장되도록 할 수 있다. 예를 들어, 스케쥴러는 제1 루프의 실행이 종료될 때, 제2 루프의 중간 데이터를 버퍼에 저장하는 명령어를 추가로 스케쥴할 수 있다. 전술한 명령어는 소스 코드에는 존재하지 않으나, 스케쥴러가 자동으로 전술한 명령어를 추가할 수 있다.
도 5 및 도 6은 제1 루프의 스케쥴 결과를 언롤링하여 제2 루프를 스케쥴하는 실시예들을 나타낸 동작 흐름도이다. 도 5를 참조하면, 일 실시예에 따른 스케쥴러는 단계(510)에서 제1 루프 및 제2 루프를 선택한다. 스케쥴러는 단계(520)에서 제1 루프를 스케쥴하고, 제1 루프의 스케쥴 이후 잔여 하드웨어 자원을 이용하여 제2 루프를 스케쥴할 수 있다. 스케쥴러는 단계(530)에서 언롤링 횟수 카운트하는 변수(N)을 0으로 설정할 수 있다. 스케쥴러는 단계(540)에서 제2 루프의 스케쥴이 성공하였는지 여부를 판단할 수 있다. 제2 루프의 스케쥴이 실패한 경우, 스케쥴러는 단계(550)에서 현재 언롤링 횟수 카운트가 미리 정해진 문턱값을 초과하는지 여부를 판단할 수 있다. 만약 현재 언롤링 횟수 카운트가 미리 정해진 문턱값 이하인 경우, 스케쥴러는 단계(560)에서 제1 루프의 스케쥴 결과를 언롤링할 수 있다. 또한, 스케쥴러는 단계(560)에서 언롤링 횟수 카운트를 증가시킬 수 있다. 스케쥴러는 단계(570)에서 언롤링된 제1 루프의 스케쥴 결과를 이용하여 제2 루프를 스케쥴할 수 있다. 스케쥴러는 단계(540), 단계(550), 단계(560), 단계(570)을 반복할 수 있다. 단계(550)에서 언롤링 횟수 카운트가 미리 정해진 문턱값을 초과한다고 판단되는 경우, 스케쥴러는 단계(580)에서 제2 루프를 통상적으로 스케쥴할 수 있다. 다시 말해, 스케쥴러는 단계(580)에서 제2 루프를 제1 루프와 별개로 스케쥴할 수 있다. 이로 인하여, 스케쥴러는 루프 스케쥴링에 소요되는 시간이 일정 이상 증가하지 않도록 할 수 있다. 또한, 스케쥴러는 전술한 루프 스케쥴링 기법을 적용하기 이전에 비하여 스케쥴 결과의 ILP 성능이 더 열화되는 것을 방지할 수 있다.
도 6을 참조하면, 일 실시예에 따른 스케쥴러는 단계(610)에서 제2 루프의 II (II_Loop2)를 미리 정해진 최소 II 값(MinII_Loop2)으로 설정할 수 있다. 스케쥴러는 언롤링 횟수(Unroll_count)를 0으로 설정하고, 제1 루프의 II (II_Loop1_new)를 언롤링되지 않은 상태에서 제1 루프의 II(II_Loop1)로 설정할 수 있다. 스케쥴러는 단계(620)에서 제2 루프의 II에 따라 제2 루프를 스케쥴한다. 예를 들어, 미리 정해진 최소 II 값이 2라면, 스케쥴러는 제2 루프를 2 (cycles) 내에서 스케쥴한다. 스케쥴러는 단계(630)에서 제2 루프가 성공적으로 스케쥴되었는지 여부를 판단한다. 만약 제2 루프가 스케쥴되지 않았다면, 스케쥴러는 단계(640)에서 제2 루프의 II를 증가시킨다. 스케쥴러는 단계(650)에서, 증가된 제2 루프의 II가 제1 루프의 II 이내인지 여부를 판단한다. 스케쥴러는 단계(620), 단계(630), 단계(640), 단계(650)을 반복할 수 있다. 만약 단계(650)에서, 증가된 제2 루프의 II가 제1 루프의 II 이상인 경우 스케쥴러는 제1 루프의 II가 미리 정해진 문턱값 이하인지 여부를 판단한다. 제1 루프의 II가 미리 정해진 문턱값 이하인 경우, 스케쥴러는 단계(670)에서 제1 루프의 스케쥴 결과를 언롤링한다. 이 때, 스케쥴러는 제1 루프의 반복 횟수 % m = 0인 m을 선택하고, m배만큼 제1 루프의 스케쥴 결과를 언롤링한다. 예를 들어, 제1 루프의 반복 횟수가 300이고 선택된 m이 3이라면, 스케쥴러는 제1 루프의 스케쥴 결과가 3배 길어지도록 언롤링한다. 이 경우, 언롤링된 제1 루프의 반복 횟수는 1/m배인 100으로 갱신된다. 스케쥴러는 기존 언롤링 횟수에 m을 더하여 언롤링 횟수를 갱신하고, 제1 루프의 II를 Loop1 * unroll_count로 갱신한다. 스케쥴러는 단계(620)으로 돌아가, 언롤링된 제1 루프의 스케쥴 결과를 이용하여 제2 루프를 스케쥴한다. 스케쥴러는 단계(620), 단계(630), 단계(640), 단계(650), 단계(660), 단계(670)을 반복할 수 있다.
도 7 내지 도 12는 실시예들에 따른 최적화 대상 아키텍처(architecture)를 설명하는 도면이다. 일 실시예에 따른 루프 스케쥴링 기법은 다양한 대상 아키텍처에 적용될 수 있다. 예를 들어, 루프 스케쥴링 기법은 도 7의 CGRA 구성(710)를 갖는 프로세서(700)에 적용될 수 있다. 루프 스케쥴링 기법에 의하여, 프로세서(700)의 ILP 성능을 최적화하는 목적 코드가 생성될 수 있다. 도 7의 CGRA 구성(710)은 하나의 예시에 불과하며, 임의의 개수의 FU 배열, 임의의 인터커넥션(interconnection), 공유 레지스터 파일, 로컬 레지스터 파일, 구성 메모리(configuration Memory), 명령어 메모리(instruction Memory), 데이터 메모리(data memory)로 변형될 수 있다. 각각의 FU는 임의의 개수의 오퍼레이션(operation)을 수행 하거나, 데이터 라우팅(data routing)에 이용될 수 있다. FU는 다른 FU의 출력 포트나 레지스터 파일 등으로부터 입력 데이터를 수신할 수 있으며, 다른 FU의 입력 포트나 레지스터 파일 등으로 출력 데이터를 전송할 수 있다. 또한, 에필로그 및 프롤로그의 제어나 조건부 분기(conditional branch)의 실행을 위해 프레디케이트 오퍼레이션(predicate operation)이 지원될 수 있다. 구성 메모리(configuration memory)는 CGRA의 구성정보를 저장할 수 있다. 구성 메모리 CGRA 구성정보는 레지스터 파일, FU, 먹스(MUXs), 인터커넥션 등을 제어하는 신호를 생성하기 위하여, 구성 패치/디코드 유닛(configuration fetch/decode unit)에 의해 해독될 수 있다.
일 실시예에 따른 루프 스케쥴링 기법은 도 8의 프로세서(800)에 적용될 수 있다. 루프 스케쥴링 기법은 제1 루프의 데이터 흐름 그래프 또는 제2 루프의 데이트 흐름 그래프를 프로세서(800)가 가지는 대상 아키텍처에 맵핑할 수 있다. 루프 스케쥴링 기법에 의하여 생성된 스케쥴 결과는 구성 메모리(1070)에 저장될 수 있고, 프로세서(800)는 CGA 모드에서 구성 메모리(1070)에 저장된 결과를 이용하여 제1 루프 및 제2 루프를 병렬적으로 처리할 수 있다. 이하, 프로세서(800)가 가지는 대상 아키텍처를 상세히 설명한다.
프로세서(800)는 제어부(810), 명령어 메모리(820), 스칼라 메모리(830), 중앙 레지스터 파일(central register file)(840), 복수의 미니-코어들, 복수의 벡터 메모리들 및 구성 메모리(870)를 포함할 수 있다. 도 8에서, 복수의 미니-코어들로서, MC0(850-1), MC1(850-2) 및 MC2(850-3)이 도시되었다. MC0(850-1), MC1(850-2) 및 MC2(850-3)는 각각 미니-코어(100)일 수 있다. 복수의 벡터 메모리들로서 제1 벡터 메모리(860-1) 및 제2 벡터 메모리(860-2)이 도시되었다. 제어부(810)는 프로세서(800)의 다른 구성요소들을 제어할 수 있다. 예컨대, 제어부(810)는 복수의 미니-코어들을 제어할 수 있다. 제어부(810)는 하나 이상의 미니-코어들 중 일부 또는 전부의 미니-코어의 동작을 중단시킬 수 있다. 제어부(810)는 미니-코어의 동작, 쓰레드의 실행 및 복수의 벡터 FU들의 연결에 관련하여 전술된 프로세서(300)의 기능을 수행할 수 있다. 명령어 메모리(820) 및 구성(configuration) 메모리(870)는 프로세서(800) 또는 미니-코어가 실행할 명령어들을 저장할 수 있다. 스칼라 메모리(830)는 스칼라 데이터를 저장할 수 있다. 중앙 레지스터 파일(840)은 레지스터들을 저장할 수 있다.
프로세서(800)는 VLIW 모드 및 CGRA 모드에서 동작할 수 있다. VLIW 모드에서, 프로세서(800)는 스칼라 데이터를 처리하거나, 제어 연산을 수행할 수 있다. CGRA 모드에서, 프로세서는 가속/병렬처리가 요구되는 코드 내의, 루프 등의 연산을 처리할 수 있다. 여기서, 루프는 재귀적(recursive) 루프일 수 있다. 루프 내의 연산은 심한(heavy) 벡터 프로세싱을 요구할 수 있다. 말하자면, 제어에 관련된 명령어들은 VLIW 모드에서만 가용할 수도 있고, 벡터 명령어들은 CGRA 모드에서만 가용할 수도 있다. 이러한 2 개의 모드들 간의 명령어들의 엄격한 분리(strict separation)는 프로세서(800)의 디자인을 더 단순하게 할 수 있고, 전력 효율을 향상시킬 수 있다.
VLIW 모드에서, 명령어들은 명령어 메모리(820)로부터 패치(fetch)될 수 있다. 패치된 명령어들은 복수의 미니-코어들의 스칼라 FU들에 의해 실행될 수 있다. CGRA 모드에서, 명령어들은 구성(configuration) 메모리(870)로부터 패치될 수 있다. 패치된 명령어들은 복수의 미니-코어들의 모든 FU들에 의해 실행될 수 있다. 복수의 미니-코어들의 FU들 중, 스칼라 FU는 VLIW 모드 및 CGRA 모드 양자에서 사용될 수 있다. 말하자면, 스칼라 FU는 VLIW 모드 및 CGRA 모드에서 공유될 수 있다. 프로세서(800)는 VLIW 모드에서 동작할 때, 프로세서(800)는 미니-코어들의 FU들 중 3 개의 스칼라 FU들만을 동시에 동작시킬 수 있다. 프로세서(800)의 동작 모드가 VLIW 모드에서 CGRA 모드로 변환되면, 프로세서(800)는 복수의 미니-코어들의 모든 FU들을 동작시킬 수 있다. 프로세서(800)가 CGRA 모드에서 동작할 때, 프로세서(800)는 복수의 미니-코어들의 모든 FU들을 동작시킴으로써 가속 처리를 지원할 수 있다. 따라서, 프로세서(800)가 VLIW 모드에서 동작할 때, 프로세서(800)는 복수의 미니-코어들의 FU들 중 스칼라 FU들을 제외한 불필요한 나머지 FU들의 동작을 중단시킴으로써 절전 모드에서 동작할 수 있다. 여기서, 나머지 FU들은 팩/언팩 FU, 벡터 LD/ST FU 및 벡터 FU를 포함할 수 있다. 2 개의 모드들 간에 요구되는 파라미터들을 공통되는 FU를 통해 전송함으로써, 프로세서(800)는 빠르게 동작 모드를 전환할 수 있으며, VLIW 모드 및 CGRA 모드 간의 데이터의 복사가 회피될 수 있다.
복수의 미니-코어들의 FU들 중 스칼라 FU들만이 중앙 레지스터 파일(840)에 대한 접근이 가능할 수 있다. 중앙 레지스터 파일(840)에 대한 접근을 스칼라 FU들만으로 제한함으로써 광폭의(wide) 레지스터 파일을 배제할 수 있다. 또는, 복수의 미니-코어들은 각각 중앙 레지스터 파일(840)에 대한 독출(read) 접근을 할 수 있고, 복수의 미니-코어들 중 단지 스칼라 FU들만이 각각 중앙 레지스터 파일(840)에 대한 기입(write) 접근을 할 수 있을 수 있다. 복수의 미니-코어들의 각각은 복수의 벡터 메모리들 중 하나의 벡터 메모리를 사용할 수 있다. 또는, 복수의 미니-코어들의 각각은 복수의 벡터 메모리들 중 하나의 벡터 메모리를 포함할 수 있다. 도 8에서, MC0(850-1)는 제1 벡터 메모리(860-1)를 사용할 수 있다. MC2(850-3)는 제2 벡터 메모리(860-2)를 사용할 수 있다. 복수의 미니-코어들의 각각에게 별개의 벡터 메모리를 제공함으로써, 큐(queue)와 같은 벡터 메모리의 공유를 위한 복잡한 구조가 요구되지 않을 수 있다. 말하자면, 미니-코어들 각각에게 개별적으로 제공된 메모리에 의해 메모리 접근 로직이 단순하게 될 수 있다. 복잡한 구조의 배제는 프로세서(800)의 디자인을 단순하게 할 수 있고, 전력 및 면적에 있어서 프로세서(800)에게 이득을 줄 수 있다.
도 9 내지 도 12는 실시예들에 따른 도 8의 프로세서(800)에 포함된 미니 코어를 설명하는 도면이다. 일 실시예에 따른 루프 스케쥴링 기법은 미니 코어(900)에 포함된 복수의 FU들을 이용하여 제1 루프 및 제2 루프를 스케쥴할 수 있다. 미니 코어(900)에 FU들의 구성, FU들 사이의 연결 등 미니 코어(900)의 구조가 변경됨에 따라 루프 스케쥴링 기법의 대상 아키텍처가 변경될 수 있다. 이하, 미니 코어(900)가 가지는 대상 아키텍처를 상세히 설명한다.
미니-코어(900)는 복수 개의 FU를 결합(combine)함으로써 구성된 단위 코어일 수 있다. 미니-코어(900)는 스칼라 도메인부(910) 및 벡터 도메인부(960)를 포함할 수 있다. 스칼라 도메인부(910)는 스칼라 데이터의 연산을 수행할 수 있다. 벡터 도메인부(960)는 벡터 데이터의 연산을 수행할 수 있다. 스칼라 도메인부(910)는 스칼라 데이터의 연산을 위한 FU를 포함할 수 있다. 스칼라 도메인부(910) 스칼라 FU(920) 및 팩(pack)/언팩(pack) FU(950)를 포함할 수 있다. 벡터 도메인부(960)는 벡터 데이터의 연산을 위한 FU를 포함할 수 있다. 벡터 도메인부(960)는 팩/언팩 FU(950), 벡터 로드(load; LD)/스토어(store; ST) FU(970) 및 벡터 FU(980)를 포함할 수 있다. 예컨대, 미니-코어(900)는 스칼라 FU(910), 팩/언팩 FU(950), 벡터 LD/ST FU(970) 및 벡터 FU(980)를 포함할 수 있다. 설명된 FU들의 종류 및 개수는 예시적인 것이다. 스칼라 FU(920), 팩/언팩 FU(950), 벡터 LD/ST FU(970) 및 벡터 FU(980)는 각각 복수일 수 있다. 스칼라 FU(920)는 스칼라 데이터의 연산, 제어에 관련된 코드 또는 명령어를 처리할 수 있다. 제어에 관련된 코드 또는 명령어는, 비교(comparison) 연산 또는 분기(branch) 연산에 관련된 코드 또는 명령어일 수 있다. 또한, 스칼라 FU(920)는 스칼라 데이터의 로드 및 스토어를 처리할 수 있다. 또한, 스칼라 FU(920)는 공통적으로 사용되는 단일-사이클(single-cycle) 명령어들을 처리할 수 있다. 스칼라 데이터는 다수의 데이터가 조합되지 않은, 최소의 연산 단위의 데이터일 수 있다. 일반적으로, 하기의 기본적인 프리미티브(primitive) 데이터 타입은 스칼라 데이터의 타입으로 간주될 수 있다.
1) 불리언(boolean) 데이터 타입
2) 뉴메릭(nuemeric) 타입들 (예컨대, "int", "short int", "float" 및 "double")
3) 케릭터 타입들 (예컨대, "char" 및 "string")
스칼라 FU(920)는 단일한 데이터 타입을 위한 것이기 때문에, 일반적으로 스칼라 FU(920)는 낮은 비트-넓이의 데이터-패스를 요구한다. 벡터 LD/ST FU(970)는 벡터 데이터의 로드 및 스토어를 처리할 수 있다. 벡터 LD/ST FU(970)는 벡터 메모리로부터 데이터를 로드할 수 있고, 벡터 메모리에 데이터를 스토어할 수 있다. 벡터 데이터의 로드 및 스토어는 벡터 LD/ST FU(970)에서만 이루어질 수도 있다. 벡터 FU(980)는 벡터 데이터의 연산을 처리할 수 있다. 벡터 FU(980)는 단일 명령어 다중 데이터(Single Instruction Multiple Data; SIMD)로 벡터 데이터의 연산을 처리할 수 있다. 벡터 데이터의 연산은 벡터 산술(arithmetic), 쉬프트(shift), 곱(multiplication), 비교(comparison) 및 데이터 셔플링(data shuffling)을 포함할 수 있고, 소프트디맵(softdemap)을 위한 몇몇 특별한 명령어들이 후술될 VFU 모드에서 지원될 수 있다.
SIMD는 하나의 명령어를 사용하여 다수의 데이터를 동시에 처리하는 병렬 기법일 수 있다. SIMD는 다수의 연산 장치들이 주로 동일한 연산을 다수의 데이터에 동시에 ?Э淪臼? 다수의 데이터를 동시에 처리하는 방식일 수 있다. SIMD는 벡터 프로세서에 이용될 수 있다. 벡터 데이터는 동일한 타입의 다수의 스칼라 데이터를 포함하는 데이터일 수 있다. 벡터 데이터는 다수의 스칼라 데이터가 묶여진(merged) 연산 단위의 데이터일 수 있다. 예컨대, 오픈씨엘(OpenCL)에서는, "charn", "ucharn", "shortn", "ushortn", "intn", "longn", "ulongn" 및 "floatn" 등의 벡터 데이터의 타입이 정의되었다. n은 스칼라 데이터의 개수를 나타낸다. n의 값은 2 이상이며, 일반적으로 2, 4, 8 및 16 등이 n의 값으로서 사용된다. 벡터 데이터는 다수의 데이터가 묶여진 것이기 때문에, 벡터 FU(980)는 높은 비트-넓이의 데이터-패스를 요구한다. 벡터 FU(980)는 다수의 데이터를 병렬로 처리하는 유닛이다. 따라서, 벡터 FU(980)의 크기는 다른 FU의 크기에 비해 더 클 수 있고, 미니-코어(900) 내의 영역 중 대부분을 차지할 수 있다.
팩/언팩 FU(950)는 스칼라 도메인부(910) 및 벡터 도메인부(960) 간의 데이터의 전송을 위한 데이터 변환을 처리할 수 있다. 팩/언팩 FU(950)는 스칼라 도메인부(910) 및 벡터 도메인부(960)의 공통의 FU일 수 있다. 또는, 팩/언팩 FU(950)는 스칼라 도메인부(910) 및 벡터 도메인부(960) 사이에서 공유될 수 있다. 팩/언팩 FU(950)는 다수의 스칼라 데이터를 벡터 데이터로 변환할 수 있다. 팩/언팩 FU(950)는 다수의 스칼라 데이터를 묶음으로써 벡터 데이터를 생성할 수 있다. 또는, 팩/언팩 FU(950)는 벡터 데이터의 특정한 위치에 스칼라 데이터를 삽입(insert)함으로써 벡터 데이터를 생성 또는 갱신할 수 있다. 팩/언팩 FU(950)는 벡터 데이터를 하나 또는 다수의 스칼라 데이터로 변환할 수 있다. 팩/언팩 FU(950)는 벡터 데이터를 분할함으로써 다수의 스칼라 데이터를 생성할 수 있다. 또는, 팩/언팩 FU(950)는 벡터 데이터의 특정한 위치 또는 슬롯(slot)에서의 요소를 추출(extract)함으로써 스칼라 데이터를 생성할 수 있다. 벡터 데이터의 요소는 스칼라 데이터일 수 있다. 말하자면, 팩/언팩 FU(950)는 스칼라 도메인 및 벡터 도메인의 중간에 위치할 수 있고, 스칼라 도메인 및 벡터 도메인의 가교의 역할을 할 수 있다. 스칼라 도메인 및 벡터 도메인 간의 데이터의 교환은 가교의 역할을 하는 팩/언팩 FU(950)에 의한 데이터의 형 변환(type conversion)의 이후에 이루어질 수 있다.
상술된 FU들 간의 조합을 통해, 미니-코어(900)는 프로세서에서 처리되어야 하는 모든 명령어들을 처리할 수 있다. 따라서, 프로세서 내에 하나의 미니-코어(900)만이 독립적으로 존재 또는 동작하더라도, 프로세서 또한 동작할 수 있다. 전술된 것처럼, FU는 스칼라 FU(920), 팩/언팩 FU(950), 벡터 LD/ST FU(970) 및 벡터 FU(980)의 핵심 FU들로 분리될 수 있으며, 핵심 FU들이 미니-코어(900)를 구성할 수 있다. 다양한 FU들의 임의의(random) 조합 대신, 미니-코어(900)의 확장을 통해 프로세서 내의 로직이 단순화될 수 있다. 또한, 미니-코어(900)의 확장을 통해, 디자인 공간 탐색(design space exploration; DSE)에 있어서 발생 가능한 디자인의 경우의 개수가 대폭적으로 감소될 수 있다.
도 10는 일 예에 따른 미니-코어 내의 데이터-패스를 설명한다. 스칼라 도메인부(910)의 FU들 간에는 데이터-패스가 존재할 수 있다. 예컨대, 미니-코어(900)는 스칼라 FU(920) 및 팩/언팩 FU(950) 간의 데이터-패스를 포함할 수 있다. 벡터 도메인의 FU(960)의 FU들 간에는 데이터-패스가 존재할 수 있다. 예컨대, 미니-코어(900)는 팩/언팩 FU(950), 벡터 LD/ST FU(970) 및 벡터 FU(980) 중 2 개의 FU들 간의 데이터-패스를 포함할 수 있다.
팩/언팩 FU(950)를 제외하고, 스칼라 도메인부(910) 및 벡터 도메인의 FU(950)를 직접적으로 연결하는 데이터-패스는 존재하지 않을 수 있다. 말하자면, 스칼라 도메인부(910) 및 벡터 도메인의 FU(960) 간의 데이터의 전달은 팩/언팩 FU(950)에서의 형 변환의 후에 수행될 수 있다. 형 변환은 스칼라 데이터의 벡터 데이터로의 변환 및 벡터 데이터의 스칼라 데이터로의 변환을 포함할 수 있다. 동일한 도메인 내의 FU들은 풀(full) 데이터 연결을 가질 수 있다. 데이터-패스의 넓이는 도메인 별로 서로 상이할 수 있다. 예외적으로, 스칼라 FU(920)에서 연산된, 로드 또는 스토어를 위한 메모리 주소의 값은 벡터 LD/ST FU(970)로 전달될 수 있다. 미니-코어(900)는 로드 또는 스토어를 위한 메모리 주소를 스칼라 FU(920)로부터 벡터 LD/ST FU(970)로 전달하기 위한 데이터-패스를 포함할 수 있다. 여기서, 메모리 주소를 전달하기 위한 데이터-패스는 상대적으로 좁은 데이터-패스일 수 있다. 후술될 데이터 전달을 위한 데이터-패스는 상대적으로 넓은 데이터-패스일 수 있다.
미니-코어들 간의 데이터 전달을 의해 두 가지의 타입의 채널들이 존재할 수 있다. 두 가지의 타입의 채널을은 스칼라 데이터 채널 및 벡터 데이터 채널일 수 있다. 미니-코어(900)는 스칼라 데이터 채널을 통해 다른 미니-코어로 스칼라 데이터를 전송할 수 있고, 스칼라 데이터 채널을 통해 다른 미니-코어로부터 스칼라 데이터를 수신할 수 있다. 스칼라 데이터 채널은 스칼라 도메인부(910)의 FU에 연결될 수 있다. 미니-코어(900)는 벡터 데이터 채널을 통해 다른 미니-코어로 벡터 데이터를 전송할 수 있고, 벡터 데이터 채널을 통해 다른 미니-코어로부터 벡터 데이터를 수신할 수 있다. 벡터 데이터 채널은 벡터 도메인의 FU(960)의 FU에 연결될 수 있다. 미니-코어(900)는 다른 미니-코어들 각각과의 스칼라 데이터의 전송을 위해 다른 미니-코어들의 개수만큼의 스칼라 데이터 채널들을 가질 수 있다. 스칼라 데이터 채널들은 다른 미니-코어들에 각각 연결될 수 있다. 또는, 멀티-패스를 위해, 미니-코어(900)는 다른 미니-코어들의 개수 이상의 개수의 스칼라 데이터 채널들을 가질 수 있다. 미니-코어(900)는 복수의 스칼라 데이터 채널들을 통해 하나의 다른 미니-코어와 스칼라 데이터를 교환할 수 있다.
미니-코어(900)는 다른 미니-코어들 각각과의 벡터 데이터의 전송을 위해 다른 미니-코어들의 개수만큼의 벡터 데이터 채널들을 가질 수 있다. 벡터 데이터 채널들은 다른 미니-코어들에 각각 연결될 수 있다. 또는, 멀티-패스를 위해, 미니-코어(900)는 다른 미니-코어들의 개수 이상의 개수의 벡터 데이터 채널들을 가질 수 있다. 미니-코어(900)는 복수의 벡터 데이터 채널들을 통해 하나의 다른 미니-코어와 벡터 데이터를 교환할 수 있다. 상술된 것과 같은 데이터 채널의 구성을 통해, 연결이 요구되지 않는 FU들 간의 데이터-패스가 미니-코어 및 프로세서에서 제외될 수 있다. 말하자면, FU들 간의 데이터-패스 중 불필요한 데이터-패스를 제거함으로써 미니-코어(900) 또는 프로세서 내의 연결을 최소화할 수 있다. 예컨대, 불필요한 데이터 패스는 스칼라 FU(920) 및 벡터 FU(980) 간의 데이터-패스일 수 있다. 미니-코어(900)에게 스칼라 데이터 채널 및 벡터 데이터 채널을 제공함으로써 미니-코어들 간의 데이터의 전송이 단순화될 수 있다.
미니-코어(900)는 벡터 메모리(1010)를 더 포함할 수 있다. 벡터 메모리(1010)는 벡터 LD/ST FU(970)의 전용의 메모리일 수 있다. 미니-코어(900)는 벡터 LD/ST FU(970)가 벡터 메모리(1010)에 접근하기 위해 사용하는 접근 포트(access port)를 더 포함할 수 있다. 접근 포트를 통한 벡터 메모리(1010)로의 접근에 의해, 벡터 메모리(1010)는 벡터 LD/ST FU(970) 외의 다른 FU들과 공유되지 않을 수 있다. 벡터 메모리(1010)를 공유하지 않음으로써 포트의 개수가 감소될 수 있고, 벡터 메모리(1010)의 접근에 관련된 접근 로직이 단순화될 수 있다. 포트의 개수의 감소 및 접근 로직의 단순화는 프로세서의 전력 소모 및 미니-코어(900)의 면적(area)의 측면에서 이익이 될 수 있다.
도 11은 일 예에 따른 미니-코어의 용이한 확장성을 설명한다. 프로세서(800)는 하나 이상의 미니-코어들을 포함할 수 있다. 하나 이상의 미니-코어들의 각각은 도 9을 참조하여 전술된 미니-코어(900)일 수 있다. 도 11에서는, 하나 이상의 미니-코어들로서, MC0(1110-1), MC1(1110-2), MC2(1110-3) 및 MCm(1110-4)가 도시되었다. MC0(1110-1), MC1(1110-2), MC2(1110-3) 및 MCm(1110-4)는 각각 미니-코어(900)일 수 있다. 말하자면, 도 11에서, 프로세서(800)는 m+1 개의 미니-코어들을 포함하는 것으로 도시되었다. 각 미니-코어 내에서, FU들이 도시되었다. 도 11에서는, 각 미니-코어의 FU들이 FU0, FU1 및 FUn으로 표시되었다. 말하자면, 각 미니-코어는 n+1 개의 FU들을 포함할 수 있다. FU들은 각각 스칼라 FU(920), 팩/언팩 FU(950), 벡터 LD/ST FU(970) 및 벡터 FU(980) 중 하나일 수 있다. 또는, 하나 이상의 미니-코어들 중 제1 미니-코어는 도 9을 참조하여 전술된 미니-코어(900)일 수 있다. 도 9을 참조하여 전술된 것과 같이 하나의 미니-코어(900)는 프로세서에서 처리되어야 하는 모든 명령어들을 처리할 수 있다. 프로세서(800) 상에서 어떤 어플리케이션이 실행될 때, 어플리케이션에 의해 요구되는 연산 량은 어플리케이션마다 모두 상이할 수 있다. 프로세서(800)는, 간단한 어플리케이션에 대해서는 한 개의 미니-코어(900)를 사용함으로써 어플리케이션에 의해 요구되는 연산 량에 대응할 수 있다. 또한, 프로세서(800)는, 더 많은 연산 량을 요구하는 어플리케이션에 대해서는 요구되는 연산 량에 맞춰 사용될 미니-코어(900)의 개수를 조절할 수 있다. 효율적으로 구성된 미니-코어들을 확장함으로써, 프로세서(800)의 설계가 용이하게 이루어질 수 있다.
도 12를 참조하면, 프로세서(800)는 두 가지 타입들의 레지스터 파일들을 제공할 수 있다. 도 8을 참조하여 전술된 중앙 레지스터 파일(840)은 주로 VLIW 모드 및 CGRA 모드 간에서의 데이터의 전송을 위해 사용될 수 있다. CGRA 모드의 라이브-인(live-in) 변수들 및 라이브-아웃(live-out) 변수들은 중앙 레지스터 파일(840) 내에 머무를 수 있다. 미니-코어(900)는 스칼라 FU(920)를 위한 제1 지역 레지스터 파일(Local Register File; LRF)(1210) 및 벡터 FU(980)을 위한 제2 지역 레지스터 파일(1220)을 더 포함할 수 있다. 제1 지역 데이터 레지스터 파일(1210)은 몇몇 싸이클들 후에 스칼라 FU(920)가 스칼라 데이터를 요구할 때, 상기의 스칼라 데이터를 임시로 저장할 수 있다. 제2 지역 데이터 레지스터 파일(1220)는 몇몇 싸이클들 후에 벡터 FU(980)가 벡터 데이터를 요구할 때, 상기의 벡터 데이터를 임시로 저장할 수 있다. 전술된 실시예들에 의해 다수의 FU들의 조합인 미니-코어(900)가 구성될 수 있다. 미니-코어(900)에 의해 FU들 및 FU들의 연결인 데이터-패스의 구조가 최소화될 수 있다. 미니-코어의 개수를 조절함으로써 프로세서는 요구되는 연산량에 쉽게 대응할 수 있는 확장성을 가질 수 있다. 미니-코어(900) 및 프로세서는 DLP를 사용하는 멀티미디어 분야 및 통신 분야에서 널리 사용될 수 있다.
이상에서 설명된 장치는 하드웨어 구성요소, 소프트웨어 구성요소, 및/또는 하드웨어 구성요소 및 소프트웨어 구성요소의 조합으로 구현될 수 있다. 예를 들어, 실시예들에서 설명된 장치 및 구성요소는, 예를 들어, 프로세서, 콘트롤러, ALU(arithmetic logic unit), 디지털 신호 프로세서(digital signal processor), 마이크로컴퓨터, FPGA(field programmable gate array), PLU(programmable logic unit), 마이크로프로세서, 또는 명령(instruction)을 실행하고 응답할 수 있는 다른 어떠한 장치와 같이, 하나 이상의 범용 컴퓨터 또는 특수 목적 컴퓨터를 이용하여 구현될 수 있다. 처리 장치는 운영 체제(OS) 및 상기 운영 체제 상에서 수행되는 하나 이상의 소프트웨어 애플리케이션을 수행할 수 있다. 또한, 처리 장치는 소프트웨어의 실행에 응답하여, 데이터를 접근, 저장, 조작, 처리 및 생성할 수도 있다. 이해의 편의를 위하여, 처리 장치는 하나가 사용되는 것으로 설명된 경우도 있지만, 해당 기술분야에서 통상의 지식을 가진 자는, 처리 장치가 복수 개의 처리 요소(processing element) 및/또는 복수 유형의 처리 요소를 포함할 수 있음을 알 수 있다. 예를 들어, 처리 장치는 복수 개의 프로세서 또는 하나의 프로세서 및 하나의 콘트롤러를 포함할 수 있다. 또한, 병렬 프로세서(parallel processor)와 같은, 다른 처리 구성(processing configuration)도 가능하다.
소프트웨어는 컴퓨터 프로그램(computer program), 코드(code), 명령(instruction), 또는 이들 중 하나 이상의 조합을 포함할 수 있으며, 원하는 대로 동작하도록 처리 장치를 구성하거나 독립적으로 또는 결합적으로(collectively) 처리 장치를 명령할 수 있다. 소프트웨어 및/또는 데이터는, 처리 장치에 의하여 해석되거나 처리 장치에 명령 또는 데이터를 제공하기 위하여, 어떤 유형의 기계, 구성요소(component), 물리적 장치, 가상 장치(virtual equipment), 컴퓨터 저장 매체 또는 장치, 또는 전송되는 신호 파(signal wave)에 영구적으로, 또는 일시적으로 구체화(embody)될 수 있다. 소프트웨어는 네트워크로 연결된 컴퓨터 시스템 상에 분산되어서, 분산된 방법으로 저장되거나 실행될 수도 있다. 소프트웨어 및 데이터는 하나 이상의 컴퓨터 판독 가능 기록 매체에 저장될 수 있다.
실시예에 따른 방법은 다양한 컴퓨터 수단을 통하여 수행될 수 있는 프로그램 명령 형태로 구현되어 컴퓨터 판독 가능 매체에 기록될 수 있다. 상기 컴퓨터 판독 가능 매체는 프로그램 명령, 데이터 파일, 데이터 구조 등을 단독으로 또는 조합하여 포함할 수 있다. 상기 매체에 기록되는 프로그램 명령은 실시예를 위하여 특별히 설계되고 구성된 것들이거나 컴퓨터 소프트웨어 당업자에게 공지되어 사용 가능한 것일 수도 있다. 컴퓨터 판독 가능 기록 매체의 예에는 하드 디스크, 플로피 디스크 및 자기 테이프와 같은 자기 매체(magnetic media), CD-ROM, DVD와 같은 광기록 매체(optical media), 플롭티컬 디스크(floptical disk)와 같은 자기-광 매체(magneto-optical media), 및 롬(ROM), 램(RAM), 플래시 메모리 등과 같은 프로그램 명령을 저장하고 수행하도록 특별히 구성된 하드웨어 장치가 포함된다. 프로그램 명령의 예에는 컴파일러에 의해 만들어지는 것과 같은 기계어 코드뿐만 아니라 인터프리터 등을 사용해서 컴퓨터에 의해서 실행될 수 있는 고급 언어 코드를 포함한다. 상기된 하드웨어 장치는 실시예의 동작을 수행하기 위해 하나 이상의 소프트웨어 모듈로서 작동하도록 구성될 수 있으며, 그 역도 마찬가지이다.
이상과 같이 실시예들이 비록 한정된 실시예와 도면에 의해 설명되었으나, 해당 기술분야에서 통상의 지식을 가진 자라면 상기의 기재로부터 다양한 수정 및 변형이 가능하다. 예를 들어, 설명된 기술들이 설명된 방법과 다른 순서로 수행되거나, 및/또는 설명된 시스템, 구조, 장치, 회로 등의 구성요소들이 설명된 방법과 다른 형태로 결합 또는 조합되거나, 다른 구성요소 또는 균등물에 의하여 대치되거나 치환되더라도 적절한 결과가 달성될 수 있다. 그러므로, 다른 구현들, 다른 실시예들 및 특허청구범위와 균등한 것들도 후술하는 특허청구범위의 범위에 속한다.

Claims (37)

  1. 하나의 프로세서에 포함된 복수의 실행 유닛들을 이용하여 적어도 하나의 선순위 루프를 스케쥴하는 단계; 및
    상기 실행 유닛들 중 상기 적어도 하나의 선순위 루프의 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 후순위 루프를 스케쥴하는 단계
    를 포함하고,
    상기 후순위 루프를 스케쥴하는 단계는
    상기 적어도 하나의 선순위 루프가 스케쥴된 복수의 사이클들에서, 상기 적어도 하나의 선순위 루프를 위해 할당되지 않은 실행 유닛들을 이용하여 상기 후순위 루프의 적어도 일부를 스케쥴하는 단계
    를 포함하는
    루프 스케쥴링 방법.
  2. 제1항에 있어서,
    상기 적어도 하나의 선순위 루프를 스케쥴하는 단계는
    상기 복수의 실행 유닛들을 이용하여 최우선순위 루프를 스케쥴하는 단계
    를 포함하는 루프 스케쥴링 방법.
  3. 삭제
  4. 제1항에 있어서,
    상기 적어도 하나의 선순위 루프를 스케쥴하는 단계는
    소스 코드에 포함된 복수의 루프들 중 서로 독립적인 적어도 두 개의 루프들을 선택하는 단계; 및
    상기 적어도 두 개의 루프들의 우선순위들을 결정하는 단계
    를 포함하는 루프 스케쥴링 방법.
  5. 제1항에 있어서,
    상기 적어도 하나의 선순위 루프의 우선순위는 상기 후순위 루프의 우선순위보다 높고, 루프의 우선순위는 루프의 반복 횟수 및 루프의 단일 반복을 위한 사이클 수 중 적어도 하나에 기초하여 계산되는, 루프 스케쥴링 방법.
  6. 제1항에 있어서,
    상기 후순위 루프를 스케쥴하는 단계는
    상기 후순위 루프에 포함된 복수의 명령어들 사이의 데이터 의존 관계에 기초하여 상기 복수의 명령어들을 상기 적어도 하나의 선순위 루프가 스케쥴된 복수의 사이클들에서 상기 이용 가능한 실행 유닛들에 할당하는 단계
    를 포함하는 루프 스케쥴링 방법.
  7. 제1항에 있어서,
    상기 후순위 루프를 스케쥴하는 단계는
    상기 후순위 루프를 스케쥴하기 위한 실행 유닛을 결정하는 단계; 및
    상기 적어도 하나의 선순위 루프가 스케쥴된 사이클에서 상기 결정된 실행 유닛이 이용 가능한지 여부를 판단하는 단계
    를 포함하는 루프 스케쥴링 방법.
  8. 제1항에 있어서,
    상기 적어도 하나의 선순위 루프를 스케쥴하는 단계는
    최우선순위 루프에 포함된 복수의 명령어들 사이의 데이터 의존 관계에 기초하여 상기 복수의 명령어들을 복수의 사이클들에서 상기 복수의 실행 유닛들에 할당하는 단계
    를 포함하는, 루프 스케쥴링 방법.
  9. 제1항에 있어서,
    상기 후순위 루프가 상기 이용 가능한 실행 유닛들을 이용하여 스케쥴되지 않는 경우, 상기 적어도 하나의 선순위 루프의 스케쥴 결과를 언롤링하는 단계; 및
    상기 언롤링된 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 상기 후순위 루프를 스케쥴하는 단계
    를 더 포함하는 루프 스케쥴링 방법.
  10. 제9항에 있어서,
    상기 언롤링하는 단계는
    언롤링 횟수에 대한 임계값 및 상기 언롤링된 스케쥴 결과의 사이클수에 대한 임계값 중 적어도 하나에 기초하여, 상기 적어도 하나의 선순위 루프의 스케쥴 결과를 언롤링할지 여부를 결정하는 단계
    를 포함하는 루프 스케쥴링 방법.
  11. 제1항에 있어서,
    상기 후순위 루프를 스케쥴하는 단계는
    상기 적어도 하나의 선순위 루프의 반복 횟수가 상기 후순위 루프의 반복 횟수보다 큰 경우, 프레디케이션 가딩(predication guarding)을 이용하여 상기 후순위 루프의 반복이 완료된 이후 상기 후순위 루프가 실행되는 것을 제한하는 단계
    를 포함하는, 루프 스케쥴링 방법.
  12. 제1항에 있어서,
    상기 적어도 하나의 선순위 루프의 반복 횟수가 상기 후순위 루프의 반복 횟수보다 작은 경우, 상기 적어도 하나의 선순위 루프의 반복이 완료된 이후 상기 후순위 루프의 나머지 반복이 수행되도록 상기 후순위 루프를 추가로 스케쥴하는 단계
    를 더 포함하는 루프 스케쥴링 방법.
  13. 제12항에 있어서,
    상기 적어도 하나의 선순위 루프의 반복이 완료된 이후 상기 후순위 루프의 중간 데이터를 저장하는 명령어를 추가로 스케쥴하는 단계
    를 더 포함하는 루프 스케쥴링 방법.
  14. 제1항에 있어서,
    상기 복수의 실행 유닛들은 코어스-그레인드 리콘피규어블 어레이(Coarse-Grained Reconfigurable Array; CGRA) 혹은 VLIW(Very Long Instruction Word) 프로세서에 포함되는, 루프 스케쥴링 방법.
  15. 제1항에 있어서,
    상기 복수의 실행 유닛들은
    스칼라 데이터 연산을 처리하는 스칼라 기능성 유닛(Functional Unit; FU);
    스칼라 데이터와 벡터 데이터 사이의 변환을 처리하는 팩/언팩 FU;
    벡터 데이터의 로드 및 스토어를 처리하는 벡터 로드/스토어 FU; 및
    벡터 데이터의 연산을 처리하는 벡터 FU
    를 포함하는, 루프 스케쥴링 방법.
  16. 하나의 프로세서에 포함된 복수의 실행 유닛들을 이용하여 제1 루프를 스케쥴하는 단계; 및
    상기 실행 유닛들 중 상기 제1 루프의 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 제2 루프를 스케쥴하는 단계를 포함하고,
    상기 제2 루프를 스케쥴하는 단계는
    상기 제1 루프가 스케쥴된 복수의 사이클들에서, 상기 제1 루프를 위해 할당되지 않은 실행 유닛들을 이용하여 상기 제2 루프의 적어도 일부를 스케쥴하는 단계
    를 포함하는 루프 스케쥴링 방법.
  17. 삭제
  18. 제16항에 있어서,
    소스 코드에 포함된 복수의 루프들 중 서로 독립적인 두 개의 루프들을 선택하는 단계; 및
    상기 두 개의 루프들 중 상기 이용 가능한 실행 유닛들이 많아지도록 하는 루프를 상기 제1 루프로 결정하고, 나머지 루프를 상기 제2 루프로 결정하는 단계
    를 더 포함하는 루프 스케쥴링 방법.
  19. 제16항에 있어서,
    상기 제1 루프의 우선순위는 상기 제2 루프의 우선순위보다 높고, 루프의 우선순위는 루프의 반복 횟수 및 루프의 단일 반복을 위한 사이클 수 중 적어도 하나에 기초하여 계산되는, 루프 스케쥴링 방법.
  20. 제16항에 있어서,
    상기 제2 루프를 스케쥴하는 단계는
    상기 제2 루프에 포함된 복수의 명령어들 사이의 데이터 의존 관계에 기초하여 상기 복수의 명령어들을 상기 제1 루프가 스케쥴된 복수의 사이클들에서 상기 이용 가능한 실행 유닛들에 할당하는 단계
    를 포함하는 루프 스케쥴링 방법.
  21. 제16항에 있어서,
    상기 제2 루프를 스케쥴하는 단계는
    상기 제2 루프를 스케쥴하기 위한 실행 유닛을 결정하는 단계; 및
    상기 제1 루프가 스케쥴된 사이클에서 상기 결정된 실행 유닛이 이용 가능한지 여부를 판단하는 단계
    를 포함하는 루프 스케쥴링 방법.
  22. 제16항에 있어서,
    상기 제1 루프를 스케쥴하는 단계는
    상기 제1 루프에 포함된 복수의 명령어들 사이의 데이터 의존 관계에 기초하여 상기 복수의 명령어들을 복수의 사이클들에서 상기 복수의 실행 유닛들에 할당하는 단계
    를 포함하는, 루프 스케쥴링 방법.
  23. 제16항에 있어서,
    상기 제2 루프가 상기 이용 가능한 실행 유닛들을 이용하여 스케쥴되지 않는 경우, 상기 제1 루프의 스케쥴 결과를 언롤링하는 단계; 및
    상기 언롤링된 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 상기 제2 루프를 스케쥴하는 단계
    를 더 포함하는 루프 스케쥴링 방법.
  24. 제23항에 있어서,
    상기 언롤링하는 단계는
    언롤링 횟수에 대한 임계값 및 상기 언롤링된 스케쥴 결과의 사이클수에 대한 임계값 중 적어도 하나에 기초하여, 상기 제1 루프의 스케쥴 결과를 언롤링할지 여부를 결정하는 단계
    를 포함하는 루프 스케쥴링 방법.
  25. 제16항에 있어서,
    상기 제2 루프를 스케쥴하는 단계는
    상기 제1 루프의 반복 횟수가 상기 제2 루프의 반복 횟수보다 큰 경우, 프레디케이션 가딩(predication guarding)을 이용하여 상기 제2 루프의 반복이 완료된 이후 상기 제2 루프가 실행되는 것을 제한하는 단계
    를 포함하는, 루프 스케쥴링 방법.
  26. 제16항에 있어서,
    상기 제1 루프의 반복 횟수가 상기 제2 루프의 반복 횟수보다 작은 경우, 상기 제1 루프의 반복이 완료된 이후 상기 제2 루프의 나머지 반복이 수행되도록 상기 제2 루프를 추가로 스케쥴하는 단계
    를 더 포함하는 루프 스케쥴링 방법.
  27. 제26항에 있어서,
    상기 제1 루프의 반복이 완료된 이후 상기 제2 루프의 중간 데이터를 저장하는 명령어를 추가로 스케쥴하는 단계
    를 더 포함하는 루프 스케쥴링 방법.
  28. 제1항, 제2항, 제4항 내지 제16항, 및 제18항 내지 제27항 중에서 어느 하나의 항의 방법을 실행시키기 위한 프로그램이 기록된 컴퓨터 판독 가능한 기록 매체.
  29. 하나 또는 그 이상의 프로그램들을 실행하는 하나 또는 그 이상의 프로세서들; 및
    상기 하나 또는 그 이상의 프로그램들이 저장된 메모리
    를 포함하고,
    상기 하나 또는 그 이상의 프로그램들은
    소스 코드에 포함된 복수의 루프들 중 서로 독립적인 두 개, 혹은 그 이상의 루프들을 선택하는 명령어들;
    상기 두 개의 루프들 중 우선순위가 높은 제1 루프와 우선순위가 낮은 제2 루프 혹은 그 이하의 우선순위의 루프를 결정하는 명령어들;
    하나의 프로세서에 포함된 복수의 실행 유닛들을 이용하여 상기 제1 루프를 스케쥴하는 명령어들;
    상기 실행 유닛들 중 제1 루프의 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 제2 루프 혹은 그 이하의 우선순위의 루프를 스케쥴하는 명령어들; 및
    상기 제1 루프의 스케쥴 결과 및 상기 제2 루프 혹은 그 이하의 우선순위의 루프의 스케쥴 결과를 포함하는 목적 코드를 생성하는 명령어들
    을 포함하고,
    상기 제2 루프 혹은 그 이하의 우선순위의 루프를 스케쥴하는 명령어들은
    상기 제1 루프가 스케쥴된 복수의 사이클들에서, 상기 제1 루프를 위해 할당되지 않은 실행 유닛들을 이용하여 상기 제2 루프 혹은 그 이하의 우선순위의 루프의 적어도 일부를 스케쥴하는 명령어들
    을 포함하는, 컴파일링 장치.
  30. 삭제
  31. 제29항에 있어서,
    상기 결정하는 명령어들은
    루프의 반복 횟수 및 루프의 단일 반복을 위한 사이클 수 중 적어도 하나에 기초하여 상기 제1 루프의 우선순위와 상기 제2 루프 혹은 그 이하의 우선순위를 계산하는 명령어들
    을 포함하는, 컴파일링 장치.
  32. 제29항에 있어서,
    상기 제2 루프 혹은 그 이하의 우선순위의 루프를 스케쥴하는 명령어들은
    상기 제2 루프 혹은 그 이하의 우선순위의 루프의 데이터 흐름 그래프를 상기 제2 루프 혹은 그 이하의 루프보다 앞선 우선순위의 루프들이 스케쥴된 복수의 사이클들에서 이용 가능한 실행 유닛들에 맵핑하는 명령어들
    을 포함하는 컴파일링 장치.
  33. 제29항에 있어서,
    상기 제2 루프 혹은 그 이하의 루프를 스케쥴하는 명령어들은
    상기 제2 루프 혹은 그 이하의 루프를 스케쥴하기 위한 실행 유닛을 결정하는 명령어들; 및
    상기 제2 루프 혹은 그 이하의 루프보다 앞선 우선순위의 루프들이 스케쥴된 사이클에서 상기 결정된 실행 유닛이 이용 가능한지 여부를 판단하는 명령어들
    을 포함하는 컴파일링 장치.
  34. 제29항에 있어서,
    상기 제1 루프를 스케쥴하는 명령어들은
    상기 제1 루프의 데이터 흐름 그래프를 복수의 사이클들에서 상기 복수의 실행 유닛들에 스케쥴하는 명령어들
    을 포함하는, 컴파일링 장치.
  35. 제29항에 있어서,
    상기 제2 루프 혹은 그 이하의 우선순위의 루프가 상기 이용 가능한 실행 유닛들을 이용하여 스케쥴되지 않는 경우, 상기 제2 루프 혹은 그 이하의 루프보다 앞선 우선순위의 루프들의 스케쥴 결과를 언롤링하는 명령어들; 및
    상기 언롤링된 스케쥴 결과에 따른 이용 가능한 실행 유닛들을 이용하여 상기 제2 루프 혹은 그 이하의 우선순위의 루프를 스케쥴하는 명령어들
    을 더 포함하는 컴파일링 장치.
  36. 제29항에 있어서,
    상기 제2 루프 혹은 그 이하의 우선순위의 루프를 스케쥴하는 명령어들은
    상기 제2 루프 혹은 그 이하의 루프보다 앞선 우선순위의 루프들의 반복 횟수가 상기 제2 루프 혹은 그 이하의 우선순위의 루프의 반복 횟수보다 큰 경우, 프레디케이션 가딩(predication guarding)을 이용하여 상기 제2 루프 혹은 그 이하의 우선순위의 루프의 반복이 완료된 이후 상기 제2 루프 혹은 그 이하의 우선순위의 루프가 실행되는 것을 제한하는 명령어들
    을 포함하는, 컴파일링 장치.
  37. 제29항에 있어서,
    상기 제2 루프 혹은 그 이하의 루프보다 앞선 우선순위의 루프들의 반복 횟수가 상기 제2 루프 혹은 그 이하의 우선순위의 루프의 반복 횟수보다 작은 경우, 상기 제2 루프 혹은 그 이하의 루프보다 앞선 우선순위의 루프들의 반복이 완료된 이후 상기 제2 루프 혹은 그 이하의 우선순위의 루프의 나머지 반복이 수행되도록 상기 제2 루프 혹은 그 이하의 우선순위의 루프를 추가로 스케쥴하는 명령어들
    을 더 포함하는 컴파일링 장치.
KR1020130143552A 2013-11-25 2013-11-25 다수의 기능 유닛을 가지는 프로세서를 위한 루프 스케쥴링 방법 KR102204282B1 (ko)

Priority Applications (4)

Application Number Priority Date Filing Date Title
KR1020130143552A KR102204282B1 (ko) 2013-11-25 2013-11-25 다수의 기능 유닛을 가지는 프로세서를 위한 루프 스케쥴링 방법
US14/330,675 US9292287B2 (en) 2013-11-25 2014-07-14 Method of scheduling loops for processor having a plurality of functional units
EP14193967.8A EP2876555B1 (en) 2013-11-25 2014-11-20 Method of scheduling loops for processor having a plurality of functional units
CN201410678024.2A CN104657210B (zh) 2013-11-25 2014-11-21 针对具有多个功能单元的处理器调度循环的方法

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1020130143552A KR102204282B1 (ko) 2013-11-25 2013-11-25 다수의 기능 유닛을 가지는 프로세서를 위한 루프 스케쥴링 방법

Publications (2)

Publication Number Publication Date
KR20150059894A KR20150059894A (ko) 2015-06-03
KR102204282B1 true KR102204282B1 (ko) 2021-01-18

Family

ID=51945742

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020130143552A KR102204282B1 (ko) 2013-11-25 2013-11-25 다수의 기능 유닛을 가지는 프로세서를 위한 루프 스케쥴링 방법

Country Status (4)

Country Link
US (1) US9292287B2 (ko)
EP (1) EP2876555B1 (ko)
KR (1) KR102204282B1 (ko)
CN (1) CN104657210B (ko)

Families Citing this family (15)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN105022661A (zh) * 2015-08-06 2015-11-04 四川大学 一种多处理器系统可调度性验证方法
US10528356B2 (en) * 2015-11-04 2020-01-07 International Business Machines Corporation Tightly coupled processor arrays using coarse grained reconfigurable architecture with iteration level commits
US10120685B2 (en) * 2015-11-04 2018-11-06 International Business Machines Corporation Tightly coupled processor arrays using coarse grained reconfigurable architecture with iteration level commits
US10180829B2 (en) * 2015-12-15 2019-01-15 Nxp Usa, Inc. System and method for modulo addressing vectorization with invariant code motion
CN106201988A (zh) * 2016-08-03 2016-12-07 桂林电子科技大学 一种重构高性能目标阵列的方法
KR102593320B1 (ko) * 2016-09-26 2023-10-25 삼성전자주식회사 전자 장치, 프로세서 및 그 제어 방법
EP3862871A1 (en) * 2016-12-19 2021-08-11 (Un)Manned N.V. Method and apparatus for real-time control loop application execution from a high-level description
US10331445B2 (en) * 2017-05-24 2019-06-25 Microsoft Technology Licensing, Llc Multifunction vector processor circuits
CN108052347B (zh) * 2017-12-06 2021-07-20 北京中科睿芯智能计算产业研究院有限公司 一种执行指令选择的装置、方法及指令映射方法
US10846260B2 (en) 2018-07-05 2020-11-24 Qualcomm Incorporated Providing reconfigurable fusion of processing elements (PEs) in vector-processor-based devices
WO2021035006A1 (en) * 2019-08-20 2021-02-25 Northrop Grumman Systems Corporation Simd controller and simd predication scheme
US20210157638A1 (en) * 2019-11-22 2021-05-27 Huawei Technologies Co., Ltd. Method and apparatus for functional unit assignment
US11928468B2 (en) * 2020-11-24 2024-03-12 Arizona Board Of Regents On Behalf Of Arizona State University Systems and methods for improved mapping of computational loops on reconfigurable architectures
DE102021201597A1 (de) * 2021-02-19 2022-08-25 Robert Bosch Gesellschaft mit beschränkter Haftung Verwenden von hardware-beschleunigten befehlen
US20230305842A1 (en) * 2022-03-25 2023-09-28 Micron Technology, Inc. Configure a Coarse Grained Reconfigurable Array to Execute Instructions of a Program of Data Flows

Family Cites Families (16)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5491823A (en) * 1994-01-25 1996-02-13 Silicon Graphics, Inc. Loop scheduler
US5958048A (en) * 1996-08-07 1999-09-28 Elbrus International Ltd. Architectural support for software pipelining of nested loops
US6230317B1 (en) * 1997-07-11 2001-05-08 Intel Corporation Method and apparatus for software pipelining of nested loops
US6954927B2 (en) * 1999-02-17 2005-10-11 Elbrus International Hardware supported software pipelined loop prologue optimization
GB2380825B (en) * 2001-10-12 2004-07-14 Siroyan Ltd Processors and compiling methods for processors
JP4196614B2 (ja) * 2002-08-22 2008-12-17 パナソニック株式会社 命令スケジューリング方法、命令スケジューリング装置、及びプログラム
US7206969B2 (en) * 2003-09-10 2007-04-17 Hewlett-Packard Development Company, L.P. Opportunistic pattern-based CPU functional testing
US20050283772A1 (en) 2004-06-22 2005-12-22 Kalyan Muthukumar Determination of loop unrolling factor for software loops
GB0605349D0 (en) 2006-03-17 2006-04-26 Imec Inter Uni Micro Electr Reconfigurable multi-processing coarse-grain array
KR101335001B1 (ko) * 2007-11-07 2013-12-02 삼성전자주식회사 프로세서 및 인스트럭션 스케줄링 방법
KR101553655B1 (ko) * 2009-01-19 2015-09-17 삼성전자 주식회사 재구성가능 프로세서에 대한 명령어 스케줄링 장치 및 방법
KR101515568B1 (ko) * 2009-02-03 2015-04-28 삼성전자 주식회사 재구성 가능 어레이의 스케줄러, 스케줄링 방법 및 이를 이용한 컴퓨팅 장치
US8561046B2 (en) * 2009-09-14 2013-10-15 Oracle America, Inc. Pipelined parallelization with localized self-helper threading
GB201001621D0 (en) * 2010-02-01 2010-03-17 Univ Catholique Louvain A tile-based processor architecture model for high efficiency embedded homogenous multicore platforms
KR101647817B1 (ko) * 2010-03-31 2016-08-24 삼성전자주식회사 재구성 가능한 프로세서의 시뮬레이션 장치 및 방법
KR101912427B1 (ko) * 2011-12-12 2018-10-29 삼성전자주식회사 재구성가능 프로세서 및 재구성가능 프로세서의 미니 코어

Also Published As

Publication number Publication date
CN104657210B (zh) 2020-02-28
US20150149747A1 (en) 2015-05-28
EP2876555B1 (en) 2017-08-09
US9292287B2 (en) 2016-03-22
CN104657210A (zh) 2015-05-27
KR20150059894A (ko) 2015-06-03
EP2876555A1 (en) 2015-05-27

Similar Documents

Publication Publication Date Title
KR102204282B1 (ko) 다수의 기능 유닛을 가지는 프로세서를 위한 루프 스케쥴링 방법
JP5882950B2 (ja) ステージド・ループ命令
EP3005139B1 (en) Incorporating a spatial array into one or more programmable processor cores
US9043805B2 (en) Reconfigurable processor and method
US20170277567A1 (en) Efficient work execution in a parallel computing system
US20140137123A1 (en) Microcomputer for low power efficient baseband processing
US9354850B2 (en) Method and apparatus for instruction scheduling using software pipelining
US20230093393A1 (en) Processor, processing method, and related device
KR102062208B1 (ko) 멀티스레드 프로그램 코드의 변환 장치 및 방법
US20230195526A1 (en) Graph computing apparatus, processing method, and related device
WO2022053152A1 (en) Method of interleaved processing on a general-purpose computing core
She et al. OpenCL code generation for low energy wide SIMD architectures with explicit datapath
KR102161055B1 (ko) 소프트웨어 파이프라이닝을 이용한 명령어 스케줄링 방법 및 장치
US9207922B2 (en) Compiling method and apparatus for scheduling block in pipeline
US11675572B2 (en) Sharing data structures
US11762641B2 (en) Allocating variables to computer memory
US20240231468A9 (en) Reconfiguration of a computing system using a circuit switch
US20240134441A1 (en) Reconfiguration of a computing system using a circuit switch
She et al. A co-design framework with opencl support for low-energy wide simd processor
CN116450138A (zh) 面向simd和vliw架构的代码优化生成方法及系统
Adriaansen Code generation for a Coarse-Grained Reconfigurable Architecture

Legal Events

Date Code Title Description
A201 Request for examination
E902 Notification of reason for refusal
E701 Decision to grant or registration of patent right
GRNT Written decision to grant