KR20010043818A - 알고리즘 패턴 생성기 - Google Patents

Abstract

각 클럭 사이클동안, 생성기(10)는 출력 데이터를 산출하고, 메모리(38)는 명령을 판독하고, 제어기(34)는 메모리의 주소를 증가시키지만 처리기(16)로부터 호출, 복귀, 반복 또는 분기 명령을 받은 후 다른 주소 N+1번의 클럭 사이클로 점프할 수 있고, 처리기는 메모리로부터 명령을 실행하고 출력 데이터로서 실행 명령의 데이터 필드를 제공한다. 명령의 다른 필드는 명령 처리기가 메모리 제어기에 보내는 명령을 참조한다. 제어기는 명령에 응답하기 위하여 N+1번의 클럭 사이클을 요구하기 때문에, 실제로 주소 점프를 실행하기 전에 명령을 수신한 후 N번의 클럭 사이클에 대한 메모리 주소를 계속하여 증가시킨다. 점프 명령 전송 후에 N번의 클럭 사이클 동안 메모리로부터 판독한 N개의 명령 대신에, 처리기는 버퍼에 이미 로딩된 적절한 한 세트의 N개의 명령을 실행한다. 다음 클럭 펄스 동안, 제어기(34)가 주소를 점프시킬 시간을 가지는 경우, 처리기(16)는 메모리(38)로부터의 명령 실행을 다시 시작한다.

Description

알고리즘 패턴 생성기 {ALGORITHMIC PATTERN GENERATOR}

집적 회로(integrated circuit, IC) 테스트는 통상적으로 연속된 테스트 사이클에 의해 수행된다. 집적 회로 테스트는 보통 테스트 중인 장치(DUT, device under test)의 각 핀에 대한 개별적 시퀀스(sequence)의 데이터 값(벡터)에 의하여 정의되며, 여기서 각 벡터(vector)는 한 테스트 사이클 동안 DUT 핀에서 수행하는 테스트 동작을 나타낸다. 통상적인 집적 회로 테스터는 각 DUT 핀마다 개별적인 테스터 채널을 포함한다. 각 테스터 채널은 채널의 벡터 시퀀스가 니타내는 테스트 동작을 수행하는 핀 테스팅 회로와 이 핀 테스팅 회로에 벡터를 저장 및 판독하는 메모리를 포함한다. 중앙 패턴 생성기는 클럭 신호의 각 펄스에 대한 응답으로 각 벡터 메모리에 주소를 제공하며, 각 채널의 벡터 메모리는 주소가 지정된 벡터를 판독하여 채널의 핀 테스팅 회로에 보낸다. 분산 패턴 생성기를 가지는 집적 회로 테스터는 중앙 패턴 생성기를 사용하지 않는다. 이 집적 회로 테스터는 바로 벡터를 생성하기 위하여 각 테스터 채널마다 개별적인 패턴 생성기를 사용한다.

많은 유형의 패턴 생성기가 알려져 있다. 단순 패턴 생성기는 각 주소마다 데이터 값을 저장하는 램(random access memory, RAM)과 클럭 신호의 각 펄스에 응답하여 메모리의 주소를 증가시키기 위한 카운터(counter)를 포함하며, 따라서 메모리가 연속된 주소로부터 데이터 시퀀스를 판독하도록 한다. 이러한 패턴 생성기는 집적 회로 테스터에 사용되어 왔지만, 집적 회로의 크기가 커지고 복잡해지면서, 집적 회로 테스트를 정의하는데 필요한 벡터 시퀀스의 크기를 가지게 된다. 이것은 패턴 생성기와 벡터 메모리의 크기의 증가를 요한다. 또한, 집적 회로의 작동 주파수가 계속 증가함에 따라, 테스트 사이클은 감소되어 왔다. 패턴 생성기는 각 테스트 사이클의 시작시 데이터 출력을 제공해야 하기 때문에, 테스트 주파수가 높을수록 보다 빠른 벡터 기억을 요한다. 그러나 크고 빠른 메모리는 비싸다.

알고리즘 패턴 생성기(Algorithmic Pattern Generators)

많은 테스트들이 벡터 패턴의 반복을 요구하기 때문에, 종래의 집적 회로 테스터는 저장해야 할 데이터량을 감소시키기 위하여 알고리즘 패턴 생성기를 사용하여 왔다. Brune등에게 1989년 8월 29일에 허여된 미국 특허 제 4,862,067호는 벡터 메모리와 메모리 제어기를 포함하는 알고리즘 패턴 생성기를 제시한다. 벡터 메모리는 각 주소에 벡터와 명령을 모두 저장한다. 메모리 제어기는 각 테스트 사이클의 시작 전에 메모리를 주소 지정하고 벡터 메모리로부터 판독된 벡터를 핀 테스팅 회로에 제공한다. 벡터 메모리로부터 판독된 명령은 메모리 제어기에 다음 벡터 기억 주소를 선택하는 방법을 알린다. 이 벡터 메모리 구조는 메모리 제어기에게 내린 명령으로 루프와 호출을 사용하여 벡터 시퀀스를 반복하게 한다. 핀 테스팅 회로에서의 신호가 몇몇 표준을 충족하는 DUT 출력 신호를 명령하는 경우, 메모리 제어기는 조건적인 분기(conditional branch)를 실행하도록 명령받을 수 있다. Brune의 시스템은 필요한 벡터 메모리의 크기를 감소시키는 반면에, 테스트 사이클 보다 길지 않은 액세스(access) 시간을 가지는 빠른 벡터 메모리를 요구한다. 이는 또한 명령 처리기가 한 테스트 사이클에서 명령을 실행할 수 있도록 요구한다. 따라서, 메모리 액세스 속도 또는 명령 처리 시간은 Brune의 시스템이 동작할 수 있는 주파수를 제한할 수 있다.

캐쉬 메모리(Cache Memories)

대용량 DRAM(dynamic random access memory, 디램)은 비싸지는 않지만 고속 집적 회로 테스트의 각 테스트 동안에 너무 느려서 액세스할 수 없다. 몇몇 집적 회로 테스터는 데이터를 작은 고속 캐쉬 메모리에 공급하도록 대용량의 DRAM을 사용함으로써 메모리 비용을 감소시킨다. 이러한 시스템에서, 연속적인 N번의 테스트 사이클을 위한 벡터(또는 벡터 메모리 주소)는 DRAM의 각 메모리 위치에 저장된다. DRAM의 벡터 출력은 테스트 주파수의 1/N의 비로 고속 캐쉬 메모리에 기록된다. 고속 캐쉬 메모리는 벡터(또는 벡터 메모리 주소)를 한 번에 하나씩, 요구하는 테스트 주파수 비로 판독한다.

집적 회로 테스터에 있어서는 알고리즘적으로 출력 벡터 또는 주소 패턴을 생성하며, 보다 낮은 속도로 주기억 장치를 이용할 수 있게 하는 캐쉬(caching)를 사용하는 패턴 생성기를 구비하는 것이 바람직하다. Jeffery등에게 1990년 6월 5일에 허여된 미국 특허 제 4,931,723호는 각 벡터 메모리 주소에 하나의 80비트 단어로서 8개의 10비트 벡터를 저장하는 비교적 저속인 벡터 메모리를 사용한다. 벡터 메모리로부터 판독된 각 80비트 단어는 80비트 시프트 레지스터(shift register)로 시프트된다. 작은 캐쉬 메모리 역할을 하는 시프트 레지스터는 각 테스트 사이클의 시작시 10비트 벡터를 핀 테스팅 회로로 시프트 아웃(shift out)한다.

Jeffrey의 시스템은 명령의 시퀀스를 반복할 수 있다는 점에서 제한된 알고리즘 벡터를 생성할 수 있다. 벡터 패턴을 반복하는 첫 인스턴스(instance)만이 벡터 메모리에 저장된다. 테스트 동안 그 패턴의 첫 인스턴스와 만나는 경우, 벡터 메모리 제어기는 패턴을 핀 테스팅 회로로 전송하고, 다른 캐쉬 메모리에 벡터 패턴의 인스턴스를 또한 저장한다. 그 뒤 제어기가 루프의 끝에 도달하는 경우, 제어기는 벡터 메모리 대신에 캐쉬 메모리로부터 벡터를 판독하기 시작하며 패턴 "루프"가 반복되는 횟수만큼 판독할 수 있다.

명령의 시퀀스를 반복하기 위하여, 메모리 제어기는 루프가 반복되는 횟수뿐만 아니라 루프의 시작 및 끝 벡터 메모리 주소를 알아야 한다. Jeffrey의 시스템에서 루프 시작 및 루프 끝 명령은 벡터 시퀀스에 삽입된다. 따라서, 루프가 시작되거나 끝나는 테스트 신호의 시작시, 벡터 메모리는 벡터 대신에 명령을 판독한다. 벡터는 모든 테스트 사이클의 시작시 핀 테스팅 회로에 공급되어야 하기 때문에 루프 명령이 있는 경우 벡터 시퀀스에 공백(gap)을 야기한다. Jeffrey는 이러한 문제점을 해결하기 위하여 캐쉬 메모리를 사용한다.

테스트의 시작 전에, 벡터 메모리 제어기는 실행할 반복 회수뿐만 아니라 제1 루프의 시작 및 끝 벡터의 벡터 시퀀스 출력에서의 위치를 나타내는 명령을 수신한다. 테스트 동안, 벡터 메모리 제어기가 제1 루프의 제1 벡터와 만나는 경우, 벡터 메모리 제어기는 루프의 마지막 벡터에 도달하기까지 캐쉬 메모리에 루프의 벡터 저장을 시작한다. 이 지점에서, 벡터 메모리 제어기는 벡터 메모리로부터 벡터를 판독하는 대신에 캐쉬 메모리로부터 벡터를 판독하기 시작한다. 시작 및 끝 주소와 제2 루프의 길이를 가리키는 명령은 제1 루프의 마지막 벡터를 따라 벡터 메모리에 저장된다. 제1 루프를 끝내고 제2 루프를 통과하는 동안, 메모리 제어기는 캐쉬 메모리로부터 벡터를 판독하면서 벡터 메모리로부터 제2 루프에 대한 명령을 판독한다. 따라서 캐쉬 메모리가 벡터 메모리로부터 다음 루프 명령을 판독하는 동안, 캐쉬 메모리는 메모리 제어기에 벡터의 대체 소스를 제공한다. 이는 삽입된 루프 명령에 의하여 야기된 벡터 시퀀스에서의 공백을 제거한다. Jeffrey시스템이 메모리 캐슁(caching) 및 패턴 생성을 모두 이용하지만, Jeffrey시스템의 알고리즘 패턴 생성 능력은 다소 제한적이다. Jeffrey시스템은 루프만을 실행할 수 있고, 서브루틴 호출 또는 조건적인 분기를 실행할 수는 없다.

