KR100394967B1 - 개선된 마이크로프로세서를 위한 게이트 저장 버퍼 - Google Patents

Abstract

게이트 저장 버퍼는 호스트 프로세서가 타겟 명령어의 시퀀스를 호스트 명령어로 변환하는 변환 인터벌 동안 다른 메모리 저장과는 별도로 순차적으로 발생된 모든 메모리 저장을 임시적으로 홀드하는 회로와, 변환이 예외를 발생하지 않고 실행될 경우 변환 인터벌 동안 순차적으로 발생된 메모리 저장을 메모리로 전송하는 회로와, 동일한 메모리 어드레스에 대한 메모리 저장이 메모리 어드레스에서의 메모리 액세스에 응답하는 가장 최근의 것임을 나타내는 회로와, 변환이 예외를 발생시키는 경우 변환 인터벌 동안 순차적으로 발생된 메모리 저장을 소거하는 회로를 포함한다.

Description

개선된 마이크로프로세서를 위한 게이트 저장 버퍼{A GATED STORE BUFFER FOR AN ADVANCED MICROPROCESSOR}

발명의 배경

특정 마이크로프로세서 패밀리에 대해 설계된 컴퓨터 상에서 실행되는 응용 프로그램은 무수히 존재한다. 기존의 대다수의 프로그램들은 캘리포니아주 산타클라라의 Intel 사가 설계 제조하는 "X86" 마이크로프로세서 패밀리 (Intel 8O88, Intel 8086, Intel 80186, Intel 80286, i386, i486, 및 여러 가지의 Pentium마이크로프로세서의 발전형을 포함함)를 이용하는 컴퓨터(일반적으로, "IBM 호환 퍼스널 컴퓨터"라 불림)상에서 실행되도록 설계되어 있다. 다른 프로세서 패밀리를 채용한 컴퓨터 상에서 실행되도록 설계된 다른 프로그램의 예도 많다. 이러한 컴퓨터 상에서 실행되는 많은 응용 프로그램이 있기 때문에, 그런 컴퓨터, 특히 X86 프로그램을 처리하도록 설계된 컴퓨터에서 사용 가능한 마이크로프로세서의 시장은 방대하다. 마이크로프로세서의 시장은 클 뿐만 아니라, 매우 수익성이 높다.

다수의 응용 프로그램을 실행 할 수 있는 마이크로프로세서의 시장은 크게 수익성이 높지만, 경쟁력이 있는 새로운 마이크로프로세서를 설계하기란 매우 어렵다. 예를 들면, X86 프로세서 패밀리는 오랜 기간동안 존재하여 왔고, 이들 프로세서는 판매 및 사용되고 있는 컴퓨터의 대부분에 채용되지만, X86의 프로그램을 실행 할 수 있는 경합 프로세서로서 성공한 것은 대부분 없다. 그 이유는 많다.

성공을 위해서는, 새로운 마이크로프로세서는 기존 프로세서보다 더 비용이 들지 않고, 기존 프로세서만큼 빠르게 이 프로세서 패밀리를 위해 설계된 (운영 체제 및 레거시(legacy) 프로그램을 포함함) 모든 프로그램을 실행할 수 있어야 한다. 또한, 경제적으로 성공하기 위해서는, 새로운 마이크로프로세서는 바이어로 하여금 기존의 검증된 프로세서 대신에 새로운 프로세서를 선택하도록, 최소한 하나 이상의 기존 프로세서보다 뛰어난 기능을 수행할 수 있어야만 한다.

최신의 마이크로프로세서 만큼 빠르게 마이크로프로세서를 실행시키기란 어렵고, 비용도 많이 든다. 프로세서는 적재(loading), 시프트(shifting), 가산(adding), 저장(storing)과 같은 원시 동작들(primitive operations) 및 유사한 저 레벨의 동작에 의해 명령어들을 실행할 때에도 그런 원시 명령어에만 응답한다. 예를 들면, 명령어가 비교적 높은 레벨로 실행해야 할 프로세스를 지정할 수가 있는 X86와 같은 복잡 명령어 세트 컴퓨터(CISC : complicated instruction set computer)의 명령어를 실행하도록 설계된 프로세서는 이전부터 판독전용 메모리(ROM)를 포함하고 있어, 여기에 이른바 마이크로 명령어를 저장하고 있다. 각 마이크로 명령어는 원시 명령어 시퀀스를 포함하며, 이것들을 연속적으로 실행함으로써 높은 레벨의 CISC 명령어에 의해 지령된 결과를 가져온다. 전형적으로, "add A to B"(A를 B에 가산)라고 하는 CISC 명령어는 이 "add A to B" 명령어의 기능을 실행하는 마이크로 명령어가 저장되고 있는 ROM내의 어드레스를 탐색(look up)하도록 디코드 된다. 이 마이크로 명령어가 적재되어 그 원시 명령어를 순차적으로 실행함으로써, "add A to B" 명령어가 실행된다. 이러한 CISC 컴퓨터의 경우, 마이크로 명령어내의 원시 동작은 프로그램의 실행 중 결코 변경될 수 없다. 각 CISC 명령어는 명령어를 디코드하고, 마이크로 명령어를 어드레스싱 및 인출하고, 마이크로 명령어에 주어진 시퀀스로 일련의 원시 동작을 실행하는 것에 의해서만 실행 될 수가 있다. 마이크로 명령어를 실행 할 때마다 같은 시퀀스가 수반되어야 한다.

X86 응용을 실행하기 위한 현재의 프로세서는 다수의 기술을 이용하여 가능한 한 고속으로 그리고 경제적으로 낮은 가격으로 처리를 수행한다. 프로세서가 실행 할 수 있는 속도를 가속시키기 위한 공지의 하드웨어 기술을 채용하는 새로운 프로세서는 모두 처리 하드웨어의 세련성을 증대시킬 필요가 있다. 이는 하드웨어 비용을 증대시킨다.

예를 들면, 복수의 처리 채널을 이용하여 한 번에 2개 이상의 동작을 실행하는 수퍼스칼라 마이크로프로세서에는 다수의 추가 요건이 있다. 가장 기본적인 레벨에서, 단순한 수퍼스칼라 마이크로프로세서는 각 응용 명령어를 마이크로 명령어로 디코드 하여, 응용 명령어의 기능을 실행할 수가 있다. 여기서, 단순한 수퍼스칼라 마이크로프로세서는 2개의 마이크로 명령어가 같은 하드웨어 자원을 요구하지 않고 그리고 마이크로 명령어의 실행이 처리되는 다른 마이크로 명령어의 처리 결과에 의존하지 않을 경우에, 이들 2개의 마이크로 명령어를 함께 실행하도록 스케줄링을 행한다.

더욱 개선된 수퍼스칼라 마이크로프로세서에는 전형적으로 각 응용 명령어를 원시 명령어 시퀀스로 디코드 함으로써, 이러한 원시 명령어를 재배열(reorder)하여, 가장 효율적인 실행 시퀀스로 스케줄링이 이루어지게 한다, 이는 각각의 개별 원시 동작이 어드레스싱 및 인출 되어야 함을 요한다. 재배열을 수행하기 위해서, 프로세서는 다른 원시 명령어로부터 발생하는 데이터를 필요로 하는 원시 명령어를 다른 원시 명령어가 필요한 데이터를 생성한 후에 실행되게 해야한다. 이러한 수퍼스칼라 마이크로프로세서는 함께 실행되는 2개의 원시 명령어가 동일한 하드웨어 자원을 요구하지 않게 해야 한다. 이러한 프로세서는 또한 조건부 분기를 해결하여, 그 후에 분기 동작의 효과가 완료되도록 해야 한다.

따라서, 수퍼스칼라 마이크로프로세서는 복수의 원시 명령어의 관계를 서로 비교하고, 이들 원시 명령어를 재배열 및 스케줄링하기 위한 광범위한 하드웨어를 필요로 한다. 처리 채널수가 증대함에 따라, 이들 수퍼스칼라 가속 기술을 달성하기 위한 하드웨어의 량 및 비용은 거의 4배로 증대한다. 이러한 하드웨어 요건은 모두 관련 회로의 복잡성 및 비용을 증대시킨다. 마이크로 명령어를 처리하는데 있어, 응용 명령어를 실행할 때마다 수퍼스칼라 마이크로프로세서는 이들 원시 명령어들 각각을 인출하는데 비교적 복잡한 어드레싱 및 인출 하드웨어를 이용해야만 하고, 다른 원시 명령어 및 하드웨어 사용 상황에 근거하여 이들 원시 명령어를 재배열 및 재스케줄링 해야 하며, 재스케줄링된 모든 원시 명령어를 실행해야만 한다. 각 응용 명령어를 실행할 때마다 하드웨어 시퀀스 전체로 이것을 실행해야만 하는 요건은 수퍼스칼라 프로세서가 그 명령어를 실행 할 수 있는 속도를 제한한다.

더욱이, 비록 이들 여러 가지의 하드웨어 기술이 처리 속도를 높인다고 해도 이러한 하드웨어를 갖추는데 따르는 복잡성은 이러한 마이크로프로세서의 비용을 크게 증대시킨다. 예를 들면, 인텔 i486DX4 프로세서는 약 150만개의 트랜지스터를 사용한다. Intel Pentium와 같은 기본적인 수퍼스칼라 마이크로프로세서에서 두 채널에 의해 명령어를 처리하는데 필요한 의존성 및 스케줄링을 체크하는데 요구되는 하드웨어를 추가하려면 300만개 이상의 트랜지스터의 사용이 필요하다. 서로 다른 타겟 명령어로부터 파생되는 원시 명령어들을 재배열하고, 추측 실행(speculative execution)을 수행하고, 레지스터를 명칭변경(rename)하고 그리고 분기 예측을 제공하기 위한 하드웨어의 추가는 Intel Pentium Pro^TM에서 트랜지스터의 수가 600만개 이상으로 증대되게 한다. 따라서, 동작 속도를 높이기 위한 하드웨어의 추가는 최신의 마이크로프로세서에서 트랜지스터의 수를 급증 시켰음을 알 수 있다.

이들 공지된 기술을 이용해도 기존의 마이크로프로세서보다 고속의 마이크로프로세서를 생산할 수가 없는 경우가 있는데, 그 이유는 제조자들은 기존의 마이크로프로세서의 동작을 가속시키는 것으로 알려진 경제적으로 실현 가능한 기술을 대부분 이용하기 때문이다. 결과적으로, 고속 프로세서의 설계는 매우 어렵고 비용이 많이 드는 작업이 된다.

프로세서의 비용 삭감 역시 매우 곤란하다. 전술한 것처럼, 충분한 능력이 있는 프로세서를 생산하는 하드웨어 가속 기술은 매우 고가이다. 새로운 프로세서를 설계하고자 하는 사람은 하드웨어를 생산하는 설비를 취득해야 한다. 이러한 설비의 취득은 매우 곤란한데, 이는 칩 제조자들은 전형적으로 소량의 디바이스에 그의 자산을 소비하지 않기 때문이다. 칩 제조 설비를 생산하는데 필요한 자본 투자는 막대하여 대부분의 회사 능력 범위를 넘는다. 경쟁 프로세서만큼 빠른 프로세서패밀리를 위해 설계된 모든 응용 프로그램을 실행하는 새로운 프로세서를 설계할 수가 있는 사람이 있다손 치더라고, 경쟁 프로세서의 가격은 충분한 이익을 포함하고 있어 어느 경쟁자도 상당한 가격인하에 직면할 것임이 확실하다.

하드웨어의 복합성을 증가시켜 경쟁력이 있는 프로세서를 설계하기란 매우 곤란하지만 특정의 마이크로프로세서(타겟 마이크로프로세서) 패밀리에 대해 설계된 응용 프로그램 (타겟 응용 프로그램)을 실행하는 다른 방법으로서 소프트웨어로 다른 것보다 빠른 마이크로프로세서(호스트 마이크로프로세서) 상에서 타겟 마이크로프로세서를 에뮬레이트하는 것이 행해져 왔다. 이것은 극히 저렴한 비용으로 이러한 프로그램을 실행하는 방법인데, 이는 보다 빠른 마이크로프로세서 상에서 응용 프로그램을 실행하는 어떤 형태의 에뮬레이션 소프트웨어를 추가하기만 하면 되기 때문이다. 에물레이터 소프트웨어는 타겟 프로세서 패밀리에 대해 기입된 응용 프로그램의 타겟 명령어를 호스트 프로세서에 의해 실행 가능한 호스트 명령어로 변경한다. 이들 변경된 명령어는 보다 빠른 호스트 마이크로프로세서상의 운영 체제의 제어 하에서 실행된다.

타겟 컴퓨터의 프로세서보다 빠른 프로세서를 갖는 호스트 컴퓨터 상에서 타겟 응용을 실행할 수 있는 다수의 서로 다른 설계들이 존재한다. 일반적으로, 에뮬레이션 소프트웨어를 이용하여 타겟 프로그램을 실행하는 호스트 컴퓨터는 축소 명령어 세트(RISC : reduced instruction set) 마이크로프로세서를 이용하는데, 그 이유는 RISC 프로세서는 이론상 다른 형식의 프로세서보다 단순하여, 결과적으로 이들 보다 빠르게 실행 할 수가 있기 때문이다.

그러나, 에뮬레이터 소프트웨어를 실행하는 RISC 컴퓨터 시스템은 종종 X86(또는 기타)프로그램을 실행 할 수가 있지만, 이들이 실행하는 속도는 현재의 X86 컴퓨터 시스템이 동일 프로그램을 실행하는 속도보다 훨씬 늦다. 더욱이, 이러한 에뮬레이터 프로그램은 종종 이용 가능한 모든 또는 대부분의 타겟 프로그램을 실행 할 수 없다.

에뮬레이터 프로그램이 타겟 마이크로프로세서 만큼 빠르게 타겟 프로그램을 실행 할 수가 없는 이유는 매우 복잡하고 서로 다른 에뮬레이션 동작에 대한 이해를 요한다. 도 1은 복수의 서로 다른 종류의 마이크로프로세서가 타겟 응용 프로그램을 실행하는 다수의 서로 다른 방법을 나타내는 일련의 도면을 포함한다.

도 1a는 Intel X86 마이크로프로세서와 같은 전형적인 CISC 마이크로프로세서가 타겟 프로세서 상에서 실행되도록 설계된 타겟 응용 프로그램을 실행하는 경우를 보인 것이다. 도시한 바와 같이, 컴퓨터의 하드웨어에 액세스를 얻기 위한 인터페이스를 제공하도록 설계된 CISC 운영 체제(X86 컴퓨터와 함께 이용되는 MSDOS, Windows3. 1, WindowsNT, OS/2 등)을 이용하여, CISC 프로세서 상에서 응용을 실행한다. 통상, 응용 프로그램의 명령어는 운영 체제에 의해 제공되는 액세스만을 통해서 컴퓨터의 디바이스들을 이용하도록 선택된다. 따라서, 운영 체제는 응용들이 컴퓨터의 메모리 및 여러 가지의 입출력 디바이스에 액세스될 수 있게 하는 동작을 처리한다. 타겟 컴퓨터는 운영 체제가 인식하는 메모리 및 하드웨어를 포함하고, 타겟 응용으로부터 운영 체제로의 호출에 의하여 운영 체제의 디바이스 드라이버는 정의된 타겟 컴퓨터의 디바이스를 이용하여 예상되는 동작을 발생하게 한다.응용 프로그램의 명령어는 프로세서상에서 실행되며, 여기서 상기 명령어들은 상기 프로세서가 실행할 수 있는 (마이크로코드 또는 마이크로 코드가 어셈블되는 더 많은 원시 동작들로 구현되는) 동작들로 변경된다. 전술한 바와 같이, 복잡한 타겟 명령어를 실행할 때마다, 명령어는 마이크로코드로서(또는 동일 세트의 원시 동작으로서) 저장된 동일 서브루틴을 호출한다. 동일 서브루틴은 항상 실행된다. 프로세서가 수퍼스칼라인 경우, 타겟 명령어를 실행하는 이들 원시 동작은 종종 프로세서에 의해 재배열 및 재스케줄링되어 전술한 바와 같이 여러 가지의 처리 채널을 이용하여 실행된다. 그러나, 여전히 서브루틴을 인출하여 실행한다.

도 1b는 도 1a의 CISC 프로세서상에서 실행하도록 설계된 동일한 타겟 응용 프로그램을 실행하는 Apple Macintosh 컴퓨터에서 이용되는 PowerPC 마이크로프로세서와 같은 전형적인 RISC 마이크로프로세서를 도시한다. 알 수 있는 바와 같이, 타겟 응용은 적어도 부분적인 타겟 운영 체제를 이용, 호스트 프로세서상에서 실행되어 타겟 응용이 발생하는 호출의 일부에 응답한다. 통상, 이들은 디스플레이상에 그래픽 인터페이스를 제공하기 위해 이용되는 타겟 운영 체제의 응용형(application-like)부분들로의 호출 및 일반적으로 응용형의 짧은 유틸리티 프로그램이다. 타겟 응용 및 타겟 운영 체제의 이러한 부분은 Soft PC와 같은 소프트웨어 에뮬레이터에 의해 변경된다. 이 소프트웨어 에뮬레이터는 타겟 응용 프로그램 및 응용형 타겟 운영 체제 프로그램에 의해 주어지는 명령어를 분해하여, 호스트 프로세서 및 그 호스트 운영 체제가 실행할 수 있는 명령어로 만든다. 호스트 운영 체제는 RISC 컴퓨터의 메모리 및 입출력 하드웨어로의 액세스를 얻을 수 있는 인터페이스를 제공한다.

그러나, 호스트 RISC 컴퓨터내의 호스트 RISC 프로세서 및 이와 관계하는 하드웨어 디바이스는 통상, 타겟 응용의 설계 대상인 프로세서와 관계하는 디바이스와는 아주 다르다. 더욱이, 타겟 응용 프로그램에 의해 주어지는 여러 가지의 명령어는 타겟 컴퓨터의 여러 가지의 부분에 액세스할 때, 타겟 운영 체제의 디바이스 드라이버와 협력하도록 설계된다. 결과적으로, 타겟 응용 프로그램의 명령어를 호스트 운영 체제가 활용할 수 있는 원시 호스트 명령어로 변경하는 에뮬레이션 프로그램은 어떠한 방법을 통해, 타겟 컴퓨터내의 하드웨어 디바이스를 동작시키도록 설계된 동작을 호스트 시스템의 하드웨어 디바이스가 구현 할 수 있는 동작에 링크해야 한다. 이 때문에, 에뮬레이터 소프트웨어는 종종 타겟 응용의 명령어에 응답하는 가상 디바이스를 생성하여, 호스트 시스템이 실행할 수 없는 명령어를 실행하도록 해야하는 바, 그 이유는 타겟 디바이스는 호스트 컴퓨터의 타겟 디바이스가 아니기 때문이다. 때때로, 에뮬레이터는 이들 가상 디바이스로부터 호스트 운영 체제를 통해서 존재하지만 호스트 운영 체제에 의해 서로 다른 방식으로 어드레스 되는 호스트 하드웨어 디바이스로 이어지는 링크를 생성할 것을 요구받는다.

이런 식으로 실행될 시, 타겟 프로그램은 많은 이유로 비교적 저속으로 실행된다. 먼저, 타겟 응용 프로그램 및 타겟 운영 체제로부터의 각 타겟 명령어는 에뮬레이터에 의해 호스트 프로세서가 이용하는 호스트 원시 기능으로 변경되어야 한다. 타겟 응용이 X86와 같은 CISC 머신용으로 설계될 경우, 타겟 명령어의 길이는 여러 가지로 변하여 매우 복잡하기 때문에 이 명령어를 호스트의 원시 명령어로 변환하는 것은 많은 혼란을 수반한다. 먼저, 원래의 타겟 명령어를 디코드하고, 타겟 명령어를 구성하는 원시 호스트 명령어의 시퀀스를 결정한다. 그 다음에, 원시 호스트 명령어의 각 시퀀스의 어드레스(또는 어드레스들)를 결정하고, 원시 호스트 명령어의 각 시퀀스를 인출하여, 이들 원시 호스트 명령어를 시퀀스대로 또는 시퀀스 없이 실행한다. 명령어를 실행할 때마다, 타겟 응용 및 운영 체제 명령어를 호스트 프로세서가 이해하는 호스트 명령어로 변경하기 위해서는 에뮬레이터에 필요한 많은 추가 단계를 수행해야만 하므로, 에뮬레이션의 프로세스는 늦어진다.

둘째로, 많은 타겟 명령어는 호스트 컴퓨터에서는 사용할 수 없는 타겟 컴퓨터의 하드웨어에 대해 특정의 방식으로 기능하는 특정의 하드웨어 디바이스가 수행하는 동작에 대한 참조(reference)를 포함한다. 이 동작을 실행하기 위해서, 에뮬레이션 소프트웨어는 기존의 호스트 운영 체제를 통해서 호스트 컴퓨터의 하드웨어 디바이스에 소프트웨어 접속을 수행하거나, 에뮬레이션 소프트웨어가 가상 하드웨어 디바이스를 가져야만 한다. 다른 컴퓨터의 하드웨어를 소프트웨어로 에뮬레이트 하는 것은 매우 어렵다. 에뮬레이션 소프트웨어는 호스트 운영 체제에 대한 타겟 응용 호출 각각에 대해서 가상 디바이스를 생성해야만 하며, 이들 가상 디바이스 각각이 실제 호스트 디바이스에 호출을 제공해야 한다. 하드웨어 디바이스를 에뮬레이트 하는데는, 타겟 명령어가 디바이스를 사용할 수 있을 때 상기 명령어가 요구하는 가상 디바이스를 나타내는 코드를 메모리로부터 인출하고 이를 실행하여 상기 디바이스를 구현해야 한다. 이런 문제를 해결하는 모든 방법들은 명령어의 시퀀스의 실행에 다른 일련의 동작을 추가하게 된다.

에뮬레이션의 문제를 복잡하게 하는 것은, 타겟 응용이 여러 가지 예외를 발생하여, 컴퓨터 시스템이 동작하도록 타겟 컴퓨터의 하드웨어 및 타겟 운영 체제가 이것을 실행해야 하기 때문이다. 타겟 컴퓨터의 동작 중에 타겟 예외가 발생했을 경우, 예외 시점에서의 컴퓨터 상태를 세이브 해야 한다. 통상, 이것을 수행하려면, 이 동작을 달성하기 위한 마이크로코드 시퀀스를 호출한다. 더욱이, 정확한 예외 조정기(exception handler)를 검색해야 하고, 예외를 처리해야 하며, 이어서 프로그램을 계속하기 위해서 프로그램내의 정확한 지점을 발견해야 한다 이는 때때로, 예외가 발생한 시점으로 및 예외 조정기에 의해 제공된 분기가 발생한 다른 시점의 타겟 컴퓨터 상태로 프로그램을 회귀(revert) 시켜야 함을 요한다. 어느 경우에서는, 이러한 동작을 수행하는데 필요한 타겟 컴퓨터의 하드웨어 및 소프트웨어를 어떠한 방법을 통해 에뮬레이션의 프로세스에 제공해야만 한다. 적정한 실행을 위해서는, 이러한 예외의 어느 시점에서도 정확한 타겟 상태를 얻을 수 있어야만 하기 때문에, 에뮬레이터는 이러한 예외에 정확히 응답할 수 있게 항상 이 상태를 정밀하게 추적할 수 있어야만 한다. 이 때문에, 종래 기술에서는 타겟 응용이 제공하는 시퀀스로 각 명령어를 수행해야 할 필요가 있었는 바, 이렇게 해야 만이 정확한 타겟 상태를 유지할 수 있기 때문이다.

