KR100601745B1

KR100601745B1 - 다중 데이터형 결과를 발생하는 컴퓨터 명령

Info

Publication number: KR100601745B1
Application number: KR1020007006536A
Authority: KR
Inventors: 데이비드더블유. 트리쎌
Original assignee: 프리스케일 세미컨덕터, 인크.
Priority date: 1997-12-15
Filing date: 1998-12-10
Publication date: 2006-07-19
Also published as: JP4088418B2; WO1999031579A2; US6039765A; WO1999031579A3; EP1040412A2; AU1998399A; JP2002508563A; DE69830804T2; KR20010040298A; DE69830804D1; EP1040412B1; TW446916B

Abstract

소프트웨어 에뮬레이션 및 다른 데이터 처리 동작들을 가속화하는 것은 하나의 소스로부터의 다중 데이터형 결과들을 생성하는 하나의 컴퓨터 명령의 실행을 이용한다. 상기 명령은 후속적으로 실행하는 명령들에 대해 입력 피연산자들로서 이용할 수 있는 대응하는 복수의 레지스터들(102-106)에서의 복수의 상이한 유형의 출력들을 하나의 피연산자로부터 발생시킨다.

다기능 명령 실행 회로, 소프트웨어 저장 매체, 컴퓨터 명령, 자바 바이트코드 해석기, 컴퓨터 소프트웨어, 테이블 엔트리 어드레스, 브랜치

Description

다중 데이터형 결과를 발생하는 컴퓨터 명령{Computer instruction which generates multiple data-type results}

본 출원은 미국 특허출원번호 제08/990780호이다.
본 발명은 일반적으로 컴퓨터에 관한 것으로서, 보다 구체적으로는 해석된 소프트웨어의 실행이나 소프트웨어의 에뮬레이션에 관한 것이다.

컴퓨터 업계에서, 소프트웨어가 다수의 상이한 하드웨어 플랫폼 상에서 실행되는 것을 허용하기 위하여 에뮬레이션 기술 및 해석된 컴퓨터 언어 실행에 대하여 강조되고 있다. 에뮬레이션 및 해석 언어 실행을 이용하는 이점은, 일단 소프트웨어가 하나의 하드웨어 플랫폼상에서의 실행을 위해 기록되면, 동일한 소프트웨어가, 많은 부가적인 노력이 없이도 다른 하드웨어 플랫폼에 이식될 수 있다는 것이다. 그러나, 에뮬레이션 및 해석 언어 실행은 사용자의 소프트웨어 코드의 하드웨어 독립성을 달성하기 위해 사용자의 실행가능한 소프트웨어 코드 및 물리적 하드웨어 간에 여분의 소프트웨어의 레이어(layer)를 필요로 한다. 이 부가적인 소프트웨어의 레이어는 사용자 소프트웨어가 특정 하드웨어 플랫폼에 대해 직접적으로 콤파일링되거나 그 하드웨어 플랫폼 상에서 직접 실행되는 다른 컴퓨터 시스템들에서 통상적으로 발견되지 않는 에뮬레이션 오버헤드이다. 비록 에뮬레이션에서 여분의 소프트웨어의 레이어가 하드웨어의 미묘한 차이들에 상관없이 보다 큰 호환성을 초래할지라도, 사용자 소프트웨어의 실행은 보다 더 느려진다.

컴퓨터 업계의 목표는 소프트웨어의 이 부가적인 레이어의 성능 영향을 감소시켜서 다양한 에뮬레이터들이나 해석된 언어 머신들(예컨대, Java, Smalltalk, BASIC)의 실행 속도를 증가시키는 것이다. 에뮬레이션 오버헤드를 감소시키기 위하여, 업계는 커스터마이즈된 하드웨어를 생산하고 소프트웨어의 중간 레이어를 단순화하여 성능을 향상시키고자 하고 있다. 그러므로, 에뮬레이션/해석 성능이 향상되는 오버헤드를 감소시킨 새로운 에뮬레이션 펫치(fetch) 및 디코드 루틴에 대한 필요성이 존재한다.

일반적으로, 본 발명은 에뮬레이터 시스템에 대한 연산 부호(opcode) 에뮬레이트된 실행 오버헤드 및 펫치 뿐만 아니라 디코드 에뮬레이터 오버헤드를 감소시키기 위한 방법 및 장치이다. 본 명세서에 개시된 시스템은 예를 들어 Java나, Small Talk나, BASIC 컴퓨터 코드의 실행 또는 임의의 컴퓨터 언어의 에뮬레이션을 가능하게 하도록 임의의 유형의 에뮬레이션 또는 해석 언어 실행을 수행하는데 이용될 수 있다. 구체적으로는, 본원에서는 새로운 컴퓨터 명령이 이용되고, 그 새로운 컴퓨터 명령은 각각의 레지스터가 상이한 데이터 포맷으로 결과를 포함하는 다수의 레지스터들 내에 저장되는 복수의 결과들을 발생하기 위하여 명령 피연산자들을 처리한다. 이 명령(본원에서는 축약하여 LGMDT)이 결과에 대해 전처리하거나 상이한 포맷을 이용하여 다른 레지스터들 내에 결과를 제공하므로, 에뮬레이터 루틴들에서 필요로 되는 연산 부호 에뮬레이션 명령들의 수가 감소될 수 있어, 에뮬레이션 또는 해석 언어 실행이 보다 빠른 레이트로 일어날 것이다. 부가적으로, 이 LGMDT 명령으로 인해, 시스템에서 모든 에뮬레이트된 명령에 대하여 실행되는 펫치 및 디코드 에뮬레이션 오버헤드 역시 감소되어, 에뮬레이션 성능이 한층 향상된다. 실험적인 결과들은 본원에서 개시된 방법들을 통해 10% 이상 향상됨을 보여주었다.

본 발명의 특징 및 이점들은 첨부 도면들과 관련하여 기술된 하기의 상세한 설명들로부터 보다 명확히 이해될 것이며, 도면에 있어서 동일한 참조 부호들은 동일하고 대응하는 부분들을 언급하는 것으로 한다.

도 1은 본 발명에 따라 이용하기 위한 에뮬레이터 소프트웨어 아키텍처를 도시하는 블록도.

도 2는 도 1의 소프트웨어 에뮬레이터의 특정 소프트웨어 명령 내용을 도시하는 블록도로서, 상기 소프트웨어 내용은 기술적으로 공지되어 있으며 다량의 에뮬레이션 오버헤드를 갖고 있음을 도시한 도면.