파이프 라인 명령 제어기(Pipeline Instruction Processors)

몇몇 패턴 생성기는 각 메모리 주소에 동시에 저장되는 명령와 패턴 데이터를 갖춘 명령 제어기와 메모리를 포함한다. 명령/패턴 데이터 쌍이 메모리로부터 판독되는 경우, 패턴 데이터는 패턴 생성기 출력을 제공한다. 명령은 명령 제어기에 판독할 다음의 명령/패턴 데이터 쌍의 메모리 주소를 선택하는 방법을 알린다. 이러한 패턴 생성기는 호출(call), 복귀(return), 분기(branch) 및 루프(loop) 등을 포함한 넓은 범위의 명령을 포함할 수 있다. 그러나 명령 제어기가 테스트 사이클의 시작시 명령을 해독해야 하고 다음 테스트 사이클의 시작까지 새로운 메모리 주소로 점프할 준비를 해야 하기 때문에, 메모리 제어기가 명령을 해독할 수 있는 속도로는 패턴 생성기의 동작 주파수가 제한될 수 있다.

몇몇 애플리케이션에서, 고속 명령 제어기는 명령을 해독하고 실행하는 파이프 라인 구조를 사용한다. 파이프 라인 제어기에서 명령은 연속적인 파이프 라인 단계에 의하여 동시에 처리되는 연속적인 명령와 함께 많은 처리 단계를 통하여 연속적으로 클럭된다. 각 단계의 처리량이 비교적 적은 명령을 처리할 것을 필요로 하기 때문에, 단계를 통하여 명령을 클럭하는 클럭 신호는 비교적 높은 주파수일 수 있다. 모든 파이프 라인 단계가 명령을 완전히 처리하기 위하여 필요한 전체 시간은 비교적 길지만, 명령 처리기는 클럭 신호의 각 펄스에서 명령을 완전히 처리할 수 있다. 따라서 파이프 라인 처리기는 큰 클럭 주파수에서 명령을 처리한다.

파이프 라인 명령 처리기는 고주파수에서 명령을 처리할 수 있지만, 패턴 생성기에는 사용되지 않는다. 예를 들어 파이프 라인 명령 처리기가 보통 각 테스트 사이클의 시작시 벡터 메모리로부터 순차적으로 벡터를 판독하지만, 주소 점프를 요하는 분기, 호출 또는 복귀 같은 명령에 응답하여 몇몇 다른 메모리 주소로 점프할 수 있다고 가정하자. 또한 파이프 라인 명령 처리기가 명령을 완전히 실행하기 위하여 N번의 클럭 사이클을 필요로 한다고 가정하자. 명령 처리기가 주소 점프를 요하는 명령과 만나는 경우, 처리기가 패턴 생성기 출력의 연속성을 유지하기 위하여 다음 테스트 사이클에서 곧 점프하는 것이 바람직하다. 그러나 명령 처리기는 점프하기 위하여 실제로 N번의 테스트 사이클을 요하기 때문에, 명령 처리기는 다음 N개의 메모리 주소에 저장된 명령의 판독을 계속할 것이다. N개 명령의 여분(extra)의 세트는 N개의 패턴 데이터 값의 시퀀스가 패턴 생성기의 출력 데이터 시퀀스에 삽입되도록 한다.

캐쉬 메모리 시스템을 사용하고, 여분의 데이터를 각 메모리의 주소 점프 전에 출력 데이터 패턴에 삽입하지 않고 파이프 라인 명령 처리 구조를 이용하는 알고리즘 패턴 생성기를 필요로 한다.

본 발명은 알고리즘 패턴 생성기에 관한 것이다.

도 1은 블록도로 나타낸 본 발명에 따른 알고리즘 패턴 생성기이고,

도 2 내지 도 7은 도 1의 상태 기계(state machine)의 동작을 예시하는 순서도이고,

도 8은 보다 상세한 블록도로 도 1의 메모리 제어기를 나타내고,

도 9는 보다 상세한 블록도로 도 8의 명령 제어기를 나타낸다.

본 발명에 따른 알고리즘 패턴 생성기는 고주파수 클럭 신호의 각 사이클 동안에 출력 데이터 값을 산출한다. 패턴 생성기는 각 클럭 신호 사이클 동안 메모리 제어기로 주소 지정된 명령을 판독하기 위한 메모리 제어기와 주소 지정 가능(addressable) 명령 메모리를 포함한다. 메모리 제어기는 보통 각 클럭 신호 사이클 동안 명령 메모리 판독 주소를 증가시키지만, 명령 제어기로부터 호출, 복귀, 반복 또는 분기 명령을 수신한 후, 다른 주소의 N+1번의 클럭 신호 사이클로 점프할 수 있다. 명령 처리기는 보통 각 클럭 신호 사이클동안 명령 메모리로부터 판독한 명령을 실행하고, 패턴 생성기의 출력 데이터처럼 실행된 명령에 포함된 데이터 필드를 제공한다. 명령의 다른 필드는 명령 처리기가 메모리 제어기에 전송하는 명령을 참조한다. 메모리 제어기는 명령에 응답하여 N+1번의 클럭 신호 사이클을 요구하기 때문에, 실제로 주소 점프를 실행하기 전에 점프 명령을 수신한 후 N번의 클럭 신호 사이클에 대한 명령 메모리 주소를 계속 증가시킨다.

명령 처리기가 메모리 제어기에 주소 점프 명령을 전송한 후에, 패턴 생성기는 N번의 클럭 사이클동안 실행되는 적합한 N개 세트의 명령으로 이미 로딩되는 보조 버퍼 메모리(auxiliary buffer memory)를 포함한다. 이러한 N번의 사이클 동안, 명령 처리기는 명령 메모리로부터 판독한 명령 대신에 보조 버퍼 메모리에 저장된 N개의 명령을 실행한다. 그 뒤의 다음 클럭 신호 펄스에서, 메모리 제어기가 주소 점프할 시간을 가지는 경우, 명령 처리기는 명령 메모리로부터 판독한 명령의 실행을 다시 시작한다.

따라서 본 발명의 목적은 클럭 신호의 각 펄스에 응답하여 벡터 데이터 값을 알고리즘적으로 생성하는 패턴 생성기를 제공하는 것이다.

본 명세서의 특허 청구 범위에는 본 발명을 정의하고 보호받고자 하는 사항이 기재되어 있다. 그러나 당업자가 본 발명의 이점 및 목적과 함께, 참조 부호로 표기해 첨부한 도면으로 명세서의 나머지 부분을 읽으면 본 발명의 구조 및 방법을 잘 이해할 수 있을 것이다.

도 1은 본 발명에 따른 알고리즘 패턴 생성기(10)를 예시한다. 패턴 생성기(10)는 대용량 DRAM, 캐쉬 메모리 시스템(14) 및 명령 처리기(instruction processor)(16)를 포함한다. 외부 호스트 컴퓨터(host computer)(도면에 도시하지 않음)는 버스(22)를 통하여 DRAM(12)에 기록 액세스(write access)한다. 캐쉬 메모리 시스템(14)은 DRAM(12)을 판독 액세스(read access)한다. 패턴 생성기(10)를 프로그래밍하기 위하여, 호스트 컴퓨터는 DRAM(12)의 각 주소에 16개 명령의 블록을 기록한다. 패턴 생성을 시작하기 위하여, 호스트 컴퓨터는 캐쉬 메모리 시스템(14)내의 메모리 제어기(34)에 시작 신호를 전송한다. 시작 신호에 응답하여 메모리 제어기(34)는 DRAM(12)의 연속된 주소로부터 명령 블록(INST_BLK)을 판독하기 시작하고, 한 세트의 5개의 캐쉬 메모리(38_1 내지 38_5)내에 연속된 주소의 개별적인 명령을 저장하기 시작한다. 메모리 제어기(34)가 DRAM(12)으로부터 판독한 명령으로 캐쉬 메모리(38)를 채우는 때, 시작(START) 신호를 명령 처리기 (16)에 전송하여 캐쉬 메모리 시스템(14)이 명령 판독을 시작함을 알린다. 이 후, 외부에 발생된 PCLK(periodic clock signal, 주기 클럭 신호)의 각 펄스상에서 메모리 제어기(34)는 캐쉬 메모리(38) 중 하나를 판독할 수 있고 주소를 지정하여 캐쉬 메모리로 하여금 주소가 지정된 명령(CACHE_INST)를 판독하고 명령 처리기(16)에 전송하도록 한다.

캐쉬 메모리(38_1 내지 38_3)는 주프로그램 명령을 저장한다. 주프로그램 명령을 판독하기 위하여, 메모리 제어기(34)는 순차적으로 각 캐쉬 메모리(38_1 내지 38_3)를 차례로 판독한 뒤, 다시 순차적으로 캐쉬 메모리(38_1)의 주소 지정을 시작한다. 캐쉬 메모리(38_1 내지 38_3) 중 어느 하나에 마지막 주소를 판독 액세스한 후, 메모리 제어기(34)는 통상적으로 새로운 명령의 블록을 DRAM(12)으로부터 캐쉬 메모리에 전송한다.

캐쉬 메모리(38_4)는 서브루틴(subroutine)을 저장하기 위하여 마련되며, 캐쉬 메모리(38_5)는 프로그램 분기의 다수의 제1 명령을 저장하도록 마련된다. 아래에 상세히 논의되는 것처럼, 메모리 제어기(34)는 DRAM(12)으로부터의 서브루틴을 캐쉬 메모리(38_4)에 전송하고, 시작 신호를 수신한 후 프로그램 분기의 다수의 제1 명령을 캐쉬 메모리(38_5)에 전송한다. 이 서브루틴과 분기 명령은 캐쉬 메모리(38_4 및 38_5)에 남아 있어 주 프로그램에 의하여 호출될 때마다 캐쉬 메모리에서 바로 접근 가능하다.