더욱이, 종래 기술의 에뮬레이터는 여러 가지 이유들 가운데에서도 특히 타겟 응용의 실행 시퀀스를 항상 유지할 필요가 있었다. 타겟 명령어는 두 가지 타입 즉, 메모리에 영향을 주는 타입 및 메모리 맵 입출력(I/O) 디바이스에 영향을 주는 타입으로 될 수 있다. 어느 동작이 메모리에 영향을 주는지 또는 메모리 맵 I/O디바이스에 영향을 주는지에 대해서는 명령어를 실행해 보지 않고서는 알 수 가 없다. 명령어가 메모리 상에서 동작하는 경우, 최적화 및 재배열이 가능하고, 시스템 동작의 고속화에 매우 도움이 된다, 그러나, 상기 I/O디바이스에 영향을 주는 동작은 어떤 단계도 제거함이 없이, 프로그램된 동작 시퀀스대로 정확하게 수행되어야 한다. 그렇지 않으면, I/O디바이스의 동작에 어떠한 악영향을 미칠 가능성이 있다. 예를 들면, 특정의 I/O동작은 I/O 레지스터를 클리어 시키는 결과를 초래할 수 도있다. 동작이 시퀀스대로 행해지지 않고 아직도 필요한 값이 레지스터로부터 클리어 되었을 경우, 그 동작의 결과는 타겟 명령어가 지령한 동작과는 다르게 될 가능성이 있다. 메모리를 메모리 맵 I/O로부터 구별하는 수단이 없는 경우, 모든 명령어는 이 명령어들이 메모리 맵 I/O에 영향을 끼치면서 처리되어야 함을 필요로 한다. 이것은 달성 가능한 최적화를 심하게 제한한다. 종래 기술의 에뮬레이터는 어드레스 되는 메모리의 특성을 검출하는 수단 및 이러한 불능 상태로부터 복원을 행하는 수단이 결여되어 있으므로, 각 동작이 메모리 맵 I/O에 영향을 끼치면서 타겟 명령어 전체를 통해서 순차적으로 진행되어야함을 필요로 한다. 이는 호스트 명령어를 최적화할 가능성을 현저히 제한한다.

종래 기술의 에뮬레이터의 호스트 코드를 최적화 하는 능력을 저해하는 다른 문제는 자기 변경 코드(self-modifying code)에 의해서도 야기된다, 타겟 명령어가 호스트 명령어의 시퀀스로 변환되고 그 다음에 다시 기입되어 원래의 타겟 명령어를 변경했을 경우, 호스트 명령어는 이제 더 이상 유효하지 않다. 결과적으로, 에뮬레이터는 저장이 타겟 코드 영역에 대한 것인지 여부를 판정하기 위해 항상 체크를 행해야만 한다. 이러한 모든 문제 때문에, 이러한 타입의 에뮬레이션은 타겟 프로세서상에서 타겟 응용을 실행하는 것보다도 속도가 크게 느려지게된다.