도 3은 본 발명에 따라서 감소된 에뮬레이션 오버헤드를 갖는 도 1의 소프트웨어 에뮬레이터를 실행시키는데 이용될 수 있는 개선된 소프트웨어 명령 내용을 도시하는 도면.

도 4는 본 발명에 따라서 소프트웨어 명령 에뮬레이션 루틴의 벡터 어드레스를 발생시키는 방법을 도시한 블록도.

도 5는 본 발명에 따라서 감소된 에뮬레이션 오버헤드를 갖는 도 1의 소프트웨어 에뮬레이터를 실행하는데 이용될 수 있는 개선된 소프트웨어 명령 내용을 도시하는 블록도.

도 6은 본 발명에 따라서 감소된 에뮬레이션 오버헤드를 갖는 도 1의 소프트웨어 에뮬레이터를 실행하는데 이용될 수 있는 개선된 소프트웨어 명령 내용을 도시하는 블록도.

도 7은 본 발명에 따라서 도 6에서 도시한 소프트웨어를 실행하기 위한 특정 하드웨어를 도시하는 블록도.

도 8은 도 7에 도시된 특정 하드웨어를 포함하는 범용 컴퓨터를 도시하는 블록도.

설명의 단순화 및 명료화를 위하여 첨부 도면에 도시된 구성요소들은 일정 비례에 따라 도시되어 있지 않음을 이해하기로 한다. 예컨대, 몇몇 구성 요소들의 치수들은 명료화를 위해 다른 구성요소들에 대해 확대되어 있다. 또한, 이해를 고려하여, 참조부호들은 대응하거나 유사한 구성요소들을 나타내도록 전체 도면에 걸쳐 반복 사용하였다.

본 발명은 도면의 도 1 내지 도 8을 참조하여 한층 더 이해될 수 있다. 도 1은 본 발명에 따라 에뮬레이션을 행하거나 해석 언어 실행을 수행하기 위해 이용되는 에뮬레이션 시스템(10)의 블록도이다. 이 에뮬레이션 시스템(10)은 다수의 부분들/루틴들 각각이 하나 이상의 소프트웨어 명령들을 포함하는 상기 다수의 부분들/루틴들로 구성된다. 도 1은 하나의 그러한 부분/루틴이 셋업 코드(11)임을 도시하며, 그 셋업 코드(11)는 적절한 소프트웨어 에뮬레이션을 가능하게 하도록 레지스터들을 초기화하는 컴퓨터 명령들을 포함한다. 에뮬레이션 시스템(10)은 또한 어느 벡터 에뮬레이션 루틴이 실행되어야 하는가를 결정하기 위하여 메모리(124)(도 8 참조)로부터 명령 에뮬레이션 연산 부호들 및 피연산자 데이터를 반복적으로 펫치하고 그 명령에 대해 적절한 디코드 동작을 수행하는 펫치-및-디코드 루프(12)를 포함한다. 상기 루틴(12)에 의해 행해진 "디코드" 처리는 일반적으로 테이블(14) 내의 하나 이상의 에뮬레이션 루틴들로 에뮬레이션 소프트웨어 실행 흐름을 루팅하는 테이블 벡터 어드레스의 발생을 포함한다.

도 1은 룩업 테이블(14)내의 복수의 벡터 에뮬레이션 루틴을 도시한다. 도 1의 벡터 에뮬레이션 루틴(14)은 구체적으로 5개의 에뮬레이션 루틴들(16-24)을 도시하고 있다. 그러나, 이것은 단지 예일 뿐이며 임의의 수의 에뮬레이션 루틴들을 사용할 수도 있다. 도 1의 각각의 루틴(16-24)는 16개의 32비트 워드 정보를 포함한다. 그러므로, 제 1 에뮬레이션 루틴은 바이트 레벨 어드레싱을 이용하는 경우에 도 1의 TABLEBASE로서 언급되는 어드레스에서 시작되고 어드레스 TABLEBASE+63에서 종료된다. 제 2 에뮬레이션 루틴은 도 1에서 TABLEBASE+64로서 레이블링된 어드레스에서 시작되고 또한 메모리 어레이 내의 64바이트(즉, 16워드)에서 종료된다. 64바이트가 특정 명령을 에뮬레이트하는데 충분한 공간이 아닌 경우에, 그 특정 명령의 에뮬레이션을 완료하기 위하여 브랜치 또는 점프 명령은 테이블(14)내의 블록의 끝에서 이용되어 테이블(14) 이외의 또다른 위치로 브랜치/점프한다. 각각의 에뮬레이션 루틴은 에뮬레이션 루틴을 저장할 수 있는 64바이트(즉, 16워드)의 공간씩 할당되므로, 각각의 에뮬레이션 루틴은 어드레스 TABLEBASE로부터 64의 배수인 어드레스 값에서 시작된다. 그리고 64바이트 이외의 크기의 테이블 엔트리들도 사용될 수 있음을 유의한다.

도 1은 어드레스 TABLEADDRESS에서 시작되고 어드레스 TABLEADDRESS+63에서 종료되는 NOP(no operation) 루틴을 도시한다. 루틴을 위해 제공된 테이블 공간의 전부가 각각의 루틴에 사용될 필요는 없으므로 약간의 소모 공간이 쉽게 허용될 수 있게 된다. 도 1은 또한 BIPUSH(byte integer push) 명령에 대한 BIPUSH 루틴을 도시한다. BIPUSH 루틴은 어드레스 TABLEBASE+64×N에 위치한다. 이 BIPUSH 루틴(20)은 에뮬레이션 동안에 바이트 정수 푸쉬(push)를 수행하는 컴퓨터 명령을 포함한다. 도 1에서의 에뮬레이션 POP 루틴(22)은 어드레스 TABLEBASE+64×M에서 시작되고 메모리 내의 피연산자 스택의 탑 워드를 POP하기 위하여 이용되는 컴퓨터 명령을 포함한다. 도 1에서의 최종 에뮬레이션 루틴(24)은 어드레스 TABLEBASE+64×255에서 시작되는 것으로서 도시되어 있다. 다시 말해서, 도 1은 도 1의 테이블(14)내에 2⁸=256루틴들이 있는 것을 구체적으로 도시한다. 이 256 루틴 실시예에서, Java에서 이용되는 바와 같이 단일 연산 부호 바이트만이 도 1의 256 루틴들중 어느 한 루틴에 대해 어드레스 지정할 수 있다. 임의의 수의 루틴들이 이용될 수 있으므로 Java, Pentium 코드, BASIC, Smalltalk 등 중에서 어느 하나의 에뮬레이션이 본원에서 개시한 방법을 이용하여 수행될 수 있다.