캐쉬 메모리 시스템(14)은 각 PCLK 신호 사이클 동안 캐쉬 메모리(38_1 내지 38_5) 중 하나로부터 명령을 판독하고 이 명령(CACHE_INST)를 명령 처리기(16)에 제공한다. DRAM(12)은 대용량이고 비교적 저가이나 저속 메모리는 PCLK 신호의 고주파수에서 데이터를 판독할 수 없다. 그러나, DRAM(12)이 각 주소마다 16개의 명령을 보유하기 때문에, 여전히 PCLK 신호의 각 사이클마다 한 명령의 평균을 제공하면서 보다 낮은 주파수에서 명령의 블록을 판독할 수 있다. 한편, 캐쉬 메모리(38_1 내지 38_5)는 비교적 작고 보유한 명령 숫자에 비해 고가이지만, 높은 PCLK 신호 주파수에서는 개별적인 명령을 판독할 수 있다.

PCLK 신호의 각 펄스상에서 명령 처리기(16)는 메모리 제어기(34)에 명령을 전송하도록 알리는 명령을 실행한다. 대부분의 명령은 명령 처리기(16)에 증가 명령(increment command, INC)을 메모리 제어기(34)로 전송함을 알려 캐쉬 메모리 주소가 증가함을 메모리 제어기(34)에게 알린다. 그러나, 몇몇 명령은 메모리 제어기(34)에게 특별한 캐쉬 메모리 주소로 점프하도록 알린다. 예를 들어, 서브루틴 호출 명령(CALL)은 현재의 캐쉬 메모리 판독 주소를 저장한 뒤, 캐쉬 메모리(38_4)의 제1 주소로 점프하도록 메모리 제어기(34)에게 알린다. 호출된 서브루틴의 마지막 명령이 캐쉬 메모리(38_4)로부터 판독되어 실행된 후, 서브루틴 복귀 명령은 메모리 제어기(34)에 다음의 주프로그램 주소로 복귀할 것을 알린다. 주소 점프를 요구하는 다른 명령은 아래에 서술한다.

캐쉬 메모리 시스템(14)의 각 출력 명령(CACHE_INST)은 연산 코드(OPCODE), 피연산자(OPERAND) 및 데이터 필드를 포함한다. PCLK 신호의 각 사이클 동안, 명령 처리기(16)는 통상적으로 캐쉬 메모리 시스템(14)의 출력 명령을 실행하며, 패턴 생성기의 데이터 출력으로서 실행 명령의 데이터 필드를 제공한다. 각 명령의 연산 코드 필드는 명령 처리기(16)가 메모리 제어기(34)에 전송하는 특수 명령을 참조한다. 명령의 피연산자 필드에 전달되는 정보는 연산 코드에 좌우된다. 연산 코드가 현재 명령이 반복될 명령(루프) 시퀀스의 제1 명령임을 가리키는 경우, 피연산자는 루프가 반복된 회수를 가리킨다. 연산 코드가 메모리 제어기(34)가 분기를 실행하도록 명령하는 경우, 피연산자는 어떤 메모리 제어기(34)를 분기할지를 DRAM(12) 메모리 주소에 명령한다. 이러한 경우, 명령 처리기는 분기 명령을 갖춘 메모리 제어기(34)에 피연산자를 전달한다.

지연 주소 점핑(Delayed Address Jumping)

이상적으로 메모리 제어기(34)가 명령 처리기(16)로부터 주소 점프를 요청하는 명령을 수신한 후, 다음 PCLK 신호에 응답하여 정확한 캐쉬 메모리 주소에 바로 점프하는 것이 바람직하다. 그러나, 패턴 생성기(10)가 매우 높은 PCLK 신호 주파수에서 동작하기 때문에, 캐쉬 메모리 시스템이 명령에 응답할 수 있는 PCLK 신호 사이클 동안의 충분한 시간이 없다. 따라서 캐쉬 메모리 시스템(14)은 명령 처리기(16)로부터 수신 명령을 처리하는 파이프 라인 구조를 사용한다. 파이프 라인 구조 때문에, 메모리 제어기(34)는 수신 명령을 처리할 N번의 PCLK 신호 사이클(N은 1보다 큼)를 요구하고, 그 명령에 의하여 요구되는 주소로 점프하며, 명령 처리기(16)에 점프 주소의 명령을 전달한다.

예를 들어, 메모리 제어기(34)가 몇몇 주소(Y)로 점프하라는 명령을 수신하는 경우, 현재 몇몇 캐쉬 메모리 주소(X)를 주소 지정(address)한다고 가정하자. 메모리 제어기(34)가 점프 명령을 실행할 것을 요하는 N번의 PCLK 펄스 동안, 메모리 제어기(34)는 캐쉬 메모리 주소(X+1)부터 캐쉬 메모리 주소(X+N)까지에 저장된 N개 명령의 시퀀스를 판독한다. 캐쉬 메모리 제어기(34)가 실제로 주소(Y)에 점프할 수 있는 경우는 주소(Y)에 점프하라는 명령을 수신한 후에 (N+1)번째 PCLK 신호 펄스 상에 있을 때이다. 따라서 주소 점프를 호출하는 명령을 메모리 제어기(34)에 전송한 후, 명령 처리기(16)는 점프 주소(Y)에 저장된 명령을 수신하기 위하여 (N+1)번의 사이클을 기다려야 한다. 그 동안, 명령 처리기(16)는 캐쉬 메모리 주소(X+1)부터 캐쉬 메모리 주소(X+N)까지에 저장된 N개의 명령을 수신한다. 그러나 이러한 명령은 N번의 PCLK 사이클 동안 실행되어야 하는 것이 아니다. 명령 처리기(16)는 이러한 문제점을 버퍼 메모리(39)의 도움으로 해결한다.

버퍼 메모리(39)는 한 세트의 FIFO(first-in/first-out, 선입 선출) 버퍼 (40_1 내지 40_5)를 포함하며, 각 버퍼는 N개 명령의 시퀀스를 저장할 수 있다. 캐쉬 메모리 시스템(14)뿐만 아니라 각 FIFO 버퍼의 명령 출력은 상태 기계(36)의 제어 데이터 출력(OUTSEL)에 의하여 제어되는 출력 다중화기(multiplexer)의 개별적인 입력을 유도한다. 출력 다중화기(42)는 출력 명령(OUT_INST)으로서 입력 명령 전부를 선택할 수 있다. 출력 명령(OUT_INST)의 데이터 필드는 패턴 생성기 (10)의 출력 데이터를 구성한다. 출력 명령(OUT_INST)의 연산 코드 필드는 상태 기계(36)에 입력을 제공한다. 출력 명령(OUT_INST)의 피연산자 필드는 한 쌍의 카운터(45_1 및 45_2)에 데이터 입력을 제공하고 명령 처리기(16)가 메모리 제어기(34)에 전송하는 명령의 한 부분을 형성한다.

서브루틴 명령 로딩(Subroutine Instruction Loading)

위에 언급한 것처럼, 캐쉬 메모리(38_4)는 서브루틴 명령을 저장한다. 실제로 이것은 서브루틴의 거의 N개의 제1 명령을 저장한다. 프로그래밍 단계 동안, 호스트 컴퓨터는 서브루틴을 DRAM(12)의 다수의 제1 주소에 기록한다. 호스트 컴퓨터가 메모리 제어기(34)에 시작 신호를 전송한 후에, 메모리 제어기(34)는 DRAM(12)으로부터 서브루틴을 판독하고, 캐쉬 메모리(38_1)의 N개의 제1 주소에 N개의 제1 서브루틴 명령을 기록하며 캐쉬 메모리(38_4)에 잔여 서브루틴 명령을 기록한다.

캐쉬 메모리(38_1 내지 38_3)의 잔여 부분을 주프로그램 명령으로 채운 후, 메모리 제어기(34)는 시작 신호를 상태 기계(36)로 전송하고, 명령을 명령 처리기 (16)에 전송하도록 캐쉬 메모리(38_1)의 판독 주소 지정을 시작한다. 따라서 캐쉬 메모리 시스템(14)은 초기에 서브루틴의 N개의 제1 명령을 판독하고, 이를 명령 처리기(16)에 전송한다.

시작 신호를 수신한 후, 상태 기계(36)는 제어 데이터(OUTSEL)를 다중화기 (multiplexer)(42)에 입력하도록 설정하여 캐쉬 메모리 시스템(14)의 출력 명령을 FIFO 버퍼(40_1)에 전달한다. 상태 기계(36)는 시작 신호 펄스에 따른 PCLK 신호의 각 N개의 제1 펄스에 응답하여 신호(SHIFT1)를 펄스화하며, 이로써 제1 7개의 명령(CACHE_INST)을 FIFO 버퍼(40_1)로 시프트(shift)한다. 상태 기계(36)는 제2 세트의 N개의 캐쉬 메모리 출력 명령을 FIFO 버퍼(40_4)에 로딩하는 다음 N개의 PCLK 펄스에 응답하여 출력 신호(SHIFT4)를 펄스화한다. 따라서, "호출" FIFO 버퍼(40_1)는 서브루틴의 N개의 제1 명령을 저장한다.

분기 명령 로딩(Branch Instruction Loading)

프로그램 실행 중에 메모리 제어기(34)가 몇몇 DRAM 메모리 주소에 분기되도록 명령을 받는 경우, 선택된 메모리 주소에서 DRAM(12)으로부터 하나의 명령 블록을 판독해야 하며, 이들을 캐쉬 메모리(38_1)에 기록해야 하고, 캐쉬 메모리로부터 명령을 판독하기 시작하여 이를 명령 처리기(16)에 전송해야 한다. 메모리 제어기 (34)가 한 사이클에 이를 할 수 없기 때문에, 명령 처리기(16)는 FIFO 버퍼(40_4)로부터 분기의 N개의 제1 명령을 얻는다. 메모리 제어기(34)는 시스템 시작 동안 이러한 N개의 명령을 FIFO 버퍼(40_4)에 로딩한다. 캐쉬 메모리 제어기(34)는 또한 다음 M개의 분기 명령을 시스템 시작시의 캐쉬 메모리(38_5)에 로딩한다. M값은 메모리 제어기(34)가 DRAM(12)으로부터 여러 명령 블록을 판독하고 이를 캐쉬 메모리(38)에 기록하는데 필요한 시스템 클럭 사이클의 수로 선택된다.