도 1b에 도시한 타입의 에뮬레이션 소프트웨어의 다른 예가, 명칭이 "Talisman:Fast and Accurate Multicomputer Simulation"(타리스만 : 고속의 정확한 멀티 컴퓨터 시뮬레이션) (R. C. Bedichek, laboratory for Computer Sciences, Massachusetts Institute of Technology (R. C. 베디체크, 컴퓨터 과학 연구소, 매사추세츠 공과대학)인 논문에 기재되어 있다. 이것은 더욱 복잡한 변환의 예로써,완전한 개발 시스템을 에뮬레이트 하여 개발용 타겟 운영 체제를 실행 할 수가 있다. 타리스만은 호스트 UNIX 운영 체제를 이용하고 있다.

도 1c는 다른 에뮬레이션의 예를 도시한다. 이 경우에서는 원래의 Machintosh 컴퓨터에 이용되고 있던 Motorola68000 패밀리 CISC 프로세서상에서 실행 되도록 설계된 타겟 응용 프로그램을 실행하는 Apple Machintosh 컴퓨터에 이용되고 있는 PowerPC 마이크로프로세서를 나타내고 있다. 이런 종류의 구성은 Apple의 레거시 프로그램을 RISC 프로세서를 갖는 Machintosh 컴퓨터상에서 실행하기 위해서 필요로 되었다. 알 수 있는 바와 같이, 적어도 부분적으로 타겟 운영 체제를 이용, 호스트 프로세서상에서 타겟 응용을 실행하여 타겟 운영 체제의 응용형 부분에 응답한다. 소프트웨어 에뮬레이터에는, 타겟 응용 프로그램이나 응용형 타겟 운영 체제 프로그램이 제공하는 명령어를 호스트 프로세서나 그 호스트 운영 체제가 실행 할 수 있는 명령어로 분해하는 것이 있다. 호스트 운영 체제는 인터페이스를 제공하여, 이것을 통해서 호스트 컴퓨터의 메모리 및 입출력 하드웨어로의 액세스를 얻을 수 있도록 한다.

다시, 호스트 RISC 컴퓨터에 있어서의 호스트 RISC 프로세서 및 그것과 관계하는 디바이스는 Motorola의 CISC 프로세서와 관계하는 디바이스와는 완전히 다르며, 여러 가지의 타겟 명령어는 타겟 컴퓨터의 여러 가지의 부분에 액세스할 때, 타겟 CISC 운영 체제와 협력하도록 설계된다. 결과적으로, 에뮬레이션 프로그램은 타겟 컴퓨터의 하드웨어 디바이스를 동작시키도록 설계된 동작을 호스트 시스템의 하드웨어 디바이스가 실현 할 수 있는 동작에 링크 해야 한다. 이 때문에, 에뮬레이터는 타겟 응용의 명령어에 응답하는 소프트웨어의 가상 디바이스를 생성하며, 이러한 가상 디바이스로부터 호스트 운영 체제를 통해서 존재하지만 호스트 운영 체제에 의해 다른 방식으로 어드레스되는 호스트 하드웨어 디바이스로의 링크를 생성할 필요가 있다.

이러한 방식으로 실행하는 타겟 소프트웨어는 도 1b의 에뮬레이션이 느리게 실행되는 것과 같은 이유로 비교적 느리게 실행된다. 첫째, 타겟 응용 및 타겟 운영 체제로부터의 각 타겟 명령어는 해당 명령어를 인출함으로써 변환되어야 한다. 명령어를 실행할 때마다, 해당 명령어로부터 파생하는 모든 호스트 원시 기능을 순차적으로 실행해야 한다. 둘째, 에뮬레이션 소프트웨어는 호스트 운영 체제로의 타겟 응용의 호출마다 가상 디바이스를 생성해야 하며, 이들 가상 디바이스 각각은 실제의 호스트 디바이스에 호출을 제공해야 한다. 셋째, 에뮬레이터는 메모리 맵 I/O 디바이스로 향해진 명령어 또는 그것이 복원할 수 없는 예외를 생성할 위험을 처리하기 위해서, 모든 명령어를 보존적으로 처리해야 한다. 마지막으로, 에뮬레이터는 항상 정확한 타겟 상태를 유지해야만 하며, 저장 동작은 해당 저장이 타겟 코드 영역에 대한 것인지 여부를 판정하기 위해서 항상 미리 체크를 수행해야 한다. 이러한 모든 요건은 호스트 프로세서상에서 실행되는 코드의 중요한 최적화를 수행하는 에뮬레이트의 능력을 상실시켜, 어떤 타입의 에뮬레이터의 속도를 타겟 프로세서 상에서 타겟 응용을 실행하는 것보다도 크게 저하시킨다. 에뮬레이션 속도가 현재의 프로세서 속도보다 1/4 미만이면 이는 매우 양호한 것으로 생각된다. 이 때문에, 상기와 같은 타입의 에뮬레이션 소프트웨어는 다른 프로세서에 대해 설계된 응용을 실행하는 성능은 유용하지만, 주요 목적으로는 사용되지 못한다.

도 1d는 호스트 프로세서상에서 타겟 응용 프로그램을 에뮬레이션 하여, 매우 제한된 일련의 타겟 응용에 대해서 비교적 양호한 처리 성능을 제공하는 특정의 방법을 도시한다.

타겟 응용은 명령어를 에뮬레이터에 제공하며, 에뮬레이터는 이러한 명령어를 호스트 프로세서 및 호스트 운영 체제에 대한 명령어로 변경한다. 호스트 프로세서는 Digital Esuipment사의 Alpha RISC 프로세서이며, 호스트 운영 체제는 Microsoft NT이다. 이 시스템에 의해 실행 할 수 있는 유일한 타겟 응용은 Windows WIN32s에 준거하는 운영 체제를 갖는 타겟 X86 프로세서에 의해 실행되도록 설계된 32 비트 응용뿐이다. 호스트 및 타겟 운영 체제는 대부분 동일하고, 이러한 동일 명령어를 처리하도록 설계되고 있으므로 에뮬레이터 소프트웨어는 명령어를 매우 간단하게 변환할 수가 있다. 더욱이, 호스트 운영 체제는 이미 타겟 응용이 발생하는 같은 호출에 응답하도록 설계되고 있으므로, 가상 디바이스의 생성은 크게 감소한다.

기술적으로 호스트 프로세서 상에서 타겟 응용을 실행하는 에뮬레이션 시스템이 있지만, 이는 매우 특수한 경우이다. 여기에서, 에뮬레이션 소프트웨어는 유사한 응용을 실행하도록 이미 설계되고 있는 호스트 운영 체제 상에서 실행된다. 이 때문에, 타겟 응용으로부터의 호출이 호스트 및 호스트 운영 체제의 보정 메커니즘에 향하도록 하는 것이 한층 용이해진다. 더욱 중요한 것은, 이 시스템은 아마 모든 X86 응용의 1퍼센트에도 못 미치는 양의 32비트 Windows 응용만을 실행할 것이다. 더욱이 이 시스템은 1개의 운영 체제 즉, WindowsNT상에서만 응용을 실행하지만, X86 프로세서는 다수의 운영 체제에 대해 설계된 응용을 실행한다. 따라서, 이러한 시스템은 본 명세서의 서두에 언급한 의미에서는 호환성이 있다고 볼 수 없다. 따라서, 이러한 에뮬레이터를 실행하는 프로세서는 경쟁력있는 X86 프로세서라고 볼 수 없다.

다른 명령어 세트를 인식하는 컴퓨터 상에서, 소프트웨어를 이용하여 제 1 명령어 세트에 대해서 기입된 응용의 부분을 실행하는 것을 가능하게 하는 다른 에뮬레이션 방법이 도 1e에 나타나있다.

이러한 형태의 에뮬레이션 소프트웨어는 통상 어느 컴퓨터 시스템으로부터 다른 시스템에 응용을 이식(port)하고자 하는 프로그래머에 의해 이용된다. 통상, 타겟 응용은 에뮬레이터를 실행하는 호스트 머신 이외의 몇 개의 타겟 컴퓨터용으로 설계되고 있다.

에뮬레이터 소프트웨어는 타겟 명령어를 분석하여, 이러한 명령어를 호스트머신 상에서 실행할 수 있는 명령어로 변환하고, 이러한 호스트 명령어를 캐시(cache)하여, 그것들을 재사용 가능하게 한다. 동적 변환 및 캐싱에 의해 응용의 부분을 매우 고속으로 실행하는 것이 가능해진다. 이 형태의 에뮬레이터는 통상 소프트웨어 트레이스 툴과 함께 이용되어 실행중의 타겟 프로그램의 동작에 관한 상세한 정보를 제공한다.

한편, 트레이스 툴의 출력은 트레이스 정보를 분석하는 분석기 프로그램을 구동하는데 이용할 수가 있다.

실제로 코드가 어떻게 기능하는지 여부를 판정하기 위해서, 이런 타입의 에뮬레이터는 다른 동작들 중에서도 특히, 호스트 머신 상에서 호스트 운영 체제와 함께 실행하여 호스트 운영 체제가 제공하지 못하는 가상 하드웨어를 제공하며, 그렇지 않으면, 응용의 설계 대상인 컴퓨터의 동작을 호스트 머신의 하드웨어 자원에 법정하여 실행되고 있는 프로그램의 동작을 수행한다. 이 소프트웨어에 의한 하드웨어의 가상화 및 호스트 컴퓨터로의 매정은 매우 늦고 불완전해질 수 있다.

더욱이, 타겟 명령어들 중의 하나를 실행하기 위해서 복수의 호스트 명령어를 필요로 하는 경우가 많기 때문에, 타겟 운영 체체의 예외 조정기를 필요로 하는 폴트나 트랩을 포함한 예외가 발생할 가능성이 있어, 타겟 명령어의 경계와는 무관한 지점에서 호스트가 호스트 명령어의 처리를 중지시키게 하는 경우가 있다. 이것이 발생했을 경우, 예외를 올바르게 처리하는 것이 불가능해질 수 있는데, 이는 호스트 프로세서 및 메모리 상태가 올바르지 않기 때문이다. 이러한 경우, 에뮬레이터를 정지하고 재차 실행하여, 예외를 발생한 동작을 추적해야 한다. 따라서, 이러한 에뮬레이터는 타겟 코드의 시퀀스를 매우 신속히 실행할 수 있지만, 이러한 예외로부터 복원할 방법이 없고, 따라서 응용의 중요한 부분을 신속히 실행할 수 없다.

이는 이러한 형태의 에뮬레이터에서 특별한 문제가 되지 않는데, 그 이유는 에뮬레이터, 트레이서 및 관련 분석기가 실행하는 기능은 새로운 프로그램을 생성하든가 혹은 오래된 프로그램을 다른 머신에 이식함으로써, 에뮬레이터 소프트웨어가 실행하는 속도는 대부분 문제가 되지 않게 하기 때문이다. 즉, 프로그래머는 에뮬레이터가 생성한 코드가 호스트 머신상에서 얼마나 빠르게 실행되는가에 관심이 있는 것은 아니라, 에뮬레이터가 생성하는 코드가 설계 대상의 기계상에서 실행 가능한지 및 해당 머신상에서 신속히 실행될 것인지에 대해 관심이 있는 것이다, 결과적으로, 이런 타입의 에뮬레이션 소프트웨어는 프로그래밍 이외의 목적으로 다른 타입의 마이크로프로세서상에서 실행하기 위해서 제1 명령어 세트에 기입된 응용 프로그램을 실행하는 방법을 제공하지 못한다. 이런 타입의 에뮬레이션 소프트웨어의 일례가, "Shade: A First Instruction-Set Simulator for Execution Profiling"(쉐이드: 실행의 특성을 알기 위한 고속 명령어 세트 시뮬레이터)라는 제목의 Cmelik(스메릭크) 및 keppel(켑펠)의 논문에 기재되어 있다.

현재의 마이크로프로세서보다 고속이고 비용이 저렴하고, 현재의 마이크로프로세서에 대해 설계된 타겟 응용 프로그램과 완전하게 호환성이 있으며, 이러한 마이크로프로세서에서 이용 가능한 모든 운영 체제를 실행할 수가 있는 경쟁력이 있는 마이크로프로세서를 제공하는 것이 바람직하다.

특히, 예외로부터의 신속한 회복을 가능하게 하는 방식으로, 프로세서가 동작하는 속도를 높이도록 호스트 프로세서의 메모리 저장을 처리하는 회로를 제공하는 것이 바람직하다.

발명의 요약

그러므로, 본 발명의 목적은 프로그램의 실행동안에 발생하는 메모리 저장을 가속화하는 장치에 의하여 마이크로프로세서의 동작을 개선하는 것이다.

본 발명의 이 목적 및 기타 목적은 타겟 명령어 시퀀스를 호스트 명령어로 변환하는 호스트 프로세서가 변환 인터벌 동안 순차적으로 발생한 모든 메모리 저장을 다른 메모리 저장으로부터 분리하여, 일시적으로 홀드하는 버퍼와; 변환이 예외를 발생함이 없이 실행되었을 경우, 변환 인터벌 동안 순차적으로 발생한 메모리 저장을 메모리에 전송하는 회로와; 메모리 어드레스에서의 메모리 액세스에 응답하여, 동일한 메모리 어드레스에 대해서 어느 메모리 저장이 최신의 것인지를 나타내는 회로와; 그리고 변환이 예외를 발생함이 없이 실행되었을 경우, 변환 인터벌 동안 순차적으로 발생한 메모리 저장을 소거하는 회로를 포함하는 장치 및 방법에 의해 실현된다.

본 발명의 이들 및 기타 목적은 도면을 참조로 한 이하의 상세한 설명을 통해 보다 잘 이해될 것이다. 여러 도면에 있어서, 동일 구성요소는 동일 참조번호로 표시했다.

본 발명은 컴퓨터 시스템에 관한 것으로, 보다 특별하게는 다른 프로세서로 실행하도록 설계된 프로그램으로부터 변환된 프로그램을 실행하는 호스트 마이크로프로세서에 의해 메모리 저장(memory stores)을 제어하는데 이용되는 게이트 저장 버퍼(gated store buffer)에 관한 것이다.

도 1a 내지 도 1e는 종래 기술에 따라 설계된 마이크로프로세서의 동작을 예시하는 도면이다.

도 2는 다른 마이크로프로세서에 대해 설계된 응용을 실행하는 마이크로프로세서의 블럭도이다.

도 3은 도 2에 도시된 마이크로프로세서의 일부를 도시한 도면이다.

도 4는 도 3에 도시된 것 같은 마이크로프로세서에 대해 이용되는 레지스터 파일을 도시한 블럭도이다.

도 5는 본 발명에 따라 설계된 게이트 저장 버퍼를 도시한 블럭도이다.

도 6a 내지 도 6c는 종래 기술의 여러 가지의 마이크로프로세서 및 도 3에 도시된 것 같은 마이크로프로세서에 대해 이용되는 명령어를 도시한다.

도 7은 도 3에 도시된 것 같은 마이크로프로세서의 소프트웨어 부분에 의해 수행되는 한 방법을 도시한다.

도 8은 도 3에 도시한 것 같은 마이크로프로세서의 소프트웨어 부분에 의해 수행되는 다른 방법을 도시한다.

도 9는 도 3에 도시한 것 같은 개량된 컴퓨터 시스템을 도시한 블럭도이다.

도 10은 도 3에 도시한 마이크로프로세서의 일부를 도시한 블럭도이다.

도 11은 도 3의 마이크로프로세서 내에 도시한 변환 룩 어사이드 버퍼의 상세 블럭도이다.

도 12는 도 3에 도시한 것 같은 프로세서에 대해 이용되는 메모리의 상세 블럭도이다.

도 13은 본 발명에 의한 게이트 저장 버퍼의 제1의 논리적 실시예를 도시한 블럭도이다.

도 14는 본 발명에 의한 게이트 저장 버퍼의 제2의 실시예를 도시한 블럭도이다.

표기 및 명명

이하의 상세한 설명의 일부는 컴퓨터 메모리내의 데이터 비트에 대한 동작을 상징적인 표현으로 제시한다. 이러한 기재 및 표현은 데이터 처리 기술 분야의 당업자에 의해 이용되어 다른 당업자에게 그러한 동작의 본질을 가장 효과적으로 전하는 수단이 된다. 동작은 물리적인 양의 물리적인 조작을 필요로 하는 것이다. 통상, 이러한 양은 저장, 전송, 결합, 비교 및 그 이외의 조작이 가능한 전기적 또는 자기적 신호의 형태를 취하지만, 반드시 그렇다고는 할 수 없다. 주로 공통 사용의 이유 때문에, 이러한 신호를 비트, 값, 엘리먼트(element), 심볼, 문자, 말, 수치 등으로서 언급하는 것이 때로 편리한 것으로 여겨진다.

그러나, 이들 및 유사한 용어는 모두 적절한 물리량에 관련지을 수 있고, 이러한 양에 적음된 단지 편의상의 표시에 지나지 않는 것임을 염두에 두어야 하는 것일 것이다.

더욱이, 실행되는 조작은 종종 가산 또는 비교라는 용어로 언급하지만, 이것들은 인간 오퍼레이터가 실행하는 정신적인 동작과 일반적으로 관련이 있다. 인간 오퍼레이터의 이러한 능력은 대부분의 경우 본 발명의 일부를 형성하는 여기에 기재하는 동작중 어느 것에도 필요하거나 바람직한 것은 아니다, 동작이란 기계적 동작이다. 본 발명의 동작을 실행하는데 유용한 머신은 범용 디지탈 컴퓨터 또는 기타 디바이스를 포함한다. 모든 경우에 대하여, 컴퓨터를 동작시키는데 있어서의 방법 동작과 계산 자체의 방법간의 구별을 염두에 두어야 한다. 본 발명은 전기적 또는 기타(예를 들면, 기계적, 화학적) 물리적 신호를 처리하여, 기타 원하는 물리적 신호를 발생하도록 컴퓨터를 동작시키는 방법 및 장치에 관한 것이다.

이하의 설명에서, 경우에 따라서는 상세한 동작 예를 제공하기 위해서, 타겟 프로그램은 X86 마이크로프로세서상에서 실행하도록 설계된 프로그램으로서 언급하기로 하는데, 이는 대부분의 에뮬레이터는 X86 응용을 실행하기 때문이다. 그러나, 타겟 프로그램은 어느 타겟 컴퓨터 패밀리상에서 실행되도록 설계된 것으로도 될 수 있다. 이것은 Pcode 머신, Postscript 머신, 또는 Java 가상 머신과 같은 타겟 가상 컴퓨터를 포함한다.

본 발명은 종래 기술의 문제를 극복하는데 도움이 되는 것으로써, 종래 기술의 마이크로프로세서보다 고속으로, 종래 기술의 다수의 마이크로프로세서 패밀리에 의해 실행될 수 있는 모든 운영 체제에 대해서 모든 소프트웨어를 실행할 수가 있으며, 종래 기술의 마이크로프로세서보다 저렴한 마이크로프로세서를 제공한다.

더욱 복잡한 하드웨어에 의해 그 동작을 가속시키는 마이크로프로세서를 이용하기보다는, 본 프로세서는 기존의 마이크로프로세서보다 매우 단순한 개량 하드웨어 처리부(본 명세서에서는 "모프 호스트"라 칭한다)와 에뮬레이트 소프트웨어부(본 명세서에서는 "코드 모핑(code morphing) 소프트웨어"라 칭한다)를 포함한 조합을 일부로 하여, 이들 2개의 부분이 일체가 되어 마이크로프로세서로서 기능하여, 공지된 그 어떤 경합 마이크로프로세서보다 높은 성능을 지니게 된다.

더욱 구체적으로는, 모프 호스트는 예외 또는 에러가 발생했을 경우, 즉시 타겟 컴퓨터 상태를 얻을 수 있게 지원해주는 하드웨어 기능 강화를 포함하는 프로세서이며, 코드 모핑 소프트웨어는 타겟 프로그램의 명령어를 모프 호스트를 위한 모프 호스트 명령어로 변환해서, 예외 및 에러에 응답하여 필요에 따라 작업 상태를 정확한 타겟 상태로 치환함으로써, 정확한 재변환을 하도록 하는 소프트웨어이다. 코드 모핑 소프트웨어는 또한 처리 속도를 높이기 위한 여러 가지의 프로세스를 포함할 수 있다. 종래 기술의 초고속 마이크로프로세서는 그 모두가 하드웨어를 갖추어 처리 속도를 높이지만, 이에 반하여 본 발명의 개량 프로세서는 코드 모핑소프트웨어에 의해 다수의 가속 보강 기술이 선택 가능한 스테이지에서 실행 가능하게 해준다. 코드 모핑 소프트웨어에 속도 증강 기술을 제공함으로써, 복잡성이 현격히 낮은 하드웨어를 이용하여, 모프 호스트를 실현하는 것이 가능해진다. 이것은 종래 기술의 마이크로프로세서의 하드웨어보다 고속이며, 비용이 상당히 저렴하다. 비교로서, 이용 가능한 X86 응용 모두를 실행하도록 설계된 마이크로프로세서를 포함하는 일 실시예는 Pentium Pro 마이크로프로세서의 게이트 수의 약 1/4를 포함하는 모프 호스트에 의해 실현되며, Pentium pro 마이크로프로세서 또는 X86 응용을 처리할 수 있는 다른 공지의 마이크로프로세서가 실행하는 것보다 훨씬 빠르게 이러한 응용을 실행한다.

코드 모핑 소프트웨어는 새로운 소프트웨어를 설계하거나 혹은 새로운 하드웨어를 에뮬레이트 하는 프로그래머에 의해서만 이전부터 이용되고 있던 어떤 타입의 기술을 이용한다. 모프 호스트는 특히, 코드 모핑 소프트웨어가 제공하는 가속 기술을 효율적으로 이용할 수 있도록 해주는 복수의 하드웨어 기능 강화를 포함한다. 이러한 하드웨어 기능 강화는 코드 모핑 소프트웨어가 보다 광범위한 명령어들에 대해서 가속 기술을 실현 가능하게 해준다. 이러한 하드웨어 기능 강화는 또한 하드웨어 프로세서에서는 얻을 수 없고, 불합리한 비용을 들인 프로세서가 아니면 실현될 수 없는 추가의 가속 기술을 코드 모핑 소프트웨어에 의해 실행 가능하게 한다. 이러한 기술은 네이티브 명령어 세트(native instruction sets)의 실행을 수행하는 종래 기술의 마이크로프로세서의 속도와 비교하여, 마이크로프로세서의 속도를 현격히 높여준다.

예를 들면, 개량 모프 호스트와 조합된 코드 모핑 소프트웨어는 대량의 회로를 추가할 필요가 없이, 타겟 명령어의 시퀀스에 의해 발생된 원시 명령어의 재배열 또는 재스케줄링을 가능하게 하는 기술을 사용할 수 있게 한다. 다수의 타겟 명령어 전체의 재배열 및 재스케줄링을 가능하게 함으로써, 다른 최적화 기술을 이용하여 타겟 명령어들을 실행하는데 필요한 프로세서 단계수를 타겟 응용을 실행하는 다른 어느 마이크로프로세서가 필요로 하는 것보다 삭감할 수가 있다.

개량 모프 호스트와 조합된 코드 모핑 소프트웨어는 타겟 명령어를 실행 중에 모프 호스트의 명령어로 변환하여, 이러한 호스트 명령어를 메모리 데이터 구조(본 명세서에서는 "변환 버퍼"라 칭한다)에 캐시한다. 변환 버퍼를 이용해 변환된 명령어를 홀드함으로써, 어느 원시 명령어가 각 타겟 명령어를 실현하는데 필요한지를 판정하고, 각 원시 명령어를 어드레스 하고, 각 원시 명령어를 인출하고, 원시 명령어의 시퀀스를 최적화하고, 각 원시 명령어에 자산(assets)을 할당해 원시 명령어를 재배열하고 그리고 각 타겟 명령어를 실행할 때마다 필요한 원시 명령어의 각 시퀀스의 각 단계를 실행하는 긴 프로세스를 재차 실행함이 없이도 명령어를 호출하는 것이 가능해진다. 일단 타겟 명령어가 변환되면, 이는 무수한 단계를 전혀 필요로 함이 없이 변환 버퍼로부터 호출되어 실행될 수가 있다.

종래 기술에 따른 에뮬레이션 기술의 주된 문제는, 이러한 기술들이 타겟 프로그램의 실행중에 발생하는 예외를 효율적으로 처리할 수 없다는 점에 있다.

종래 기술은 특히, 예외 및 이에 따르는 명령어의 적절한 실행을 위해서 예외의 어느 시점에서도 정확한 타겟 상태를 얻을 수 있어야만 하는 타겟 운영 체제를 대상으로 하는 타겟 응용을 실행하고 있을 때에 발생하는 예외들에 대해 효율적으로 처리할 수 없다. 결과적으로, 종래 기술의 에뮬레이터는 항상 타겟 상태를 고정밀도로 추적해야 함을 요구받으며, 저장 내용이 타겟 코드 영역에 대한 것인지 여부를 판정하기 위해서 항상 체크를 행해야 한다.

다른 예외들도 유사한 문제를 일으킨다. 예를 들면, 에뮬레이터가 어느 특정의 호스트 기능에 의해 치환된 특정의 타겟 동작을 검출하는 경우에 예외가 발생하는 일이 있다. 즉, 타겟 프로세서의 여러 가지의 하드웨어 동작은 에뮬레이터 소프트웨어가 제공하는 소프트웨어 동작으로 치환할 수가 있다. 또한, 타겟 명령어로부터 파생한 호스트 명령어를 실행하는 호스트 프로세서도 예외를 발생할 가능성이 있다. 이러한 예외는 모두 에뮬레이터가 타겟 명령어를 호스트 명령어로 변환하려 하고 있는 동안에 발생하거나 또는 호스트 변환이 호스트 프로세서 상에서 실행될 때 발생할 가능성이 있다. 효율적인 에뮬레이션을 위해서는, 예외를 올바르게 처리하면서, 이러한 예외로부터 효율적으로 복원을 행하는 어떠한 방법을 갖출 필요가 있다. 에뮬레이트되어야만 하는 모든 소프트웨어에 대해서 이것을 수행할 수 있는 종래 기술은 없다.

이들 종래 기술의 한계를 극복하기 위해서, 개량 모프 호스트에는 다수의 하드웨어의 개선이 포함되어 있다. 이러한 개선에는, 게이트 저장 버퍼 및 다수의 추가 프로세서 레지스터가 포함된다. 추가 레지스터들 중 일부는 레지스터의 명칭 변경을 이용하므로 같은 하드웨어 자원을 필요로 하는 명령어의 문제를 경감할 수가 있다. 또, 추가 레지스터에 의해 호스트 명령어를 처리하는 한 세트의 호스트 레지스터 또는 작업 레지스터 및 한세트의 타겟 레지스터를 유지하여, 타겟 응용을 생성한 타겟 프로세서의 오피셜 상태(official state)를 홀드할 수가 있다. 타겟(또는 새도우) 레지스터는 전용의 인터페이스를 통해 그러한 작업 레지스터의 동등물에 접속된다. 전용 인터페이스는 "커미트(commit)"로 불리는 동작에 의하여, 모든 작업 레지스터의 내용을 재빠르게 오피셜 타겟 레지스터에 전송시키며, "롤백(rollback)"으로 불리는 동작에 의하여, 모든 오피셜 타겟 레지스터의 내용을 그러한 작업 레지스터 동등물에 재빠르게 역전송 시키는 것을 가능하게 한다. 게이트 저장 버퍼는 하드웨어 게이트의 "언커미티드(uncommitted)" 측의 작업 메모리 상태 변화를 저장하고, 하드웨어 게이트의 "커미티드(committed)" 측의 오피셜 메모리 상태 변화를 저장한다. 이 경우, 커미티드된 저장은 메인 메모리로 "배출(drain)"된다. 커미트 동작은 게이트의 언커미티드 측으로부터 게이트의 커미티드측에 저장을 전송한다. 일단 1개 또는 1군의 타겟 명령어를 변환하여, 에러 없이 실행했다면, 추가의 오피셜 레지스터 및 게이트 저장 버퍼에 의하여, 메모리 상태 및 타겟 레지스터 상태를 함께 갱신하는 것이 가능해진다.

이러한 갱신은 코드 모핑 소프트웨어에 의하여, 정수 타겟 명령어 경계(integral target instruction boundary)상에서 발생하도록 선택된다. 따라서, 타겟 명령어 시퀀스의 변환을 구성하는 원시 호스트 명령어가 예외를 발생함이 없이 호스트 프로세서에 의해 실행되었을 경우, 이러한 명령어에 의해 발생한 작업 메모리의 저장 및 작업 레지스터 상태는 오피셜 메모리 및 오퍼셜 타겟 레지스터에 전송된다. 이와 같은 방식으로, 변환되는 한개 또는 한세트의 타겟 명령어의 경계상에는 없는 지점에서 호스트 명령어를 처리하고 있을 때 예외가 발생했을 경우, 마지막 갱신(또는 커미트)에 있어서의 타겟 레지스터내의 원래 상태는 작업 레지스터에 재호출할 수가 있어 게이트 저장 버퍼 내의 언커미티드 메모리 저장이 소거(dump)될 수 있다. 이어서, 발생된 예외가 타겟 예외인 경우, 이 타겟 예외를 일으킨 타겟 명령어를 1회에 1개씩 재변환하여, 이들이 타겟 마이크로프로세서에 의해 실행되도록 일련의 시퀀스로 실행할 수가 있다. 각 타겟 명령어는 에러 없이 올바르게 실행되므로, 타겟 레지스터 상태를 갱신할 수 있어 저장 버퍼 내의 데이터가 메모리에 게이트(gate)될 수 있다. 다음에, 호스트 명령어를 실행하고 있을 때 예외가 다시 발생했을 경우, 타겟 컴퓨터의 정확한 상태는 모프 호스트의 타겟 레지스터 및 메모리에 홀드되어 동작을 지연 없이 정확하게 처리할 수가 있다. 이 정확한 변환에 의해 얻을 수 있는 새로운 변환 각각은 향후를 위해서 캐시해 두어, 그것을 변환할 때 또는 일단 그것을 소거할 때, 혹은 페이지 폴트와 같이 드문 사건 시에 사용할 수가 있다. 이에 의하여, 코드 모핑 소프트웨어와 모프 호스트와의 조합으로 구성한 마이크로프로세서가 원래 소프트웨어가 기입될 대상인 프로세서보다 빠르고, 명령어를 실행하는 것이 가능하게 된다.

본 발명을 포함한 마이크로프로세서를 이용해 타겟 프로그램을 실행하는 경우, 다른 방법으로 처리되는 많은 다른 타입의 예외가 발생할 가능성이 있음이 주목된다. 예를 들면, 예외에는, 예외를 발생하는 타겟 소프트웨어가 원인의 것도 있어, 이것에는 타겟 운영 체제의 예외 조정기를 이용한다. 이러한 예외 조정기의 사용에서는, 프로세스의 처리를 위해서, 코드 모핑 소프트웨어는 타겟 컴퓨터가 갖추는 모든 하드웨어를 포함한 예외 처리 프로세스 전체를 에뮬레이트 하는 루틴을 포함하는 것이 괼요하다. 이 때문에, 코드 모핑 소프트웨어가 타겟 프로세서 상태를 세이브하는 기능을 갖추어 예외를 모두 처리한 후에 올바르게 이행할 수 있도록 할 필요가 있다. 변환되는 프로세스를 수행하기 전에 메모리의 새로운 페이지에 데이타를 인출할 필요가 있는 페이지 폴트와 같은 일부 예외에서는, 예외를 처리한 후에 변환 대상의 프로세스의 시점으로 돌아갈 필요가 있다. 다른 예외는 동작이 하드웨어에 의해 주어지지 않는 경우, 소프트웨어로 특정의 동작을 실현한다. 이것들은 예외 조정기가 예외를 처리한 후에 변환에 있어서 동작을 다음의 단계로 되돌리는 것을 필요로 한다. 이들 다른 타입의 예외들 각각은 본 발명을 포함한 마이크로프로세서에 의해 효율적으로 처리될 수가 있다.

또한, 일부 예외가 호스트 하드웨어에 의해 발생되어, 여러 가지의 호스트 및 타겟 상태를 검출한다. 또, 일부 예외는 종래의 마이크로프로세서상의 예외와 같이 행동하지만은 그 외의 예외들은 코드 모핑 소프트웨어가 여러 가지의 추측의 실패를 검출하는데 이용된다, 이러한 경우, 코드 모핑 소프트웨어는 전술한 상태 세이브 및 복원 메커니즘을 이용하여, 타겟 상태를 그 최근의 오피셜 버젼으로 복원시켜, 그 실패한 추측을 회피하는 새로운 변환을 발생하여 세이브한다(혹은, 이전에 발생된 안전한 변환을 재이용한다). 다음에, 이 변환을 실행한다.

모프 호스트는 추가의 하드웨어 예외 검출 메커니즘을 포함하여, 전술의 롤백 및 재변환 방법과 함께, 한층 더 최적화를 가능하게 한다. 예로서, 메모리를 메모리 맵 I/O로부터 구별하는 수단, 및 어드레스 또는 어드레스 범위를 보호하여 메모리의 참조를 필요로하지 않으면서 타겟 변수를 레지스터에 홀드할 수 있게 하는 수단이 있다.

동작이 메모리 또는 메모리 맵 I/O에 영향을 주는지 여부와 같은 그러한 다른 추측들의 실패를 검출하는데 예외가 이용되는 경우, 서로 다른 메모리 동작 및 서로 다른 최적화를 갖는 새로운 변환의 생성에 의해 복원이 달성된다.

도 2는 도 1a의 CISC 프로세서 상에서 실행되는 동일 응용 프로그램을 실행하는 모프 호스트 하드웨어의 블럭선도이다. 도시된 바와 같이, 마이크로프로세서는 전술한 코드 모핑 소프트웨어부와 기능 강화 하드웨어 모프 호스트부를 포함한다. 타겟 응용은 타겟 명령어를 코드 모핑 소프트웨어에 제공하여 모프 호스트가 실행 가능한 호스트 명령어로 변환시킨다. 한편, 타겟 운영 체제는 타겟 응용 프로그램으로부터의 호출을 받아, 이것들을 코드 모핑 소프트웨어에 전송한다. 마이크로프로세서의 바람직한 실시예에서, 모프 호스트는 최장 명령어 워드(VLIW : very long instruction word) 마이크로프로세서이며, 복수의 처리 채널에 의해 설계되어 있다. 이러한 프로세서의 전체적인 동작에 대해서는 도 6c에 더욱 상세히 도시한다.

도 6a 내지 도 6c는 CISC 프로세서, RISC 프로세서 및 VLIW 프로세서 각각과 사용하도록 구성된 명령어를 도시한다. 도시된 바와 같이, CISC 명령어는 가변 길이로 되며, 보다 많은 원시 동작(예를 들면, 적재 및 가산)을 복수개 포함할 수가 있다. 한편, RISC 명령어는 길이가 동일하고 본질적으로 원시 동작이다. 도시된 VLIW 프로세서에 대한 단일의 최장 명령어는 CISC 및 RISC 명령어의 것보다 많은 원시 동작(즉, 적재, 저장, 정수 가산, 비교, 부동 소수점 곱셈, 분기) 각각을 포함한다. 도 6c에 도시된 바와 같이, 일체로 되어 단일의 최장 명령어 워드를 구성하는 원시 명령어 각각은 다른 원시 명령어와 병렬로, VLIW 프로세서의 복수의 개별 처리 채널중 하나에 제공되거나 또는 처리 채널과 메모리에 의해 병렬로 처리될 메모리에 제공된다. 이들 병렬 동작의 모든 결과는 멀티 포토 레지스터 파일에 전송된다.

모프 호스트 방식의 VLIW 프로세서는 전술한 다른 프로세서보다 훨씬 단순한 프로세서이다. 이것은 발행 의존성(issue dependency)을 검출하는 회로나 원시 명령어를 재배열, 최적화 및 재스케줄링 하는 회로를 포함하지 않는다. 이 때문에, 원래 타겟 응용 프로그램의 설계 대상인 프로세서나, 에뮬레이션 프로그램을 이용하여 타겟 응용 프로그램을 실행하는 그 외의 프로세서 중 어느 하나로 가능한 클럭 속도보다 높은 클럭 속도로 빠른 처리가 가능해진다. 그러나, 프로세서는 VLIW 프로세서로 제한되는 것은 아니며, RISC 프로세서와 같은 모든 타입의 프로세서로서 기능 할 수가 있다.

도 2에 도시한 마이크로프로세서의 코드 모핑 소프트웨어는 변환기(translator)를 포함한다. 이 변환기는 타겟 응용의 명령어를 디코드하고, 이러한 타겟 명령어를 모프 호스트에 의해 실행이 가능한 원시 호스트 명령어로 변환하고, 타겟 명령어가 요구하는 동작을 최적화하고, 원시 명령어를 재배열 및 스케줄링을 통해 모프 호스트의 VLIW 명령어로 변환하여, 이 호스트 VLIW 명령어를 실행한다. 변환기의 동작을 도 7에 나타냈다. 도 7은 코드 모핑 소프트웨어의 메인 루프의 동작을 도시한다.

코드 모핑 소프트웨어 및 개량 모프 호스트 하드웨어를 포함한 마이크로프로세서의 동작을 가속하기 위해서, 코드 모핑 소프트웨어는, 도 2에 도시한 것 같은 변환 버퍼를 포함한다. 일실시예의 변환 버퍼는, 메모리에 저장 가능한 소프트웨어 데이터 구조이다. 특정의 실시예에서는, 하드웨어의 캐시도 이용할 수 있는 경우가 있다. 변환 버퍼는 타겟 명령어의 완료된 변환 각각을 실체화하는 호스트 명령어를 저장하기 위해서 이용된다. 알 수 있는 바와 같이, 일단 개개의 타겟 명령어를 변환하여 결과적인 호스트 명령어의 최적화, 재배열 및 재스케줄링을 수행했다면, 결과적인 호스트 변환을 변환 버퍼에 저장한다. 다음에, 변환을 구성하는 호스트 명령어를 모프 호스트에 의해 실행한다. 호스트 명령어를 실행하여 예외가 발생하지 않는 경우, 그 후 타겟 명령어 또는 명령어들이 필요로 하는 동작이 요구될 때 언제라도 변환을 호출할 수가 있다.

따라서, 도 7에 보인 바와 같이, 응용 프로그램에 의해 타겟 명령어의 어드레스가 주어졌을 때의 마이크로프로세서의 코드 모핑 소프트웨어의 전형적인 동작은 처음에 타겟 어드레스에서의 타겟 명령어가 변환되었는지 여부를 판정하는 것이다. 타겟 명령어가 변환되지 않은 경우, 변환기에 의하여 그것 및 후속의 타겟 명령어를 인출, 디코드, 변환하고, 그 다음에 (가능하면)최적화, 재배열 및 새로운 호스트 변환내로 재스케줄링 하여, 변환 버퍼에 저장한다. 이후 설명하는 바와 같이, 가능한 최적화에는 여러 가지 정도가 있다. 이 명세서에서, "최적화"라는 용어는 처리를 가속시키기 위한 기술을 총칭하는데 흔히 이용된다. 예를 들면, 재배열은 고속 처리를 가능하게 하며, 본 용어 범위내에 포함되는 최적화의 한 형태이다. 가능한 최적화의 상당수는 종래 기술의 컴파일러의 최적화에서 설명되고 있으며, "슈퍼 블록 (suPer-block)"과 같은 종래 기술의 범위 내에서는 실행이 곤란한 일부 최적화가 VLIW의 연구로부터 분명해졌다. 이어서, 제어가 변환에 전송되어, 개량 모프 호스트 하드웨어에 의한 실행이 재개되도록 한다.

다음, 응용을 실행하는 데에 특정의 타겟 명령어 시퀀스를 접하게 되면, 호스트 변환은 이제 변환 버퍼 내에서 발견되어, 변환, 최적화, 재배열 또는 재스케줄링을 행할 필요 없이 즉시 실행된다. 후술하는 개선된 기술을 이용할 때, 타겟 명령어에 대한 변환은 (일단 완전하게 변환되면) 거의 100만회 변환 실행마다 1회로 변환 버퍼에서 발견되는 것으로 추정되었다. 그 결과, 최초의 변환 후에, 디코드, 원시 명령어의 인출, 원시 명령어의 최적화, 호스트 변환내로의 재스케줄링 및 변환 버퍼로의 저장과 같은 변환에 필요한 모든 단계들이 필요한 처리로부터 제외될 수가 있다. 타겟 명령어 기록 대상의 프로세서는 명령어를 실행할 때마다 각 명령어에 대해 더코드, 인출, 재배열 및 재스케줄링을 실행해야 하므로, 이것은 타겟 명령어를 실행하는데 필요한 작업을 격감시켜, 개량 마이크로프로세서의 속도를 높이게 된다.

종래 기술의 프로세서에 의한 타겟 응용의 실행에 필요한 이러한 모든 단계를 제거함으로써, 본 발명이 포함된 마이크로프로세서는, 상당한 속도로도 이러한 동작을 행할 수 없었던 종래 기술의 문제를 극복한다. 예를 들면, 개량 마이크로프로세서의 기술들 중 일부가 응용을 다른 시스템에 이식하는데 이용되는 전술한 에뮬레이터에서 이용되었다. 그러나, 이러한 에뮬레이터들 중 일부는 응용의 짧은 부분 이외의 부분을 실행 할 방법이 없었는데, 그 이유는 변환된 명령어를 처리할 때, 여러 가지의 시스템 예외 조정기에 호출을 발생하는 예외가 호스트 프로세서 상태가 동일 명령어를 처리하고 있는 타겟 프로세서 상태와 관계가 없는 동작 시점에서 발생했기 때문이다. 이 때문에, 이러한 예외가 발생한 시점에서의 타겟 프로세서 상태는 알 수 없었다. 따라서, 타겟 머신의 정확한 상태가 판정되지 못하고 동작이 정지 및 재시작 되어야만 하여, 정확한 상태를 파악하지 않으면 예외에 대처해 실행을 계속할 수가 없었다. 이 때문에, 응용 프로그램을 호스트의 속도로 실행하는 것이 불가능했다.

모프 호스트 하드웨어는 이 문제를 극복하는 다수의 기능 강화를 포함한다. 이러한 기능 강화를 각각 도 3, 도 4 및 도 5에 도시한다. 에러가 발생한 시점에서 레지스터의 정착한 상태를 판정하기 위해서, 제 1세트의 오피셜 타겟 레지스터가 개량 하드웨어에 의해 제공되어, 원래 응용의 설계 대상인 타겟 프로세서의 레지스터 상태를 홀드한다. 이러한 타겟 레지스터는 부동 소수점 유니트, 모든 정수 유니트 및 그 외의 모든 실행 유니트 각각에 포함되게 할 수가 있다. 이러한 오피셜 레지스터를 모프 호스트에게 추가하고 통상의 작업 레지스터 수를 증가시킴으로써, 레지스터의 명칭 변경을 포함한 다수의 최적화가 실행될 수 있다. 개량 하드웨어의 일실시예는 정수 유니트에 64개의 작업 레지스터를 그리고 부동 소수점 유니트에 32개의 작업 레지스터를 포함한다. 또한, 이 실시예는 개량된 세트의 타겟 레지스터를 포함하는데, 이 타겟 레지스터는 타겟 프로세서 상태를 제공하는데 필요한 타겟 프로세서의 빈번하게 변화하는 레지스터 모두를 포함한다. 이들 레지스터는 조건 제어 레지스터 및 시뮬레이션 대상이 되는 시스템의 제어에 필요한 다른 레지스터를 포함된다.

모프 호스트가 이용하는 개량 처리 하드웨어의 타입에 따라서, 변환된 명령어 시퀀스는 원래 응용으로부터의 복수의 타겟 명령어를 구성하는 원시 동작을 포함할 수 있음이 주목된다. 예를 들면, VLIW 마이크로프로세서는, 도 6a 내지 도 6c에 보인 바와 같이, 복수의 CISC 또는 RISC 명령어를 동시에 실행 할 수 있다. 모프 호스트의 타입이 무엇이든 간에, 모프 호스트 하드웨어의 타겟 레지스터 상태는 정수 타겟 명령어 경계(integral target instruction boundary) 이외에서는 변경되지 않으며, 그 다음, 모든 타겟 레지스터는 갱신된다. 따라서, 만일 재배열 및 호스트 변환에 재스케줄링될 가능성이 있는 원시 명령어 시퀀스로 변환된 타겟 명령어 또는 명령어들을 마이크로프로세서가 실행하고 있는 경우, 프로세서가 그 변환된 명령어 시퀀스를 실행하기 시작할 때, 오피셜 타겟 레지스터는 최초의 타겟 명령어가 어드레스 되었을 때 응용 설계 대상의 타겟 프로세서의 레지스터가 홀드하고 있던 값을 홀드한다. 그러나, 모프 호스트가 변환 후의 명령어를 실행하기 시작한 후, 작업 레지스터는 그 시점까지 실행된 변환 후의 명령어의 원시 동작에 의해 결정되는 값을 홀드한다. 따라서, 이러한 작업 레지스터들 중 일부는 오피셜 타겟 레지스터에 있어서의 값과 동일한 값을 홀드할 가능성이 있지만, 다른 작업 레지스터는 타겟 프로세서에 무의미한 값을 홀드한다. 이것은 특히, 특정의 타겟 머신보다 훨씬 많은 레지스터를 제공하여 개선된 가속 기술을 가능하게 하는 실시예에 적용된다. 일단 변환된 호스트 명령어가 실행되면, 작업 레지스터들의 값은 이러한 변환된 호스트 명령어가 작업 레지스터 상태를 결정하는데 이용되는 간이 된다. 예외를 발생함이 없이 한 세트의 변환된 호스트 명령어가 실행되었을 경우, 상기 세트의 명령어의 종료시에 결정된 새로운 작업 레지스터 값이 함께 오피셜 타겟 레지스터에 전송된다(가능하게는 타겟 명령어 포인터 레지스터를 포함한다), 프로세서에 대한 본 실시예에서, 이 전송은 추가의 파이프라인 스테이지에서 호스트 명령어의 실행 이외로 행해지므로, 모프 호스트의 동작이 느려지지 않게 된다.

마찬가지로, 도 5에 도시한 실시예와 같은 게이트 저장 버퍼를 개량 마이크로프로세서의 하드웨어에서 이용하여, 데이터가 메모리에 전송되는 것을 제어한다. 게이트 저장 버퍼는 다수의 엘리먼트를 포함하며, 그 각각은 메모리 저장 동작에 대해서 어드레스 및 데이터를 홀드하는 저장 위치로서 역할을 할 수가 있다. 이러한 엘리먼트는 다수의 서로 다른 하드웨어 구성 중 어느 것(예컨대, 선입선출버퍼)으로도 실현 가능한데, 도시된 실시예는 랜덤 액세스 메모리 및 3개의 전용 작업 레지스터를 이용해 실현되고 있다. 3개의 레지스터는 각각 메모리 저장의 대기행렬(que)의 선두에 대한 포인터, 게이트에 대한 포인터 및 메모리 저장의 대기행렬의 말미에 대한 포인터를 저장한다. 또한, 데이터를 메모리에 배출하는 엘리먼트를 나타내는 포인터가 별개의 레지스터(도 5에 도시되지 않음)에 저장된다. 대기행렬의 선두와 게이트와의 사이의 저장 위치에 있는 메모리 저장은 이미 메모리에 커미트되며(커미티드), 대기행렬의 게이트와 말미와의 사이의 다른 위치로부터 분리 또는 격리된 저장 위치에 있는 메모리 저장은 아직도 메모리에 커미트되지 않는다(언커미티드). 호스트 변환의 실행 중에 발생한 메모리 저장은 모프 호스트에 의한 호스트 명령어의 실행 중에 발생한 시퀀스로 정수 유니트에 의해 저장 버퍼에놓여지지만, 호스트 명령어에 대해 커미트 동작이 발견될 때까지 메모리로의 기입은 허용되지 않는다. 이와 같이, 변환을 실행하면, 저장 동작이 대기행렬 내에 놓여진다. 이것들이 최초의 저장이며 다른 저장이 게이트 저장 버퍼 내에 없다고 가정하면, 선두 포인터 및 게이트 포인터는 같은 위치를 나타낼 것이다. 각 저장이 실행됨에 따라, 이 저장은 대기행렬내의 다음의 위치에 놓여져 말미 포인터가 상기 다음의 위치(도면에서는 상향으로)로 증분(increment)된다. 이것은 커미트 커맨드가 실행될 때까지 계속된다. 커미트 커맨드의 실행은 통상 예외나 에러 종료 상태를 발생함이 없이 한세트의 타겟 명령어의 변환을 완료했을 때 일어난다. 에러 없이 모프 호스트에 의해 변환이 실행되었을 경우, 실행중에 발생한 저장 버퍼 내의 메모리 저장은 함께 저장 버퍼의 게이트를 통과(커미트)하여, 메모리에 기입된다. 도시된 실시예에서, 이것은 말미 포인터를 홀드하는 레지스터내의 값을 게이트 포인터를 홀드하는 레지스터에 복사함으로써 행해진다.

따라서, 작업 레지스터로부터 오피셜 타겟 레지스터로의 레지스터 상태의 전송 및 작업 메모리 저장의 오피셜 메모리로의 전송은 모두 함께 행해져 명시적인 커미트 동작에 응답하여 정수 타겟 명령어간의 경계상에서만 행해짐을 알 수 있다.

이것에 의하여, 마이크로프로세서는 개량 모프 호스트에 의해 실행중에 발생한 타겟 예외로부터, 그 어떠한 중대한 지연 없이도 복원을 행할 수가 있다. 변환된 명령어 또는 명령어들의 몇개의 실행중에 타겟 예외가 발생했을 경우, 이 예외는 모프 호스트 하드웨어 또는 소프트웨어에 의해 검출된다. 타겟 예외의 검출에 응답하여, 코드 모핑 소프트웨어는 오피셜 레지스터내에 홀드되고 있는 값을 작업 레지스터에 되돌려, 게이트 저장 버퍼 내의 커미트되어 있지 않은 메모리 저장이 모두 덤프되게 한다(이 동작을 롤백이라 부른다). 도 5의 게이트 저장 버퍼 내의 메모리 저장은 게이트 포인터를 홀드하는 레지스터내의 값을 말미 포인터를 홀드하는 레지스터에 복사함으로써 덤프된다.

타겟 레지스터로부터 작업 레지스터에 값을 옮김으로써, 예외가 발생했을 때에 실행되고 있던 타겟 명령어의 첫번째 어드레스를 작업 명령어 포인터 레지스터내에 둘 수가 있다. 작업 레지스터에서 타겟 프로세서의 이와 같은 오피셜 상태로부터 개시하여, 예외가 발생했을 때에 실행되고 있던 타겟 명령어는 연속 시퀀스로 재변환되지만, 재배열되거나 그 외의 최적화는 전혀 수행되지 않는다. 각 타겟 명령어를 새롭게 디코드하여 새로운 호스트 변환으로 변환한 후, 타겟 명령어를 나타내는 변환된 호스트 명령어를 모프 호스트에 의해 실행하면, 예외가 발생하거나 혹은 발생하지 않는 경우가 있다. (모프 호스트가 VLIW 프로세서가 아닌 경우, 호스트 변환의 원시 동작 각각이 순차적으로 실행된다. 호스트 변환을 실행하고 있을 때에 예외가 발생하지 않는 경우, 다음의 원시 기능이 실행된다.) 이것은 예외가 재차 발생하든가 흑은 단일의 타겟 명령어가 변환 및 실행될 때까지 계속된다. 일 실시예에서는, 예외를 발생함이 없이 타겟 명령어의 변환이 실행되었을 경우, 작업 레지스터 상태가 타겟 레지스터에 전송되고 게이트 저장 버퍼 내의 모든 데이터가 커미트되어 메모리에 전송될 수가 있다. 그러나, 변환의 실행중에 예외가 재차 발생했을 경우, 타겟 레지스터 및 메모리 상태는 변화하지 않고, 예외가 발생했을 때에 타겟 컴퓨터내에 생긴 상태와 동일하게 된다. 그 결과, 타겟 예외가 발생했을 경우, 이 예외는 타겟 운영 체제에 의해 올바르게 처리된다.

마찬가지로, 변환에 의해 예외가 발생한 명령어 시퀀스중 제 1의 타겟 명령어가 일단 예외의 발생없이 실행되면, 타겟 명령어 포인터는 다음의 타전 명령어를 가리킨다. 이 제2의 타겟 명령어는 제1의 타겟 명령어와 같은 방식으로, 최적화 또는 재배열을 수행함이 없이 디코드하여 재변환한다. 단일의 타겟 명령어의 호스트 변환 각각이 모프 호스트에 의해 처리되면, 타겟 레지스터 및 메모리 상태가 타겟 컴퓨터 내에서 발생하는 상태와 동일한 경우, 어떠한 예외가 발생한다. 그 결과, 예외를 즉시 올바르게 처리할 수가 있다. 이들 새로운 변환은 타겟 응용에 있어서의 명령어의 시퀀스에 대한 정확한 변환으로서 변환 버퍼 내에 저장되어 명령어를 재차 실행할 메는 언제라도 호출할 수가 있다.

도 5의 게이트 저장 버퍼와 동일한 결과를 얻는 다른 실시예는 저장을 직접 메모리에 전송함과 아울러, 변환의 예외가 롤백을 필요로 하는 예외 또는 에러를 야기한 경우에 타겟 컴퓨터 상태를 복원하기에 충분한 데이터를 기록하는 구성을 포함할 수 있다. 이러한 경우, 변환 및 실행동안에 발생된 메모리 저장의 효과를 역전시켜, 변환의 시작 시에 존재하고 있던 메모리 상태를 복원해야 하며, 작업 레지스터는 전술한 것처럼 오피셜 타겟 레지스터내에 홀드되고 있는 데이터를 받아야만 한다. 이것을 수행하는 일실시예는 별개의 타겟 메모리를 유지해 원래의 메모리 상태를 홀드해 두어 롤백이 발생했을 경우에, 이것을 이용하여 고쳐쓰기된 메모리를 치환한다. 메모리 롤백을 수행하는 다른 실시예는 각 저장을 기록하여 메모리 데이터가 발생할 때마다 이것을 치환하여, 그 다음에 롤백이 필요한 경우에 저장 프로세스를 역전시킨다.

전술한 게이트 저장 버퍼를 실시하는데는 다수의 문제가 발생한다. 예를 들면, 마이크로프로세서의 동작 동안, 데이터가 항상 같은 메모리 어드레스에 저장되고 있는 경우가 있다. 어떤 그러한 저장의 데이터가 실제로 메모리에 보내지기 전어느 시점에서, 상기 데이터는 마이크로프로세서에 의한 다른 동작을 위해서 필요하게 될 수도 있다. 통상, 사용해야 할 데이터는 사용 가능한 최신의 유효 데이터이다. 전형적인 저장 버퍼에서는, 버퍼 내에 이미 있는 데이터의 어드레스와 동일한 버퍼 내의 메모리 어드레스에 전송되는 데이터는 통상 오래된 데이터를 대신하여 저장된다. 그 결과, 해당 어드레스에 있어서의 유효한 데이터를 탐색할 필요 없이, 항상 최신의 데이터를 버퍼로부터 즉시 얻을 수 있다.

그러나, 이것은 전술의 게이트 저장 버퍼로는 불가능한데, 그 이유는 이 버퍼는 아직도 최종적인 것으로 판단되고 있지 않은 동작으로부터의 메모리 저장을 홀드하도록 특별히 고안되었기 때문이다. 이러한 저장이 메모리에 커미트되기 전에, 저장을 일으키는 명령어의 시퀀스가 올바르게 실행되는지 여부의 판정을 수행해야 한다. 결과적으로, 이미 커미트된 앞의 메모리 저장에 대신하여 나중에 발생한 메모리 저장을 버퍼 위치에 세이브하는 것은, 사실상 새로운 입력 데이터를 발생하는 호스트 명령어의 실행이 예외를 발생함이 없이 완료하기 전에 그 데이터를 커미트하게 될 것이다. 이것은 게이트 저장 버퍼의 목적 전체에 반하게 된다.

결과적으로, 게이트 저장 버퍼의 일실시예에서, 새로운 메모리 저장은 같은 어드레스에 대한 오래된 저장을 대신하여 저장되는 것이 아니라, 이것들이 발생할 때마다 버퍼의 분리 또는 격리된 부분에 순차적으로 저장된다. 그리고, 어느 시점에 있어도, 게이트 저장 버퍼에는 같은 메모리 어드레스에 다수의 저장이 있는 경우가 있어, 그러한 저장들 중 일부는 메모리에 커미트되며, 그러한 저장의 다른 부분들은 여전히 언커미트인 상태에 놓인다. 게이트 저장 버퍼 내의 각 저장 위치는 해당 위치에 있는 데이터의 유효성에 대한 어떤 지정(designation)을 포함한다. 도 13에 보인 논리 구성을 나타내는 실시예에서는, 게이트 저장 버퍼 내의 저장 위치에 있어서의 데이터의 각 바이트(본 실시예에 있어서의 최소 어드레스 가능 데이터량)마다 유효 비트(V로 가리키는 열)가 제공된다. 전형적으로, 각 버퍼 저장 위치에 있어, 데이터를 저장하기 위해서 64 비트가 사용 가능하여, 버퍼 내의 각 저장 위치에는 각각 그 자체의 유효 비트를 갖는 8개의 개별 바이트가 포함된다.

버퍼 내에 홀드되고 있는 어느 메모리 어드레스에 대한 최신의 저장을 구별하기 위해서, 각 저장 위치의 각 바이트에는 제1의 비트(M으로 표시된 열)가 제공되며 그 바이트가 해당 메모리 어드레스에 있어서의 최신의 데이터 바이트인 것을 나타내는데 이용된다. 각 메모리 위치는 비교 회로를 포함하여 게이트 저장 버퍼에 대한 새로운 기입 때마다, 그 메모리 어드레스(바이트 어드레스를 포함함) 및 제어 비트를 검사한다. 새로운 데이터가 저장 버퍼가 있는 저장 위치에 저장되는 경우, 새롭게 저장되는 데이터의 각 바이트에는 그 최신 저장 비트가 어서트된다. 새롭게 저장되는 데이터가 게이트 저장 버퍼 내에 이미 있는 유효 데이터의 메모리 어드레스와 동일 메모리 어드레스에 저장되는 경우, 비교 회로는 이것을 바이트마다 판정하여, 동일 메모리 어드레스에 대해 이전에는 마지막에 저장된 것인 모든 바이트에 대한 최신 비트를 디어서트한다. 이와 같이, 해당 메모리 어드레스에 있어서의 데이터의 적재에 대한 최신 데이터의 필요성은 특정의 메모리 어드레스에 대해 최신 비트(복수의 비트)가 어서트되고 있는 데이터를 검출함으로써 만족된다.

본 실시예에서는, 종래 기술에서와 같이 게이트 저장 버퍼의 메모리 어드레스에 저장되고 있는 오래된 데이터를 고쳐쓰기하는 대신에 이에 관련된 오래된 최신 비트를 디어서트함으로써, 해당 어드레스로부터 마이크로프로세서의 레지스터로의 적재 목적을 위해서 오래된 데이터를 가상적으로 소거함을 알 수 있을 것이다. 적재를 위해서 액세스된 메모리 어드레스에 있어서의 바이트의 최신 비트를 디어서트함으로써, 해당 바이트는 무시되는 한편 최신 비트에 의해 마크된 동일 어드레스의 바이트는 적재 동작을 위해서 저장 버퍼로부터 독출되게 된다. 동시에, 더 이상 최신이 아닌 해당 위치에 있는 데이터는 저장 버퍼 내에 남게 되므로, 그것이 게이트 저장 버퍼에 놓여진 시퀀스에 따라 최종적으로 메모리에 커미트될 수가 있다.

게이트 저장 버퍼 내의 데이터는 전술한 바와 같이 마이크로프로세서의 동작의 고속화를 완수하기 위해서 커미트 동작 및 롤백 동작을 받으므로 언커미트된 저장에 있는 데이터가 롤백 동작 동안에 펌프(소거)될 가능성이 있다. 이 데이터는 게이트 저장 버퍼 내에 홀드되고 있고 같은 메모리 어드레스에 대해 커미트된 어느 데이터보다 항상 새롭다. 결과적으로, 덤프된 언커미티드 데이터와 같은 메모리 어드레스를 갖는 커미트된 데이터가 게이트 저장 버퍼 내의 다른 저장 위치에 존재하는 경우, 롤백후, 그 메모리 어드레스에 대한 상기 커미트된 최신의 데이터는 저장 버퍼 내의 그 메모리 어드레스에 잔류하는 최신의 데이터가 될 것이며 또한 그렇게 표시되어야 한다. 그러나, 이 커미트된 데이터의 최신 비트는, 이제는 덤프된 동일 어드레스에 대한 새로운 언커미트 데이터가 게이트 저장 버퍼에 놓여질 때 디어서트될 것이다.

어느 메모리 어드레스에 대한 최신 데이터가 롤백 동작이나 커미트 동작후 올바르게 지정된 상태로 남아 있게 하기 위해서 각 바이트는 최신 비트 위치 뿐만이 아니라, 제2의 새도잉 최신 비트(shadowing-most-recent bit) 위치(도 13에서 "S"로 표시됨)를 갖는다. 게이트의 위치를 버퍼의 말미까지 이동시켜, 게이트 저장 버퍼 내의 1개이상의 저장 위치의 데이터를 커미트했을 경우, 버퍼에 저장된 각 어드레스의 최신 데이터는 그의 새도잉 최신 비트가 어서트되며 동시에 이미 어서트된 동일 메모리 어드레스의 다른 데이터에 대한 모든 새도잉 최신 비트도 디어서트된다. 이것이 발생하는 순간, 새롭게 커띠트된 데이터는 실제로 해당 메모리 어드레스에 대한 최신 데이터가 되므로, 필요한 모든 것은 커미트된 각 저장 위치의 각 바이트에 관련된 최신 비트를 해당 바이트에 대한 새도잉 최신 비트로 복사하는 것이 된다. 저장 버퍼의 그 같은 메모리 어드레스에 보다 새로운 데이터가 기입될 경우, 커미트된 데이터의 최신 비트가 디어서트되지만, 새도잉 최신 비트는 어서트된 채로 남는다. 그 다음에, 롤백이 이후에 행해져 그 어드레스 앞으로 보낼 수 있었던 것보다 새로운 언커미트 데이터가 덤프되는 경우, 그 커미트된 데이터 중 최신 데이터의 새도잉 최신 비트는 커미트된 바이트의 최신 비트 위치에 복사되어 가장 최근에 커미트된 데이터가 실제로 가장 최근에 저장된 데이터임을 정확하게 표시하게 된다.

따라서, 전술한 실시예에서는, 게이트 저장 버퍼에 기입을 하는데 이용되는 논리는 다음의 연속 메모리 위치에 새로운 데이터를 기입하여, 그 위치에 기입된 각 바이트에 대한 유효 비트 및 최신 비트를 어서트함을 알 수 있을 것이다. 이 논리는 기입된 데이터의 메모리 어드레스를 버퍼 내의 저장 위치에 있는 메모리 어드레스와 비교하여, 그 어드레스 앞으로 보낼 수 있었던 것보다 오래된 데이터가 버퍼 내에 있는지 여부의 판정을 수행한다. 만일 그러한 데이터가 발견되었을 경우, 그 어드레스에 대한 것보다 오래된 데이터의 어서트된 그 최신 비트가 디어서트된다. 커미트 동작에서, 최신 비트가 어서트된 모든 데이터는 그 새도잉 최신 비트가 어서트되며, 새도잉 최신 비트가 어서트된 모든 데이터는 해당 미트가 디어서트된다. 롤백 동작에서는, 언커미트 데이터가 덤프되고, 새도잉 최신 비트가 이미 어서트된 커미트된 데이터에 대해서 최신 비트가 어서트된다.

도시된 실시예에서는 추가의 레지스터를 이용, 다음에 메모리에 배출해야 할 메모리 저장 위치에 대한 포인터를 저장하여, 데이터를 순차적으로 메모리에 배출하도록 할 수 있다. 각 저장 위치에 있는 데이터를 메모리에 배출할 때마다, 해당 데이터에 대한 유효, 최신 및 새도잉 최신 비트를 클리어 하여 정확한 배출 시퀀스를 유지한다. 배출되는 저장 위치를 가리키는 이와같은 추가의 레지스터는 각 메모리 어드레스에 저장해야 할 모든 커미트된 데이터를 비교하는 논리를 실행하여 메모리 어드레스에 대한 최신의 커미트된 데이터만을 메모리에 배출하면서, 커미트되었지만 최신이 아닌 데이터를 무시함으로써, 메모리에 배출하는 동작을 단축시키는 데도 이용된다.

게이트 저장 버퍼의 제2 실시예를 도 14에 도시한다. 이 실시예는 복수의 저장 위치 그룹을 이용하여 각 그룹이 타겟 명령어 시퀀스의 전형적인 완전한 변환에 의해 발생하는 저장을 홀드하기 위해서 충분한 수의 저장 위치를 홀드한다. 보다 많은 수의 저장이 발생했을 경우, 1개 이상의 그룹을 이용하여 해당 변환을 저장한다. 도 13의 실시예의 경우와 같이, 그룹의 각 저장 위치는 다수의 입력 데이터 바이트, 메모리 어드레스 및 각 바이트 마다의 유효 비트를 홀드한다. 각 저장 위치 그룹은 (예를 들면, 해당 그룹에 관련된 비트 W를 어서트함으로써) 발생한 입력 데이터를 현재 저장해 두는 작업 그룹으로서 지정할 수가 있다. 작업 그룹내의 데이터는 모두 언커미트된다. 그러나, 각 그룹은 어소시에이트 캐시(associate cache)의 경우와 같게 어드레스 되도록 구성되어 특정의 메모리 어드레스에 기입된 새로운 입력 데이터는 작업 그룹 내에 이미 있는 보다 오래된 입력 데이터상에 고쳐쓰기되어 동일 메모리 어드레스에 기입된다. 이것은 도시된 실시예에서는, 각 저장 위치에 있는 비교기에 의해 행해진다, 이와 같이, 어느 그룹 내에 저장된 어느 메모리 어드레스에 어드레스된 데이터는 해당 저장 위치 그룹 내에서 1개의 저장 위치에게만 존재한다. 따라서, 데이터가 커미트되기 전에, 적재를 위해서 호스트 프로세서가 이용할 필요가 있는 경우, 해당 그룹내의 메모리 어드레스를 검사함으로써 찾아낼 수가 있다. 이는 전술의 실시예에서 같은 최신 비트 및 새도잉 최신 비트의 필요성을 없앤다.

예외를 발생함이 없이 타겟 명령어 시퀀스를 실행했을 경우, 해당 시퀀스에 의해 작업 그룹 내에 발생한 데이터 저장은 일괄적으로 커미트된다. (이전의 실시예에서, 게이트 포인터를 말미 포인터의 위치까지 이동시키는 것과 등가인) 이 커미트는 특정의 저장 위치 그룹과 관련된 커미트 비트(비트 C)를 어서트하고 그리고 해당 그룹에 대한 작업 비트(비트 W)를 디어서트함으로써 행해진다. 일단 저장 위치 그룹이 커미트되었다면, 그러한 위치에 있는 데이터는 메모리에 배출될 때까지 해당 그룹 내에 머물 수가 있다. 따라서, 커미트된 저장 및 언커미트된 저장을 지정하기 위해서 헤드 포인터, 게이트 포인터 및 말미 포인터를 홀드하는데 필요한 회로는 필요없게 되며, 작업 비트 및 커미트 비트의 사용에 의해 동일 결과를 얻을 수 있다.

따라서, 변환된 타겟 명령어 시퀀스를 실행하고 있는 동안에 롤백이 필요한 예외가 발생했을 경우, 작업 그룹 내에 저장된 데이터는 간단히 소거(덤프)된다. 이는 예를 들면, 커미트 비트를 어서트함이 없이, W비트로서 저장된 작업 지시를 제거함으로써 달성된다. 실제로, 작업 지시를 제거하는 것은 앞의 실시예에서 말미 포인터를 게이트 포인터의 위치로 이동시키는 것과 등가이다.

당업자이면, 전술한 2개의 실시예들의 여러 가지 조합들을 패할 수 있을 것이다. 예를 들면, 게이트와 말미 사이에 있으면서 데이터 저장이 여전히 커미트되지 않은 저장 위치 내에서만 새로운 데이터 저장이 오래된 데이터 저장에 대해 고쳐쓰기 되도록 허용하는 논리를 이용함으로써, 제1 실시예의 사이즈를 축소할 수가 있다. 마찬가지로, 동일 어드레스를 가지는 모든 커미트된 저장을 검출하여, 전술한 바와 같은 방식으로 배출 포인터를 사용하여 커미트된 데이터 중 최신의 것을 가리킴으로써, 최신의 것(바이트)만을 메모리에 기입하는 논리도 이용 가능하다.

또한, 전술한 실시예의 상세를, 전형적인 프로세서 캐시와 조합해 두 가지 목적을 단일의 회로로 달성하는 것도 가능하다. 이러한 경우, 커미트된 메모리 저장 및 언커미트된 메모리 저장을 저장하는 캐시의 라인을 나타내는 수단 및 그 외의 제어 지시자(indicator)를 제공해야할 필요가 있다.

코드 모핑 소프트웨어는 변환되고 있는 프로그램을 처리하는 속도를 큰 폭으로 높이는 추가의 동작을 제공한다. 단순하게 명령어를 변환, 최적화, 재배열, 재스케줄링, 캐시 및 각 변환을 실행하여 한 세트의 명령어를 실행할 필요가 있을 때면 언제라도 재차 실행할 수가 있도록 하는 것에 부가적으로, 변환기는 다른 변환을 링크하여, 대부분 모든 경우에, 변환 프로세스의 메인 루프로의 리턴을 불필요하게 한다. 도 8은 이 링크 프로세스를 수행할 때, 코드 모핑 소프트웨어의 변환기가 실행하는 과정을 도시한다. 당업자이면, 이 링크 동작은 대부분의 명령어의 변환에 대해 본질적으로 메인 루프로의 리턴을 불필요하게 하여, 이 오버헤드를 제거하게 됨을 알 수 있을 것이다.

예시의 목적을 위해서, 실행되는 타겟 프로그램이 X86의 명령어로 구성되는 것으로 가정한다. 타겟 명령어의 시퀀스의 변환을 수행하여, 원시 호스트 명령어를 재배열 및 재스케줄링하는 경우, 각 호스트 변환의 종료 시에 2개의 원시 명령어가 발생할 가능성이 있다. 최초의 것은 타겟 프로세서에 대한 명령어 포인터의 값(또는 그 동등물)을 갱신하는 원시 명령어이다. 이 명령어는 다음의 타겟 명령어의 정확한 어드레스를 타겟 명령어 포인터 레지스터에 두기 위해서 이용된다. 이 원시 명령어를 뒤따르는 것은 분기 명령어이며, 이는 해당 분기에 대한 2개의 가능한 타겟의 각각의 어드레스를 포함한다, 분기 명령어에 앞서는 원시 명령어가 타겟 프로세서에 대한 명령어 포인터의 값을 갱신하는 방법은 조건 코드 레지스터내의 해당 분기에 대한 조건 코드를 시험하여, 분기를 제어하는 조건이 가리키는 2개의 분기 어드레스 중 하나가 변환 버퍼 내에 저장되고 있는지 여부의 판정을 수행하는 것이다. 최초로 타겟 명령어의 시퀀스를 변환하는 경우, 호스트 명령어의 2개의 분기 타겟 모두는 변환기 소프트웨어의 메인 루프에 대해서 동일한 호스트 프로세서 어드레스를 홀드하고 있다.

호스트 변환이 완료되고, 변환 버퍼에 저장되어 최초로 실행될 때, 타겟 명령어 포인터 레지스터에서 명령어 포인터를 갱신(타겟 레지스터의 나머지와 같게)하며, 이 동작은 분기되어 메인 루프에 돌아온다. 메인 루프에서 변환 소프트웨어는 타겟 명령어 포인터 레지스터 내에서 다음의 타겟 명령어로의 명령어 포인터를 참조한다. 그후, 다음의 타겟 명령어 시퀀스를 어드레스한다. 이 타겟 명령어의 시권스가 아직도 변환되지 않았고, 따라서 변환이 변환 버퍼 내에 없는 것으로 가정하면, 다음 세트의 타겟 명령어를 메모리로부터 인출, 디코드, 변환, 최적화, 재배열 및 재스케준링을 수행하고, 변환 버퍼 내에 캐시하여 실행한다. 제2 세트의 타겟 명령어가 제1 세트의 타겟 명령어에 계속되므로, 제1 세트의 타겟 명령어의 호스트 변환의 마지막 원시 분기 명령어는 자동적으로 갱신되어 제2 세트의 타겟 명령어의 호스트 변환의 어드레스를 해당 분기를 제어하는 특정의 조건에 대한 분기 어드레스로서 치환한다.

다음에, 제 2의 변환된 호스트 명령어가 제 1의 변환된 호스트 명령어에 루프 백하는 경우, 제2의 변환의 마지막에서의 분기 동작은 메인 루프의 어드레스 및 제1의 변환의 X86 어드레스를 해당 분기에 가능한 2개의 타겟으로서 포함한다. 분기에 앞서는 갱신-명령어-포인터 원시 동작은 조건을 시험하여 제1의 변환으로의 루프 백을 수행하는 것을 결정하여, 최초의 변환의 X86 어드레스로의 타겟 명령어 포인터를 갱신한다. 이것에 의하여, 변환기는 변환 버퍼를 조사해 탐색중인 X86 어드레스가 거기에 있는지 여부를 확인한다. 최초의 변환의 어드레스가 발견되면, 호스트 메모리 공간 내의 그 값은 제2의 호스트 변환 명령어의 마지막 분기내의 X86 어드레스로 치환된다. 다음에, 제2의 호스트 변환 명령어를 캐시하여 실행한다. 이것에 의하여, 제1의 변환으로부터 제2의 변환으로의 분기를 수행하게 하는 조건이 실패할 때까지 이 루프를 실행하여 메인 루프로 돌아오는 경로를 취하는 분기를 수행한다. 이것이 행해지면, 제1의 변환된 호스트 명령어는 메인 루프로 돌아오도록 분기하여, 타겟 명령어 포인터에 의해 지정되는 다음 세트의 타겟 명령어를 변환 버퍼 내에서 탐색하여, 캐시로부터 호스트 변환을 인출하거나 혹은 변환 버퍼에서의 탐색이 실패했을 경우, 타겟 명령어를 메모리로부터 인출하여 변환한다. 이 변환된 호스트 명령어가 변환 버퍼에서 캐시될 때, 그의 어드레스는 루프를 종료한 분기 명령어내의 메인 루프 어드레스를 치환한다.

이와 같은 방식으로, 여러 가지의 변환된 호스트 명령어가 서로 연쇄되어, 변환 메인 루프를 통과하는 긴 경로를 따를 필요성은 단지 링크가 존재하지 않는 경우에서만 생기게 된다. 최종적으로, 호스트 명령어의 분기 명령어에 있어서의 메인 루프의 참조는 대부분 완전하게 제거된다. 이 조건에 이르렀을 경우, 어느 호스트 명령어를 실행하기 전, 타겟 명령어를 인출하고, 디코드하고, 해당 타겟 명령어를 구성하는 원시 명령어를 인출하고, 이러한 원시 동작을 최적화하고, 원시 동작을 재배하여 이들 원시 동작을 재스케줄링하는데 필요한 시간이 불필요해진다. 따라서, 어느 응용의 명령어 시퀀스를 실행하는 경우, 그때마다 이러한 단계를 각각 실행해야 하는 모든 종래 기술의 마이크로프로세서와는 대조적으로 개량 마이크 로프로세서를 이용하면, 최초의 변환을 수행한 후 어느 세트의 타겟 명령어를 실행하는데 필요한 작업을 크게 줄일 수 있다. 이 작업은 각 세트의 변환된 호스트 명령어를 다른 세트의 변환된 호스트 명령어에 링크함으로써 더욱 감소된다. 실제로, 응용을 실행하고 있는 동안, 100만회의 명령어 실행 중 1회 미만의 변환이 필요로 되는 것으로 추정된다.

변환되는 각 세트의 명령어는 재차 변환할 필요가 없게 되도록 캐시되기 때문에, 이 마이크로프로세서의 실현에는 큰 변환 버퍼가 필요하게 됨을 당업자는 인식할 것이다. 서로 다른 시스템에 대해서 프로그램된 응용과 함께 기능하도록 설계된 변환기들은 버퍼 메모리를 지원하기 위한 이들의 필요성에 따라 다양하게 될 것이다. 그러나, X86 프로그램을 실행하도록 설계된 마이크로프로세서의 일실시예는 2 메가바이트의 랜덤 액세스 메모리를 변환 버퍼로서 이용하고 있다.

2개의 추가적인 하드웨어 기능 강화는 본 발명을 포함한 마이크로프로세서가 응용을 처리할 수 있는 속도를 높이는데 도움이 된다. 이들 중 최초의 것은 비정상/정상(A/N) 보호 비트로서, 이는 타겟 명령어의 물리적 어드레스의 참조를 최초로 행하는 변환 록 어사이드 버퍼(TIB)(도 3 참조)에 각 어드레스 변환과 함께 저장된다. 변환들 내에서의 타겟 메모리의 동작에는 두가지 타입이 있을 수 있는데, 하나는 메모리 상에서 동작하는 타입(정상)이고 다른 하나는 메모리 맵 I/O 디바이스 상에서 동작하는 타입(비정상)이다.

메모리에 영향을 주는 정상 액세스는 정상적으로 완료한다. 명령어가 메모리상에서 동작하는 경우, 이러한 명령어의 최적화 및 재배열을 수행하는 것이 적당하며, 본 발명을 포함한 마이크로프로세서를 이용하는 시스템의 속도를 높이는데 매우 도움이 된다. 한편, I/O 디바이스에 영향을 주는 비정상 액세스의 동작은 어느 단계도 제거함이 없이 이러한 동작이 프로그램된 정확한 시퀀스로 수행되어야만 하는 경우가 많다, 그렇지 않으면, I/O 디바이스에 어떠한 악영향을 줄 가능성이 있다. 예를 들면, 특정의 I/O 동작이 I/O 레지스터를 클리어하는 결과를 가져오는 경우가 있는 바, 만일 원시 동작이 제대로 실행되지 않는 경우, 그 동작의 결과는 타겟 명령어가 지령한 동작과는 다르게 될 수 있다. 메모리를 메모리 맵 I/O와 구별 하는 수단이 없는 경우, 메모리 맵 I/O에 영향을 주는 명령어를 변환하는데 이용되는 보존적 가정(conservative assumptions)을 통해 모든 메모리를 취급해야만 한다. 이것은 달성 가능한 최적화 특성을 현저하게 제한하게 된다. 종래 기술의 에뮬레이터는 어드레스되고 있는 메모리의 특성에 대한 추측의 실패를 검출하는 수단 및 이러한 실패로부터 복원하는 수단 둘다를 결여하고 있었으므로, 이들의 처리 능력에는 한계가 있었다.

도 11에 도시한 마이크로프로세서의 일실시예에서, A/N비트는 메모리 페이지 또는 메모리 맵 I/O를 나타내도록 변환 록 어사이드 버퍼 내에 설정할 수가 있는 비트이다. 변환 록 어사이드 버퍼는 메모리 액세스에 대한 페이지 테이블 엔트리를 저장한다, 이리한 엔트리는 각각, 액세스되는 가상 어드레스 및 탐색중의 데이터에 액세스 가능한 물리적 어드레스 및 엔트리에 관한 기타 정보를 포함한다. A/N비트는 기타 정보의 일부이며, 물리적 어드레스가 메모리 어드레스 혹은 메모리 맵 I/O 어드레스인지를 나타낸다. 메모리에 영향을 주는 동작을 메모리 동작인 것 같이 변환하는 것은 실제로 이 동작이 메모리에 영향을 주는 것이라는 추측이다. 일실시예에서, 코드 모핑 소프트웨어가 처음 메모리 또는 메모리 맵 I/O 디바이스의 액세스를 필요로 하는 변환을 실행하려고 하는 경우, 실제로는 그 액세스는 메모리 액세스인 것으로 가정한다. 다른 실시예에서, 상기 소프트웨어는 타겟 커맨드가 I/O 액세스를 요구하는 것으로 가정한다. 그 어드레스로의 액세스가 아직 행해지지 않았다고 가정하면, 변환 록 어사이드 버퍼 내에는 엔트리가 없게 되며, 변환 록 어사 이드 버퍼에서 이 액세스는 실패한다. 이 실패로 인해, 소프트웨어는 페이지 테이블 참조를 수행하고, 변환 록 어사이드 버퍼의 저장 위치에 페이지 테이블 엔트리를 입력하여, 가상 어드레스에 대한 정확한 물리적 어드레스 변환을 제공하게 된다. 이것을 수행할 때에, 소프트웨어는 이 물리적 어드레스에 대한 A/N비트를 변환 록 어사이드 버퍼에 입력시킨다. 그 다음에, 액세스가 메모리 어드레스에 대한 것이라고 가정하면서, 그 액세스를 재차 실행하려고 하는 또다른 시도가 행해진다. 액세스가 시도되면, 가정된 액세스 타입(정상 또는 비정상)을 현재 TIB 페이지 테이블 엔트리 내에 있는 A/N보호 비트와 비교함으로써, 타겟 메모리 참조를 체크한다. 액세스 타입이 A/N보호와 일치하지 않는 경우, 예외가 발생한다. 실제로 동작이 메모리에 영향을 주는 경우, 전술한 최적화, 재배열 및 재스케줄링 기술이 변환중에 올바르게 적용된다. 그러나, TIB내의 A/N비트와의 비교가 동작이 I/O디바이스에 영향을 주고 있음을 가리키는 경우, 실행에 의해 예외가 발생하며, 변환기는 최적화, 재배열 및 재스케줄링을 수행함이 없이 한번에 1개의 타겟 명령어씩 새로운 변환을 수행한다. 마찬가지로, 변환이 실제로는 메모리에 영향을 주는 동작을 I/O 동작으로 잘못 가정했을 경우, 실행에 의해 예외가 발생하여, 최적화, 재배열 및 재스케줄링 기술을 이용하여 타겟 명령어를 재변환한다. 이와 같이 하여, 본 프로세서는 종래에 가능했던 것보다 훨씬 뛰어난 성능 개선을 가져올 수가 있다.

A/N비트를 이용하여, 액세스가 메모리 또는 메모리 맵 I/O 디바이스에 대한 것인지에 관한 추측이 실패했는지 여부를 판정하는 기술은 메모리 웹 어드레스의 다른 특성에 관한 추측에도 사용될 수 있음을 당업자이면 인식할 수 있을 것이다. 예를 들면, 이러한 정상/비정상 비트를 이용하여 다른 타입의 메모리를 구별할 수가 있다. 다른 유사한 방법도 메모리 특성을 구별하는데 이용될 수 있음을 당업자이면 이해할 수 있을 것이다.

개량 마이크로프로세서가 가장 빈번하게 수행하는 추측 중 하나는 변환 중에 타겟 예외가 발생하지 않을 것이라는 추측이다. 이것에 의하여, 종래 기술보다도 뛰어난 최적화가 가능해진다. 먼저, 타겟 상태를 각 타겟 명령어 경계마다 갱신할 필요가 없고, 변환 경계상에 발생하는 타겟 명령어 경계상에서만 갱신하면 좋다. 이것에 의하여, 각 타겟 명령어 경계마다 타겟 상태를 세이브하는데 필요한 명령어가 불필요해진다. 스케줄링이나 장황한 동작을 제거하는데 있어, 종래 기술로는 불가능했던 최적화 역시 가능해진다.

격찬할 만한 특징으로서, 개량 마이크로프로세서는 적절한 변환 프로세스를 선택할 수 있다. 전술한 변환 방법에 의하면, 먼저 한 세트의 명령어를 그것이 메모리에 영향을 주는것 같이 변환할 수가 있다. 다음에, 호스트 명령어의 최적화, 재배열 및 재스케줄링을 실행하면, 변환 록 어사이드 버퍼 내에 제공된 A/N비트 상태에 의하여, I/O 디바이스를 참조하는 어드레스를 얻을 수 있다. 어느 동작이 I/O동작임을 나타내는 변환된 명령어 어드레스와 A/N비트와의 비교에 의하여, 에러 예외가 발생하며, 이로 인해 소프트웨어로 개시되는 롤백 절차가 발생되어, 모든 언커미트 메모리 저장이 덤프되고 타겟 레지스터내의 값은 작업 레지스터 내로 되돌려길다. 다음에, 최적화, 재배열 혹은 재스케줄링을 행함이 없이, 한번에 1 타겟 명령어씩 변환이 시작된다. 이 재변환은 I/O 디바이스에 적절한 호스트 변환이다.

마찬가지 방식으로, 메모리 동작이 I/O동작으로 잘못 변환될 가능성이 있다. 발생된 에러를 이용, 정확한 재변환을 실행하게 한다. 이 재변환에는 최적화, 재배열 및 재스케줄링이 수행되어 보다 빠른 동작을 제공한다.

종래 기술의 에뮬레이터는 또한 일반적으로 자기 변경 코드(self modifying code)로 불리는 것에도 고투하고 있었다. 타겟 프로그램이 타겟 명령어를 수용하고 있는 메모리에 기입을 행했을 경우, 이러한 타겟 명령어에 대해 존재하는 변환은 "진부"한 것이 되어 더이상 유효하지 않게 된다. 이러한 저장이 발생할 때에, 동적으로 이것들을 검출할 필요가 있다. 종래 기술에서는, 각 저장에 대해서 추가의 명령어를 이용해 이러한 검출을 수행해야 한다. 이 문제는 프로그램이 그 자체를 변경하는 것보다도 범위가 넓다. 제2의 프로세서나 DMA 디바이스와 같은 메모리에 기입을 수행할 수 있는 모든 에이전트도 이 문제를 발생할 가능성이 있다.

본 발명의 개량 마이크로프로세서는 모프 호스트에 대한 다른 기능 강화에 의하여, 이 문제에 대처한다. 변환 록 어사이드 버퍼에 역시 저장될 수 있는 변환 비트(T비트)가 변환이 존재하는 원인인 타겟 메모리 페이지를 나타내는데 이용된다. 따라서, T비트는 타겟 메모리의 특정의 페이지가 호스트 변환이 존재하는 원인인 타겟 명령어를 포함하고 있음을 나타낼 수가 있다. 이러한 타겟 명령어가 고쳐쓰기되었을 경우, 그 변환은 진부한 것으로 되게 된다. 메모리 내의 보호된 페이지에 기입을 수행하고자 하는 시도가 있을 경우, 그 변환 비트의 존재에 의해 예외가 발생하며, 이것을 코드 모핑 소프트웨어로 처리하게 될 때, 그 적절한 변환들을 무효화시켜, 변환 버퍼로부터 제거되게 할 수가 있다. T비트는 또한 기입이 행해지지 않은 타겟 페이지에 마크를 붙이는데 이용되어 이것에 근거해 변환을 수행하는 일도 가능하다.

이는 본 발명을 포함한 마이크로프로세서의 전체적인 기능 엘리먼트를 블럭도로 도시한 도 3을 참조함으로써 이해할 수 있다. 모프 호스트가 타겟 프로그램을 실행하는 경우, 모프 호스트에서 효과적으로 실행되는 원래의 변환되지 않은 호스트 명령어만을 포함하고 있는 코드 모핑 소프트웨어의 변환기 부분을 실행한다. 도 3의 우측에는, 본질적으로 변환기 및 변환 버퍼를 포함하는 호스트 부분과 그리고 타겟 운영 체제를 포함하는, 타겟 명령어 및 데이터를 갖는 타겟 부분으로 분할된 메모리가 나타나 있다. 모프 호스트 하드웨어는 변환기를 실행하기 시작할 때, 메모리로부터 호스트 명령어를 인출하고, 이러한 명령어를 명령어 캐시 내에 둔다. 변환기의 명령어는 메모리의 타겟 부분에 저장된 최초의 타겟 명령어의 인출을 발생한다. 타겟 인출을 실행함으로써, 정수 유니트는 타겟 명령어의 제1 어드레스를 요구하여, 오피셜 타겟 명령어 포인터 레지스터를 찾게된다. 다음에, 메모리 관리 유니트의 변환 록 어사이드 버퍼에서 최초의 어드레스가 액세스된다. 메모리 관리 유니트는 페이징을 위한 하드웨어를 포함하며, TIB에 메모리 매핑 기능을 제공한다. TIB가 정확하게 맵핑되어 타겟 메모리의 정확한 페이지에 대한 참조 데이터를홀드하는 것으로 가정하면, 타겟 명령어 포인터 값은 타겟 명령어의 물리적 어드레스로 변환된다. 이 시점에 있어, 변환이 타겟 명령어에 대해서 행해졌는지 여부를 나타내는 비트(T비트) 상태가 검출되지만, 액세스는 특출 동작이며, T비트의 예외는 발생하지 않는다. 액세스가 메모리에 대한 것인지 아니면 메모리 맵 I/O에 대한 것인지를 나타내는 A/N비트 상태도 검출된다. 마지막에 말한 비트가 메모리 위치를 나타낸다고 가정하면, 변환이 존재하지 않기 때문에, 타겟 메모리내의 타겟 명령어에 액세스한다. 이 타겟 명령어 및 후속의 타겟 명령어는 모프 호스트 계산기 유니트으로의 데이터로서 전송되어 명령어 캐시에 저장된 변환 명령어의 제어하에서 변환된다. 변환 명령어는 이 타겟 명령어가 메모리에 영향을 주는 것 같이, 재배열 기술, 최적화 기술 및 재스케줄링 기술을 이용한다. 다음에, 호스트 명령어 시퀀스를 포함하는 결과적인 변환이 호스트 메모리내의 변환 버퍼에 저장된다. 변환은 게이트 저장 버퍼를 통해 호스트 메모리내의 변환 버퍼에 직접 전송된다. 일단 변환이 호스트 메모리에 저장되면, 변환기는 변환에 분기하고, 그 다음에 이것을 실행한다. 이 실행(및 후속의 실행)은 변환이 예외 및 메모리에 관해서 정확한 가정을 수행했는지 여부에 대해 판정을 행한다. 변환을 실행하기 전에, 변환된 타겟 명령어를 포함하고 있는 타겟 페이지(들)에 대해 T비트를 설정한다. 이 지시는 명령어가 변환되었음을 경고하며, 만일 타겟 어드레스에 대한 기입 시도가 발생하면, 이 시도는 예외를 발생하여 변환이 무효가 되든가 혹은 제거되게 할 수도 있다.

T비트에 의해 마크된 타겟 페이지에 기입이 시도되면, 예외가 발생하여 이 기입은 중지된다. 이 기입을 계속하라는 허락은 그 예외에 응답하여 기입될 타겟 메모리 어드레스와 관련된 변환이 무효로 표시되거나 혹은 적절히 갱신되고 끝날 때까지, 그 사용으로부터의 보호가 보장된 상태에서 이루어지게 된다. 일부 기입 동작에는 유효한 변환이 영향을 받지 않기 때문에, 실제로는 아무것도 수행하는 것을 요구하지 않는 경우도 있다. 다른 기입 동작에는 어드레스된 타겟 메모리에 관련된 1개이상의 변환에 적절히 마크를 붙이든가 혹은 이것들을 제거하는 것을 요구하는 경우도 있다. 도 11은 T비트 지시를 홀드하기 위해서 각각 엔트리를 갖는 저장 위치를 포함한 변환 록 어사이드 버퍼의 일실시예를 도시한다.

모프 호스트에 대한 추가의 하드웨어 기능 강화는 통상은 메모리에 저장되지만 동작의 실행에 대해 빈번하게 이용되는 데이터를 실행 유니트 레지스터 내에 복제(즉, "앨리어스")하여, 해당 데이터를 메모리로부터 인출하거나 혹은 메모리에 저장할 때에 요구되는 시간을 불필요하게 하기 위해 이용되는 회로이다. 예를 들면, 메모리내의 데이터가 코드 시퀀스의 실행 중 빈번하게 재사용 되는 경우, 통상이 데이터가 이용될 때에, 메모리로부터 검색해 실행 유니트내의 레지스터에 적재해야 한다. 이와 같이 빈번한 메모리 액세스에 필요로 되는 시간을 단축하기 위해서, 데이터를 일단 코드 시퀀스의 시작 시에 메모리로부터 실행 유니트 레지스에 적재하여, 그 코드 시퀀스가 계속되는 기간 중 메모리를 대신하는 기능을 하도록 이 레지스터를 지정한다. 일단 이것을 수행하면, 통상 데이터를 지정한 메모리 어드레스로부터 레지스터에 적재하는 경우에 필요한 적재 동작 각각은 단순한 레지스터간의 복사 동작이 되어, 훨씬 빠른 페이스로 진행한다. 또한, 한층 더 최적화에 의하여 이러한 복사 동작은 불필요하게 할 수가 있다.

마찬가지로, 코드 시퀀스의 실행은 종종 코드 시퀀스의 실행 중 데이터를 메모리 어드레스에 빈번하게 기입하는 것을 필요로 한다. 이러한 동일 어드레스로의 빈번한 메모리 저장에 요구되는 시간을 단축하기 위해서, 데이터를 메모리 어드레스에 기입하려고 할 때에, 코드 시퀀스가 계속하는 기간 중, 메모리 공간을 대신하여 기능하도록 지정한 실행 유니트 레지스터에 전송할 수가 있다. 일단 실행 유니트 레지스터를 지정하면, 데이터를 변경할 때마다 필요한 것은 단순한 레지스터간 전송 동작뿐인바, 이 동작은 메모리 어드레스에 저장하는 것 보다 훨씬 빠르게 행된다.

본 개량 마이크로프로세서는 이들 앨리어스 동작을 수행하는 독특한 구성을 제공한다. 도 10에 도시한 일실시예에서, 모프 호스트는 코드 시퀀스로 빈번하게 이용되는 지정 메모리 어드레스에 대해서, "적재 및 보호" 커맨드에 응답하도록 설계되고 있다. 모프 호스트는 실행 유니트(110)내의 작업 레지스터(111)를 할당하여, 메모리 데이터를 홀드하고, 메모리 제어 유니트의 특수 레지스터(112)내에 그 메모리 어드레스를 저장한다. 작업 레지스터(111)는 이러한 목적을 위해서 할당할 수 있는 실행 유니트내의 다수의 레지스터(예를 들면, 도 4에 도시한 작업 레지스터의 8개) 중 하나가 될 수 있다.

메모리의 앨리어싱을 이용하여, 메모리 어드레스로부터 실행 유니트으로의 적재를 없애려고 하는 경우, 먼저 해당 메모리 어드레스에 있는 데이터를 레지스터(111)에 적재하여 이 메모리 어드레스를 레지스터(112)에 둔다. 그 후, 레지스터(111)내의 데이터를 이용하여, 가속 속도로 코드 시퀀스를 실행한다. 이 기간중, 통상 레지스터(112)내에 홀드되고 있는 메모리 어드레스로부터의 적재를 필요로 하는 각 동작은 대신에 레지스터(111)로부터 데이터를 복사함으로써 행해진다. 이것은 코드 시퀀스가 완료되어(혹은, 다른 어떠한 방식으로 종료되어) 메모리 공간의 보호가 해제될 때까지 계속된다.

마찬가치로, 실행 유니트(110)으로부터 동일 메모리 어드레스에 일정하게 데이터를 저장하는 코드 시퀀스를 가속하기 위해서, 유사한 앨리어스 동작을 수행할 수가 있다. "적재 및 보호" 커맨드가 메모리 어드레스를 레지스터(112)내에 두어, 통상 그 메모리 어드레스에 저장되는 데이터를 대신에, 작업 레지스터(111)에 전송한다. 예를 들면, 통상 루프의 실행에 의해 일련의 값을 동일 메모리 어드레스에 저장하는 연산에서, 데이터를 홀드하는 레지스터(111)를 할당해 레지스터(112)에 메모리 어드레스를 홀드함으로써, 저장을 행하는 동작은 실행 유니트 내부의 레지스터간 전송 동작된다. 이 동작도 코드 시퀀스가 완료되고(또는 다른 어떠한 방식으로 종료되어), 메모리 공간이 갱신되어 메모리 공간의 보호가 해제될 때까지 계속한다.

이들 앨리어스 기법 각각은 일부 코드 시퀀스의 실행 속도를 크게 높이지만, 메모리 액세스를 필요로 하지 않는 이들 동작은 매우 많은 문제의 원인이 된다. 호스트 프로세서의 동작 대부분이 타겟 명령어 세트와 호스트 명령어 세트간의 명령어의 변환에 관계하는 경우에 특히 그러하다. 이러한 문제는 모두, 명령어의 실행중에 이용되는 데이터는 그들이 사용될 때 유효해야함을 보증할 필요성과 관계한다.

한 메모리 어드레스에 저장되어 있는 데이터와 실행 유니트 레지스터에 저장되어 있는 데이터가 다르기 때문에, 특정의 시점에서 전자의 데이터 또는 후자의 데이터가 무효가 되는 경우가 다수 있다. 예를 들면, 코드 시퀀스 동안 메모리 공간으로부터 레지스터들에 정상적으로 빈번하게 적재되는 데이터를 홀드하기 위해서 작업 레지스터(111)를 이용하는 경우, 실행 유니트 레지스터 내의 데이터를 이용하는 코드 시퀀스가 완료하기 전에, 한 명령어가 그 메모리 어드레스에 기입을 실시할 가능성이 있다. 이러한 경우, 코드 시퀀스가 이용하고 있는 실행 유니트 레지스터 내의 데이터는 진부하게 되므로 갱신해야 한다.

다른 예로서, 코드 시퀀스 동안 메모리 어드레스에 빈번하게 저장되는 데이터를 홀드하기 위해서, 어느 작업 레지스터를 이용하는 경우, 메모리 대신에 실행 유니트 레지스터를 이용하는 코드 시퀀스가 완료하기 전에, 한 명령어가 해당 메모리 어드레스에 기입을 실시하려고 하는 경우가 있다. 메모리 어드레스에 있는 데이터를 코드 시퀀스의 종료 시에만 갱신하는 모드(라이트-백 모드(write-back mode))로 호스트 프로세서가 기능하고 있는 경우, 실행 유니트 레지스터 내의 데이터는 진부하게 되므로 해당 메모리 어드레스에 기입된 데이터로부터 갱신해야만 한다. 물론, 이 메모리 어드레스에 있는 데이터를 실행 유니트 레지스터에 기입할 때마다 정상적으로 갱신하는 모드(라이트-스루 모드(write-through mode))로 호스트 프로세서가 실행하고 있다면, 레지스터와 메모리는 일관성이 있다.

또 다른 예로서, 코드 시퀀스 동안 빈번하게 메모리 어드레스에 저장하는 데이터를 홀드하기 위해 작업 레지스터를 이용하는 경우, 레지스터(111)에 데이터를 전송하는 코드 시퀀스가 완료하기 전에, 한 명령어가 그 메모리 어드레스로부터 데이터를 독출하려고 하는 경우가 있다. 코드 시퀀스의 종료 시에만 메모리 어드레스에 있는 데이터를 정상적으로 갱신하는 모드(라이트-백 모드)로 호스트 프로세서가 기능하고 있는 경우, 메모리 내의 데이터는 진부하게 되어, 독출을 허가하기 전에, 실행 유니트 레지스터로부터의 데이터에 의해 갱신해야 한다. 전술의 예에서와 같이, 그 메모리 어드레스에 있는 데이터를 실행 유니트 레지스터에 기입할 때마다 그것을 정상적으로 갱신하는 모드(라이트-스루 모드)로 호스트 프로세서가 기능하고 있는 경우, 레지스터와 메모리는 일관성이 있다.

그 밖에도, 메모리에 홀드되고 있는 데이터와 앨리어스 레지스터들(aliasingregisters)에 홀드되고 있는 데이터가 모순되는 경우가 있을 수 있다. 왜냐하면, 모프 호스트와 코드 모핑 소프트웨어의 조합에 의해 형성된 마이크로프로세서는 실행을 가속하기 위해서, 호스트 명령어의 재배열 및 재스케줄링을 실시하도록 구성되어 있기 때문이다. 이하에 제시하는 코드 시퀀스의 여러 가지 예에서 보여지듯이, 일단 메모리 데이터를 실행 유니트 레지스터 내에 앨리어스하여, 코드 시퀀스의 실행 중에 사용되도록 하고, 실행 유니트 레지스터내의 데이터를 다른 레지스터에 복사하고, 그 다음에 명령어를 재배열하고 재스케줄링하는 프로세스를 실시할 수가 있다. 재배열 및 재스케줄링을 했다면, 코드 시퀀스 내의 명령어를 앨리어스되고 있는 메모리 어드레스에 기입하는 것이 가능해지므로, 실행 유니트 레지스터내의 데이터는 재차 사용하기 전에 갱신해야 한다. 그렇지만, 실행 유니트 레지스터(111) 내에서 이미 진부한 데이터를 추가의 레지스터에 이미 복사하고 있어, 이러한 레지스터를 이용하는 명령어의 코드 시퀀스가 이미 변화하고 있는 경우, 데이터를 복사한 앞의 레지스터에 있는 진부한 데이터를 코드 시퀀스를 실행할 때에 이용하는 경우가 있다. 이와 같이 하여, 이차적인 비일관성이 발생할 가능성이 있다.

보호되고 있는 메모리 어드레스로부터의 적재 및 이 메모리 어드레스로의 저장이 일어나지 않는 것을 확실히 함으로서, 적재 또는 저장 동작 이후, 메모리 어드레스 및 레지스터(111)내의 데이터가 일치하는 것의 확인을 불필요하게 하기 위해서, 메모리 제어 유니트 내의 비교기(113)는 어드레스 레지스터(112)와 관계한다. 비교기(113)는 변환 중에 메모리로부터 적재되고 메모리로 향해진 게이트 저장 버퍼로 저장되는 어드레스를 수신한다. 적재 또는 저장 중 어느 하나에 대한 메모리 어드레스를 레지스터(112)(또는 실시 형태에 따라서는 추가의 레지스터들) 내의 어드레스와 비교했을 경우, 모드에 따라서는 예외가 발생할 가능성이 있다. 코드 모핑 소프트웨어는 메모리 어드레스 및 예외 유니트 레지스터(111)가 동일한 정확한 데이터를 홀드하고 있다는 것을 보장함으로써, 이 예외에 응답한다. 이것에 의하여, 전술의 비일관성을 보정하는 것이 가능해진다.

코드 모핑 소프트웨어가 응답하는 방법은 특별한 예외에 따라서 다르다. 데이터가 동일하지 않은 경우, 일실시 형태에서는, 변환을 롤백하여, 실행 유니트 레지스터 내에 "앨리어스" 데이터 없이 재실행한다. 이러한 해결 방법에 따라, 코드 시퀀스의 재배열 또는 재스케줄링을 실시하기 전에, 메모리와 실행 유니트 레지스터와의 사이 및 메모리와 실행 유니트 레지스터(111)로부터의 데이터를 복사한 다른 레지스터와의 사이의 비일관성의 보정이 가능해진다. 이 문제를 보정하는 다른 가능한 방법으로서, 실행 유니트 레지스터를 최신의 메모리 데이터로 갱신하던가 또는 메모리를 최신의 적재 데이터로 정신하는 것을 들 수 있다. 메모리 어드레스를 앨리어스하여, 해당 메모리 어드레스로부터의 적재를 불필요하게 하는 기간 중, 비교기는 이 메모리 어드레스에 기입하려고 하는 시도를 찾는다. 왜냐하면, 새로운 데이터가 이 메모리 어드레스에 기입되었을 경우, 실행 유니트 레지스터(111) 내의 데이터가 진부하게 될 가능성이 있기 때문이다. 이러한 경우, 비교기(113)는 보호되고 있는 메모리 어드레스에 대한 기입의 시도를 검출하여, 이러한 시도가 있었을 경우, 예외를 발생한다. 이 예외에 의하여, 레지스터 데이터를 더욱 사용하기 전에, 메모리 내의 데이터를 레지스터(111)에 기입해 이 레지스터를 갱신하던가 또는 실행 유니트 레지스터를 이용하지 않는 코드의 롤백 및 실행에 의하여, 앨리어스 최적화를 실시한다. 이것은 타겟 코드의 재변환을 수반하는 경우가 있다.

메모리 어드레스를 앨리어스함으로써, 레지스터(111)를 이용하는 순차적 저장 동작이 이 메모리 어드레스를 나타낼 수 있게 하는 기간 동안, 이 메모리 어드레스로의 저장에 대한 예외의 발생은 앨리어스의 체크를 실시할 필요없이 이 레지스터(111)로부터 이 메모리 어드레스로의 저장을 실시할 수가 있는 모드(라이트-스루 모드)에 회로를 두는 커맨드에 의해 디스에이블되며, 이것에 의하여 메모리의 보호된 어드레스에 대한 레지스터로부터의 연속적인 저장을 가능하게 한다.

대안적으로, 메모리 어드레스를 앨리어스함으로써, 레지스터(111)를 이용하는 저장 동작이 이 메모리 어드레스를 나타낼 수 있게 하는 동안, 코드 시퀀스가 완료할 때까지 또는 그 이외의 경우로 종료할 때까지, 그 메모리 위치의 데이터를 갱신하지 않는 모드(라이트-백 모드)에 회로를 둘 수 있다. 이러한 모드에서는, 명령어에 의한 이 메모리 어드레스로의 기입은 실행 유니트 레지스터 내에 홀드되고 있는 데이터를 갱신하여, 새로운 데이터와의 일관성을 유지하는 것이 필요한 경우가 있다. 한편, 이러한 모드에서는, 메모리 어드레스를 독출하려고 하는 시도는 그것을 독출하기 전에, 예외를 발생해 메모리 공간에 홀드되고 있는 데이터를 갱신하여, 실행 유니트 레지스터 내의 새로운 데이터와의 일관성을 유지할 수 있도록 할 필요가 있다.

도 12는 보호된 메모리 공간에 대한 적재 및 저장 동작을 검출해 제어하는 비교기(120)의 일실시 형태를 포함하는 앨리어스 회로를 나타낸다. 비교기(120)는 보호해야 할 메모리 어드레스의 엔트리에 대해서, 컨텐트 어드레스가능 메모리(content addressable memory)와 같은 복수의 저장 위치(122)(이들중 1개 만을 도시한다)를 포함한다. 예를 들면, 엔트리에 대해서 8개의 위치가 있는 경우가 있다. 각 엔트리는 해당 메모리 위치에 물리적 어드레스를 저장하기 위해서 충분한 수의 비트 위치(예를 들면, 32), 바이트 마스크 및 여러 가지의 속성 비트를 포함한다. 속성 비트들중에는 보호 메모리의 사이즈를 나타내거나, 메모리 어드레스가 정상적인지 또는 비정상적인지를 나타내는 것이 있다. 비교기(120) 내의 엔트리에 대한 위치는 각각 도 10에 나타내는 레지스터(112)와 동등하므로, 비교기(120)는 도 10의 레지스터(112) 및 비교기(113) 모두의 목적을 달성하게 해 준다.

앨리어스 회로는 또한 앨리어스 인에이블 레지스터(124), 앨리어스 인에이블 레지스터를 새도우(shadow)하기 위한 레지스터(125), 앨리어스 폴트 레지스터(126), 앨리어스 회로가 인에이블 되어 있다는 표시(예를 들면, 단일 비트)를 저장하는 레지스터(127) 및 모드 비트를 저장하는 레지스터(128)를 포함한다.

동작에 있어서, 보호해야 할 물리적 어드레스를 바이트 마스크와 함께 엔트리에 대한 위치들 중 하나에 저장한다. 바이트 마스크의 비트는 그 위치의 어느 바이트가 보호되고 있는지를 나타낸다. 이러한 물리적 어드레스는 64 비트의 데이터를 어드레스하여, 바이트 마스터의 각 비트는 그 어드레스에 있는 데이터의 1바이트를 나타내게 된다. 보호되고 있는 특정의 엔트리는 하드웨어 인에이를 레지스터(124)의 특정의 비트를 설정하는 것에 의해 표시된다. 레지스터(125)는 변환 동안, 커미트점들(commit points)에 대해 레지스터(124) 내의 값을 새도우하여, 변환 동안에 롤백을 실시하는 것을 가능하게 한다. 도시한 실시 형태에서, 인에이블 레지스터(24) 및 새도우 인에이블 레지스터는 저장 위치들(122)의 속성 비트로서 물리적으로 분배되고 있다.

레지스터(127)에 의해 나타내진 것처럼 앨리어싱이 인에이블 되면, 레지스터(128)에 의해 나타내진 것처럼 모드가 설정되는 상태에 응하여, 비교기는 물리적 메모리 어드레스와 바이트 마스크를 홀드하여, 이것들을 이용해 메모리에 대한 저장 또는 적재 및 저장 모두의 어드레스를 체크한다. 모드가 라이트 스루 상태에 설정되는 경우, 보호된 메모리 어드레스의 데이터를 홀드하는 실행 유니트 레지스터로부터 계속적으로 메모리를 갱신하여, 그 메모리 어드레스로부터 다른 어드레스로의 적재가 항상 최신이 되어, 체크할 필요를 없애도록 한다. 그렇지만, 이 메모리 어드레스로의 저장은 실행 유니트 레지스터(112) 내의 데이터를 무효화할 가능성이 있으므로, 이러한 저장을 시험할 필요가 있다. 저장이 보호 어드레스에 대한 것이고, 그 바이트 마스크가 비교기(120)에 홀드되고 있는 메모리 어드레스에서 보호 바이트에 데이터를 저장하고 있음을 나타내는 경우, 비교기는 앨리어스 예외를 발생하여, 라이트-스루 모드에서 저장을 시험한다.

한편, 모드가 라이트-백 상태로 설정되는 경우, 앨리어스 하드웨어가 해제되었을 때 또는 예외가 발생했을 때만, 메모리 어드레스를 갱신한다. 그 결과, 이 메모리 어드레스에 있는 데이터는 진부하게 될 가능성이 있으므로, 앨리어스 하드웨어를 인에이블 할 경우에, 적재 및 저장 모두를 시험해야 한다. 이것을 실시하기 위해서, 적재 또는 저장 중 한쪽이 보호 어드레스에 대한 것이고, 그 바이트 마스크가 비교기(120)내에 홀드되고 있는 메모리 어드레스의 보호 바이트에 대해 데이터를 액세스하고 있는 것을 나타내는 경우, 미교기는 앨리어스 예외를 발생한다.

몇 개의 모드에 대해 발생한 예외는, 앨리어스 폴트 레지스터(126) 내의 적절한 비트를 설정하여, 예외를 발생하는 어드레스를 치정한다. 코드 모핑 소프트웨어의 특정의 예외 조정기에 따라, 발생한 특정의 예외는 문제를 보정하기 위해서 복구 또는 롤백을 실시할 수가 있다. 문제의 복구에 의하여, 최신의 데이터를 실행 유니트 데이터 레지스터의 영향을 받은 특정의 바이트 및 메모리 어드레스 내에 둔다. 롤백에 의하여, 레지스터 상태를 타겟 레지스터 내에 홀드되고 있는 상태로 치환한다. 이것은 레지스터(125)에 홀드되고 있는 상태로 롤백하는 인에이블 레지스터(124) 상태를 포함한다.

앨리어스 검출 하드웨어를 이용함으로써, 적재 및 저장을 제거하는 최적화를 가능하게 하고, 또한 제거한 적재 및 저장에 따라서 동작의 재정비 및 재스케줄링을 가능하게 하는 것에 대해서 전술하였다. 이 재배열은 수퍼스칼라 또는 VLIW 머신과 같은 병렬 실행 자원을 가지는 머신에서 동작들에 대한 양호한 스케줄링을 가능하게 한다.

상기 방법은 또한 적재나 저장 동작을 제거하는 일없이, 적재 및 저장에 따라, 동작의 안전한 재배열을 가능하게 하는데 이용될 수 있다. 이것에 의하여, 스케줄링 성능이 개선되어 적재 또는 저장 동작의 반복이 없는 코드에 유용하게 된다.

당업자이면, 전술한 마이크로프로세서를 전형적인 컴퓨터 엘리먼트를 가지는 회로에 연결했을 때, 도 9에 나타내는 것과 같은 컴퓨터를 형성할 수 있음을 알 수 있을 것이다. 알 수 있는 바와 같이, 최근의 X86 컴퓨터에 이용하는 경우, 전술의 마이크로프로세서는 프로세서 버스를 통해 메모리 및 버스 제어 회로에 결합된다. 메모리 및 버스 제어 회로는 메인 메모리 및, 마이크로프로세서와 함께 이용 가능한 캐시 메모리로의 액세스를 제공하도록 구성되어 있다. 또한, 메모리 및 버스 제어 회로는 PCI 또는 그 외의 로컬 버스와 같은 버스로의 액세스를 제공하여 이 버스를 통해서 I/O디바이스에 액세스 할 수가 있다. 개개의 컴퓨터 시스템은 본 발명의 프로세서에 의해 치환되는 전형적인 마이크로프로세서와 함께 이용되는 회로에 의존한다.

프로세서의 동작 및 실행의 가속화를 실시하는 방식을 나타내기 위해서, X86 타겟 코드의 작은 샘플의 호스트 원시 명령어로의 변환을 여기서 제시한다. 이 샘플은, X86 타겟 명령어의 모프 호스트 명령어로의 변환을 나타내며, 본 발명을 포함한 마이크로프로세서에 의한 최적화, 재배열 및 재스케줄링 단계의 여러 가지 예를 포함한다. 예시된 프로세서를 따름으로써, 타겟 프로세서를 이용해 원래의 명령어를 실행할 때에 필요한 동작과 호스트 프로세서 상에서 변환을 실행할 때에 필요한 동작 사이에 큰 차이가 있음이 당업자에게 명백해질 것이다.

C 언어의 소스 코드로 예시한 원래의 명령어는 매우 간단한 루프 동작을 기술한다. 본질적으로, 각 루프 후에 감분되는 어떤 변수 'n" 이 "0"보다 큰 동안에도, 값 "c"가 포인터 "*s"가 가리키는 어드레스에 저장된다. 포인터 '*s'는 각 루프 후에 증분된다.

원래의 C 코드

이 C 코드를 컴파일하는 컴파일러에 의해 생성된 Win32x86 명령어

주석: [...](은)는 메모리 오퍼랜드에 대한 어드레스 표현을 나타낸다. 상기 예에서는, 메모리 오퍼랜드에 대한 어드레스는 레지스터의 내용을 Ox프리픽스가 가리키는 16진수에 가산하여 형성된다. 타겟 레지스터는 %프리픽스로 나타난다. 예를 들면, %ecx는 exc 레지스터를 나타낸다. 동작의 목적지는 좌측이다.

타겟 명령어 키

이 샘플의 제1 부분에서, C 언어의 명령문(statement)에 의해 정의되는 동작을 수행하기 위한 개별의 X86 어셈블리 언어의 명령어는 그 동작에 대한 어셈블리 언어 니모닉크(assembly language mnemonic)에 의해 목록화되며, 특정의 원시 동작에 관계하는 파라미터가 뒤따른다. 동작의 설명이 또한 각 명령어에 대한 코멘트에 제공된다. 비록 실행의 시퀀스는 타겟 프로세서에 의해, 보여진 것과 다르게 될 수도 있지만, 이러한 어셈블리 언어 명령어 각각은 타겟 C언어 명령어를 수행하는 데에 있어 루프가 실행될 때 마다 매번 실행되어야 한다. 따라서, 루프가 100회 행해지는 경우, 상기에 나타낸 각 명령어는 100회 실행되지 않으면 안 된다.

위에서 나타낸 각 X86 명령어 및 이에 뒤따르는 X86 명령어를 실행하는데 필요한 호스트 명령어를 나타낸다.

다음 샘플은 C 언어 명령어를 실행하는 동일한 타겟 원시 명령어를 나타낸다. 그렇지만, 각 원치 타겟 명령어의 다음에, 마이크로프로세서의 특정 실시예에서 동일 동작을 실시하는데 필요한 원시 호스트 명령에가 목록화 되어 있다. 이 마이크로프로세서에서, 모프 호스트는 여기에 기재한 것처럼 설계된 VLIW 프로세서이다. 주목할 사항으로서, 오피셜 타겟 레지스터에 의해 새도우된 호스트 레지스터는 "R"로 지정되고 뒤이어 X86 레지스터 지정이 이어지므로, 예를 들면, Reax는 EAX 오피셜 타겟 레지스터와 연동되는 작업 레지스터가 된다.

X86 어드레스 계산 및 세그먼트의 상한 및 하한 체크를 실시하는데 필요한 호스트 명령어를 추가한다.

다음의 샘플은 원시 타겟 명령어 각각에 대하여 호스트 원시 명령어의 추가를 나타내고, 이것에 의하여 타겟 동작에 필요한 어드레스가 코드 모핑 소프트웨어에 의해 발생할 수가 있는 것이다. 주목할 사항으로서, 호스트 어드레스 발생 명령어는 어드레스 발생 하드웨어 대신에, 코드 모핑 소프트웨어를 어드레스 발생에 이용하는 마이크로프로세서의 실시예에 대해서만 필요하다. X86 마이크로프로세서와 같은 타겟 프로세서에서는, 어드레스 발생 하드웨어를 이용해 이러한 어드레스를 발생한다. 이러한 실시예에서. 어드레스가 발생했을 때는 언제라도 계산을 하고 또한, 호스트 원시 명령어를 추가하여, 어드레스 값을 체크함으로써 산출된 어드레스가 적절한 X86 세그먼트(segment)의 한도 내에 있는지를 판정한다.

타겟 X86 명령어 포인트 "eip"를 유지하기 위한 명령어 및 특수한 모프 호스트 하드웨어를 이용해 X86 상태를 갱신하는 커미트 명령어를 추가한다.

이 샘플은, 원시 호스트 명령어의 각 세트에 2단계를 추가함으로써, 게이트 저장 버퍼 내의 언커미트값들(uncommitted values)을 메모리에 커미트하는데 필요한 호스트 명령어의 실행 후에, 각 원시 타겟 명령어를 실행하여 오피셜 타겟 레지스터를 갱신하는 것을 예시한다. 샘플로 보여지는 바와 같이, 각 경우에 대하여, 타겟 명령어의 길이를 작업 명령어 포인터 레지스터(Reip) 내의 값에 가산한다. 다음에, 커미트 명령어를 실행한다. 일실시 형태에서, 커미트 명령어는 연동하는 오피셜 타겟 레지스터에 새도우되는 각 작업 레지스터의 현재값을 복사하여, 게이트 저장 버퍼의 게이트의 위치를 지정하는 포인터 값을 언커미트의 저장의 직전부터, 그러한 저장의 직후에 이동시켜 그것들을 메모리 내에 두도록 한다.

상기의 마지막에 가리킨 명령어의 리스트는 원래의 타겟 어셈블리 언어 명령어의 호스트 변환을 형성하는데 필요한 명령어의 전부임을 이해해야 한다. 변환이 이 시점에서 정지했을 경우, 원시 호스트 명령어의 수는 타겟 명령어의 수보다 훨씬 많아져(아마, 6배 많은 명령어), 그 실행은 타겟 프로세서 상에서의 실행보다 길게 될 가능성이 있다. 그렇지만, 이 시점에서는 재배열이나, 최적화나, 재스케줄링은 여전히 행해지지 않았다,

명령어를 한번만 실행하는 경우, 더욱 재배열하거나 그 외의 최적화를 실시하는데 필요로되는 시간은 이 시점에서 존재하는 변환을 실행하기 위한 시간보다 길어지게 될 수 있다. 그 경우, 마이크로프로세서의 일실시 형태에서는, 이 시점에서 변환을 중지하고, 변환을 저장하여, 그 다음에 그것을 실행해 예외 또는 에러가 발생하는지 대해서 판정을 실시한다. 이 실시 형태에서, 재배열 및 그 외의 최적화를 수행하는 것은 특정의 변환을 다수회 실행하거나 최적화 해야 하는 것으로 결정했을 경우뿐이다. 이것은, 예를 들면, 호스트 명령어를 각 변환에 두어, 변환을 실행한 회수를 카운트하여 특정한 칼에 이르렀을 때에 예외(또는 분기)를 발생함으로서 달성된다. 예외(또는 분기)는, 동작을 코드 모핑 소프트웨어에 전송하고, 그 다음에 코드 모핑 소프트웨어는 이하의 최적화의 일부 또는 전부, 및 해당 변환에 유용한 것으로 판정되는 모든 추가의 최적화를 실현한다. 변환을 실행한 회수를 판정하여 최적화를 요구하는 제2의 방법은 상당한 빈도 또는 상당한 통계적 기준에 근거하여 변환의 실행을 중단하고, 그 시점에서 진행되고 있는 어느 변환이라도 최적화하는 것이다. 이것은, 궁극적으로 가장 빈번하게 실행하는 명령어를 최적화하려고 하는 것이다. 다른 해결책으로서는, 루프를 형성하거나, 그 외에 가장 빈번하게 실행할 가능성이 있는, 소정의 특별한 유형의 호스트 명령어들 각각을 최적화하는 것이 있다.

최적화세그먼트 베이스 가산 및 몇 개의 한도 체크의 제거를 가능하게 하는 32 비트의 플랫 어드레스 공간(32 bit flat address space)을 가정한다.

이 샘플은 개량 마이크로프로세서를 이용해 실시 가능한 최적화의 제1 스테이지를 예시한다. 이 최적화 스테이지는 코드 모핑 소프트웨어의 많은 다른 동작과 같이 최적의 결과를 가정한다. 특정의 최적화는 X86 프로세서 패밀리에 의해 주어지는 플랫 메모리 모델(flat memory model)에 대해서 기입된 32 비트 프로그램으서 시작되는 타겟 응용 프로그램이 그러한 프로그램으로서 계속하는 것을 가정한다. 이러한 가정은 X86 패밀리에게 특정한 것이며 에뮬레이트 대상의 다른 프로세서 패밀리에서는 반드시 적용되는 것이 아님이 주목된다.

이 가정을 실시했을 경우, X86용 응용에서는 모든 세그먼트가 동일 어드레스 공간에 맵핑된다. 이것에 의하여, X86 분할 프로세스가 요구하는 원시 호스트 명령어를 제거하는 것이 가능해진다. 샘플에서 보여지는 바와 같이, 최초로 세그먼트 값을 제로로 설정한다. 다음에, 데이터의 베이스를 제로로 설정하여, 한도를 최대 사용 가능 메모리에 설정한다. 그러면, 타겟 원시 명령어를 실행하기 위한 각 세트의 원시 호스트 명령어에 대하여 분할에 필요한 세그먼트 베이스 칼(segment base value)의 체크 및 세그먼트 베이스 어드레스(segment base address)의 계산이 모두 불필요해진다, 이것에 의하여, 어드레싱 기능을 필요로 하는 각 타겟 원시 명령어에 대해서, 2개의 호스트 원시 명령어가 실행해야 할 루프가 감소된다. 이 시점에서, 메모리 상한에 대한 호스트 명령어 체크는 여전히 존재한다.

주목할 사항으로서, 이러한 최적화는 응용이 32 비트 플랫 메모리 모델을 이용한다고 하는 추측을 필요로 한다. 이것이 참이 아닌 경우, 메인 루프가 제어 전송의 목적지를 분석하여, 발신지의 가정(source assumption)이 목적지의 가정과 일치하지 않음을 검출할 때에, 에러가 발견된다. 그러면, 새로운 변환이 필요하다. 이 기법은 매우 일반적이고, 여러 가지의 분할 및 그 외의 "모드화"의 경우에 대하여, 디버그, 시스템 관리 모드, 또는 "리얼" 모드와 같이, "모드"가 빈번하게 변화하는 경우에 적용 가능하다.

어드레스된 데이터는 컴퓨터 메모리의 한도 이외의 바이트를 포함하지 않는 것으로 가정한다. 한도를 넘을 가능성이 있는 것은, 메모리 상한에 있어 메모리 참조와 교차하는 정합되어 있지 않은 페이지에서만 발생할 수 있고, 특수한 경우의 소프트웨어 또는 하드웨어에 의해 처리 가능하다.

위의 샘플은 최적화의 다음의 스테이지를 예시한다. 이 경우, 추측적 변환(speculative translation)에 의하여, 메모리 어드레스 공간의 상단의 메모리 참조와 교차하는 정합되어 있지 않은 페이지만을 필요로 하는 상부 메모리 경계 체크를 불필요하게 한다. 이 가정의 실패는, 하드웨어 정합을 수정하든지 소프트웨어 정합을 수정하든지 하여 검출된다. 이것에 의하여, 어드레싱을 필요로 하는 타겟 원시 명령어 각각에 대한 다른 호스트 원시 명령어에 의한 변환이 감소한다. 이 최적화는, 응용이 32 비트 플랫 메모리 모델을 이용한다고 하는 가정과, 명령어가 정합되고 있다고 하는 추측 모두를 필요로 한다. 이것들이 참이 아닌 경우, 변환을 실행했을 때 실패로 끝날 것이므로, 새로운 변환이 필요하다.

과다한 어드레스 산출을 검출해서 제거한다. 이 예는 과다한 동작을 제거한 후의 코드를 나타낸다.

이 샘플은 공통의 호스트 표현을 제거하는 다음의 최적화를 예시한다. 보다 구체적으로, 2번째의 타겟 원시 명령어를 변환할 때, 작업 레지스터 Rebp(X86 프로세서의 스택 페이스 포인트 레지스터를 나타내는 작업 레지스터) 내의 값을, 오프셋(offset) 값 Ox8에 가산하여, 호스트 작업 레지스터 R2에 둔다. 가산의 결과가 작업 레지스터 R5에 놓여진 것을 제외하고는 이전의 샘플에서 타겟 원시 명령어 5 를 변환할 때에 동일한 동작이 발생됨이 주목된다. 그 결과, 작업 레지스터 R5에 놓여지는 값은 호스트 원시 명령어 5가 발생하려고 할 경우 이미 작업 레지스터 R2에 존재한다. 따라서, 호스트의 가산 명령어를 타겟 원시 명령어 5의 변환으로부터 제거할 수가 있어, 작업 레지스터 R2 내의 값을 작업 레지스터 R5에 복사할 수 있다. 유사하게, 작업 레지스터 Rebp 내의 값을 오프셋 값 Ox1O과 가산하는 호스트 명령어도, 타겟 원시 명령어 8의 변환에서 제거할 수가 있다. 왜냐하면, 이 단계는 이미 타겟 원시 명령어 6의 변환에서 수행되어, 그 결과가 레지스터 R7에 있기 때문이다. 주목할 사항으로서, 이 최적화는 추측에 의존하지 않으며, 그 때문에 실패나 재변환을 겪지 않게 된다.

변환 내에서는 타겟 예외가 발생하지 않을 것이며, 따라서 eip나 타겟 상태를 갱신할 때 지연도 발생하지 않는 것으로 가정한다.

위의 샘플은, 변환 전체를 구성하는 원시 타겟 명령어의 변환이 예외를 발생하는 일없이 달성될 수가 있는 지를 추측하는 최적화를 예시한다. 이것이 참이면, 오피셜 타겟 레지스터를 갱신하거나 개개의 타겟 원시 명령어를 실행하는 호스트 원시 명령어의 각 시퀸스마다, 그 종료 시에 저장 버퍼에 있어서의 언커미트의 저장을 커미트할 필요가 없어진다. 추측이 참이면, 타겟 원시 명령어의 시퀀스의 종료 시에, 오피셜 타겟 레지스터만을 갱신하고 저장을 커미트하는 것은 한 번만으로 좋다. 이것에 의하여, 각 원시 타겟 명령어를 실행하기 위해 2개의 원시 호스트 명령어를 제거하는 것이 가능해진다. 이것들은, 오피셜 타겟 레지스터를 갱신하여 언커미트의 저장을 메모리에 커미트하는 단일의 호스트 원시 명령어로 치환된다.

이해할 수 있는 바와 같이, 이것은 정확한 추측을 포함할 가능성이 매우 높은 다른 추측적 동작이다. 이 단계는, 추측이 창이면, 종래 기술의 에뮬레이션 기술 모두에 대해서, 매우 큰 이점을 제공하게 된다 이것은, 타겟 원시 명령어의 시퀸스 전체를 실행하는 원시 호스트 명령어의 모두를 한 시퀀스로 그룹화할 수 있게 하는 바, 이렇게해서 개개의 호스트 원시 명령어의 모두를 함께 최적화할 수가 있다. 이는 최장 명령어 워드 기술을 이용한 모프 호스트 상에서 다수의 동작을 병렬로 실행할 수 있는 이점이 있다. 이는 또한 다수의 그 외의 최적화를 가능하게 하는바, 그 이유는 이러한 최적화에 대한 선택이 보다 많이 존재하기 때문이다. 그렇지만, 추측이 참이 아닌 것으로 판명되어, 루프의 실행 시에 예외가 발생했을 경우, 오피셜 타겟 레지스터 및 메모리는 타겟 원시 명령어의 시퀀스의 개시 시에 존재한 오피셜 타겟 상태를 홀드한다. 이는 호스트 명령어의 시퀀스가 실제로 실행될 때까지, 커미트가 발생하지 않기 때문이다. 예외로부터 복구하기 위해 필요한 모든 것은 언커미트의 저장을 소거하고, 오피셜 레지스터를 작업 레지스터에 롤백(rollback)하여, 시퀀스의 개시 시에 타겟 원시 명령어의 변환을 재차 개시하는 것이다. 이 재변환은, 한번에 1타겟 명령어씩의 변환을 실시하여, 각 타겟 원시 명령어를 나타내는 호스트 시퀀스를 변환한 후, 오피셜 상태를 갱신한다. 다음에, 이 변환을 실행한다. 이 재변환에 대해 예외가 발생했을 경우, 이 예외를 실행하기 위해서, 오피셜 타겟 레지스터 및 메모리에 대하여 정확한 타겟 상태를 즉시 얻을 수 있다.

요약

코멘트 "Live Out"은 커미트 전에 정확하게 Reax 및 Recx를 실제로 홀드할 필요성을 의미한다. 그렇지 않으면, 추가의 최적화가 가능하게 될 것이다.이 요약은, 최적화 프로세스의 이 시점에 남아 있는 호스트 원시 명령어의 시퀀스를 예시한다. 이 예는 타겟 명령어 포인터(EIP) 인라인(inline)의 유지를 나타내지만, 변환 시에 라인으로부터 분기를 위한 포인터 EIP를 유지하는 것이 가능하다. 이 경우, 포인터 EIP 갱신 시퀀스를 이 단계 및 본 예의 후속 단계로부터 제거할 수가 있다.

레지스터 자원 의존성을 감소시키기 위한 명칭 변경. 이것에 의하여, 이후의 스케줄링이 한층 효과적이 된다. 이 시점 이후, 개개의 타겟 X86 명령어와 호스트 명령어 간의 관계가 점점 더 애매하게 되므로, 원래의 타겟 X86 코드를 생략한다.

이 샘플은, 통상 레지스터 명칭 변경으로 불리는, 최적화의 다음의 단계를 나타낸다. 여기에서, 호스트 원시 명령어의 시퀀스에 대해 1회 이상의 동작에 이용되는 작업 레지스터를 필요로 하는 동작은 다른 미사용의 작업 레지스터를 이용하도록 변경되어 2개의 호스트 명령어가 동일한 하드웨어를 필요로 할 가능성을 없앤다. 따라서, 예를 들면, 앞의 2개의 샘플에 대하여, 2번째의 호스트 원시 명령어는 오피셜 타겟 레지스터 ECX를 나타내는 작업 레지스터 Recx를 사용한다. 10번째의 호스트 원시 명령어도 작업 레지스터 Recx를 사용한다. 2번째의 호스트 원시 명령어에 있어서의 동작을 변경하여, R0 내의 어드레스에 의해 나타나는 값을 레지스터 Recx가 아닌, 작업 레지스터 R1에 저장함으로써, 앞의 2개의 호스트 명령어가 양쪽 모두 같은 레지스터를 사용하지 않게 된다. 유사하게, 4번째, 5번째 및 6번째의 원시 명령어 모두가 앞의 샘플의 작업 레지스터 Reax를 이용한다, 4번째의 호스트 원시 명령어를 변경하여, 작업 레지스터 Reax 대신에 이전에 미사용된 작업 레지스터 R3을 이용하도록 하고, 또한 6번째의 호스트 원시 명령어를 변경하여, 레지스터 Reax 대신에, 이전에 미사용된 작업 레지스터 R4를 이용함으로써, 그러한 하드웨어 의존성이 없어진다.

호스트 VLIW 하드웨어 상에서 병렬로 실행 가능한 다수의 동작으로서 원시 호스트 동작을 조직화하는 스케줄링 프로세스 이후, 각 행은 VLIW머신이 실행하는 병렬 동작을 나타내며, "＆"는 병렬화를 나타낸다.

위의 샘플은 모프 호스트 상에서 실행하기 위한 호스트 원시 명령어의 스케줄링을 나타낸다. 이 예에서는, 모프 호스트를 VLIW 프로세서로 가정되는데, 이 VLIW 프로세서는 코드 모핑 소프트웨어와 협동하도록 제공된 하드웨어 기능 강화에 부가하여, 다른 처리 유니트들중에서도 특히, 2개의 산술 및 논리(ALU) 유니트를 또한 포함하고 있다. 최초의 행은, 모프 호스트 상에서 함께 실행되도록 스케줄링된 2개의 개별의 가산 명령어를 나타낸다. 보여지는 바와 같이, 이것들은 상기 요약의 직전의 샘플에 있어서 3번째 및 8번째의 원시 호스트 명령어이다. 2번째의 행은 NOP 명(동작은 없지만, 다음의 명령어로 진행된다) 및 다른 가산 명령어를 포함한다. NOP 명령어는 어떤 스케줄링 최적화가 실시된 이후에도 함께 실행될 수 있는 2개의 명령어가 항상 존재하지는 않음을 나타낸다. 어느 경우이든지, 이 샘플은 단지 9개(set)의 원시 호스트 명령어만이 이 시점에 남게 되어 원래의 10개의 타겟 명령어를 실행하는 것을 나타낸다.

호스트 분기 타겟 및 연쇄 저장 변환의 해결

이 샘플은 본질적으로 호스트 원시 명령어의 같은 세트를 예시하지만, 명령어는 이 시점에서 변환 버퍼에 저장되어 1회 이상 실행된다는 점에서 다르다. 그 이유는 마지막 점프(jp) 명령어는 이제, 변환된 명령어의 다른 시퀀스에 연쇄됨으로써 주어지는 점프 어드레스를 나타내기 때문이다. 연쇄 프로세스는 변환기의 메인 루프로부터 명령어의 시퀀스를 진행시키며, 따라서 그 시퀀스의 변환은 완료된다.

향상된 최적화, 역방향 코드 이동본 예 및 이후의 예들은, 스케줄링 이전의 코드로부터 시작된다. 이 최적화는 우선 코드가 루프인 것의 검출에 의존한다. 다음에, 루프 본체로부터 불변의 동작을 제거하여, 루프 본체에 들어가기 전에 1회 실행할 수가 있다.

위의 예는 대체적으로 여러 번 반복하는 시퀀스로 이용되는 향상된 최적화 단계를 예시한다. 이 프로세스는 먼저 루프를 형성하는 변환을 검출하고, 개개의 원시 호스트 명령어를 조사하여, 어느 명령어들이 루프 본체 내에서 일정한 결과를 생성하는지를 판정한다. 이러한 명령어를 루프 본체로부터 제거, 1회만 실행하여, 레지스터 내에 값을 둔다. 그 시점 이후, 이 레지스터에 저장한 값을 이용하며, 명령어를 재차 실행하지는 않는다.

역방향 코드 이동 후의 루프 본체의 스케줄링예시의 목적을 위해서, 루프 본체 내의 코드를 스케줄링하는 것에 대해서만 나타낸다.

이들 비-반복 명령어를 루프로부터 제거하고, 실행을 위해 시퀀스를 스케줄링 하면, 스케줄링 된 명령어는 상기 마지막 샘플과 같이 된다. 초기의 명령어는 루프의 최초의 반복 동안 1번만 실행되고, 그 후는 나타낸 바와 같이 7개의 클럭 인터벌(clock intervals)에 남아 있는 호스트 원시 명령어만이 이 루프 동안에 실행된다는 것을 알 수 있다. 따라서, 실행 시간은 원시 타겟 명령어를 실행하기 위해 필요한 10개의 명령어 인터벌로부터 7개의 명령어 인터벌로 단축된다.

알 수 있는 바와 같이, 루프로부터 제거된 어드레스 발생 단계이다. 따라서, 어드레스 발생은 개선된 마이크로프로세서에서는 루프 호출마다 1회 실시만을 필요로 한다. 즉, 어드레스 발생은 단지 1회만 실시하면 된다. 한편, X86 타겟 프로세서의 어드레스 발생 하드웨어는 이러한 어드레스를 루프를 실행할 때마다 발생해야 한다. 루프를 100회 실행하는 경우, 개량 마이크로프로세서는 1회만 어드레스를 발생하는데 반하여, 타겟 프로세서는 각 어드레스를 100회 발생하게 된다.

역방향 코드 이동 후

레지스터 할당이것은, 변수를 안전하게 메모리로부터 레지스터로 이동시킬 수가 있는 모프 호스트의 레지스터 앨리어스 검출 하드웨어의 사용을 나타낸다. 시작점은 "역방향 코드 이동"의 후의 코드이다. 이것은 적재를 제거할 수가 있는 최적화를 나타낸다.

먼저, 적재를 실행한다. 앨리어스 하드웨어에 의해 어드레스가 보호되고 있어, 이 어드레스로의 저장이 행해지면 "앨리어스" 예외가 발생한다. 다음에, 루프 본체 내의 적재가 복사로 치환한다. 루프의 본체 이후에서, 앨리어스 하드웨어는 자유로운 상태로 된다.

이 샘플은, 보다 향상된 최적화를 예시하며, 본 발명을 포함하는 마이크로프로세서에 의해 실시할 수가 있다. 이 샘플 전의 두번째 샘플을 재차 참조하면, 최초의 3개의 가산 명령어가 스택 상의 어드레스의 계산에 관계하고 있었음을 알 수 있을 것이다. 이러한 어드레스는 호스트 동작 시퀀스의 실행중 변화하지 않는다. 즉, 이러한 어드레스에 저장되어 있는 값은 메모리로부터 검색되어 레지스터에 적재됨으로써 실행을 위해 즉시 이용될 수 있다. 보여진 바와 같이, 이것은 호스트 원시 명령어 6, 8, 및 1O에서 행해진다. 명령어 7, 9 및 11에서, 메모리 어드레스들 각각에는 특수한 호스트 앨리어스 하드웨어에 의해 보호되고 있다고 하는 표를 붙일 수 있고 레지스터들은 이들 메모리 어드레스들을 위한 앨리어스로서 표시되고 있으므로, 그 데이터를 변경하려고 하는 어느 시도도 예외의 원인이 된다. 이러한 점에서, 이들 스택 메모리 어드레스로부터의 데이터 이동을 수반하는 적재 동작 각각은 단순한 레지스터간 복사 동작이 되는바, 이는 메모리 어드레스로부터의 적재보다 현격히 빠르게 진행된다. 주목할 사항으로서, 일단 n=0까지 루프가 실행되었다면, 만일 그러하지 못한 경우 앨리어스 레지스터를 이용할 수 있도록, 메모리 어드레스를 각각으로부터 상기 보호를 제거해야만 한다.

복사 전파앨리어스 하드웨어를 이용하여 루프 본체 내의 적재를 복사로 전환한 후, 복사전파에 의하여 몇 개의 복사가 불필요하게 될 수 있다.

이 샘플은 최적화의 다음의 단계를 나타낸다. 여기에서는 마지막 샘플에서 예시된 최적화에서 적재 명령어를 치환한 복사 명령어의 대부분이 불필요하고, 제거될 수 있다는 것이 인식될 것이다. 즉, 레지스터간 복사 동작을 하면, 데이터를 복사한 원래의 레지스터 내에 그 동작 전의 데이터가 존재한다. 그 경우, 데이터는 그것이 복사된 레지스터가 아닌, 최초의 레지스터에 액세스 할 수가 있어 복사 동작을 제거할 수가 있다. 알 수 있는 바와 같이, 마지막 샘플의 루프에 보여지는 1번째, 2번째, 5번째 및 9번째의 원시 호스트 명령어가 제거된다. 또한, 다른 호스트 원시 명령어에 이용되고 있는 레지스터도 변경되어 해당 데이터에 대한 정확한 레지스터를 반영한다. 따라서, 예를 들면, 1번째와 2번째의 복사 명령어를 제거했을 경우, 3번째의 저장 명령어는 레지스터 R1 보다는 데이터가 존재하는 작업 레지스터 Rc로부터 데이터를 복사하여, (레지스터 R3 보다는) 어드레스가 존재하는 작업 레지스터 Rs 내에 나타나는 어드레스에 그 데이터를 두어야 한다.

루프 본체만의 스케줄링을 나타내는 예

위의 샘플에는 스케줄링된 호스트 명령어가 나타나 있다. 이 시퀀스는 소스 코드로부터 원래 디코드된 원시 타겟 명령어를 실행하는 것보다 루프를 실행하는데 더 적은 수의 클럭이 필요하다는 것이 주목될 것이다. 따라서, 행해진 다른 모든 가속화와는 별도로, 결합된 동작을 실행하는 총회수는 원래의 타겟 코드를 실행하는데 필요한 동작보다 적게 된다.앨리어스 하드웨어의 사용에 의한 저장 제거

이 샘플에 나타낸 최종적인 최적화는 앨리어스 하드웨어의 사용에 의한 저장 제거이다. 이것은 루프 본체내로부터 저장들을 제거하여, 그것들을 루프 에필로그(loop epilog)에서만 실행된다 이것에 의하여, 루프 본체내의 호스트 명령어 수가 원래의 10개의 타겟 명령어에 비해 3개로 감소한다.

본 발명을 양호한 실시예에 관해서 기재했지만, 본 발명의 정신 및 범위로부터 벗어남이 없이, 당업자는 여러 가지의 변경이나 변형이 가능하다는 것을 이해할 수 있을 것이다. 예를 들면, 본 발명은, X86 프로세서의 에뮬레이션에 관해서 설명했지만, 유사하게 다른 프로세서 아키텍처를 위해 설계된 프로그램, 및 P 코드, 포스트스크립트(Postscript), 또는 자바(Java) 프로그램과 같은 가상 머신 상에서 실행하는 프로그램에도 적용된다는 것을 이해해야 한다. 따라서, 본 발명은, 이하의 청구의 범위에 따라 해석해야 한다.

Claims (34)

1. 프로세서에 의한 명령어 시퀀스 실행 동안 발생된 데이터의 메모리로의 저장을 제어하는 버퍼로서,

   각각, 메모리로 어드레스된 데이터 및 이 데이터의 어드레스를 홀드할 수 있는 복수의 저장 위치와;

   상기 명령어 시퀀스가 실행을 완료할 때까지 프로세서의 동작에 의해 발생되는 데이터를 그 데이터가 발생될 때 마다 상기 저장 위치로 전송하는 수단과;

   실행을 완료하지 않은 명령어 시퀀스에 의해 발생된 상기 버퍼 내의 데이터를 식별하는 수단과;

   메모리 액세스에 응답하여 특정 메모리 어드레스로 보내지는 상기 버퍼 내의 가장 최근의 데이터가 어느 것인지를 검출하는 수단과;

   저장을 발생시키는 명령어 시퀀스가 예외 또는 에러를 발생시키지 않고 실행된 후에, 상기 저장 위치 내의 데이터를 메모리로 전송하는 수단과; 그리고

   저장을 발생시키는 명령어 시퀀스의 실행이 예외 또는 에러를 발생시킬 때, 상기 저장 위치 내의 메모리 저장을 소거하는 수단을 포함하는 것을 특징으로 하는 버퍼.
2. 제 1 항에 있어서,

   메모리 액세스에 응답하여 특정 메모리 어드레스로 보내지는 버퍼 내의 가장 최근의 데이터가 어느 것인지를 검출하는 상기 수단은 특정 메모리 어드레스로 어드레스되는 상기 버퍼 내의 각각의 가장 최근의 어드레스될 수 있는 데이터량을 나타내는 수단을 포함하는 것을 특징으로 버퍼.
3. 제 2 항에 있어서,

   실행을 완료하지 않은 명령어 시퀀스에 의해 발생된 상기 버퍼 내의 데이터를 식별하는 상기 수단은 실행을 완료하지 않은 명령어 시퀀스에 의해 발생된 데이터를 상기 명령어 시퀀스가 실행될 때까지 버퍼 내의 다른 데이터와 분리하는 수단을 포함하는 것을 특징으로 하는 버퍼.
4. 제 3 항에 있어서,

   명령어 시퀀스가 실행될 때 까지 상기 데이터를 버퍼 내의 다른 데이터와 분리하는 상기 수단은 버퍼내 데이터 시퀀스의 시작과 끝을 가리키는 수단인 것을 특징으로 하는 버퍼.
5. 제 4 항에 있어서,

   메모리 액세스에 응답하여 특정 메모리 어드레스로 어드레스되는 버퍼 내의 각각의 가장 최근의 어드레스될 수 있는 데이터량을 나타내는 상기 수단은 상기 버퍼 내의 데이터 시퀀스의 시작과 끝 사이의 저장 위치 내의 오래된 데이터를 동일한 메모리 어드레스에 어드레스되고 아직 실행되지 않은 명령어 시퀀스에 의해 발생되는 새로운 데이터로 치환하는 수단을 포함하는 것을 특징으로 하는 버퍼.
6. 제 4 항에 있어서,

   특정 메모리 어드레스로 어드레스되는 상기 버퍼 내의 각각의 가장 최근의 어드레스될 수 있는 데이터량을 나타내는 상기 수단은,

   상기 버퍼 내에 위치하는 데이터를 가장 최근의 데이터로서 식별하기 위한 어스레스될 수 있는 저장 위치에 대한 제1 지시자와;

   저장 위치 내에 위치하는 데이터의 메모리 어드레스와 저장 위치 내에 이미 존재하는 데이터의 메모리 어드레스를 비교하고, 상기 저장 위치 내에 위치하는 상기 데이터의 메모리 어드레스와 동일한 메모리 어드레스를 갖는 데이터에 대한 지 시자를 소거하는 비교기와;

   에러나 예외 없는 명령어 시퀀스의 실행에 응답하여, 상기 저장 위치 내의 명령어를 명령어 시퀀스에 의해 발생된 가장 최근 데이터로서 식별하기 위한 어스레스될 수 있는 저장 위치에 대한 제2 지시자와; 그리고

   상기 저장을 발생시키는 명령어 시퀀스의 실행이 예외나 에러를 발생시킬 때, 상기 버퍼로부터 소거되는 데이터의 메모리 어드레스와, 에러나 예외 없는 명령어 시퀀스의 실행에 응답하여 상기 제2 지시자에 의해 명령어 시퀀스에 의해 발생된 소거되지 않은 가장 최근의 데이터로 식별된 데이터를 식별하는 데이터의 메모리 어드레스를 비교하여, 제1 지시자를 가장 최근의 것으로서 기입하는 비교기를 포함하는 것을 특징으로 하는 버퍼.
7. 제 2 항에 있어서,

   상기 저장을 발생시키는 명령어 시퀀스의 실행이 예외 또는 에러를 발생시킬 때 상기 저장 위치 내의 메모리 저장을 소거하는 수단은, 명령어 시퀀스 실행시 발생된 에러나 예외에 응답하여 상기 데이터를 무효화시키는 지시자를 포함하는 것을 특징으로 하는 버퍼.
8. 제 3 항에 있어서,

   상기 명령어 시퀀스가 실행될 때 까지 상기 데이터를 버퍼 내의 다른 데이터와 분리하는 수단은, 아직 실행되지 않은 명령어 시퀀스로부터의 데이터를 포함하는 것으로 나타내진 버퍼의 물리적으로 분리된 부분에 데이터 시퀀스를 위치시키는 수단을 포함하는 것을 특징으로 하는 버퍼.
9. 제 8 항에 있어서,

   상기 메모리 액세스에 응답하여 특정 메모리 어드레스로 어드레스되는 상기 버퍼 내의 각각의 가장 최근의 어드레스될 수 있는 데이터량을 나타내는 수단은,

   아직 실행되지 않은 명령어 시퀀스로부터의 데이터를 포함하는 것으로 나타내진 버퍼의 물리적으로 분리된 부분에 있는 저장 위치 내의 오래된 데이터를 동일한 메모리 어드레스로 어드레스되고 아직 실행되지 않은 상기 명령어 시퀀스에 의해 발생되는 새로운 데이터로 치환하는 수단을 포함하는 것을 특징으로 하는 버퍼.
10. 제 8 항에 있어서,

    상기 데이터를 발생시키는 명령어 시퀀스가 예외나 에러를 발생함이 없이 실행될 때 상기 저장 위치 내의 데이터를 메모리로 전송하는 수단은, 에러 없이 실행된 명령어 시퀀스에 의해 상기 데이터가 발생되었음을 나타내는 수단을 더 포함하는 것을 특징으로 하는 버퍼.
11. 제 8 항에 있어서,

    상기 저장을 발생시키는 명령어 시퀀스가 예외나 에러를 발생함이 없이 실행된 후, 상기 저장 위치 내의 데이터를 메모리로 전송하는 수단은, 에러나 예외 없이 실행된 명령어 시퀀스에 의해 발생된 상기 버퍼 내의 데이터의 메모리 어드레스들을 비교하여, 어느 메모리 어드레스에 저장을 위해 가장 최근의 어스레스될 수 있는 데이터 만을 선택하는 비교기를 포함하는 것을 특징으로 하는 버퍼.
12. 명령어 시퀀스 실행에 의해 발생된 데이터의 메모리로의 저장을 프로세스에 의해 제어하는 방법으로서,

    데이터가 발생될 때마다 메모리 어드레스와 관련된 데이터를 순차적으로 저장 버퍼의 격리 부분에 전송하는 단계와;

    상기 메모리 어드레스의 액세스에 응답하여 상기 저장 버퍼에서 특정 메모리 어드레스를 갖는 가장 최근의 데이터를 검출하는 단계와;

    상기 명령어 시퀀스가 예외나 에러를 발생시키지 않으면, 배출을 위해 상기 저장 버퍼의 격리 부분으로부터 모든 데이터를 메모리에 전송하는 단계와; 그리고

    명령어 시퀀스가 예외나 에러를 발생시키면, 상기 저장 버퍼의 격리 부분으로부터 모든 데이터를 소거하는 단계를 포함하는 것을 특징으로 하는 방법.
13. 제 12 항에 있어서,

    상기 데이터가 발생될 때마다 메모리 어드레스와 관련된 데이터를 순차적으로 저장 버퍼의 격리 부분에 전송하는 단계는, 최초와 마지막 저장 위치 지시 사이의 상기 저장 버퍼의 부분에 있는 연속 저장 위치들에 데이터를 위치시키는 단계를 포함하는 것을 특징으로 하는 방법.
14. 제 13 항에 있어서,

    상기 명령어 시퀀스가 예외나 에러를 발생시키지 않으면, 배출을 위해 상기 저장 버퍼의 격리 부분으로부터 모든 데이터를 메모리에 전송하는 단계는, 상기 최초 저장 위치 지시를 이동시켜 상기 마지막 저장 위치를 지정하는 단계를 포함하고,

    상기 명령어 시퀀스가 예외나 에러를 발생시키면, 상기 저장 버퍼의 격리 부분으로부터 모든 데이터를 소거하는 단계는, 상기 마지막 저장 위치 지시를 이동시켜 상기 최초 저장 위치를 지정하는 단계를 포함하는 것을 특징으로 하는 방법.
15. 제 14 항에 있어서,

    상기 메모리 어드레스의 액세스에 응답하여 상기 저장 버퍼에서 특정 메모리 어드레스를 갖는 가장 최근의 데이터를 검출하는 단계는,

    어드레스될 수 있는 어느 데이터가 저장 위치에 있을 때, 상기 데이터는 상기 데이터와 관련된 메모리 어드레스에 대한 가장 최근의 데이터라는 제1 지시를 두는 단계와;

    어드레스될 수 있는 어느 데이터가 저장 버퍼의 격리 부분으로부터 전송될 때, 상기 데이터는 상기 저장 버퍼의 격리 부분으로부터 가장 최근에 전송된 것이라는 제2 지시를 두는 단계와;

    상기 저장 버퍼의 격리 부분의 모든 데이터를 소거할 때, 제2 지시를 갖는 어드레스될 수 있는 어느 데이터와 함께 상기 제1 지시를 두는 단계와; 그리고

    상기 저장 버퍼 내에 홀드된 데이터의 메모리 어드레스 액세스에 응답하여, 어드레스될 수 있는 저장 위치 내에 홀드된 어느 데이터의 제1 지시와 상기 메모리 어드레스를 비교하는 단계를 포함하는 것을 특징으로 하는 방법.
16. 제 12 항에 있어서,

    상기 데이터가 발생될 때마다 메모리 어드레스와 관련된 데이터를 순차적으로 저장 버퍼의 격리 부분에 전송하는 단계는,

    상기 데이터 시퀀스를 상기 버퍼의 물리적으로 분리된 부분에 위치시키는 단계와; 그리고

    상기 저장 버퍼의 물리적으로 분리된 부분이 실행이 완료되지 않은 명령어 시퀀스로부터의 데이터를 포함함을 나타내는 단계를 포함하는 것을 특징으로 하는 방법.
17. 제 16 항에 있어서,

    상기 메모리 어드레스의 액세스에 응답하여 상기 저장 버퍼에서 특정 메모리 어드레스를 갖는 가장 최근의 데이터를 검출하는 단계는,

    상기 저장 버퍼의 격리 부분 내의 동일한 메모리 어드레스로 어드레스된 데이터에 대해, 데이터의 각각 개별적으로 어드레스 가능한 부분을 상기 저장 버퍼의 격리 부분에 기입하는 단계와; 그리고

    상기 저장 버퍼 내의 상기 가장 최근의 데이터를 검출하기 위해, 상기 저장 버퍼 내의 모든 데이터의 메모리 어드레스들과 액세스되는 어떤 메모리 어드레스를 비교하는 단계를 포함하는 것을 특징으로 하는 방법.
18. 제 16 항에 있어서,

    상기 명령어 시퀀스가 예외나 에러를 발생시키지 않으면, 배출을 위해 저장 버퍼의 격리 부분으로부터 모든 데이터를 메모리로 전송하는 단계는, 버퍼의 물리적으로 분리된 부분이 실행된 명령어 시퀀스로부터의 데이터를 포함함을 나타내는 단계를 포함하며, 그리고

    상기 명령어 시퀀스가 예외나 에러를 발생시키면, 상기 저장 버퍼의 격리 부분으로부터 모든 데이터를 소거하는 단계는, 상기 버퍼의 물리적으로 분리된 부분이 무효 데이터를 포함함을 나타내는 단계를 포함하는 것을 특징으로 하는 방법.
19. 제 18 항에 있어서,

    각 메모리 어드레스에 대한 상기 격리 부분으로부터 전송된 모든 데이터의 어드레스를 비교하여, 어느 메모리 어드레스에 대해서도 가장 최근의 데이터 만을 메모리로 배출함으로써, 상기 저장 버퍼의 격리 부분으로부터 전송된 모든 데이터를 메모리로 배출하는 단계를 더 포함하는 것을 특징으로 하는 방법.
20. 호스트 프로세서에 의해 제1 명령어 세트로 변환되는 상이한 명령어 세트의 명령어를 실행하는 것을 돕기 위해 상기 제1 명령어 세트를 실행할 수 있는 호스트 프로세서를 갖는 프로세싱 시스템에서 사용하는 장치로서,

    변환된 명령어 시퀀스가 상기 호스트 프로세서 상에서 예외나 에러 없이 실행될 것이라고 판정할 때까지, 발생된 메모리 저장을 일시적으로 저장하기 위한 격리 영역을 포함하는 버퍼와;

    메모리 어드레스의 액세스에 응답하여, 버퍼 내에 홀드된 특정 메모리 어드레스로의 가장 최근의 메모리 저장을 검출하는 논리 회로와;

    상기 격리 영역으로부터 임시적으로 저장된 메모리 저장을 소거하고, 변환된 명령어 시퀀스가 상기 호스트 프로세서 상에서 예외나 에러 없이 실행될 것이라고 판정될 때 메모리 저장을 영구히 저장하는 배출 회로와; 그리고

    변환된 명령어 시퀀스가 상기 호스트 프로세서 상에서 예외나 에러를 발생시킬 것이라고 판정될 때, 상기 버퍼의 격리 부분 내에 임시적으로 저장된 메모리 저장을 소거하는 수단을 포함하는 것을 특징으로 하는 장치.
21. 제 20 항에 있어서,

    상기 버퍼의 상기 격리 영역은 최초 및 마지막 저장 위치에의 포인터에 의해 정의되며;

    상기 메모리 어드레스의 액세스에 응답하여, 상기 버퍼 내에 홀드되는 특정 메모리 어드레스로의 가장 최근의 메모리 저장을 검출하는 상기 논리 회로는,

    가장 최근의 메모리 저장을 가리키는 각 저장 위치 내의 제1 위치와,

    메모리 저장이 저장 위치 내에 위치될 때 마다 제1 위치 내에 지시를 위치시키고, 동일한 메모리 어드레스로의 더 오래된 메모리 저장에 대한 제1 위치 내의모든 지시를 소거하는 회로와,

    상기 버퍼의 격리 부분 외에 있는 가장 최근의 메모리 저장을 나타내는 각 저장 위치 내의 제2 위치와,

    배출 회로에 의해 상기 격리 부분으로부터 상기 메모리 저장이 소거될 때마다 상기 제2 위치 내에 지시를 위치시키고, 동일한 메모리 어드레스로의 더 오래된 메모리 저장에 대한 제2 위치 내의 모든 지시를 소거하는 회로와, 그리고

    메모리 어드레스를 비교하여 메모리 저장에 대한 제1 위치 내의 지시를 검출하는 비교기를 포함하는 것을 특징으로 하는 장치.
22. 제 20 항에 있어서,

    상기 버퍼의 격리 영역은 실행이 완료되지 않은 명령어 시퀀스에 의해 상기 부분의 메모리 저장이 발생되었다는 지시를 갖는 저장 위치의 물리적으로 분리된 부분에 의해 정의되고,

    메모리 어드레스의 액세스에 응답하여 상기 버퍼 내에 홀드된 특정 메모리 어드레스로의 가장 최근의 메모리 저장을 검출하는 상기 논리회로는

    격리 부분내에 이미 존재하는 모든 메모리 저장에 대해 메모리 저장을 기록하는 메모리 어드레스 검출기와,

    메모리 저장이 버퍼의 물리적으로 분리된 모든 부분에 위치된 시퀀스를 지정하는 회로와, 그리고

    메모리 어드레스를 비교하여 버퍼의 일부분의 어떤 저장 위치에서 가장 오래된 메모리 저장을 검출하는 비교기를 포함하는 것을 특징으로 하는 프로세싱 시스템에서 사용하는 장치.
23. 타겟 명령어 시퀀스를 호스트 명령어로 변환하는 호스트 프로세서에 의해 변환된 인터벌 동안에 순차적으로 발생된 모든 메모리 저장을 다른 메모리 저장과는 별도로 일시적으로 홀드하는 수단과;

    변환이 예외를 발생시키지 않고 실행되면, 변환 인터벌 동안 순차적으로 발생된 메모리 저장을 메모리로 전송하는 수단과;

    메모리 어드레스에서의 메모리 액세스에 응답하여 동일한 메모리 어드레스로의 메모리 저장들중 어느 것이 가장 최근의 것인지를 지시하는 수단과; 그리고

    변환이 예외를 발생시키면, 변환 인터벌 동안 순차적으로 발생된 메모리 저장을 소거하는 수단을 포함하는 것을 특징으로 하는 게이트 저장 버퍼.
24. 호스트 명령어 세트의 명령어를 실행하도록 설계된 호스트 프로세서와;

    타겟 명령어 세트로부터의 명령어를 호스트 명령어 세트의 명령어로 변환하는 호스트 소프트웨어와;

    메모리와; 그리고

    호스트 프로세서상의 타겟 명령어 시퀀스를 변환할 때 상기 호스트 소프트웨어에 의해 발생된 데이터를 홀드하는 저장 버퍼를 포함하며,

    상기 저장 버퍼는,

    각각 메모리로 어드레스된 데이터 및 데이터의 어드레스를 홀드할 수 있는 복수의 저장 위치와,

    명령어 시퀀스가 실행을 완료할 때까지 데이터가 발생될 때마다 프로세서의 동작에 의해 발생된 데이터를 상기 저장 위치로 전송하는 수단과,

    실행을 완료하지 않은 명령어 시퀀스에 의해 발생된 버퍼 내의 데이터를 식별하는 수단과,

    메모리 액세스에 응답하여 특정 메모리 어드레스로 보내지는 버퍼 내의 가장 최근의 데이터가 어느 것인지를 검출하는 수단과,

    저장을 발생시키는 명령어 시퀀스가 예외 또는 에러를 발생시키지 않고 실행된 후에, 상기 저장 위치 내의 데이터를 메모리로 전송하는 수단과, 그리고

    저장을 발생시키는 명령어 시퀀스의 실행이 예외 또는 에러를 발생시킬 때, 상기 저장 위치 내의 메모리 저장을 소거하는 수단을 포함하는 것을 특징으로 하는 컴퓨터.
25. 제 24 항에 있어서,

    명령어 시퀀스가 실행을 완료할 때까지 데이터가 발생될 때마다, 프로세스의 동작에 의해 발생된 데이터를 저장 위치로 전송하는 상기 수단은 데이터를 버퍼 내의 연속적인 저장 위치로 전송하는 수단을 포함하며, 그리고

    메모리 액세스에 응답하여 특정 메모리 어드레스로 보내지는 버퍼 내의 가장 최근 데이터가 어느 것인지를 검출하는 상기 수단은 특정 메모리 어드레스로 어드레스된 버퍼 내의 각각의 가장 최근의 어스레스될 수 있는 데이터량을 나타내는 수단을 포함하는 것을 특징으로 하는 컴퓨터.
26. 제 25 항에 있어서,

    실행이 완료되지 않은 명령어 시퀀스에 의해 발생된 버퍼 내의 데이터를 식별하는 상기 수단은 명령어 시퀀스가 실행될 때까지 상기 데이터를 버퍼 내의 다른 데이터로부터 분리하는 수단을 포함하는 것을 특징으로 하는 컴퓨터.
27. 제 26 항에 있어서,

    명령어 시퀀스가 실행될 때까지 상기 데이터를 버퍼 내의 다른 데이터와 분리하는 상기 수단은 버퍼 내의 데이터 시퀀스의 시점과 끝을 나타내는 수단인 것을 특징으로 하는 컴퓨터.
28. 제 27 항에 있어서,

    메모리 액세스에 응답하여 특정 메모리 어드레스로 어드레스된 버퍼 내의 각각의 가장 최근의 어스레스될 수 있는 데이터량을 나타내는 상기 수단은 버퍼 내의 데이터 시퀀스 시점과 끝 사이의 저장 위치에 있는 오래된 데이터를 동일한 메모리 어드레스로 어드레스되고 그리고 아직 실행되지 않은 명령어 시퀀스에 의해 발생되는 새로운 데이터로 치환하는 수단을 포함하는 것을 특징으로 하는 컴퓨터.
29. 제 27 항에 있어서,

    상기 메모리 액세스에 응답하여 특정 메모리 어드레스로 어드레스된 버퍼 내의 각각의 가장 최근의 어스레스될 수 있는 데이터량을 나타내는 수단은,

    버퍼 내에 위치하는 데이터를 가장 최근의 데이터로서 식별하기 위한 어드레스될 수 있는 저장 위치에 대한 제1 지시자와;

    저장 위치 내에 위치하는 데이터의 메모리 어드레스와 저장 위치 내에 이미 존재하는 데이터의 메모리 어드레스를 비교하고, 저장 위치 내에 위치하는 데이터의 메모리 어드레스와 동일한 메모리 어드레스를 갖는 데이터에 대한 치시자를 소거하는 비교기와;

    에러나 예외 없는 명령어 시퀀스의 실행에 응답하여 저장 위치 내의 명령어를 시퀀스에 의해 발생된 가장 최근 데이터로서 식별하기 위한 어스레스될 수 있는 저장 위치에 대한 제2 지시자와; 그리고

    저장을 발생시키는 명령어 시퀀스의 실행이 예외나 에러를 발생시킬 때 버퍼로부터 소거되는 데이터의 메모리 어드레스와, 소거되지 않고 에러나 예외 없는 명령어 시퀀스의 실행에 응답하여 제2 지시자에 의해 명령어 시퀀스에 의해 발생된 가장 최근의 데이터로 식별된 데이터를 식별하는 데이터의 메모리 어드레스를 비교하고, 제1 지시자를 가장 최근의 것으로 기입하는 비교기를 포함하는 것을 특징으로 하는 컴퓨터.
30. 제 24 항에 있어서,

    명령어 시퀀스에 의해 발생된 것으로서 식별된 버퍼 내의 데이터를 소거하는 상기 수단은 명령어 시퀀스를 수행할 때 발생된 에러나 예외에 응답하여 상기 데이터를 무효화시키는 지시자를 포함하는 것을 특징으로 하는 컴퓨터.
31. 제 26 항에 있어서,

    명령어 시퀀스가 실행을 완성할 때까지 상기 데이터를 버퍼 내의 다른 데이터와 분리하는 상기 수단은 아직 실행되지 않은 명령어 시퀀스로부터 데이터를 포함하는 것으로 나타난 버퍼의 물리적으로 분리된 부분에 데이터 시퀀스를 위치시키는 수단을 포함하는 것을 특징으로 하는 컴퓨터.
32. 제 31 항에 있어서,

    메모리 액세스에 응답하여 특정 메모리 어드레스로 어드레스된 버퍼 내의 각각의 가장 최근의 어스레스될 수 있는 데이터량을 나타내는 상기 수단은

    저장 위치에서 아직 실행되지 않은 명령어 시퀀스로부터의 데이터를 포함하는 것으로 나타난 버퍼의 물리적으로 분리된 부분에 있는 저장 위치의 오래된 데이터를 동일한 메모리 어드레스로 어드레스되고, 아직 실행되지 않은 명령어 시퀀스에 의해 발생된 새로운 데이터로 치환하는 수단을 포함하는 것을 특징으로 하는 컴퓨터.
33. 제 31 항에 있어서,

    상기 데이터를 발생시키는 명령어 시퀀스가 예외나 에러를 발생시키지 않고 실행할 때, 저장 위치 내의 데이터를 메모리로 전송하는 상기 수단은 에러 없이 실행된 명령어 시쿼스에 의해 상기 데이터가 발생되었다고 나타내는 수단을 포함하는 것을 특징으로 하는 컴퓨터.
34. 제 31 항에 있어서,

    저장을 발생시키는 명령어 시퀀스가 예외나 에러를 발생하지 않고 실행된 후에, 저장 위치 내의 데이터를 메모리로 전송하는 상기 수단은 에러나 예외 없이 실행된 명령어 시퀀스에 의해 발생된 버퍼 내의 데이터의 메모리 어드레스를 비교하고, 어느 메모리 어드레스에 대해서도 저장을 위해 어스레스될 수 있는 가장 최근의 데이터만을 선택하는 비교기를 포함하는 것을 특징으로 하는 컴퓨터.