도 2는 도 1에서 앞서 설명한 다양한 기능들을 구현하기 위해 이용되는 특정 소프트웨어 코드를 도시한다. 예를 들면, 도 2는 도 1로부터 셋업 코드(11)를 구현하는데 이용되는 특정 명령(들)을 도시한다. 도 2는 LA(load address) 명령이 어셈블러-결정된 TABLEBASE 어드레스를 TABLEBASE 레지스터 내로 복사하기 위하여, 셋업 코드(11)의 일부로서 실행되고, 여기서 CPU(central processing unit) 하드웨어 레지스터는 RTABLEBASE로 언급한다. 상기 LA 명령에 부가적으로, 에뮬레이션 또는 해석된 언어 실행을 위한 하드웨어 시스템을 준비하도록 도 2에서의 셋업 코드(11)의 일부로서 다른 명령들을 실행할 수도 있다.

셋업 코드(11)의 실행 이후에, 도 2의 펫치 및 디코드 루프(12)가 실행된다. 도 2에서의 펫치/디코드 루프(12)는 컴퓨터 코드(12)를 실행하는 경우에 어드레스들을 상징적으로 설명하는 "FETCH" 및 "FETCH2"라 표기된 두 개의 어셈블러를 포함한다. 펫치 및 디코드 유닛(12)의 펫치 및 디코드 동작은 갱신을 갖는 로드 바이트 제로(LBZU: load byte zero with update) 명령을 실행함으로써 시작된다. 이 명령의 실행은 ROPCODE라고 언급되는 CPU 하드웨어 레지스터 내로 프로그램 카운터 레지스터(RPC)내에 저장된 어드레스로부터의 연산 부호를 로드한다. 구체적으로는, 도 2의 루프(12)에서의 제 1 LBZU 명령은 정수 1을 프로그램 카운터 레지스터(RPC)에 부가하고, 이 증분된 어드레스를 메모리로부터 연산 부호를 액세스하여 ROPCODE 레지스터에 그 연산 부호를 저장하는데 이용한다. ROPCODE 레지스터 값은 Java를 위한 256개의 고유한 값들 중 하나를 포함할 수 있는 32비트 길이의 값이다. 이 8비트의 고유 연산 부호 값은 도 2의 테이블(14)내의 특정 에뮬레이션 루틴을 액세스하도록 인덱스 값으로서 이용된다. 테이블(14)내의 루틴들이 길이에 있어 16워드(또는 64바이트)의 메모리의 블록들이므로, 도 2에서의 제 1 LBZU 명령을 통해 판독된 연산 부호 값은 6비트 위치들만큼 좌측으로 시프트되어야 한다. 이 인덱스 시프트 기능을 수행하기 위하여, SWLI(shift word left immediate) 명령이 6비트 위치만큼의 ROPCODE 레지스터 좌측에 저장된 값을 시프트하는데 이용되어 그 시프트된 결과가 ROPCODE에 다시 저장된다.

그리고 ADD 명령은 RTABLEBASE 레지스터내에 저장된 TABLEBASE 어드레스와 ROPCODE 레지스터 내에 저장된 시프트된 인덱스를 부가하는 데 이용된다. RTABLEBASE 레지스터 값 및 ROPCODE 레지스터 값의 이러한 가산은 RTEMP로 표기된 임시 레지스터인 목적지 내로 수행된다. 이제 RTEMP 값은 원하는 컴퓨터 명령의 적합한 에뮬레이션을 수행하기 위하여 에뮬레이터에 의해 실행되어야 하는 테이블(14)내의 특정 에뮬레이터 명령의 어드레스를 포함한다.

테이블(14)내의 특정 에뮬레이션 루틴으로 적당히 브랜치하기 위하여, 카운트 레지스터로의 이동(MTCTR:move to count register) 명령이 CPU 하드웨어 아키텍처 내의 카운트 레지스터(RCTR)로 RTEMP 레지스터에 저장된 어드레스를 이동시키도록 실행된다. 카운트 레지스터는 CPU의 브랜치 처리 유닛(BPU: branch processing unit)에 연결되는 경우 CPU 또는 프로세서의 아키텍처의 내부에 있는 레지스터이다. 루틴(12)에서의 MTCTR 명령을 뒤따르는 후속하는 브랜치 카운터 레지스터(BCTR: branch count register) 명령은 에뮬레이트된 프로그램으로 하여금 카운트 레지스터 내에 저장된 어드레스로 브랜치하여 테이블(14)내의 루틴으로의 실행 흐름의 변화를 가능하게 한다. 도 2에 도시된 바와 같이, 펫치 디코드 루프(12)에서의 최종 명령은 테이블(14)내의 루틴들중 어느 하나의 후속적인 실행을 허용할 BCTR 명령이다.

도 2의 루틴(12)에서 MTCTR 명령 및 BCTR 명령의 실행 사이에, 프리펫치(prefetch) 동작이 수행된다. 프리펫치 동작은 도 2에서의 펫치 디코드 루프(12)의 끝 부근에서 부가적인 LBZU 명령을 실행함으로써 수행된다. 루틴(12)내의 이 제 2 LBZU 명령은 1만큼 프로그램 카운터 레지스터(RPC)를 증분시키고 다음으로 그 증분된 프로그램 카운터 값에 위치한 메모리로부터 데이터 값을 액세스한다. 이 때에, 그 프로그램은 이 제 2 LBZU 명령을 통해 액세스된 데이터가 에뮬레이션 데이터 피연산자인지 또는 새로운 에뮬레이션 명령 연산 부호인지에 관해 불확실하다. 상기 프리펫치 명령으로부터 무엇이 포함되는가의 결정은 도 2의 루틴(12)에서 BCTR 명령의 실행에 후속하여 테이블(14)내에서 실행된 코드에 의해 이루어진다.