시스템의 시작 전에, 호스트 컴퓨터는 서브루틴 명령에 따라 바로 분기 시퀀스의 제1 명령(N+M)을 DRAM(12)에 기록한다. 시작 명령을 수신하고 DRAM(12)으로부터 N개의 제1 서브루틴 명령을 FIFO 버퍼(40_1)에, 잔여 서브루틴 명령을 캐쉬 메모리(38_4)로 시프트한 후에, 메모리 제어기(34)는 N개의 제1 분기 명령을 캐쉬 메모리(38_1)의 한 세트의 N개의 제2 주소로 이동하고 캐쉬 메모리(38_5)에 다음 M개의 분기 명령을 기록한다. 메모리 제어기(34)는 시작 신호를 펄스화하고, 캐쉬 메모리(38_1)로부터 명령을 판독하기 시작하여 이들을 명령 처리기(16)에 전송한다. 명령 처리기(16)는 호출 FIFO 버퍼(40_1)에서 수신하는 N개의 제1 명령을 저장하고, 분기 FIFO 버퍼(40_4)에서 수신하는 다음 N개의 명령을 저장한다.

메모리 제어기(34)가 시작 신호를 표명(assert)한 후에, 패턴 생성기(10)는 PCLK 신호의 (2N+1)번째 펄스에 그 출력 패턴을 산출하기 시작한다. 이 때, 상태 기계(36)는 캐쉬 메모리 시스템(14)의 다음 출력 명령(CACHE_INST)을 선택하도록 출력 다중화기(42)를 설정하고, 드라이버(driver)(37)를 구동하는 출력에 신호(OE)를 표명한다. 드라이버(37)는 패턴 생성기 출력 데이터로서 현재의 실행 명령(OUT_INST)의 데이터 필드를 전달한다. 그 후 다른 방법으로 실행하도록 알리는 명령 연산 코드를 수신할 때까지, 상태 기계(36)는 현재 실행 명령(OUT_INST)으로서 캐쉬 메모리 시스템 출력 명령(CACHE_INST)을 선택한다.

호출 및 복귀 명령 처리(CALL and RETURN Instruction Processing)

현재 명령(OP_INST)의 연산 코드(OPCODE)가 메모리 제어기(34)가 거의 N개의 제1 서브루틴 명령을 저장하는 캐쉬 메모리(38_4)의 제1 주소로 점프하는 것을 명령하는 경우, 상태 기계(36)는 메모리 제어기(34)에 호출 명령을 전송한다. 동시에 상태 기계(36)는 출력 다중화기(42)를 스위치하여 메모리 제어기(34)의 출력(CACHE_INST) 대신에 호출 FIFO 버퍼(40_1)의 명령 출력을 선택한다. 상태 기계(36)는 또한 다중화기(42)를 스위치하는 신호(OUTSEL)를 설정하므로 캐쉬 메모리 시스템(14)의 출력(CACHE_INST)을 "복귀" FIFO 버퍼(40_5)에 경로화(route)하기 시작한다. 다음 N개의 PCLK 신호 펄스의 각각에 응답하여, 상태 기계(36)는 FIFO 버퍼(40_1 및 40_5)를 통하여 명령을 시프트하도록 신호(SHIFT1 및 SHIFT5)를 펄스화한다. 호출 FIFO(40_1)는 서브루틴의 N개의 제1 명령으로 미리 로딩되기 때문에, 그러한 N개의 제1 서브루틴 명령은 FIFO 버퍼(40_1)에서 시프트 아웃(shift out)하여 다음 N개의 실행 명령(OUT_INST)로 되도록 출력 다중화기(42)를 통과한다. 신호(SHIFT1)는 또한 그러한 N개의 명령(OUT_INST)을 다시 호출 FIFO 버퍼(40_1)로 시프트시켜, FIFO 버퍼가 서브루틴이 다시 호출되도록 한다는 점에서 유용할 것이다. 상태 기계(36)의 신호(SHIFT5) 출력은 캐쉬 메모리 시스템(14)으로부터의 다음 N개의 명령(CACHE_INST)을 복귀 FIFO(40_5)로 시프트한다. 그러한 것은 서브루틴 호출을 초기화하는 명령에 따라 캐쉬 메모리에 저장된 N개의 제1 명령이기 때문에, 프로그램이 호출된 서브루틴으로부터 복귀하는 경우 명령 처리기(16)가 나중에 실행해야 할 N개의 제1 명령이어야 한다.

상태 기계(36)가 호출 명령을 전송한 후 PCLK 신호의 (N+1)번째 펄스에서, 상태 기계는 캐쉬 메모리 시스템(14)의 출력(CACHE_INST)을 다시 선택하도록 출력 다중화기(42)를 스위치한다. 이 경우, 메모리 제어기(34)는 호출 명령에 응답하고 서브루틴의 (N+1)번째 명령을 포함하는 캐쉬 메모리(38_4)의 제1 주소를 판독 주소 지정한다. 그 후, 메모리 제어기(34)는 상태 기계(36)로부터 복귀 명령을 수신하고 처리할 때까지 캐쉬 메모리(38_4)를 순차적으로 계속해 주소 지정을 한다.

캐쉬 메모리(38_4)에 저장된 서브루틴의 마지막 명령은 "복귀" 연산 코드를 포함한다. 상태 기계(36)가 복귀 연산 코드를 탐지하는 경우, 서브루틴 점프로부터 복귀함을 알리도록 메모리 제어기(34)에 복귀 명령을 전송한다. 복귀 연산 코드를 수신한 후의 N번의 제1 사이클동안, 상태 기계(36)는 복귀 FIFO 버퍼(40_5)에 저장된 N개의 명령을 선택하도록 출력 다중화기(42)를 스위치한다. 그 동안 복귀 명령을 처리할 충분한 시간을 확보할 때까지, 메모리 제어기(34)는 복귀 명령에 따라 N개의 주소에 저장되는 명령은 무엇이든 판독하는 캐쉬 메모리(38_4)를 순차적으로 주소 지정하는 작업을 계속한다. 명령 처리기(16)는 그러한 명령을 수신하지만 저장하거나 실행하지 않는다.

메모리 제어기(34)가 호출 명령에 응답하여 주소 점프를 하는 경우, 현재의 캐쉬 주소(X)를 저장한다. 메모리 제어기(34)는 호출 명령에 응답하여 (N+1)번의 사이클을 요구했기 때문에, 주소(X)는 호출 명령이 저장되는 캐쉬 메모리 주소보다 N+1만큼 큰 주소를 참조한다. 메모리 제어기(34)는 또한 복귀 명령에 응답하여 N+1번의 사이클을 요구하기 때문에, 복귀 명령후 실행되는 (N+1)번째 주프로그램 명령을 포함하는 캐쉬 메모리 주소(X+N+1)로 점프한다. 따라서, 복귀 연산 코드의 탐지를 따르는 (N+1)번째 PLCK 신호 펄스상에서 캐쉬 메모리 시스템(14)이 주소(X+N+1)에서의 명령을 판독함에 따라, 상태 기계(36)는 현재 명령(OUT_INST)로서 캐쉬 메모리 시스템 출력 명령(CACHE_INST)을 선택하기 위하여 출력 다중화기(42)를 스위치한다.

분기 명령 처리(Branch Instruction Processing)

상태 기계(34)에 입력되는 외부에 생성된 사건(EVENT) 신호가 현재 표명되는 경우, 상태 기계(36)는 분기 명령을 메모리 제어기(34)에 전송하도록 알리는 연산 코드를 수신할 수 있다. 분기(BRANCH) 명령이 연산 코드를 수반한 피연산자에 의하여 가리키는 몇몇 DRAM(12) 주소로 분기하도록 메모리 제어기(34)에게 알린다. 피연산자(OPERAND)는 분기 명령과 함께 메모리 제어기(34)에 제공된다. 메모리 제어기(34)에 분기 명령을 전송한 후에, 상태 기계(36)는 출력 다중화기(42)를 스위치하여 다음 N번의 PCLK 신호 사이클 동안 FIFO 버퍼(40_4)의 출력을 선택한다. 그 뒤 다음 각 N번의 PCLK 신호 펄스에 응답하여, 상태 기계(36)는 실행할 다음 N개의 명령(OUT_INST)을 제공하는 FIFO 버퍼에 저장된 N개의 제1 명령을 시프트 아웃하도록 출력(SHIFT4)을 펄스화한다. 그 뒤, 상태 기계(36)는 실행 명령 (OUT_INST)의 소스로서 메모리 제어기(34)의 출력(CACHE_INST)의 선택을 다시 시작하도록 출력 다중화기(42)를 스위치한다. 그 동안, 메모리 제어기(34)는 다음 M개의 분기 명령을 저장하는 캐쉬 메모리(38_5)의 제1 주소로 점프하도록 요구되는 N+1번의 PCLK 신호 사이클을 지닌다. 다음 M번의 PCLK 신호 사이클 동안 캐쉬 메모리(38_5)로부터 그러한 M개의 명령을 판독하면서, 메모리 제어기(34)는 피연산자에 의하여 식별된 분기 주소 다음의 (N+M+1)번째 명령을 포함하는 DRAM(12) 주소와 DRAM(12)으로부터의 명령을 캐쉬 메모리(38_1 내지 38_3)에 전송하기 시작한다. 캐쉬 메모리(38_5)에 저장된 M개의 명령 중 마지막 명령을 판독한 후에, 메모리 제어기(34)는 다음 분기 명령을 포함하는 캐쉬 메모리(38_1)의 제1 주소로 점프한다.

루프 명령(LOOP Instruction)

패턴 생성기(10)는 중첩된 명령 루프의 두 레벨을 실행할 수 있고, 따라서 두 세트의 루프 명령(LOOP1_START/LOOP1_END 및 LOOP2_START/LOOP2_END)을 포함한다.