도 2는 도 1에서 처음으로 도시된 세 개의 에뮬레이션 루틴들(16, 20, 22)을 구체적으로 도시한다. 루틴(16)은 테이블(14)내의 제 1 루틴이고 제로(예컨대, 00000000 이진수)의 8비트 연산 부호 값에 의해 액세스된다. 모두 제로인 값을 갖는 연산 부호가 루틴(12)에 의해 판독되는 경우, 이 제로 값은 TABLEBASE값에 대한 인덱스로서 시프트되고 부가되어서, RTEMP 레지스터가 TABLEBASE+0을 포함할 것이다. 판독된 연산 부호가 제로인 경우, 루틴(12)에서의 BCTR 명령의 실행은 BCTR 명령의 실행이후에 테이블(14)내의 루틴(16)에서의 소프트웨어 명령들의 실행을 초래할 것이다. 루틴(16)은 NOP(no-operation) 루틴을 구현하여, 어떠한 기능 동작도 시스템에 의해 수행되지 않고, 상기 시스템은 단지 시간을 스톨링(stall)하기를 시도한다. 루틴(16)에 의해 어떠한 동작도 수행되지 않기 때문에, 루틴(16)은 단순히 도 2의 펫치 디코드 루프(12)내에 브랜치 백(branch back)을 포함한다. 루틴(16)이 NOP 명령 에뮬레이션 루틴이고 NOP 명령이 어떤 피연산자들도 갖지 못하기 때문에, 루틴(16)은 루틴(12)에서의 제 2 LBZU 명령으로부터의 프리펫치 값이 연산 부호가고 데이터/피연산자가 아님을 이해한다. 이것이 의미하는 바는, 루틴(12)에서의 제 2 LBZU 명령을 통해 액세스된 메모리로부터의 프리펫치된 값이 연산 부호인 것을 의미한다. 이 프리펫치 값이 연산 부호가기 때문에, 루틴(16)은 연산 부호로서 프리펫치된 값을 처리하기 위하여 루틴(12)에서 레이블링된 FETCH2로 브랜치될 것이다. 테이블(14)에서의 모든 루틴들의 끝에서 FETCH2 또는 FETCH 브랜치를 수행함으로써, 계속되는 루핑과 펫치 및 디코드 동작들의 실행은 소프트웨어가 종료될 때까지 에뮬레이터에 의해 수행된다.

도 2의 루틴(12)을 통해 판독된 연산 부호가 이진 값 N(예컨대, N=01101100 이진수)인 경우, 루틴(12)의 실행 이후에 카운트 레지스터 및 RTEMP값은 값 TABLEBASE+N×64를 포함할 것이다. 따라서, 루틴(12)의 끝에서 BCTR 명령은 테이블(14)의 루틴(20)내 명령들이 실행되도록 실행 흐름의 변화를 야기한다. 루틴(20)에 있어서, 제 1 명령은 ROPCODE의 내용에 대해 수행되는 EXTSB(extend sign byte) 명령이다. BIPUSH 명령이 적절한 에뮬레이션을 위해 필요로 되는 하나의 명령 피연산자를 포함하는 에뮬레이트된 명령이기 때문에 루틴(12)에서의 제 2 LBZU 명령에 의해 검색된 프리펫치값이 데이터 값을 나타내야 된다는 것이 루틴(20)에 의해 이해되어야 하므로 이 동작은 연산 부호 레지스터 상에서 수행된다. 확장 부호(sign) 바이트 명령은, 루틴(20)에 의해 수행되는 BIPUSH 동작이, 명령 LBZU이 부호없는(unsigned) 8비트값만을 32비트 공간 내에서 판독하는 경우에 부호있는(signed) 데이터 값을 필요로 하기 때문에, 실행되어야 한다.

ROPCODE 레지스터 내의 값의 부호를 확장한 이후에, STWU(store word with update) 명령이 실행된다. 이 명령은 먼저 Java 스택 포인터(RSP)를 4만큼 감소시키고나서 다음으로 ROPCODE의 32비트(4바이트)값을 상기 RSP 위치에 배치함으로써 자바 피연산자 스택상으로 ROPCODE 내의 값을 푸쉬한다. 그 스택이 루틴(20)내의 코드에 의해 적절하게 처리된 후에, 브랜치는 루틴(12)내의 어셈블러 라벨 FETCH에 다시 수행된다. 루틴(20)의 브랜치는 루틴(20)이 루틴(12)으로부터 프리펫치 바이트를 사용/소모했고 새로운 명령 펫치에 따라 루틴(12)를 시작해야 하므로 라벨 FETCH2로는 복귀하지 않는다.

루틴(12)에 의해 판독된 연산 부호가 M(예컨대, M=11100110 이진수)인 경우에, RTEMP값 및 루틴(12)의 끝에서의 카운트 레지스터는 TABLEBASE+M×64일 것이다. 이 경우에, 루틴(12)의 끝에서의 BCTR 명령은 테이블(14)내의 루틴(22)에 따라 계속되는 실행 흐름을 초래할 것이다. 루틴(22)은 피연산자 스택에 대해 POP 동작을 수행한다. 이 POP 동작을 수행하기 위하여, LA(load address) 명령이 피연산자 스택 포인터(RSP)를 이용하여 행하여진다. 이 로드 어드레스 명령은 피연산자 스택 포인터에 4의 값을 가산하고 피연산자 스택으로부터 하나의 워드를 효과적으로 제거하는 스택 포인터(RSP)내에 상기 어드레스 값을 다시 배치한다. 이 어드레스 처리가 루틴(22)에서 수행된 이후에, POP 동작은 완료되고 실행은 루틴(12)내의 라벨 FETCH2로 복귀하고, 이는 루틴(12)에서의 제 2 LBZU 명령으로부터 프리펫치된 값이 루틴(12)에서의 제 1 LBZU 명령을 통해 또다른 새로운 명령 펫치에 대한 필요없이 루틴(12)에서의 연산 부호로서 현재 처리되어야 하는 연산 부호를 포함하기 때문이다.

그러므로, 도 2는 외부 메모리로부터 하나 이상의 연산 부호 및 데이터를 검색하도록 루핑 방식으로 실행하는 특정 에뮬레이터 루틴(12)을 도시한다. 루틴(12)을 통해 판독된 연산 부호들은 특정 연산 부호에 대한 에뮬레이션 루틴들을 불러내기 위해 브랜치 명령 BCTR에 의해 사용되는 적절한 소프트웨어 에뮬레이션 벡터를 도출하기 위해 처리된다. 명령 BCTR을 수행함으로써, 테이블(14)내의 각각의 루틴들이 적절하게 실행되어, 펫치된 모든 루틴들이 결국 디코드 루틴(12)으로 실행 제어를 복귀시킨다. 반복적인 에뮬레이션/해석은 그 프로그램이 종료될 때까지 이런 루핑 방식으로 계속된다.

도 2는 에뮬레이션 및 해석 언어 실행에 대한 에뮬레이션 오버헤드의 효과들을 설명하는데 이용될 수 있다. 오버헤드의 한 예로서, 도 2에서의 루틴(22)은 POP 동작을 수행한다. 에뮬레이션 환경을 이용하여 이 POP 동작을 수행하기 위하여, 루틴(12)으로부터의 6개의 명령들 및 루틴(22)으로부터의 2개의 명령이 에뮬레이트된 POP 동작을 수행하기 위하여 실행되어야 한다. 그러나, 조합된 루틴들(12, 22)내의 상기 총 8개의 명령들 중에서, 이들 8개 명령들("LA RSP, 4(RSP)" 명령)중의 하나만이 실제적인 POP 동작을 수행하고, 8개의 명령들 중 나머지 7개의 명령은 에뮬레이션 오버헤드의 일부로서 실행된다. 그 결과로 얻어진 POP 에뮬레이션 오버헤드는 도 2의 처리에 대해 80%이상이다. 또한, 도 2의 루틴(12)이 에뮬레이션을 필요로 하는 모든 명령에 대해 실행되기 때문에, 루틴(12) 내의 임의의 오버헤드는 에뮬레이션의 전체 성능에 크게 영향을 미치고, 이는 루틴(12)이 루핑 방식으로 계속적으로 재실행되기 때문이다. 따라서, 루틴(12)에 대한 명령 카운트의 임의의 감소는 모든 에뮬레이트된 명령에 대해 필요로 되는 루프 실행 오버헤드를 크게 감소시킴으로써 에뮬레이션의 전체 성능에 크게 영향을 줄 수 있다. 또한, 펫치 및 디코드 루프(12)가 조정될 수 있어서 테이블(14)의 루틴들(16-22)내에 위치한 코드가 보다 더 적은 명령들로 최적화될 수 있는 경우에, 에뮬레이션 동안에 성능 향상이 더 커질 수 있다.

이 오버헤드 및 성능 감소는 도 1의 아키텍처를 이용하여 도 3-7을 통해 얻어진다. 도 3은 도 2에 도시된 종래의 펫치 및 디코드 루프(12) 대신에 이용될 수 있는 새로운 펫치 및 디코드 루프(12')를 도시한다. 도 3에서의 새로운 펫치 및 디코드 루프(12')는 TABLEBASE 어드레스값이 메모리 맵내의 16K 바이트 다중 어드레스(예컨대, 32K, 128K, 2048K 등)에 위치되고 있어야 하는 것을 필요로 한다. 일단 이 L*16K TABLEBASE값이 설정되면(L은 유한한 양의 정수), 도 3의 코드는 도 2로부터 펫치 및 디코드 루프(12)의 오버헤드를 감소시키는데 이용될 수 있다.

도 3에서 코드는 도 2에 관해 앞서 논의된 동일한 LBZU 명령을 수행함으로써 시작된다. 그러나, 도 3은 도 2의 SWLI 및 ADD 명령을,"워드 즉시 값(word immediate value)을 갖는 레지스터의 우측으로부터 삽입"을 나타내는 단일 명령 INSRWI으로 대체한다. 상기 INSRWI 명령에 의해 수행된 동작은 도 4의 블록도에서 한층 더 잘 설명되어 있다.

도 4는 TABLEBASE값이 16K 메모리 경계상에 위치되는 것을 도시한다. TABLEBASE값이 그와 같이 위치되기 때문에, 위치 0부터 비트 위치 17까지의 MSB(most significant bit)는 TABLEBASE값의 상위 비트들(higher order bits)을 포함하고, TABLEBASE 값의 하위 비트 위치들 18 내지 31은 고유의 이진값 0를 갖는다. INSRWI 명령은 ROPCODE 레지스터에 저장되는 연산 부호 값을 취하여 이 값을 6만큼 시프트한다. 이러한 좌측으로의 6비트 위치들의 시프트는 도 4에 도시된 바와 같이 RTABLEBASE 레지스터의 비트 위치들 18 내지 25 내로 연산 부호 값을 정렬한다. 다음으로, 이 시프트된 연산 부호 값은 TABLEBASE값의 16K 바이트 얼라인먼트로 인해 앞의 0이었던 도 4의 비트 위치들 18 내지 25 내로 ADD 명령의 필요없이도 직접적으로 삽입될 수 있다. INSRWI 명령은 값 8 및 6을 지정하는 명령 피연산자를 가지며, 6비트 위치들만큼 시프트 동작을 수행한 이후에 RTABLEBASE내로 8비트가 삽입되어야 함을 지시한다. 이들 8개의 연산 부호 비트들은 RTABLEBASE 베이스 어드레스에서의 이진수 0 논리값들로 충전되었던 부분 내의 RTABLEBASE 레지스터내에 삽입되기 때문에, 어떠한 부가 동작도 수행되는 것을 필요치 않으므로, 루틴(12)에 비해 루틴(12')에서 명령이 절약된다. 또한, 하위 비트 위치들 26-31은 도 4에 도시된 대로 0으로서 유지된다. 이들 하위 0 비트 값들은 테이블(14)이 길이가 16 워드들인 루틴을 포함하기 때문에 필요하게 된다. 따라서, TABLEBASE값을 적절히 위치시키고 조정함으로써 하나의 명령 INSRWI이 도 2로부터 이전 두 명령들 RWLI 및 ADD를 대체하기 위하여 도 3에서 사용된다. 도 2에 도시된 것에 비해 루틴(12')의 이같은 단순화만으로 자바에 기초한 에뮬레이터의 성능을 약 10% 향상시킨다는 것을 실험적으로 보여 주었다.

도 3에서의 INSRWI 명령을 수행한 이후에, RTABLEBASE에 저장된 값은 카운트 레지스터(RCTR)로 이동되고 프리펫치 동작 LBZU가 행하여진다. 이들 명령들 MTCTR 및 LBZU는 도 2에서 앞서 논의한 것과 유사하다. 프리펫치 LBZU 동작의 실행 이후에, 브랜치 카운트 레지스터(BCTR) 명령은 테이블(14)에 위치한 루틴들(16-24)중 어느 하나에서의 에뮬레이터의 실행 흐름을 계속하도록 이용된다.

도 3 및 도 4의 방법은 도 2의 종래 루틴에 비해 향상된 것이고, 도 5의 루틴은 도 3에서 논의한 것에 비해 부가적인 성능 이점을 얻을 수 있다. 도 5는 도 2 및 도 3에 도시된 것에 비해 한층 더 최적화된 새로운 펫치 및 디코드 루프(12")를 도시한다. 또한, 도 5의 루틴(12")은 테이블(14)에 위치된 개별 명령 에뮬레이션 루틴들(16-24)의 최적화를 향상시킬 수 있다. 구체적으로는, 도 2의 BIPUSH 루틴(20)은 도 5에서의 펫치 디코드 루프(12")에서의 변화들로 인해 도 5의 BIPUSH 루틴(20")으로 단순화될 수 있다.