현재 명령(OUT_INST)에서 연산 코드(LOOP1_START 또는 LOOP2_START)는 현재 명령(OUT_INST)가 M번 반복된 명령의 첫 시퀀스임을 가리킨다. 수반하는 피연산자는 M값을 가리킨다. 연산 코드(LOOP1_START 또는 LOOP2_START)를 탐지하는 경우, 상태 기계(36)는 명령(START1 또는 START2)을 메모리 제어기(34)에 전송하고, 피연산자 값(M)을 대응 제1 루프 카운터(45_1) 또는 제2 루프 카운터(45_2)에 로딩한다. 다음 N번의 테스트 사이클 동안, 상태 기계(36)는 다음 N개의 명령(OUT_INST)을 "제1 루프" FIFO 버퍼(40_2) 또는 "제2 루프" FIFO 버퍼(40_3)에 시프트(shift)한다. (N+1)번째 PCLK 신호 펄스에서, 메모리 제어기(34)는 내부 레지스터에 현재 메모리 주소를 저장함으로써 명령(START1 또는 START2)에 응답한다.

반복된 명령 시퀀스의 마지막 명령은 상태 기계(36)가 제1 루프 카운터 (45_1) 또는 제2 루프 카운터(45_2)를 감소하도록 알리는 연산 코드("LOOP1_END" 또는 "LOOP2_END")를 포함한다. 카운터의 출력이 아직 1에 도달하지 않은 경우, 상태 기계(36)는 명령(REPEAT1 또는 REPEAT2)을 메모리 제어기(34)에 전송하고 출력 다중화기(42)를 스위치함으로써 제1 루프 버퍼(40_2) 또는 제2 루프 버퍼(40_3)의 명령 출력을 선택한다.

다음 N번의 사이클동안, 메모리 제어기(34)가 명령(REPEAT1 또는 REPEAT2)을 처리하는 시간을 가질 때까지, 상태 기계(36)는 적합한 제1 루프 FIFO 버퍼(40_2) 또는 제2 루프 FIFO 버퍼(40_3)로부터 루프의 N개의 제1 명령을 시프트하여 이를 다음 N개의 명령(OUT_INST)으로서 나타낸다. 상태 기계(36)는 또한 다음 N개의 명령(OUT_INST)을 동일한 FIFO 버퍼(40_1 또는 40_2)로 시프트하므로, 루프의 다음 반복시 유용할 것이다. 명령(REPEAT1 또는 REPEAT2)을 수신한 후 (N+1)번째 주기에서, 메모리 제어기(34)는 명령(START1 또는 START2)에 응답하여 저장된 캐쉬 주소로 점프한다. 여기서 캐쉬 메모리 시스템(14)은 루프 명령의 (N+1)번째 명령을 판독한다. 이 때 상태 기계(36)는 출력 다중화기(42)를 스위치하여 메모리 제어기(34)로부터 출력(CACHE_INST)을 선택한다.

루프 끝에 연산 코드(LOOP1_END 또는 LOOP2_END)를 수신하는 경우, 상태 기계(36)가 제1 루프 카운터 또는 제2 루프 카운터의 출력 카운트가 루프의 다음 반복이 마지막 반복임을 가리키는 1에 도달함을 탐지할 때까지 과정이 계속된다. 이 때, 상태 기계(36)는 명령(REPEAT1 또는 REPEAT2) 대신에 메모리 제어기(34)에 명령(END1 또는 END2)을 전송한다. 메모리 제어기(34)는 명령(REPEAT1 또는 REPEAT2)에 응답하는 동일한 방식으로 명령(END1 및 END2)에 응답한다. 그러나 루프 명령이 한번 더 실행된 후에 명령(END1 또는 END2)이 메모리 제어기(34)에 DRAM(12)로부터의 기록 명령을 루프 명령을 포함하는 캐쉬 메모리 저장 위치로 이동하는 것이 자유롭다는 것을 알린다.

루프의 마지막 반복 끝에 명령(LOOP1_END 또는 LOOP2_END)과 만나는 경우, 상태 기계(36)는 루프 카운터(45_1 또는 45_2)의 출력(M)이 0임을 탐지한다. 이 때, 상태 기계(36)는 메모리 제어기(34)에 증가 명령을 전송하고 출력 다중화기(42)의 설정을 계속하여 캐쉬 메모리 시스템(14)의 출력 명령(CACHE_INST)을 선택한다.

명령 처리기 상태 기계(Instruction Processor State Machine)

도 2는 순서도로서 도 1의 명령 처리기(16)의 상태 기계(36)의 동작을 예시한다. 시작 신호에 의하여 리셋된 뒤에 상태 기계(36)는 위와 같은 방법으로 N개의 제1 명령(CACHE_INST)을 호출 FIFO 버퍼(40_1) 및 분기 FIFO 버퍼(40_4)에 로딩함으로써 다음 2N개의 PCLK 신호 펄스에 응답하는 "초기화(initialize)" 루틴을 수행한다(단계 60). PCLK 신호 펄스를 탐지한 후(단계 62), 상태 기계(36)는 다음에 수신된 연산 코드가 CALL(호출), RETURN(복귀), LOOP1_START(제1 루프 시작), LOOP1_END(제1 루프 끝), LOOP2_START(제2 루프 시작), LOOP2_END(제2 루프 끝) 또는 BRANCH(분기) 명령인지 검사한다(단계 64∼70). 그렇지 않은 경우, 상태 기계(36)는 증가(INC) 명령을 메모리 제어기(34)에 전송하고(단계 71), 다음 PCLK 신호 펄스를 기다리기 위하여 단계 62로 복귀한다. 단계 64∼70중 하나에 상태 기계(36)가 앞에 언급한 연산 코드 중 하나를 탐지하는 경우, 단계 72∼78중의 하나에 일치하는 루틴을 실행한 뒤, 다음 PCLK 신호 펄스를 기다리기 위하여 단계 62로 복귀한다.

도 3은 현재 명령(OUT_INST)이 호출 명령인 경우, 도 2의 단계 72에서 수행하는 호출 루틴 상태 기계(36)를 예시한다. 상태 기계(36)는 초기에 메모리 제어기(34)에 호출 명령을 전송한 뒤(단계 80), 다음의 PCLK 신호 펄스를 기다린다(단계 82). 명령(OUT_INST) 소스로서 호출 FIFO 버퍼(40_1)의 출력과, FIFO 버퍼 (40_5)를 복귀시키는 입력으로서 호출 명령의 소스를 선택하기 위하여(단계 84) 출력 다중화기(42)를 설정한다. 상태 기계(36)는 명령을 호출로 시프트 인 및 시프트 아웃하고 FIFO 버퍼(40_1 및 40_5)를 복귀시키기 위하여(단계 90) 신호(SHIFT1 또는 SHIFT4)를 펄스화한다. 상태 기계(36)가 호출 명령을 받은 후에 N번째 PCLK 펄스를 탐지하지 못한 경우(단계 92), 상태 기계(36)는 단계 82로 복귀한다. 상태 기계(36)는 호출 FIFO(40_1)로부터 서브루틴의 N개의 제1 명령을 시프트할 때까지 단계 82∼92를 N번 반복한다. 이 때(단계 94), 상태 기계(36)는 명령(OUT_INST)으로서 명령(CACHE_INST)을 제공하도록 출력 다중화기(42)를 스위치한다. 그 뒤 호출 루틴은 도 2의 주루틴으로 복귀한다.

도 4는 현재의 명령(OUT_INST)가 복귀 명령인 경우, 도 2의 단계 73에서 수행하는 상태 기계(36)의 복귀 루틴을 예시한다. 상태 기계(36)는 초기에 메모리 제어기(34)에 복귀 신호를 보내고(단계 100), 다음의 PCLK 신호 펄스를 기다린다(단계 102). 그리고 이것은 명령(OUT_INST) 소스로서 반환 FIFO 버퍼(40_5)의 출력을 선택하도록(단계 104) 출력 다중화기(42)를 설정하고 명령을 복귀 FIFO 버퍼(40_5)로부터 시프트 아웃하기 위하여(단계 106) 신호(SHIFT1 및 SHIFT5)를 펄스화한다. 단계 108에서 상태 기계(36)가 복귀 명령을 수신한 후에 N번째 PCLK 펄스를 탐지하지 못하는 경우, 상태 기계(36)는 단계 102로 복귀한다. 상태 기계(36)는 복귀 FIFO(40_5)의 N개의 명령을 시프트할 때까지 단계 102∼108를 N번 반복한다. 이 때, 상태 기계(36)는 명령(OUT_INST)로서 명령(CACHE_INST)을 제공하도록 출력 다중화기(42)를 스위치한다. 복귀 루틴은 도 2의 주루틴으로 복귀한다.

도 5는 현재의 명령(OUT_INST)이 제1 루프 시작 명령인 경우, 도 2의 단계 74에서 실행하는 루틴(START1) 상태 기계(36)를 나타낸다. (단계 76에서 실행하는 제2 시작 루틴 상태 기계(36)는 대체로 유사하다.) 상태 기계(36)는 초기에 메모리 제어기(34)(단계 112)에 명령(START1)을 전송하고, 실행할 루프의 반복 회수 M에 따라 피연산자를 로딩하도록 도 1의 제1 루프 카운터(45_1)에 신호를 전송한다.(단계 114) 상태 기계(36)는 다음의 PCLK 신호를 기다리고(단계 116), 다음의 PCLK 신호 펄스를 탐지하는 경우, 현재의 명령(OUT_INST)을 제1 루프 FIFO 버퍼)(40_2)에 시프트한다(단계 118). 상태 기계(36)가 명령(LOOP_START1)을 수신한 후 N번째 PCLK 펄스를 탐지하지 못하는 경우(단계 119), 상태 기계(36)는 단계 116으로 복귀한다. 상태 기계(36)는 N개의 명령을 제1 루프 FIFO 버퍼(40_2)로 시프트하기까지 단계 116∼119를 N번 반복한다. 이 점에서, 제1 시작 루틴은 도 2의 주루틴으로 복귀한다.

도 6은 현재 명령(OUT_INST)가 명령(LOOP1_END)인 경우, 도 2의 단계 75에서 실행하는 제1 끝 루틴 상태 기계(36)를 나타낸다. (단계 77에서 실행하는 제2 끝 루틴 상태 기계(36)는 대체로 유사하다.) 제1 루프 카운터(45_1)의 출력값(M)이 0인 경우(단계 120), 루프의 마지막 반복이 완료됨을 가리키며 상태 기계(36)는 증가(INC) 명령을 메모리 제어기(34)에 전송하고(단계 121) 주루틴으로 복귀한다. M값이 1보다 큰 경우, 실행할 루프의 하나 이상의 반복이 남아 있음을 가리키고, 상태 기계(36)는 캐쉬 메모리 제어기에 명령(REPEAT1)을 전송한다(단계 122). M의 값이 1이면, 실행할 루프의 오직 한 부분이 남아 있음을 가리키며, 상태 기계(36)는 캐쉬 메모리 제어기에 명령(LAST1)을 전송한다(단계 123). 단계 122 또는 단계 123 후에, 상태 기계(36)는 제1 루프 카운터(45_1)에 출력 카운트 M을 감소시키도록 신호를 전송하고(단계 124), 다음 PCLK 신호를 기다린다(단계 125). 다음의 PCLK 신호 펄스를 탐지하는 경우, 이것은 다음 명령(OUT_INST)의 소스로서 제1 루프 FIFO 버퍼)(40_2)를 선택하기 위하여 출력 다중화기(42)를 설정하고(단계 126), 제1 루프 FIFO 버퍼(40_2)를 시프트하기 위하여 신호(SHIFT2)를 펄스화한다(단계 128). 단계 130에서 상태 기계(36)가 명령(LOOP1_END)을 수신 후 N번째 PCLK 펄스를 탐지하지 않는 경우 단계 125로 복귀한다. 상태 기계(36)는 제1 루프 FIFO 버퍼(40_2)를 N번 시프트할 때까지 단계 125∼130를 N번 반복한다. 상태 기계(36)는 명령(OUT_INST) 소스로서 명령(CACHE_INST)을 선택하기 위하여 출력 다중화기(42)를 설정한 뒤(단계 131) 도 2의 주루틴으로 복귀한다.

도 7은 현재 명령(OUT_INST)가 분기 명령인 경우, 도 2의 단계 78에서 실행되는 분기 루틴 상태 기계(36)를 나타낸다. 상태 기계(36)가 사건(EVENT) 신호 입력이 표명되지 않는다고 탐지하는 경우(단계 132), 증가(INC) 명령을 메모리 제어기(34)에 전송하고 주루틴으로 복귀한다. 그러나 사건(EVENT) 신호가 표명되는 경우, 상태 기계(36)가 분기 명령을 캐쉬 메모리 제어기에 전송한다(단계 136). 상태 기계(36)가 다음의 PCLK 신호 펄스를 탐지하는 경우(단계 140), 다음 명령(OUT_INST)의 소스로서 분기 FIFO 버퍼(40_4)를 선택하도록 출력 다중화기(42)를 설정하며 분기 FIFO 버퍼를 시프트하도록 신호(SHIFT4)를 펄스화한다.(단계 142) 단계 148에서 상태 기계(36)가 분기 명령을 받은 후 N번째 PCLK 펄스를 탐지하지 못하는 경우, 상태 기계(36)는 단계 138로 복귀한다. 상태 기계(36)는 분기 FIFO 버퍼(40_4)에 N번 시프트할 때까지 단계 136∼144를 N번 반복한다. 이 때, 상태 기계(36)는 출력 명령의 소스로서 캐쉬 메모리를 선택하기 위하여(단계 150) 다중화기(42)를 스위치하고 도 2의 주루틴으로 복귀한다.

메모리 제어기(Memory Controller)

도 8은 보다 상세한 블록도 형태로 도 1의 메모리 제어기(34)를 예시한다. 도 1의 호스트 컴퓨터가 DRAM(12)에 테스트 명령 블록을 기록한 후, 캐쉬 제어기(200)에 시작 신호를 전송한다. 캐쉬 제어기(200)는 도 1의 DRAM(12)으로부터 연속적으로 명령 블록을 판독하고 이를 위에 언급한 방법으로 캐쉬 메모리(38_1 내지 38_4)의 적절한 위치에 기록함으로써 시작 신호에 응답한다.

시작 신호는 또한 코맨드 처리기(command processor)(202)에 적용된다. 캐쉬 제어기(200)가 캐쉬 메모리를 로딩할 충분한 시간이 있는 경우, 코맨드 처리기(202)는 결정할 PCLK 신호의 펄스를 카운트한다. 코맨드 처리기(202)는 리셋 신호(R)를 주소 카운터(204)에 전송해, 이로 하여금 출력 카운트(READ_ADDR)를 0으로 설정하도록 한다. 주소 카운터(204)의 카운트 출력(READ_ADDR)의 각 값은 도 1의 캐쉬 메모리(38_1 내지 38_4) 중 하나의 개별적인 주소를 참조한다. 카운트 출력(READ_ADDR)의 초기 0값은 캐쉬 메모리(38_1)의 제1 메모리 주소를 참조한다. 카운트(READ_ADDR)는 캐쉬 제어기(200)에 입력으로 제공된다. PCLK 신호의 각 펄스에 응답하여 캐쉬 제어기(200)는 주소와 제어 신호를 캐쉬 메모리(38_1 내지 38_4) 중 적절한 하나에 공급하여 이로 하여금 카운터(204) 출력(READ_ADDR)에 의하여 참조된 주소에서 명령을 판독하고, 도 1의 명령 처리기(16)에 명령(CACHE_INST)로서 이를 전달하도록 한다. 그 뒤 코맨드 처리기(202)는 PCLK 신호의 각 펄스에 카운터(204)를 클럭하여, 카운터(204)로 하여금 출력 주소 카운트를 증가시키도록 한다.

캐쉬 제어기(200)는 파이프 라인 구조를 가지고 약간의 PCLK 사이클을 요구하며 캐쉬 메모리로 하여금 카운터(204)로부터 명령 주소(READ_ADDR)를 수신한 후에 각 명령을 판독하도록 한다. PCLK 사이클의 충분한 회수가 제1 명령 판독 캐쉬 메모리(38_1)로 하여금 명령 처리기(16)에 도달하게 통과하는 경우, 코맨드 처리기(202)는 명령 수신을 시작함을 알리기 위하여 명령 처리기(16)에 시작 신호 입력을 표명한다.

그 뒤 코맨드 처리기(202)는 캐쉬 제어기(200)로 하여금 계속적으로 각 캐쉬 메모리(38_1 내지 38_3)를 주소 지정하도록 함으로써 카운터(204)를 계속적으로 클럭한다. 주소 카운터(204)의 출력 카운트가 캐쉬 메모리(38_3)의 마지막 주소를 참조한 값에 도달할 때마다, 다음 클럭 펄스에서 0으로 오버플로우하여 캐쉬 메모리(38_1)의 제1 저장 위치를 참조한다.

카운터(204)의 출력(READ_ADDR)은 또한 PCLK 신호에 의하여 클럭되는 레지스터 파이프 라인(208)에 입력을 제공한다. 레지스터 파이프 라인(208)은 약간의 PCLK 사이클에 의한 신호를 지연시키며, 코맨드 처리기(202)에 의하여 제어되는 한 세트의 레지스터(209∼211)에 대한 입력으로서 이를 제공한다. 도 1의 명령 처리기(16)가 서브루틴 호출 명령을 수행하는 경우, 코맨드 처리기(202)에 호출 명령을 전송한다. 코맨드 처리기(202)는 레지스터 파이프 라인(208)의 출력 (READ_ADDR_DELAYED)을 복귀 레지스터(209)에 로딩함으로써 응답한다. 코맨드 처리기(202)는 캐쉬 주소를 나타내는 출력(READ_ADDR_DELAYED) 시간이 호출 명령의 주소보다 N+1만큼 클 때까지 약간의 PCLK 사이클용 복귀 레지스터(209)의 로딩을 지연시킨다. 따라서, 복귀 레지스터(209)에 저장된 주소값은 따라서 호출된 서브루틴으로부터 복귀한 후에 캐쉬 메모리로부터 판독된 제1 명령의 주소이다. 코맨드 처리기(202)는 또한 다중화기(213)를 스위치하여 호출 명령에 응답하여 클럭된 래치(latch)(217)를 통하여 주소 카운터(204)에 입력으로서 하드 와이어(hard-wired) 데이터 값(CALL_ADDR)을 제공한 뒤, 카운터(204)에 로딩 입력을 펄스화하여 데이터 값(CALL_ADDR)을 로딩하도록 한다. 데이터 값(CALL_ADDR)은 호출된 서브루틴을 저장하는 도 1의 캐쉬 메모리(38_4)의 제1 주소를 참조한다. 데이터 값(CALL_ADDR)을 로딩한 후, 주소 카운터(204)는 출력 값(READ_ADD)을 생성하는 경우 데이터 값(CALL_ADDR)을 합한다.

도 1의 명령 처리기(16)가 지속적으로 복귀 명령을 실행하는 경우, 코맨드 처리기(202)에 복귀 명령을 전송하여 복귀 레지스터(209)의 내용을 카운터(204)에 로딩하도록 알린다.

도 1의 명령 처리기(16)가 명령(LOOP1_START 또는 LOOP2_START)을 실행하는 경우, 코맨드 처리기(202)에 명령(START1 또는 START2)을 전송한다. 데이터 값( READ_ADDR_DELAYED)이 실행된 명령(LOOP1_START 또는 LOOP2_START)의 주소보다 N+1만큼 큰 캐쉬 주소를 참조하는 경우, 코맨드 처리기(202)는 데이터 값 (READ_ADDR_DELAYED)을 제1 루프 레지스터(210) 또는 제2 루프 레지스터(211)에 한 번에 로딩함으로써 응답한다. 그 후, 명령 처리기(16)가 명령(LOOP1_END 또는 LOOP2_END)에 응답하여 명령(REPEAT1, END1, REPEAT2, END2)을 전송하는 경우, 코맨드 처리기(202)는 제1 루프 레지스터(210) 또는 제2 루프 레지스터(211)의 내용을 주소 카운터(204)에 로딩한다.

도 1의 명령 처리기(16)가 분기 명령에 응답하여, 코맨드 처리기(202)에 분기 명령을 전송하는 경우, 코맨드 처리기(202)는 다중화기(213)를 통하여 분기 캐쉬(38_5)의 제1 주소를 주소 카운터(204)에 로딩한다. 해독기(216)는 명령을 해독하고, 캐쉬 제어기(200)에 분기 신호를 전송하여 캐쉬 제어기(200)에 입력으로써 제공된 분기 명령의 피연산자에 포함된 분기 주소에 따른 (N+M+1)번째 주소로 시작한 도 1의 DRAM(12)에서 명령 블록을 판독 시작하도록 알린다. 캐쉬 제어기(200)는 DRAM(12)으로부터 판독한 분기 명령을 캐쉬 메모리(38_1)의 제1 주소로 시작한 주캐쉬 메모리(38_1 내지 38_3)에 기록한다. 캐쉬 메모리(38_5)로부터 마지막 M개의 분기 명령을 판독한 후에, 코맨드 처리기(202)는 다음 명령을 얻기 위하여 제1 주소(38_1)로 점프한다.