도 5의 펫치 및 디코드 루프(12")는 도 3에 관해 앞서 논의한 대로 LBZU 명령 및 INSRWI 명령을 실행함으로써 시작한다. 따라서, 도 5의 처리는 도 3의 에뮬레이션 방법에 대해 앞서 논의했던 이점들 모두를 갖고 있다. 도 5에서의 상기 두 명령들을 실행한 후에, RTABLEBASE 레지스터는 테이블(14)에 의해 실행하기 위하여 에뮬레이션 루틴의 벡터 어드레스를 포함한다. RTABLEBASE 내의 벡터 어드레스는 MTCTR 명령을 통해 카운트 레지스터(RCTR)로 RTABLEBASE에서의 값을 이동시킴으로써 보존된다. MTCTR 명령의 실행 이후에, LGMDT(load and generate multiple data types)라고 언급되는 새로운 명령이 수행된다. LGMDT는 일반적으로 메모리 또는 유사한 소스로부터의 입력값을 로드하고 그 입력값으로부터 복수의 결과값들을 발생하는 임의의 실행가능한 컴퓨터 명령이고, 각각의 결과값은 상이한 데이터 포맷을 갖는다. LGMDT 명령은 일반적으로 복수의 CPU 레지스터들 내의 상이한 레지스터들에 대해 상이한 데이터 포맷을 갖는 각각의 결과값들을 저장해서, 에뮬레이터는 LGMDT 명령의 실행에 이어서 데이터 포맷들 중 임의의 한 포맷을 이용할 수 있다.

구체적으로는, 도 5에 도시된 LGMDT 명령은 자바 프로그램 카운터(RPC)를 1씩 증분하고 자바 프로그램 카운터(RPC)에 의해 지시된 어드레스로부터 바이트값(즉, 8비트)을 판독한다. 그 바이트 값이 실제적으로는 메모리로부터 판독된 연산 부호일지라도, 도 5에서의 LGMDT 명령은 메모리로부터 판독된 바이트값을 데이터 피연산자로서 취급한다. 데이터 피연산자로서 바이트 값을 취급함으로써, LGMDT 명령은 판독된 데이터 바이트를 32비트 부호있는 및 부호없는 데이터값으로 변환하며, 부호없는 데이터값은 제 1 ROPCODE 레지스터(예컨대, ROPCODE 레지스터)에 저장되고 부호있는 데이터 값은 제 2 ROPCODE 레지스터(예컨대, ROPCODE+1 레지스터)에 저장된다. LGMDT 명령의 실행 이후에, BCTR 명령은 아래에서 논의한 대로 테이블(14)내의 루틴들중 하나를 실행하도록 실행 흐름을 변화시키는데 이용된다.

도 5는 BIPUSH 명령의 이용을 통해 LGMDT 명령의 이점을 구체적으로 도시하고 있다. BIPUSH 루틴(20")은 루틴(12")에서의 LGMDT 명령의 존재로 인해 도 5에서는 단순화되어 있다. LGMDT 명령의 실행으로 인해, 도 2에 도시된 바와 같은 루틴(20)에서 앞서 존재하는 확장 부호 바이트 명령은 도 5의 루틴(20")에서 제거될 수 있다. 이 제거는 LGMDT 명령이 테이블(14)내의 루틴들에 대한 부호있는 및 부호없는 결과들 모두를 사용을 위해 제공하기 때문에 허용된다. 부가적으로, 루틴(20")에서의 STWU 명령은 도 2에 도시된 대로 ROPCODE 위치를 액세스하지만, 루틴(12")에서의 LGMDT 명령에 의해 발생된 부호있는 값을 포함하는 ROPCODE+1 레지스터를 액세스할 것이다. 레지스터 ROPCODE는 루틴(20")에 의해 필요로 되지 않는 부호없는 값을 포함한다. 따라서, 비교에 의해, BIPUSH 명령을 에뮬레이트하기 위하여는 9개의 명령들이 도 2에서는 필요한 반면, 도 5의 해법을 이용하면 BIPUSH 명령을 에뮬레이트하기 위하여는 7개의 명령만이 요구된다.

도 6은 도 5에 도시된 것보다 더 나은 성능 향상 및 오버헤드의 감소를 도시하고 있다. 도 6은 도 5에 도시된 것보다 보다 복잡하고 확장된 LGMDT 명령을 도시한다. 그러나, 이 개선된 LGMDT 명령은 에뮬레이션 시스템(10)을 이용하여 수행된 에뮬레이션 알고리즘을 한층 단순화하는데 이용될 수 있다. 도 6에서의 LGMDT 명령은 4개의 명령 피연산자들을 포함한다. 제 1 피연산자는 ROPCODE 레지스터 목적지이고, 제 2 피연산자는 자바 프로그램 카운터(RPC)를 이용하여 메모리로부터 펫치하기 위한 다음 연산 부호의 어드레스이며, 제 3 피연산자는 외부 메모리(예컨대, 본 예에서는 8)로부터 판독된 연산 부호에서의 비트 수이고, LGMDT 명령에 대한 제 4 피연산자는 벡터 발생(예컨대, 본 예에서는 6) 이전에 연산 부호를 좌측으로 시프트해야 하는 비트 위치들의 수이다. LGMDT 명령에 대한 피연산자들은 LGMDT 명령 디코드 처리 시 또는 하드웨어에서의 특정 값들 또는 위치들로 어떤 피연산자들을 고정 또는 하드와이어링함으로써 감소될 수 있다는 점을 유의하는 것이 중요하다. 예를 들어, 6의 좌측 시프트값 및 8의 비트 크기는 LGMDT 명령으로 "하드와이어될(hard wired)" 수 있으므로, 이들 파라미터들은 프로그램이 불가능하지만, 명령의 실행에 의해 고정될 것이다.

LGMDT 명령은 외부 메모리로부터 8비트 값을 판독할 것이고 3개의 상이한 내부 CPU 레지스터들에서 3개의 결과를 발생한다. 도 6에서 LGMDT 명령에 의해 발생된 제 1 값은 도 4 또는 유사한 처리에 따라서 발생되는 벡터 어드레스이다. LGMDT 명령에 의해 발생된 제 2 값은 도 5에 대해 앞서 논의한 대로 부호없는 32비트 피연산자/데이터 값이다. 도 6에서의 LGMDT 명령에 의해 발생된 제 3 값은 연산 부호로부터 발생되고 내부 ROPCODE 레지스터들중의 하나에 배치되는 부호있는 32비트 피연산자/데이터 값이다. 일반적으로, LGMDT 명령으로부터의 벡터 어드레스들은 ROPCODE+2 레지스터에 배치되고, 부호있는 32비트 피연산자/데이터 값은 ROPCODE+1 레지스터에 배치되며, 부호없는 32비트 피연산자/데이터 값은 ROPCODE 레지스터에 배치된다. 주어진 LGMDT 명령으로부터의 3개의 결과들의 배치의 경우에, MTCTR은 ROPCODE+2 레지스터의 내용을 카운트 레지스터(RCTR)에 이동시킨다. 제 2 LGMDT 명령은 새로운 연산 부호, 부호있는 피연산자 또는 부호없는 피연산자 중 어느 하나의 사전 펫치를 가능하게 하도록 실행된다. BCTR 명령은 테이블(14)내에 위치된 루틴들 중 하나에서 계속되도록 실행 흐름을 허용한다.

도 6은 BIPUSH 동작(20"')을 구체적으로 도시한다. 루틴(20"')은 도 5에 관해 논의된 것과 유사하다.

도 6은 POP 동작(22"')을 도시한다. LGMDT 명령은 32비트 부호있는 및 부호없는 데이터 값들에 부가하여 벡터 계산을 제공했기 때문에, 도 6의 루틴(22"')은 도 5 및 도 2에 각각 도시된 바와 같이 INSRWI 명령이나 SWLI 명령으로 복귀하는 대신에 MTCTR 명령으로 복귀할 수 있다. 다시 말하면, 루틴(22"')은 카운트 레지스터(RCTR)를 갱신하는 루틴(12"')내의 위치로 간단하게 복귀할 수 있고, 카운트 레지스터로의 그러한 이동을 수행하기 전에 임의의 레지스터들의 전처리를 수행할 필요는 없다. 그러므로, 도 6에 이용된 코드는 POP 동작(22"')의 실행에서 하나의 명령을 절약하며, BIPUSH 동작(20"')을 실행하는 경우에 도 5에 도시된 것에 비해 추가적으로 하나의 명령을 절약한다. 필수적으로, 도 6에 이용된 코드는 BIPUSH 동작을 수행하기 위하여 6개의 명령을 필요로 하는 반면, 종래 기술은 도 2에서의 동일한 BIPUSH 처리를 행하기 위하여 9개의 동작들을 필요로 했다. 이것은 BIPUSH 루틴에서의 명령 이용에 있어서 30%이상의 절약이다. 에뮬레이션 패키지 또는 해석 언어 시스템에서 다른 모든 명령들에 대해 유사한 절약을 찾아 볼 수 있다. 요약하자면, 코드 에뮬레이션 및 해석 언어 실행에서의 오버헤드의 감소를 허용하는 본원에서 소개한 다양한 새로운 명령들에 의해, 컴퓨터의 기능은 크게 향상될 수 있다.

도 7은 도 6에 도시된 LGMDT 명령을 구현하는데 이용될 수 있는 레지스터 파일(100) 및 로드 유닛(101)을 도시한다. 레지스터 파일(100)은 6개의 레지스터들(ROPCODE 102, ROPCODE+1 104, ROPCODE+2 또는 RTABLEBASE 106, RSP 108, RPC 110, RCTR 112)를 포함하는 것으로 도시되어 있다. CPU 하드웨어 RSP(108) 레지스터는 피연산자 "스택 포인터(stack pointer)"이고, RPC(110) 레지스터는 에뮬레이션 "프로그램 카운터(program counter)"이며, RCTR(112) 레지스터는 브랜치 유닛을 이용하여 브랜치 동작을 수행하는 CPU "카운트 레지스터(count register)"이다. RSP(108) 및 RPC(110) 레지스터들은 로드 유닛(101)이 캐쉬 및/또는 외부 메모리로부터 정보를 판독하는 것을 허용한다.

로드 유닛(101)은 LGMDT 명령에 응답하여 메모리로부터 바이트를 판독한다. 이 바이트는 3개의 로드 서브유닛들(114, 116, 118)과 병렬로 제공된다. 제로 확장 유닛은 바이트 값이 부호없는 피연산자인 것처럼 32비트 부호없는 값으로 그 바이트 값을 확장시킨다. 이 부호없는 피연산자는 ROPCODE 레지스터(102)에 제공된다. 그 바이트 값은 부호 확장 유닛(116)을 이용하여 확장된 부호이다. 부호 확장 유닛(116)은 ROPCODE+1 레지스터(104)(이것은 ROPCODE 레지스터 102보다 숫자적으로 1 더 큰 레지스터임)를 액세스함으로써 부호있는 피연산자로서 이용하기 위해 32비트 부호있는 값으로 바이트 값을 변환한다. 도 7의 벡터 비트 처리기(118)는 SWLI 및 ADD 명령들의 시프트 및 부가 동작을 수행하거나, 도 4에서 논의된 동작을 수행하여, 테이블(14)내의 적어도 하나의 루틴을 액세스하는데 이용된 룩업 벡터로, RTABLEBASE/ROPCODE+2 및 바이트 값을 변환한다. 테이블(14) 및 루틴(12)에서의 코드는 필요한 값을 얻기 위하여 3개의 레지스터들 중 어느 하나를 액세스하고 레지스터들(102-106)내의 다른 모든 불필요한 값들을 무시할 수 있다.

도 8은 도 7에 도시된 로드/저장 유닛(101) 및 레지스터 파일(100)을 포함하는 범용 컴퓨터(120)를 도시하는 블록도이다. 범용 컴퓨터(120)는 로드/저장 유닛(101) 및 레지스터 파일(100)을 포함하는 CPU 또는 프로세서(122)를 갖는다. 메모리(124)는 버스(126)에 의해 프로세서(122)에 접속된다. 메모리(124)는 비교적 고속의 기기 판독가능 매체이고, DRAM 및 SRAM 등의 휘발성 메모리, 및 ROM, FLASH, EPROM, EEPROM, 및 버블 메모리 등의 비휘발성 메모리를 포함한다. 또한, 버스(126)에는 제 2 저장부(130), 외부 저장부(132), 모니터(134)와 같은 출력 디바이스들, 키보드(마우스 구비)(136)와 같은 입력 디바이스들, 및 프린터(138)들이 접속된다. 제 2 저장부(130)는 하드디스크 드라이브들, 자기 드럼, 버블 메모리와 같은 머신 판독가능 매체를 포함한다. 외부 저장부(132)는 플로피 디스크들, 착탈식 하드드라이브, 자기 테이프, CD ROM, 및 통신 라인을 통해 접속되는 기타 다른 컴퓨터들 등의 판독가능 매체를 포함한다. 본 예에서 제 2 저장부(130) 및 외부 저장부(132) 사이에 도시된 특징은 본 발명의 기술을 편리하게 하기 위한 것이다. 상기한 바와 같이, 이들 구성요소들 간에는 실질적인 기능적 오버랩이 있음을 이해하도록 한다. 에뮬레이션 코드(10-24)와 같은 컴퓨터 소프트웨어 및 사용자 프로그램들은 메모리(124), 제 2 저장부(130), 외부 저장부(132)와 같은 컴퓨터 소프트웨어 저장 매체에 저장될 수 있다. 컴퓨터 소프트웨어(133)의 실행가능 버전들은 외부 저장부(132), 제 2 저장부(130), 비휘발성 메모리와 같은 비휘발성 저장 매체로부터 판독될 수 있고, 실행을 위해 휘발성 메모리 내로 직접 로드되거나, 비휘발성 메모리로부터 직접 실행되거나, 실행을 위해 휘발성 메모리내로 로딩하기 이전에 제 2 저장부(130)에 저장될 수 있다.

비록 본 발명에 대해 특정 실시예들을 참조하여 기술되고 설명되었지만, 그것은 본 발명을 그 예시적인 실시예들에 국한시키고자 하는 것은 아니다. 당업자들은 수정예 및 변형예들이 본 발명의 의도 및 범위내에서 실시 가능함을 인식할 것이다. 예컨대, 본원에서 개시된 LGMDT 명령은 출력을 위해 8비트 값을 처리할 뿐만 아니라 어떤 크기의 값들(16비트, 4비트, 32비트, 64비트 등)도 개개의 레지스터들에의 저장을 위해 상이한 데이터 포맷으로 처리할 수도 있다. 본원에서 사용된 처리는, 소정 크기의 수, 부호없는 수, 유동점 포맷, 상이한 정수 포맷, 좌우측으로 바뀐 수, 시프트되거나 회전된 값, 큰 엔디안 값, 작은 엔디안 값, ASCII 출력, 또는 에뮬레이션 기능이나 언어 해석 실행을 개선하기 위한 어떤 다른 수적 포맷에 평행한 어떤 다른 수적 포맷을 발생시키는데 이용될 수 있다. 소정의 경우에 있어서, 루틴(12)으로부터의 코드는 브랜치 예측 및 브랜치 캐쉬 로드를 절약하기 위하여 테이블(14)내의 루틴들 내로 배치될 수 있다. 따라서, 본 발명은 첨부된 청구범위의 범위내에서 이루어지는 모든 변형예들 및 수정예들을 포함하는 것이다.

Claims

다기능 명령을 실행할 수 있는 프로세서에 있어서,

복수의 레지스터들; 및

다기능 명령 실행 회로로서,

상기 다기능 명령 실행 회로는 다기능 명령의 하나의 실행에 응답하여 공통 위치로부터 대응하는 복수의 레지스터들 내로 대응하는 복수의 포맷들로 복수의 피연산자들을 이동시키며,

상기 대응하는 복수의 포맷들 중 제 1 포맷은 부호없는 바이트 포맷으로 메모리에 엔코딩된 정수이고,

상기 대응하는 복수의 포맷들 중 제 2 포맷은 부호있는 바이트 포맷으로 메모리에 엔코딩된 정수이고,

상기 대응하는 복수의 포맷들 중 제 3 포맷은 상기 대응하는 복수의 레지스터들중 제 3 레지스터내의 고정된 위치 내에 상기 공통 위치로부터의 고정된 수의 비트들을 삽입함으로써 상기 프로세서에 의해 발생되는, 상기 다기능 명령 실행 회로를 포함하는, 프로세서.
제 1 항에 있어서,

상기 대응하는 복수의 포맷들중 제 1 포맷은 상기 대응하는 복수의 레지스터들중 제 1 레지스터내의 고정된 위치에 상기 공통 위치로부터의 고정된 수의 비트들을 삽입함으로써 상기 프로세서에 의해 발생되는, 프로세서.
삭제
삭제
삭제
복수의 레지스터들을 갖고 다기능 명령을 실행할 수 있는 프로세서 상에서의 실행을 위해 소프트웨어 저장 매체 상에 저장된 프로그램을 포함하는 컴퓨터 판독 가능한 기록 매체에 있어서,

상기 프로그램은,

상기 다기능 명령을 포함하는 상기 소프트웨어 저장 매체 상에 저장된 제 1 세트의 컴퓨터 명령들로서,

상기 다기능 명령의 하나의 실행이 공통 위치로부터 대응하는 복수의 레지스터들 내에 대응하는 복수의 포맷들로 복수의 피연산자들을 이동시키고,

상기 대응하는 복수의 포맷들의 제 1 포맷은 부호없는 바이트 포맷으로 메모리 내에 인코딩된 정수이고,

상기 대응하는 복수의 포맷들의 제 2 포맷은 부호있는 바이트 포맷으로 메모리 내에 인코딩된 정수이고,

상기 대응하는 복수의 포맷들의 제 3 포맷은 상기 대응하는 복수의 레지스터들의 제 3 레지스터 내에 공통 위치로부터 고정된 위치 내로 고정된 수를 삽입함으로써 상기 프로세서에 의해 생성되는, 상기 제 1 세트의 컴퓨터 명령들;

상기 소프트웨어 저장 매체에 저장된 제 2 세트의 컴퓨터 명령들로서,

제 1 명령 레지스터 피연산자로서 상기 대응하는 복수의 포맷들 중 상기 제 1 포맷으로 상기 대응하는 복수의 레지스터들 중 제 1 레지스터를 활용하는 제 1 피연산자 명령을 포함하는, 상기 제 2 세트의 컴퓨터 명령들;

상기 소프트웨어 저장 매체에 저장된 제 3 세트의 컴퓨터 명령들로서,

제 2 명령 레지스터 피연산자로서 상기 대응하는 복수의 포맷들 중 상기 제 2 포맷으로 상기 대응하는 복수의 레지스터들 중 제 2 레지스터를 활용하는 제 2 피연산자 명령을 포함하는, 상기 제 3 세트의 컴퓨터 명령들; 및

상기 소프트웨어 저장 매체에 저장된 제 4 세트의 컴퓨터 명령들로서,

제 3 명령 레지스터 피연산자로서 상기 대응하는 복수의 포맷들 중 상기 제 3 포맷으로 상기 대응하는 복수의 레지스터들 중 제 3 레지스터를 활용하는 제 3 피연산자 명령을 포함하는, 상기 소프트웨어 저장 매체에 저장된 제 4 세트의 컴퓨터 명령들을 포함하는, 컴퓨터 판독 가능한 기록 매체.
제 6 항에 있어서,

상기 프로그램은 자바 바이트코드 해석기인, 컴퓨터 판독 가능한 기록 매체.
삭제
삭제
삭제