종래의 캐쉬 메모리 판독 및 기록 제어기(200)는 캐쉬 메모리(38_1 내지 38_3) 중 하나의 블록 마지막 주소를 참조할 시기를 결정하기 위하여 카운터(204)로부터 주소 카운트(READ_ADDR)를 모니터(monitor)한다. 통상적으로 이러한 것이 발생하는 경우, 제어기(200)는 DRAM(12)으로부터 다음 명령 블록을 판독하고, 이를 캐쉬 메모리 주소의 블록에 미리 저장된 명령을 통하여 기록한다. 그러나, 캐쉬 메모리 시스템(14)이 반복 루프의 일부인 명령 시퀀스를 판독하는 과정 중인 경우, 제어기(200)로 하여금 루프가 필수 회수만큼 캐쉬 메모리로부터 판독되기까지 루프에 포함된 명령을 고쳐서 기록하지 못하도록 하는 것이 필요하다. 따라서, 해독기(216)는 한 쌍의 플립-플롭(218, 219)을 설정 또는 리셋하기 위하여 명령 처리기(16)의 명령 출력을 해독한다. 명령(LOOP1 또는 LOOP2)에 대한 응답으로, 해독기는 플립-플롭(218 및 219)을 설정하도록 신호(셋1 또는 셋2)를 펄스화한다. 설정시 플립-플롭의 출력은 제어기(200)로 하여금 어느 캐쉬 메모리에도 새로운 명령을 기록하지 못하게 한다. 마지막 반복 루프의 시작시 명령 처리기(16)에 의하여 생성된 명령(END1 또는 END2)에 응답하여, 해독기(216)는 플립-플롭(218 또는 219)을 리셋하기 위하여 신호(리셋1 또는 리셋2)를 펄스화하고, 이로써 제어기(202)로 하여금 새로운 명령을 캐쉬 메모리로 기록하는 것을 다시 시작하게 한다.

코맨드 처리기(Command Processor)

도 9는 보다 상세한 블록도의 형태로 도 8의 코맨드 처리기(202)를 나타낸다. PCLK 신호에 의하여 클럭된 래치(220)는 해독기(222)의 입력상에 입력 명령을 래치한다. 해독기(222)는 명령을 해독하고 PCLK 신호에 의하여 클럭된 한 세트의 시퀀서(sequencer)(224∼231) 중의 하나에 입력 신호를 생성한다.

도 8 및 도 9를 참조하면, 호출 명령은 시퀀서(224)에 신호하도록 해독기(222)에 알린다. 시퀀서(224)는 데이터 값(READ_ADDR_DELAYED)을 복귀 레지스터(209)에 로딩하기 위하여 신호(LR)를 생성함으로써 응답한다. 시퀀서(224)는 또한 주소(CAL_ADDR)를 선택하도록 다중화기(213)에 알리는 신호(S1)를 표명한 후, 주소(CAL_ADDR)를 카운터(204)에 로딩하는 신호(LD)를 표명한다.

복귀 명령은 해독기(222)에게 시퀀서(225)에 신호하도록 알린다. 시퀀서 (225)는 레지스터(209)에 저장된 복귀 주소를 선택하도록 다중화기(213)에 알리기 위하여 적절한 시간에 신호(S5)를 생성함으로써 응답한 후, 복귀 주소가 카운터(204)에 로딩되도록 신호(LD)를 표명한다.

명령(LOOP1 또는 LOOP2)은 해독기(222)에게 시퀀서(226 또는 227)에 신호하도록 알리고, 이 시퀀스는 데이터 값(READ_ADDR_DEPLAYED)을 제1 루프 레지스터 (210) 또는 제2 루프 레지스터(211)에 로딩하도록 신호(L1 또는 L2)를 발생함으로써 응답한다.

명령(REPEAT1, END1, REPEAT2 또는 END2)은 레지스터(210, 211)에 저장된 루프 시작 주소를 선택하도록 다중화기(213)에 알리기 위하여 적절한 시간에 신호(S4 또는 S3)를 생성하고, 루프 시작 주소가 카운터(204)에 로딩되도록 신호(LD)를 표명함으로써 응답한다.

분기 명령은 시퀀서(230)에 신호하도록 해독기(222)에 알린다. 시퀀서(230)는 레지스터 파이프 라인(214)의 피연산자 출력에 의하여 전달되는 분기 주소를 선택하도록 다중화기(213)에 알리는 S2 신호를 생성한 후 분기 주소를 접근 카운터(204)에 로딩하도록 신호(LD)를 표명함으로써 응답한다.

시작 명령은 캐쉬 제어기(200)가 캐쉬 메모리를 명령으로 채우도록 충분한 PCLK 사이클 회수가 통과하는 경우, 카운터(204)를 리셋하도록 출력 신호(R)를 만드는 시작 시퀀서(231)에 신호를 보낸다. 제1 캐쉬 메모리에 저장된 명령이 도 1의 명령 처리기(16)에 도달하는 경우, 시작 시퀀서(231)는 또한 시작 신호를 펄스화한다.

전술한 명세서가 본 발명의 바람직한 실시예를 기술하였지만, 당업자는 넓은 측면에서 본 발명에서 벗어나지 않고 바람직한 실시예에 많은 변형을 할 수 있다. 따라서 청구범위는 본 발명의 범위 및 사상내에서 모든 이러한 변형을 포함하도록 의도되어 있다.

Claims (16)

1. 입력 클럭 신호 펄스 시퀀스의 각 펄스에 응답하여 데이터 값을 산출하는 패턴 생성기로서,

   다수의 제1 주소 지정 가능 저장 위치 각각에 명령을 저장하고, 자신에 입력으로서 제공된 주소값에 의하여 참조된 상기 제1 주소 지정 가능 저장 위치중의 한 위치에 저장된 명령을 판독하는 제1 메모리(38),

   상기 클럭 신호를 수신하고, 특정 주소값을 참조한 명령을 수신하며, 상기 제1 메모리에 상기 주소를 입력으로 제공하고, 상기 명령을 수신한 후 발생하는 상기 클럭 신호의 (N+1)번째 펄스－여기서 N은 0보다 큰 정수－에 응답하여 상기 주소값을 상기 명령에 의하여 참조되는 특정 주소값으로 변경하나, 그렇지 않은 경우에는 상기 클럭 신호의 각 펄스에 응답하여 상기 입력 주소를 증가시키는 메모리 제어기(34),

   N개의 명령을 저장 및 판독하는 버퍼 메모리(39), 그리고

   상기 제1 메모리로부터 판독된 상기 클럭 신호와 각 명령을 수신하고, 상기 메모리 제어기가 상기 명령을 수신한 후 발생하는 상기 클럭 신호의 N개의 펄스에 각각 응답하여 상기 버퍼 메모리에 저장되는 명령을 연속적으로 판독 및 실행하나, 그렇지 않은 경우에는 상기 클럭 신호의 각 펄스에 응답하여 제1 메모리로부터 판독한 명령을 실행하는 명령 처리기(16)

   를 포함하는 패턴 생성기.
2. 제1항에서,

   적어도 한 명령은 상기 제1 메모리로부터 판독되고 상기 명령을 참조하는 상기 명령 처리기에 의하여 실행되며, 상기 명령 처리기는 상기 적어도 하나의 명령을 실행시 상기 명령을 상기 메모리 제어기에 전송하는 패턴 생성기.
3. 제1항에서,

   각 실행 명령은 데이터 값을 포함하며, 상기 명령 처리기는 패턴 생성기 출력 데이터 값으로서 각 실행 명령의 데이터 값을 제공하는 패턴 생성기.
4. 제1항에서,

   상기 버퍼 메모리는 상기 명령 처리기 후에 발생하는 상기 클럭 신호의 상기 N개의 펄스 각각에 응답하여 상기 제1 메모리로부터 판독한 명령을 수신하고 저장하는 패턴 생성기.
5. 제1항에서,

   다수의 제2 주소 지정 가능 저장 위치 각각에 다수의 명령을 저장하고, 상기 메모리 제어기－상기 제2 메모리로부터 판독된 다수의 명령 중에 각 명령을 상기 제1 메모리의 개별적인 제1 주소 지정 가능 저장 위치에 기록함 －에 의하여 자신에 입력으로서 제공되는 제2 주소값에 의하여 참조된 상기 제2 주소 지정 가능 저장 위치 중의 한 위치에 저장된 다수의 명령을 판독하기 위한 제2 메모리(12)를 포함하는 추가로 패턴 생성기.
6. 제2항에서,

   다수의 제2 주소 지정 가능 저장 위치의 각각에 다수의 명령을 저장하고, 상기 메모리 제어기－상기 제2 메모리로부터 판독한 다수의 명령 중 각 명령을 상기 제1 메모리의 개별적인 제1 주소 지정 가능 저장 위치에 기록함－에 의하여 상기 제2 메모리에 입력으로 제공된 제2 주소값에 의하여 참조된 상기 제2 주소 지정 가능 저장 위치 중의 한 위치에 저장된 다수의 명령을 판독하기 위한 제2 메모리를 추가로 포함하는 패턴 생성기.
7. 제6항에서,

   상기 각 실행 명령은 데이터 값을 포함하고, 상기 명령 처리기는 패턴 생성기 출력 데이터 값으로서 각 실행 명령의 데이터 값을 제공하고, 상기 버퍼 메모리는 상기 명령 처리기 후에 발생하는 상기 클럭 신호의 상기 각 N개의 펄스에 응답하여 상기 버퍼 메모리로부터 판독한 명령을 수신하고 저장하는 패턴 생성기.
8. 입력 클럭 신호 펄스의 각 펄스에 응답하여 출력 데이터 값을 산출하는 패턴 생성기로서,

   다수의 제1 주소 지정 가능 저장 위치 각각에 명령을 저장하고, 상기 제1 메모리에 입력으로서 제공되는 주소값에 의하여 참조된 상기 제1 주소 지정 가능 저장 위치 중 한 위치에 저장된 명령을 판독하기 위한 제1 메모리(38),

   상기 클럭 신호를 수신하고, 각각 특정 주소값을 참조한 명령을 수신하며, 상기 제1 메모리에 상기 주소를 입력으로 제공하고, 상기 명령을 수신한 후에 발생하는 상기 클럭 신호의 (N+1)번째 펄스－N은 0보다 큰 정수－에 응답하여 상기 주소값을 상기 명령에 의하여 참조되는 특정 주소값으로 변경하나, 그렇지 않은 경우에는 상기 클럭 신호의 각 펄스에 응답하여 상기 입력 주소를 증가시키는 메모리 제어기(34),

   명령을 저장하는 버퍼 메모리(39), 그리고

   상기 제1 메모리로부터 판독한 상기 클럭 신호 및 각 명령을 수신하고, 상기 메모리 제어기가 상기 명령을 수신한 후에 발생하는 상기 클럭 신호의 N개의 펄스에 각각 응답하여 상기 버퍼 메모리에 저장된 명령을 연속적으로 판독하고 실행하나, 그렇지 않은 경우에는 상기 클럭 신호의 각 펄스에 응답하여 제1 메모리로부터 판독한 명령을 실행하기 위한 명령 처리기(16)－여기서 상기 명령 처리기에 의하여 수행되는 각 명령은 메모리 제어기에 전송된 명령을 참조해 데이터 값과 연산 코드를 포함하며, 상기 명령 처리기는 상기 메모리 제어기에 연산 코드 실행 명령에 의하여 참조된 명령을 전송하고 패턴 생성기 출력 데이터 값으로서 데이터 값을 제공함－

   를 포함하는 패턴 생성기.
9. 제8항에서,

   상기 버퍼 메모리는 호출 버퍼(40_1)와 복귀 버퍼(40_5)를 포함하며, 명령을 저장하는 각 단계에서,

   상기 명령 처리기에 의하여 실행되는 한 명령의 연산 코드는 호출 신호를 참조하며, 상기 명령 처리기에 의하여 실행되는 다른 명령의 연산 코드는 복귀 명령을 참조하며,

   상기 한 명령을 실행한 후에, 상기 명령 처리기는 상기 제1 메모리에서 판독된 명령을 상기 복귀 버퍼에 기록하며, 상기 호출 버퍼로부터 다른 명령을 판독하고 상기 다른 명령을 실행함으로써 상기 클럭 신호의 다음 N개의 펄스 각각에 응답하며,

   상기 다음 N개의 펄스에 따라 상기 클럭 신호의 펄스에 응답하여 상기 명령 처리기는 상기 제1 메모리로부터 판독한 명령을 실행하는 패턴 생성기.
10. 제9항에서,

    상기 메모리 제어기는 복귀 레지스터(209)를 포함하며,

    호출 명령을 수신한 후 (N+1)번째 클럭 신호 펄스에 응답하여, 상기 메모리 제어기는 상기 복귀 레지스터에 복귀 주소를 저장하고 상기 제1 메모리에 입력하는 주소값을 상기 호출 명령에 의하여 참조된 값으로 변경하며,

    복귀 명령을 수신한 후에 (N+1)번째 클럭 신호 펄스에 응답하여, 상기 메모리 제어기가 상기 제1 메모리에 입력하는 주소값을 상기 복귀 레지스터에 저장된 복귀 주소로 변경하는 패턴 생성기.
11. 제8항에서,

    상기 버퍼 메모리(39)는 명령을 저장하는 루프 버퍼(40_2)를 포함하며,

    상기 명령 처리기에 의하여 실행되는 한 명령의 연산 코드는 명령 (LOOP_START)을 참조하며, 상기 명령 처리기에 의하여 실행되는 다른 명령의 연산 코드는 명령(LOOP_REPEAT)을 참조하며,

    상기 한 명령을 수행한 후에, 상기 명령 처리기는 실행 명령을 상기 루프 버퍼에 기록하는 상기 클럭 신호의 다음 N개의 펄스 각각에 응답하며,

    상기 다른 명령을 실행한 후에 상기 명령 처리기는 상기 루프 버퍼로부터 판독한 명령을 판독하고 상기 루프 버퍼로부터 판독한 상기 명령을 실행함으로써 상기 클럭 신호의 다음 N개의 펄스 각각에 응답하는 패턴 생성기.
12. 제11항에서,

    상기 메모리 제어기는 루프 레지스터(210)를 포함하고,

    시작 명령을 수신한 후에 (N+1)번째 클럭 신호 펄스에 응답하여, 상기 메모리 제어기는 상기 시작 레지스터에 상기 제1 메모리에 입력하는 주소값을 저장한 뒤 상기 제1 메모리에 입력하는 주소를 증가시키고,

    반복 명령을 수신한 후에 (N+1)번째 클럭 신호 펄스에 응답하여, 상기 메모리 제어기는 상기 제1 메모리에 입력하는 주소값을 상기 루프 레지스터에 저장된 값으로 변경하는 패턴 생성기.
13. 제8항에서,

    상기 버퍼 메모리는 명령을 저장하는 분기 버퍼(40_4)를 포함하며,

    상기 명령 처리기에 의하여 실행되는 한 명령의 연산 코드는 분기 명령을 참조하며, 상기 한 명령은 메모리 주소를 참조한 피연산자를 포함하며,

    상기 한 명령을 실행한 후에, 상기 명령 처리기는 상기 분기 버퍼로부터 판독한 명령을 판독하고 상기 분기 버퍼로부터 판독한 상기 명령을 실행함으로써 상기 클럭 신호의 다음 각 N개의 펄스에 응답하는 패턴 생성기.
14. 제13항에서,

    분기 명령을 받은 후 (N+1)번째 클럭 신호 펄스에 응답하여 상기 메모리 제어기는 상기 제1 메모리에 입력하는 주소를 상기 피연산자에 의하여 지시하는 값으로 변경하는 패턴 생성기.
15. 제8항에서,

    상기 버퍼 메모리는 각각 명령을 저장하기 위한 호출 버퍼(40_1), 루프 버퍼(40_2), 분기 버퍼(40_4) 및 복귀 버퍼(40_5)를 포함하며,

    상기 메모리 제어기는 복귀 레지스터(209)와 루프 레지스터(210)를 포함하며,

    상기 명령 처리기에 의하여 실행되는 제1 명령의 연산 코드는 호출 명령을 참조하고, 상기 명령 처리기에 의하여 실행되는 제2 명령의 연산 코드는 복귀 명령을 참조하고, 상기 명령 처리기에 의하여 실행되는 제3 명령의 연산 코드는 명령(LOOP_START)을 참조하고, 상기 명령 처리기에 의하여 실행되는 제4 명령의 연산 코드는 명령(LOOP_REPEAT)을 참조하고, 상기 명령 처리기에 의하여 실행되는 제5 명령의 연산 코드는 분기 명령을 참조하며, 상기 제5 명령은 메모리 주소를 참조하는 피연산자를 포함하며,

    상기 제1 명령의 실행 후에 상기 명령 처리기는 상기 제1 메모리로부터 판독한 명령을 상기 복귀 버퍼에 기록하고 상기 호출 버퍼로부터 다른 명령을 판독하며, 상기 다른 명령을 실행함으로써 상기 클럭 신호의 다음 N개의 펄스 각각에 응답하고, 상기 제1 메모리로부터 판독한 명령을 수행함으로써 상기 클럭 신호의 다음 펄스에 응답하며,

    상기 제3 명령을 실행한 후에 상기 명령 처리기는 실행된 명령을 상기 루프 버퍼에 기록함으로써 상기 클럭 신호의 다음 N개의 펄스 각각에 응답하며,

    상기 제4 명령을 실행한 후에 상기 명령 처리기는 상기 루프 버퍼로부터 판독한 명령을 판독하고 상기 루프 버퍼로부터 판독한 상기 명령을 실행함으로써 상기 클럭 신호의 다음 N개의 펄스 각각에 응답하며.

    상기 제5 명령을 실행한 후에 상기 명령 처리기는 상기 분기 버퍼로부터 판독한 명령을 판독하고 상기 분기 버퍼로부터 판독한 상기 명령을 실행함으로써 상기 클럭 신호의 다음 N개의 펄스 각각에 응답하며,

    상기 호출 명령을 수신한 후 (N+1)번째 클럭 신호 펄스에 응답하여, 상기 메모리 제어기는 상기 제5 메모리에 입력된 주소값을 상기 복귀 레지스터에 저장한 뒤 상기 제1 메모리에 입력된 주소값을 상기 호출 명령에 의하여 참조되는 값으로 변경하며,

    복귀 명령을 수신한 후 (N+1)번째 클럭 신호 펄스에 응답하여, 상기 메모리 제어기는 상기 제1 메모리에 입력된 주소값을 상기 복귀 레지스터에 저장된 값으로 변경하며,

    시작 명령을 수신한 후 (N+1)번째 클럭 신호 펄스에 응답하여, 상기 메모리 제어기는 상기 제1 메모리로 입력된 주소값을 상기 시작 레지스터에 저장한 뒤 상기 제1 메모리에 입력된 주소를 증가시키며,

    반복 명령을 수신한 후 (N+1)번째 클럭 신호 펄스에 응답하여, 상기 메모리 제어기는 상기 제1 메모리에 입력된 주소값을 상기 루프 레지스터에 저장된 값으로 변경하며,

    분기 명령을 수신한 후 (N+1)번째 클럭 신호 펄스에 응답하여, 메모리 제어기는 상기 제1 메모리에 입력된 주소를 상기 피연산자가 가리키는 값으로 변경하는 패턴 생성기.
16. 제15항에서,

    다수의 제2 주소 지정 가능 저장 위치 각각에 다수의 명령을 저장하고, 상기 메모리 제어기에 의하여 상기 제2 메모리에 입력으로써 제공되는 제2 주소의 값으로서 참조되는 상기 제2 주소 지정 가능 저장 위치에 저장되는 다수의 명령을 판독하기 위한 제2 메모리(12)를 포함하며,

    상기 메모리 제어기는 상기 제2 메모리로부터 판독된 다수의 명령 중 각 명령을 상기 제1 메모리의 개별적인 제1 주소 지정 가능 저장 위치에 기록하는 패턴 생성기.