DE69712687T2

DE69712687T2 - Sprachbearbeitende Einheit und Verfahren zur Übersetzung eines Quellprogrammes in einer Objektmoduldatei

Info

Publication number: DE69712687T2
Application number: DE69712687T
Authority: DE
Inventors: Roh Egashira
Original assignee: NEC Corp
Current assignee: NEC Corp
Priority date: 1996-08-19
Filing date: 1997-08-18
Publication date: 2003-01-02
Anticipated expiration: 2017-08-19
Also published as: US6014519A; EP0825531B1; JP3237693B2; EP0825531A1; DE69712687D1; JPH1063508A

Description

Die vorliegende Erfindung betrifft eine Sprachverarbeitungseinheit und ein Sprachverarbeitungsverfahren zum Übersetzen eines Quellprogramms und Erzeugen einer Objektmoduldatei. Genauer ausgedrückt, betrifft die vorliegende Erfindung eine Sprachverarbeitungseinheit und ein Sprachverarbeitungsverfahren, die ermöglichen, eine Objektmoduldatei mit einer kürzeren Ausführungszeit in einem Bereich von durch einen Programmierer festgelegten Codegrößen zu erzeugen.
Eine Datei, die ein Sprachverarbeitungsprogramm als ein Eingangsquellprogramm übersetzt und als Ergebnis erzeugt, wird als Objektmoduldatei bezeichnet.
In Mikrocomputern, insbesondere in Einzelchipmikrocomputern, hat die Zahl von Begrenzungen in ihrer Leistung die Tendenz, zum Zweck von Kostenverringerung zuzunehmen. Deshalb ist es in einem Sprachverarbeitungsprogramm gewünscht, dass die Ausführungszeit einer Objektmoduldatei als Ergebnis von Sprachverarbeitung (im folgenden einfach als "Ausführungszeit" bezeichnet) kurz sein sollte und die Größe einer Objektmoduldatei (im folgenden einfach als "Codegröße" bezeichnet) klein sein sollte.
In den konventionellen Sprachverarbeitungseinheiten gemäß dem Stand der Technik ist jedoch eine Objektmoduldatei durch Optimierung ausgegeben worden, in der das Gewicht bei einem Eingangsquellprogramm entweder auf Codegröße oder Ausführungszeit gelegt wird.
Als einer des oben genannten Standes der Technik gab es eine Technologie, die zum Beispiel in dem Dokument "Microsoft C Optimizing Compiler User's Guide" [Microsofts Benutzerhandbuch für optimierenden Compiler] (von Microsoft 1988) offenbart war. In dem Dokument wird eine Technik zum Erzeugen eines Ausgangscodes durch Auswählen entweder einer Ausgabe mit Priorität auf der Codegröße einer Objektmoduldatei oder einer Ausgabe mit Priorität auf der Ausführungszeit einer Objektmoduldatei durch Wahl bei der Ausführung einer Sprachverarbeitungseinheit beschrieben.
Fig. 10 zeigt eine Struktur einer konventionellen Sprachverarbeitungseinheit gemäß dem Stand der Technik.
In Fig. 10 analysiert eine Sprachverarbeitungseinheit 82 eine eingegebene Quellprogrammdatei 81 durch einen Syntaxanalyseteil 83 derselben. Nach Abschluss der Syntaxanalyse wird die Steuerung zu einem Codeerzeugungsteil 84 übertragen, ein Befehl wird auf der Grundlage der analysierten Ergebnisse durch die Festlegung eines Programmierers ausgewählt, und dadurch wird ein Ausgangscode erzeugt. Nach Abschluss der Codeerzeugung wird die Steuerung zu einem Objektmoduldatei-Ausgabeteil 85 übertragen, und eine Objektmoduldatei 86 wird ausgegeben.
Wenn in dem Codeerzeugungsteil 84 die Sprachverarbeitungseinheit 82 mehrere Ausgangscodemuster erzeugen und jegliche der Ausgangscodemuster auswählen kann, erfolgt die Auswahl des Ausgangscodemusters durch die Auswahl eines Programmierers. Wenn nämlich eine Ausgabe mit Priorität auf der Codegröße festgelegt wird, wird die Steuerung zu einem Codegrößen-Prioritätscode-Erzeugungsteil 841 übertragen, und Codeerzeugung wird so ausgeführt, dass eine Codegröße klein sein sollte.
Wenn in dem Codegrößen-Prioritätscode-Erzeugungsteil 841 Priorität auf die Verkleinerung der Codegröße anstatt auf die Verbesserung der Ausführungszeit gesetzt wird, kann die Ausführungszeit einer erzeugten Objektmoduldatei lang werden. Wenn andererseits ein Programmierer eine Ausgabe mit Priorität auf Ausführungszeit festlegt, wird die Steuerung zu dem Ausführungszeit-Prioritätscode-Erzeugungsteil 842 übertragen, und die Codeerzeugung wird so auslegt, dass die Ausführungszeit kurz werden soll. In dem Ausführungszeit-Prioritätscode-Erzeugungsteil 842 wird Priorität auf die Verbesserung der Ausführungszeit anstatt auf die Verkleinerung der Codegröße gesetzt, und deshalb kann die Codegröße zunehmen.
Als nächstes wird der Algorithmus der konventionellen Verarbeitung gemäß dem Stand der Technik unter Bezugnahme auf Fig. 11 im folgenden beschrieben.
In dem konventionellen Sprachverarbeitungsverfahren erfolgt zuerst die Syntaxanalyse einer Quellprogrammdatei, die ein Programmierer eingegeben hat (Schritt 901). Dann wird abhängig davon, ob der Programmierer die Priorität auf Codegröße festgelegt hat oder ob er die Priorität auf Ausführungszeit festgelegt hat (Schritt 902), und im Fall der Festlegung der Priorität auf Codegröße, ein Ausgangscode an einem Teil erzeugt, wo mehrere Ausgangscodemuster bei Codeerzeugung ausgewählt werden können (Schritt 903). Andererseits wird im Fall der Priorität auf Ausführungszeit ein Ausgangscode an einem Teil erzeugt, wo mehrere Codeerzeugungs-Ausgangscodemuster bei Codeerzeugung ausgewählt werden können (Schritt 904). Und nach Vollendung eines Ausgangscodes wird eine Objektmoduldatei ausgegeben (Schritt 905).
Wenn in der oben beschriebenen konventionellen Sprachverarbeitungstechnik jedoch ein Programmierer sowohl die Verringerung der Codegröße als auch die Verbesserung der Ausführungszeit gleichzeitig an einer Objektmoduldatei wünscht, war es schwierig, eine Objektmoduldatei auszugeben, die zum Erfüllen der Anforderungen eines Programmierers sowohl an Codegröße als auch Ausführungszeit ausreicht, was ein Problem bei konventioneller Technik dargestellt hat. Dies lag darin begründet, dass in der obigen konventionellen Technik ein Programmierer nur auswählen konnte, ob die Priorität auf der Verringerung der Codegröße oder die Priorität auf der Verbesserungen der Ausführungszeit liegt, und bei der Festlegung der Priorität auf Codegröße die Ausführungszeit langsam werden kann, während bei der Festlegung der Priorität auf Ausführungszeit die Codegröße groß werden kann. Sowohl die Codegröße als auch die Ausführungszeit hängen von einem Operationscode ab, es gibt jedoch nicht immer den kleinsten und kürzesten Befehl. Dementsprechend kann bei kleinster Gestaltung der Codegröße die Ausführungszeit lang werden, im Gegenteil kann bei kürzester Gestaltung der Ausführungszeit die Codegröße groß werden, was ein Problem bei der konventionellen Technik gemäß dem Stand der Technik dargestellt hat.
Dementsprechend besteht eine Aufgabe der vorliegenden Erfindung in der Schaffung einer Sprachverarbeitungseinheit und eines Sprachverarbeitungsverfahrens, die ermöglichen, eine Objektmoduldatei mit kurzer Ausführungszeit in einem Bereich von durch einen Programmierer festgelegten Codegrößen zu erzeugen.
Eine andere Aufgabe der vorliegenden Erfindung ist die Schaffung einer Sprachverarbeitungseinheit und eines Sprachverarbeitungsverfahrens, die einen Programmierer in die Lage versetzen, frei die Codegröße einer Objektmoduldatei durch einen Programmierer selbst zu entscheiden.
EP-A-0 646 864 erwähnt eine Art von Optimierung durch einen Compiler, der die Ausgabegröße eines Programms durch Aufrufen einer Laufzeitbibliothek minimiert. Außerdem schlägt dieses Dokument einen Compiler vor, in dem vorhergehend optimierte Zwischencodes durch einen Syntaxanalyseteil erzeugt und einem Optimierungsteil zugeführt werden, wo die vorhergehend optimierten Zwischencodes analysiert werden und optimierte Zwischencodes in Übereinstimmung mit einer Optimierungskombinationstabelle erzeugt werden. Die Optimierungskombinationstabelle enthält eine Mehrzahl verschiedener Kombinationen von Optimierungsfunktionen, und in einigen Fällen wird eine Mehrzahl optimierter Zwischencodes erzeugt.
Dem ersten Aspekt der Erfindung zufolge umfasst eine Sprachverarbeitungseinheit zum Übersetzen eines Quellprogramms in eine Objektmoduldatei
Syntaxanalysemittel zum Eingeben und Analysieren eines Quellprogramms, Codemuster-Registriermittel zum Registrieren eines Codeerzeugungsverfahrens und von Codegrößendifferenzen an unterschiedlichen Codemustern im Fall der Codeerzeugung, um eine Priorität darauf zu setzen, dass die Größe einer Objektmoduldatei klein gestaltet wird, und im Falle der Codeerzeugung die Priorität auf eine kurze Ausführungszeit gesetzt wird,
Codegrößen-Messmittel zum Messen der Größe einer Objektmoduldatei im Fall der Codeerzeugung mit Priorität auf der Herstellung einer kleinen Objektmoduldatei und der Größe einer Objektmoduldatei im Fall der Codeerzeugung mit Priorität auf kurzer Ausführungszeit, und zum Zählen der Anzahl von Auftritten jedes Musters des Ausgangscodes, die in den Codemuster-Registriermitteln registriert sind, in erzeugten Operationscodes,
Codemuster-Auswahlmittel zum Ersetzen eines Teils oder des Ganzen der Codeerzeugung mit Priorität auf der Ausführungszeit einer Objektmoduldatei durch Erzeugen von Codes mit Priorität auf der Größe einer Objektmoduldatei, so dass sie innerhalb der Codegröße einer Objektmoduldatei gespeichert werden können, die durch einen Programmierer mit Bezug auf die Messergebnisse der Codegrößen-Messmittel und des registrierten Inhalts der Codemuster-Registriermittel ausgelegt wurde,
Codeerzeugungsmittel zur Erzeugung eines Operationscodes entsprechend eines Analyseergebnisses durch die Syntaxanalysemittel in Übereinstimmung mit den Auswahlergebnissen der Codemuster-Auswahlmittel,
Objektmoduldatei-Ausgabemittel zum Ausgeben des Operationscodes, der durch die Codeerzeugungsmittel erzeugt wurde, als eine Objektmoduldatei.
In dem bevorzugten Aufbau können die Codemuster-Registriermittel Codemuster in einer solchen Reihenfolgen registrieren, dass die Verschlechterung in der Ausführungszeit einer Objektmoduldatei beschränkt ist und die Größe der Objektmoduldatei kleiner wird, und die Codemuster-Auswahlmittel können die Anzahlen von Codeerzeugung mit Priorität auf der Größe einer Objektmoduldatei unter den Benutzungsfrequenzen jedes Codemusters entscheiden.
Einem zweiten Aspekt der Erfindung zufolge weist ein Sprachverarbeitungsverfahren zum Übersetzen eines Quellprogramms in eine Objektmoduldatei die folgenden Schritte auf:

Eingeben und Analysieren eines Quellprogramms;

Messen der Größe einer Objektmoduldatei im Fall von Codeerzeugung mit Priorität auf Verringern der Größe einer Objektmoduldatei und der Größe einer Objektmoduldatei für den Fall der Codeerzeugung mit Priorität auf Verkürzen der Ausführungszeit entsprechend einem Analyseergebnis durch den Quellprogrammanalyseschritt und Zählen der Anzahl von Auftreten jedes Musters des Ausgangscodes, die unter den erzeugten Operationscodes registriert wurden,
selektives Ersetzen eines Teils oder des Ganzen der Codeerzeugung mit Priorität auf der Ausführungszeit einer Objektmoduldatei durch Codeerzeugung mit Priorität auf der Größe einer Objektmoduldatei, so dass sie innerhalb der Codegröße einer Objektmoduldatei gespeichert werden können, die durch einen Programmierer mit Bezug auf die Messergebnisse des Codegrößen-Messschritts und der jeweiligen Codeerzeugungsverfahren und der Daten hinsichtlich der Codeerzeugung festgelegt wurden, die hinsichtlich unterschiedlicher Codemuster im Fall mit Priorität auf kleiner Größe der Objektmoduldatei und im Fall der Priorität auf verkürzter Ausführungszeit der Objektmoduldatei gesammelt wurden,
Erzeugen eines Operationscodes für das Programm, das durch den Quellprogramm-Analyseschritt analysiert wurde, entsprechend den Auswahlergebnissen durch den Codeerzeugungs-Auswahlschritt, und
Ausgeben des Operationscodes, der durch den Operationscode-Erzeugungsschritt erzeugt wurde, als Objektmoduldatei.
In einem anderen bevorzugten Aufbau bezieht sich der Codeerzeugungs-Auswahlschritt auf die Daten, die über das Codemuster gesammelt wurden, um die Verschlechterung in der Ausführungszeit einer Objektmoduldatei zu beschränken und die Größe einer Objektmoduldatei zu verkleinern, und der Codeerzeugungsauswahlschritt beschränkt die Anzahlen der Codeerzeugung mit Priorität auf der Größe einer Objektmoduldatei aufgrund der Benutzungsfrequenzen jedes Codemusters.
Andere Aufgaben, Merkmale und Vorteile der vorliegenden Erfindung werden aus der folgenden ausführlichen Beschreibung deutlich werden.
Die vorliegende Erfindung wird vollständiger aus der im folgenden angeführten ausführlichen Beschreibung und anhand der beigefügten Zeichnungen der bevorzugten Ausführungsform der Erfindung verstanden werden, die jedoch nicht als die Erfindung begrenzend aufgefasst werden sollte, sondern nur zur Erklärung und zum Verständnis vorgesehen sind.
In den Zeichnungen:
Fig. 1 ist ein Blockdiagramm, das die Struktur einer Sprachverarbeitungseinheit gemäß einer erste bevorzugten Ausführungsform der vorliegenden Erfindung zeigt.
Fig. 2 ist ein Ablaufdiagramm, das Tätigkeiten von einem Codegrößen-Messteil zu einem Codeerzeugungsteil durch die erste bevorzugte Ausführungsform zeigt.
Fig. 3 ist ein Ablaufdiagramm, das Tätigkeiten von einem Codegrößen-Messteil zu einem Codeerzeugungsteil durch die erste bevorzugte Ausführungsform zeigt.
Fig. 4 ist ein Diagramm, das die registrierten Inhalte eines Codemuster-Registrierteils in einer Sprachverarbeitungseinheit durch die erste bevorzugte Ausführungsform zeigt.
Fig. 5 ist ein Diagramm, das ein konkretes Beispiel eines Codemuster-Registrierteils in einer Sprachverarbeitungseinheit durch die erste bevorzugte Ausführungsform zeigt.
Fig. 6 ist ein Ablaufdiagramm, das Tätigkeiten von einem Codemuster-Auswahlteil zu einem Codeerzeugungsteil durch die zweite bevorzugte Ausführungsform der vorliegenden Erfindung zeigt.
Fig. 7 ist ein Ablaufdiagramm, das Tätigkeiten von einem Codemuster-Auswahlteil zu einem Codeerzeugungsteil durch die zweite bevorzugte Ausführungsform der vorliegenden Erfindung zeigt.
Fig. 8 ist ein Diagramm, das die registrierten Inhalte eines Codemuster-Registrierteils in einer Sprachverarbeitungseinheit durch die zweite bevorzugte Ausführungsform der vorliegenden Erfindung zeigt.
Fig. 9 ist ein Diagramm, das ein konkretes Beispiel eines Codemuster-Registrierteils in einer Sprachverarbeitungseinheit durch die zweite bevorzugte Ausführungsform zeigt.
Fig. 10 ist ein Blockdiagramm, das eine Struktur der konventionellen Sprachverarbeitungseinheit zeigt.
Fig. 11 ist ein Ablaufdiagramm, das Tätigkeiten der konventionellen Sprachverarbeitungseinheit zeigt.
Die bevorzugte Ausführungsform der vorliegenden Erfindung soll im folgenden ausführlich unter Bezugnahme auf die beigefügten Zeichnungen beschrieben werden. In der folgenden Beschreibung sind zahlreiche spezielle Details aufgeführt, um ein gründliches Verständnis der vorliegenden Erfindung zu schaffen. Es wird jedoch den Fachleuten in diesem Gebiet offensichtlich sein, dass die vorliegende Erfindung ohne diese speziellen Details praktiziert werden kann. In anderen Fällen sind gut bekannte Strukturen nicht detailliert gezeigt, um die vorliegende Erfindung nicht unnötig unverständlich zu machen.
Fig. 1 ist ein Blockdiagramm, das die Struktur einer Sprachverarbeitungseinheit gemäß der ersten bevorzugten Ausführungsform der vorliegenden Erfindung zeigt.
Wie in der Figur gezeigt ist, ist eine Sprachverarbeitungseinheit 12 ausgestattet mit einem Syntaxanalyseteil 13, der eine Quellprogrammdatei 11 eingibt und die Inhalte derselben analysiert, einem Codeerzeugungsteil 17, der Codeerzeugung auf der Grundlage der Ergebnisse der obigen Syntaxanalyse durchführt, und einem Objektmoduldatei- Ausgabeteil 18, der einen durch den Codeerzeugungsteil 17 erzeugten Code als eine Objektmoduldatei 19 ausgibt, einem Codemuster-Registrierteil 16, in dem die Daten von Codemustern, deren Ausgangscode sich mit dem Fall der Priorität auf Codegröße und dem Fall der Priorität auf Ausführungszeit ändert, ein Codegrößen-Messteil 14, der eine Codegröße misst und die Benutzungsfrequenz von in dem Codemuster-Registrierteil 16 registrierten Codemustern misst, und einem Codemuster-Auswahlteil 15, der ein Auswahlcodemuster auswählt, um einen Ausgangscode innerhalb der durch einen Programmierer festgelegten Codegröße zu erzeugen. Übrigens ist in Fig. 1 nur eine charakteristische Struktur der ersten bevorzugten Ausführungsform gemäß der vorliegenden Erfindung gezeigt, und andere allgemeine Strukturen sind hier weggelassen worden.
In der obigen Struktur werden ein Syntaxanalyseteil 13, ein Codegrößen-Messteil 14, ein Codemuster-Auswahlteil 15, ein Codeerzeugungsteil 17 und ein Objektausgabeteil 18 durch CPU, RAM und andere interne Speicher realisiert, die durch ein Computerprogramm gesteuert werden. Das Computerprogramm ist auf einer Magnetplatte, einem Halbleiterspeicher und anderen Speichermedien gespeichert und wird auf den internen Speicher zum Steuern der CPU geladen und realisiert dadurch die obigen jeweiligen Ausführungsteile. Auch der Codemuster-Registrierteil 16 wird durch eine Magnetplatteneinheit und andere externe Speichereinheiten realisiert. Übrigens sind die Funktionen des Syntaxanalyseteils 13 und des Codeerzeugungsteils 17 und Objektmoduldatei-Ausgabeteils 18 die gleichen wie diejenigen in der konventionellen Technik.
Der Codemuster-Registrierteil 16 registriert für den Teil, wo Codeerzeugung mit dem Fall der Priorität auf Codegröße und dem Fall der Priorität auf Ausführungszeit variiert, die Differenz zwischen der Codegröße und dem Codemuster in dem Fall der Priorität auf Codegröße, dem Codemuster im Fall der Priorität auf Ausführungszeit, dem Codemuster im Fall der Priorität auf Codegröße und dem Codemuster im Fall von Priorität auf Ausführungszeit. Wenn die Codegröße einer Objektmoduldatei mit dem Fall der Priorität auf Codegröße und dem Fall der Priorität auf Ausführungszeit variiert, existiert wenigstens ein Codemuster, das in dem Codemuster-Registrierteil 16 registriert ist, und es tritt eine Differenz beim Erzeugen des Codes in dem registrierten Codemuster auf. Im Fall einer Differenz beim Erzeugen des Codes tritt eine Differenz in einer Objektmoduldatei in dem Fall von Priorität auf Codegröße und der im Fall von Priorität auf Ausführungszeit auf, und allgemein wird die Codegröße im Fall von Priorität auf Ausführungszeit größer.
Der Codegrößen-Messteil 14 misst die Codegröße einer Objektmoduldatei im Fall von Priorität auf Codegröße, und die Codegröße einer Objektmoduldatei im Fall von Priorität auf Ausführungszeit. Die Messung der Codegröße kann durch ein Verarbeitungsverfahren ähnlich dem für den Codeerzeugungsteil 17 zur Verfügung stehen. Zwei gemessene Codegrößenwerte werden bei der Verarbeitung des Codemuster-Auswahlteils 15 verwendet.
Und der Codegrößen-Messteil 14 zählt parallel mit der Codegrößen-Messverarbeitung, in welcher Anzahl das in dem Codemuster-Registrierteil 16 registrierte Codemuster verwendet wird, und speichert die Benutzungsfrequenz jedes Codemusters in den Codemuster-Registrierteil 16. Die Benutzungsfrequenz jedes in dem Codemuster-Registrierteil 16 gespeicherten Codemusters wird in der Verarbeitung des Codemuster-Auswahlteils 15 verwendet.
Der Codemuster-Auswahlteil 15 setzt die Daten für jedes in dem Codemuster-Registrierteil 16 gespeicherte Muster ein, um auszuwählen, ob eine Codeerzeugung mit Priorität auf Codegröße durchzuführen ist oder eine Codeerzeugung mit Priorität auf Ausführungszeit durchzuführen ist. Durch Bezugnahme auf die eingesetzten Daten ist es möglich, einen Teil oder die gesamte Codeerzeugung einer Objektmoduldatei im Fall von Priorität auf Ausführungszeit durch die Codeerzeugung im Fall von Priorität auf Codegröße zu ersetzen, so dass die Codegröße in der durch einen Programmierer festgelegten Codegröße enthalten sein sollte.
Der Codeerzeugungsteil 17 führt eine Codeerzeugung an den Codegrößen-Prioritätscode-Erzeugungsteil 171 oder den Ausführungszeit-Prioritätscode-Erzeugungsteil 172 in Übereinstimmung mit den Auswahlergebnissen durch den Codemuster-Auswahlteil 15 durch. Der Codegrößen-Prioritätscode-Erzeugungsteil 171 führt eine Codeerzeugung zum Verkleinern der Codegröße durch, während der Ausführungszeit-Prioritätscode- Erzeugungsteil 172 eine Codeerzeugung zum Verkürzen der Ausführungszeit durchführt. Bei der Codeerzeugung an dem Codeerzeugungsteil 17 werden die Codeerzeugung mit Priorität auf Codegröße und die Codeerzeugung mit Priorität auf Ausführungszeit vermischt. Nach Abschluss der Codeerzeugung wird die Steuerung zu dem Objektmoduldatei-Ausgabeteil 18 übertragen, und eine Objektmoduldatei wird ausgegeben.
Als nächstes soll unter Bezugnahme auf die in Fig. 2 und Fig. 3 gezeigten Ablaufdiagramme die Verarbeitung dieser bevorzugten Ausführungsform im folgenden ausführlich beschrieben werden.
Zuerst legt ein Programmierer eine von ihm gewünschte Codegröße fest (Fig. 2, Schritt 201). Der festgelegte Wert wird in einem auf dem Speicher spezifizierten Bereich gespeichert (im folgenden als ein "USER" [Benutzer] bezeichnet).
Wenn ein Programmierer eine von ihm gewünschte Codegröße festlegt, führt der Syntaxanalyseteil 13 eine Syntaxanalyse an dem Inhalt der Quellprogrammdatei 11 durch (Schritt 202). Nach Abschluss der Syntaxanalyse misst der Codegrößen-Messteil 14 die Codegröße einer Objektmoduldatei im Fall von Priorität auf Codegröße (Schritt 203). Zusammen mit dem Codegrößen-Messvorgang des Schritts 203 misst er die Benutzungsfrequenz des in dem Codemuster-Registrierteil 16 gespeicherten Codemusters (Schritt 204).
Fig. 4 ist ein Beispiel des registrierten Inhalts des Codemuster-Registrierteils 16. In dem Codemuster-Registrierteil 16 werden Codeerzeugungen 1A, 2A, ... im Fall von Priorität auf Codegröße, Codeerzeugungen 1B, 2B, ... im Fall von Priorität auf Ausführungszeit, Codegrößendifferenzen zwischen Codeerzeugung im Fall von Priorität auf Codegröße und Codeerzeugung im Fall von Priorität auf Ausführungszeit D[1], D[2], ... und die Benutzungsfrequenz eines Codemusters CNT[1], CNT[2], ... als Bereiche im Speicher gespeichert. Für das k-te Codemuster werden eine Codeerzeugung kA im Fall von Priorität auf Codegröße, ein Codeerzeugung kB im Fall von Priorität auf Ausführungszeit und die Codegrößendifferenz D[k] zwischen kA und kB registriert. kA und kB weisen unterschiedliche Codeerzeugungen auf, aber sie führen die gleichen Tätigkeiten aus. Die gemessene Benutzungsfrequenz wird in dem folgenden Schritt 204 auf den Bereich CNT[k] gesetzt.
Die durch die Codegrößenmessung des Schritts 203 erhaltene Codegröße wird in einem Bereich im Speicher gespeichert (im folgenden als "CODE" bezeichnet) (Schritt 205).
Nach dem Abschluss des Schritt 205 bezieht sich der Codegrößen-Messteil 14 erneut auf die Ergebnisse der Syntaxanalyse an dem Syntaxanalyseteil 11 und misst die Codegröße einer Objektmoduldatei im Fall von Priorität auf Ausführungszeit (Schritt 206). Die durch die Codegrößenmessung erhaltene Codegröße wird im Schritt 206 in einen Bereich im Speicher gespeichert (im folgenden als "SPEED" [Geschwindigkeit] bezeichnet) (Schritt 207).
Nach Abschluss des Schritts 207 wird die Steuerung zu dem Codemuster-Auswahlteil 15 übertragen. Zuerst wird die Anfangseinstellung der Codegröße einer auszugebenden Objektmoduldatei durchgeführt und in einen Bereich im Speicher gespeichert (im folgenden als "SIZE" [Grösse] bezeichnet) (Schritt S208). Der Anfangseinstellwert ist die Codegröße "SPEED" im Fall von Priorität auf Ausführungszeit.
Nach Abschluss des Schritts 208 werden für jedes in dem Codemuster-Registrierteil 16 registrierte Codemuster Bereiche im Speicher FLAG[1], FLAG[2] [Merker], ... zu "0" initialisiert (Schritt 209). Die FLAG[1], FLAG[2], ... bezeichnen die Merker zur Beurteilung, ob eine Codeerzeugung mit Priorität auf Codegröße durchzuführen ist oder ob eine Codeerzeugung mit Priorität auf Ausführungszeit durchzuführen ist. FLAG[k] repräsentiert einen Merker für das in dem k-ten des Codemuster-Registrierteil 16 registrierte Codemuster. FLAG [] repräsentiert, dass der Merker im Moment "0" unten ist, und der Merker in einem anderen Moment als "0" oben ist. Wenn bei der Codeerzeugung der Merker für jedes Codemuster oben ist, wird eine Codeerzeugung mit Priorität Codegröße durchgeführt, während, wenn der Merker unten ist, eine Codeerzeugung mit Priorität auf Ausführungszeit durchgeführt wird. Nach der Initialisierung des FLAG [] im Schritt 209, gehen alle FLAG [] nach unten, und wenn eine Codeerzeugung in dieser Form durchgeführt wird, wird eine Codeerzeugung mit Priorität auf Ausführungszeit in allen der Beschreibungen durchgeführt, in denen mehrere Codeerzeugungen zur Verfügung stehen.
Nach Abschluss der Initialisierung des FLAG [] im Schritt 209, wird die durch einen Programmierer festgelegte Codegröße "USER" mit der Codegröße im Fall von Priorität auf Codegröße "CODE" (Fig. 3, Schritt 210) verglichen. Wenn die durch einen Programmierer festgelegte Codegröße "USER" unter der Codegröße im Fall von Priorität auf Codegröße "CODE" liegt, werden die FLAG[1], FLAG[2], ... zum Durchführen der Codeerzeugung mit Priorität auf Codegröße alle hochgesetzt (Schritt S211), die Steuerung wird zu dem Codeerzeugungsteil 17 übertragen, und die Codeerzeugungsverarbeitung in und nach Schritt 217 wird durchgeführt.
Wenn im Schritt 210 die durch einen Programmierer festgelegte Codegröße "USER" größer als die Codegröße im Fall von Priorität auf Codegröße "CODE" ist, wird der Bereich im Speicher "i" zum Repräsentieren der registrierten Anzahl der in dem Codemuster-Registrierteil 16 registrierten Codegrößen zu "1" initialisiert (Schritt 212), und die durch einen Programmierer festgelegte Codegröße "USER" wird mit der Codegröße einer auszugebenden Objektmoduldatei "SIZE " verglichen (Schritt 213). Wenn die durch einen Programmierer festgelegte Codegröße "USER" kleiner als die Codegröße einer auszugebenden Objektmoduldatei "USER" ist, wird der FLAG [i] hochgesetzt, und die Codeerzeugung mit Priorität auf Codegröße wird an allen der Benutzungsteile hinsichtlich des i-ten Codemusters durchgeführt, das in dem Codemuster-Registrierteil 16 gespeichert ist (Schritt 214).
In dem Schritt 214 ändert sich ein Teil der Codeerzeugung von der Codeerzeugung mit Priorität auf Ausführungszeit zu der Codeerzeugung mit Priorität auf Codegröße, und dadurch wird die Codegröße einer auszugebenden Objektmoduldatei um das Produkt der Codegrößendifferenz, die in dem i-ten des Codemuster-Registrierteils 16 registriert ist, und der Benutzungsfrequenz CNT[i] verkleinert, so dass der durch Abziehen des Produkts von D[i] und CNT[i] von der Codegröße "SIZE " einer auszugebenden Objektmoduldatei erhaltene Wert als die Codegröße "SIZE " einer auszugebenden Objektmoduldatei zurückgesetzt wird (Schritt 215).
Nach dem Abschluss der Rücksetzung der Codegröße "SIZE " einer auszugebenden Objektmoduldatei im Schritt 215, wird "1" zu den Inhalten der registrierten Zahl "i" des Codemusters in dem Codemuster-Registrierteil 16 addiert (Schritt 216), woraufhin der Ablauf zum Schritt 213 zurückkehrt, wo ein Vergleich zwischen der durch einen Programmierer festgelegten Codegröße "USER" und der Codegröße der zurückgesetzten, auszugebenden Objektmoduldatei "SIZE " durchgeführt wird.
Wenn im Schritt 213 die durch einen Programmierer festgelegte Codegröße "USER" über der Codegröße der auszugebenden Objektmoduldatei "SIZE " liegt, wird die Steuerung zum Codeerzeugungsteil 17 übertragen, und die Codeerzeugungsverarbeitung in und nach dem Schritt 217 wird durchgeführt.
In dem Codeerzeugungsteil 17 wird zuerst beurteilt, ob die Codeerzeugung abgeschlossen ist oder nicht (Schritt 217). Wenn die Codeerzeugung nicht abgeschlossen ist, wird beurteilt, ob mehrere Codeerzeugungen vorliegen oder nicht (Schritt 218). Dies ist das gleiche wie die konventionelle Verarbeitung. Wenn nur eine Codeerzeugung vorliegt, wird eine Codeerzeugung in der gleichen Weise wie das konventionelle Verfahren durchgeführt (Schritt 219). Wenn mehrere Codeerzeugungen vorliegen, werden ihre Registrierungszahlen in dem Codemuster-Registrierteil 16 beurteilt (Schritt 220). Die registrierte Zahl des im Schritt 220 erhaltenen Codemusters wird als "k" ausgelegt.
Hiernach wird beurteilt, ob FLAG[k] für das in dem k-ten des Codemuster-Registrierteils 16 (Schritt 221) hochgesetzt ist. Wenn FLAG[k] hochgesetzt ist, wird die Steuerung zu dem Codegrößen-Prioritätscode-Erzeugungsteil 171 übertragen, und eine Codeerzeugung wird durch das Codemuster mit Priorität auf Codegröße durchgeführt (Schritt 222). Und wenn der FLAG[k] unten ist, wird die Steuerung zu dem Ausführungszeit- Prioritätscode-Erzeugungsteil 172 übertragen, und eine Codeerzeugung wird durch das Codemuster mit Priorität auf Ausführungszeit durchgeführt (Schritt 223). Nach der Codeerzeugung im Schritt 219, Schritt 222 oder Schritt 223 geht der Ablauf zurück zum Schritt 217, und es wird beurteilt, ob die Codeerzeugung abgeschlossen ist oder nicht. Wenn die Codeerzeugung nicht abgeschlossen ist, wird die nächste Codeerzeugung durchgeführt. Wenn alle Codeerzeugungen abgeschlossen sind, wird die Steuerung zu dem Objektmoduldatei-Ausgabeteil 18 übertragen, und eine Objektmoduldatei 19 wird ausgegeben.
Die obige Verarbeitung soll nun mit einem konkreten Beispiel erklärt werden. Fig. 5 ist ein Beispiel der registrierten Inhalte des Codemuster-Registrierteils 16. Wie in der Figur gezeigt ist, ist die Einheit von Codegröße in diesem Beispiel als Byte eingestellt, die Einheit der Ausführungszeit ist als Takt eingestellt, und es wird angenommen, dass sechs Codemuster registriert sind. Die Benutzungsfrequenz der Codemuster CNT [1], CNT[2], ... wird in dem Prozess beim Schritt 204 eingesetzt.
Unter Bezugnahme auf eine spezielle Quellprogrammdatei wird von der Messung der Codegröße in dem Codegrößen-Messteil 14 angenommen, dass die durch einen Programmierer festgelegte Codegröße einer Objektmoduldatei "USER" 1500 Bytes aufweist und die Codegröße einer Objektmoduldatei im Fall von Priorität auf Codegröße "CODE" 1200 Bytes aufweist und die Codegröße einer Objektmoduldatei im Fall von Priorität auf Ausführungszeit "SPEED" 1600 Bytes aufweist. Und es wird angenommen, dass die Benutzungsfrequenz des in dem Codemuster-Registrierteil 16 registrierten Codemusters CNT [] 22 Mal, 26 Mal, 34 Mal, 52 Mal, 40 Mal und 68 Mal in der Reihenfolge der registrierten Zahlen ist.
Unter den oben genannten Bedingungen wird im Schritt 208 die Codegröße einer auszugebenden Objektmoduldatei "SIZE " auf 1600 Bytes eingestellt, in der gleichen Weise wie die Codegröße der Objektmoduldatei im Fall mit Priorität auf Ausführungszeit "SPEED".
Wenn im Schritt 209 eine Mehrzahl von Codeerzeugungen vorliegt, werden alle die Merker FLAG[] zum Beurteilen, ob eine Codeerzeugung mit Priorität auf Codegröße durchzuführen ist oder nicht, auf "0" initialisiert.
In dem Vergleich der Codegröße "USER" (1500 Bytes) und der Codegröße "CODE" (1200 Bytes) im Schritt 210 ist die Codegröße "USER" größer als die Codegröße "CODE", so dass der Ablauf zum Schritt 212 übergeht, und der Bereich im Speicher "i" zum Repräsentieren der registrierten Zahl des Codemusters in dem Codemuster-Registrierteil 16 wird zu "1" initialisiert.
Im Vergleich der Codegröße "USER" (1500 Bytes) und der Codegröße "SIZE " (1600 Bytes) im Schritt 213, ist die Codegröße "USER" kleiner als die Codegröße "SIZE ", daher wird im Schritt 214 der FLAG[1] hochgesetzt. Aus Fig. 5 ist die Codegrößendifferenz D [1] 1 Byte, und die Codemuster-Benutzungsfrequenz CNT[1] beträgt 22 Mal, daher wird im Schritt 215 die Codegröße "SIZE " um (1 · 22) Bytes verringert und wird zu 1578 Bytes, und im Schritt 216 wird die registrierte Zahl des Codemusters "i" zu "2".
Beim Abschluss des Prozesses am Schritt 216 kehrt die Abfolge zurück zum Schritt 213, und erneut wird ein Vergleich zwischen der Codegröße "USER" (1500 Bytes) und der Codegröße "SIZE " (1578 Bytes) durchgeführt. Die Codegröße "SIZE " ist größer als die Codegröße "USER", daher wird im Schritt 214 der FLAG[2] hochgesetzt. Nach Fig. 5 beträgt die Codegrößendifferenz D[2] 2 Bytes, und die Codemuster-Benutzungsfrequenz CNT[2] ist 26 Mal, daher wird im Schritt 215 die Codegröße "SIZE " um (2 · 26) verkleinert und wird zu 1526 Bytes, und im Schritt 216 wird die registrierte Codemusterzahl "i" zu "3".
Zurück im Schritt 213, ist im Vergleich zwischen der Codegröße "USER" (1500 Bytes) und der Codegröße "SIZE " (1526) die Codegröße "SIZE " größer als die Codegröße "USER", daher wird im Schritt 214 der FLAG[3] hochgesetzt. Nach Fig. 5 ist die Codegrößendifferenz D[3] 1 Byte, und die Codemuster-Benutzungsfrequenz CNT[3] ist 34 Mal, daher wird im Schritt 215 die Codegröße "SIZE " um (1 · 34) verkleinert und wird zu 1492 Bytes, und im Schritt 216 wird die registrierte Codemusterzahl "i" zu "4".
Zurück im Schritt 213 liegt im Vergleich zwischen der Codegröße "USER" (1500 Bytes) und der Codegröße "SIZE " (1492 Bytes) die Codegröße "SIZE " unter der Codegröße "USER", daher wird die Verarbeitung zu der Codeerzeugung in und nach dem Schritt 217 übertragen.
Wenn bei der Codeerzeugung für das in dem Codemuster-Registrierteil 16 registrierte Codemuster der FLAG[] für die Codemuster oben ist, deren registrierte Zahl 1-3 ist, wird die Codeerzeugung mit Priorität auf Codegröße durchgeführt, und wenn der FLAG[] für die Codemuster unten ist, deren registrierte Zahl 4-6 ist, wird die Codeerzeugung mit Priorität auf Ausführungszeit durchgeführt. Nach Abschluss aller Codeerzeugungen wird eine Objektmoduldatei ausgegeben.
Die ausgegebene Objektmoduldatei zeigt ihre Codegröße als 1492 Bytes, was die Bedingung erfüllt, dass die Codegröße der vom Programmierer gewünschten Objektmoduldatei unter 1500 Bytes liegt. Und da das Codemuster mit Priorität auf der Ausführungszeit enthalten ist, wird die Ausführungszeit kürzer als für eine Objektmoduldatei in dem Fall mit Priorität auf Codegröße.
Als nächstes soll die zweite bevorzugte Ausführungsform gemäß der vorliegenden Erfindung im folgenden ausführlich unter Bezugnahme auf die Zeichnungen erklärt werden.
In der obigen ersten bevorzugten Ausführungsform wird anhand dessen, ob der FLAG [] hochgesetzt ist oder nicht beurteilt, ob die Codeerzeugung mit Priorität auf Codegröße oder die Codeerzeugung mit Priorität auf Ausführungszeit an jedem Codemuster erfolgt, das in dem Codemuster-Registrierteil 16 registriert ist, und nach der Entscheidung wird dieselbe Codeerzeugung immer an einem Teil durchgeführt, wo das Codemuster verwendet wird. Und da die in der ersten bevorzugten Ausführungsform registrierten Codemuster keine Regelungs- oder Registrierreihenfolge aufweisen, erfolgt keine Überlegung über die Effizienz hinsichtlich der Reihenfolge zum Ersetzen der Codeerzeugung mit Priorität auf Ausführungszeit durch die Codeerzeugung mit Priorität auf Codegröße.
In der vorliegenden bevorzugten Ausführungsform sind jedoch zwei Verbesserungen vorgenommen worden, um die Codeerzeugung zum Begrenzen der Verschlechterung der Ausführungszeit auszuführen.
Die erste Verbesserung ist, dass jedes registrierte Codemuster die Prioritätsreihenfolge hinsichtlich der Ersetzung von Codeerzeugungen aufweist. Die zweite Verbesserung ist, dass jedes registrierte Codemuster sowohl die Codeerzeugung mit Priorität auf Codegröße als auch die Codeerzeugung mit Priorität auf Ausführungszeit aufweist, um dadurch die Ersetzung von Codeerzeugungen zu begrenzen und die Größe einer auszugebenden Objektmoduldatei innerhalb der durch einen Programmierer festgelegten Codegröße zu gestalten.
Die Struktur einer Sprachverarbeitungseinheit gemäß der vorliegenden bevorzugten Ausführungsform ist ähnlich derjenigen der Sprachverarbeitungseinheit in der ersten bevorzugten Ausführungsform unter Ausnahme der Punkte, die zusätzlich in dem Codemuster-Registrierteil 16 zu registrieren sind, daher ist die Erklärung ihrer gesamten Struktur hier weggelassen worden.
Fig. 8 ist der registrierte Inhalt des Codemuster-Registrierteils 16 in der vorliegenden bevorzugten Ausführungsform. In dem Codemuster-Registrierteil 16 ist zusätzlich zu dem registrierten Inhalt der in Fig. 4 gezeigten ersten bevorzugten Ausführungsform die Ausführungszeitdifferenz C[1], C[2]... zwischen dem Erzeugungscode mit Priorität auf Ausführungszeit und dem Erzeugungscode mit Priorität auf Codegröße als ein Bereich in dem Speicher gespeichert und registriert.
C [k] repräsentiert die Ausführungszeitdifferenz zwischen der Codeerzeugung kA, die in dem k-ten des Codemuster-Registrierteils 16 registriert ist, und der Codeerzeugung kB.
In der ersten bevorzugten Ausführungsform gibt es keine Regelung über die Registrierungsreihenfolge der in dem Codemuster-Registrierteil 16 registrierten Codemuster, aber in der vorliegenden bevorzugten Ausführungsform ist Prioritätsreihenfolge in der Registrierungsreihenfolge gegeben, und die Codemuster mit höherer Priorität werden in der Reihenfolge von Priorität registriert. Codemuster mit höherer Priorität bedeuten solche, die geringe Verschlechterung in der Ausführungszeit aufweisen und die wirksam für die Verringerung der Codegröße sind, wenn sie von der Codeerzeugung mit Priorität auf Ausführungszeit zu der Codeerzeugung durch Priorität auf Codegröße ersetzt werden. Der Wert D [] - C [], der durch Abziehen der Ausführungszeitdifferenz C[] von der in dem Codemuster-Registrierteil 16 registrierten Codegrößendifferenz D[] erhalten wird, wird als die Prioritätsnorm gesetzt, und Codemuster mit großem Wert von D[] - C[] haben Priorität, und für diejenigen mit dem gleichen Wert hat das Codemuster mit einer kleineren Ausführungszeitdifferenz C[] Priorität. Durch Vorsehen der Prioritätsreihenfolge ist es möglich, dass der Codemuster-Auswahlteil 15 die Ersetzung von der Codeerzeugung mit Priorität auf Ausführungszeit zu der Codeerzeugung mit Priorität auf Codegröße in der Reihenfolge von Codemustern mit geringer Verschlechterung in der Ausführungszeit durchführt.
Und weiter unterscheidet sich in der vorliegenden bevorzugten Ausführungsform die Verarbeitung des Codemuster-Auswahlteils 15 von derjenigen der obigen ersten bevorzugten Ausführungsform. In der ersten bevorzugten Ausführungsform wird nämlich durch die Merker FLAG[1], [2] beurteilt, ob die Codeerzeugung mit Priorität auf Codegröße durchzuführen ist oder die Codeerzeugung mit Priorität auf Ausführungszeit durchzuführen ist. Während in der vorliegenden bevorzugten Ausführungsform die Anzahlen zum Durchführen der Codeerzeugung mit Priorität auf Codegröße für jedes in dem Codemuster-Registrierteil 16 registrierte Codemuster gesetzt werden und die Codeerzeugung mit Priorität auf Codegröße für die eingesetzten Anzahlen durchgeführt wird, wird in den restlichen Malen die Codeerzeugung mit Priorität auf Ausführungszeit durchgeführt.
Im folgenden sollen die Details der Verarbeitung in der vorliegenden bevorzugten Ausführungsform unter Bezugnahme auf die Ablaufdiagramme in Fig. 6 und Fig. 7 erklärt werden.
Zuerst werden die Prozesse bis zum Schritt 208 durch den in Fig. 2 gezeigten Codemuster-Auswahlteil 16 durchgeführt. Die Inhalte der Prozesse sind die gleichen wie in der ersten bevorzugten Ausführungsform, daher ist ihre Erklärung hier weggelassen worden.
Nach dem Abschluss der Prozesse bis zum Schritt 208, werden für jedes in dem Codemuster-Registrierteil 16 registrierte Codemuster die Bereiche im Speicher zum Repräsentieren der Benutzungsfrequenz des Codemusters mit Priorität auf Codegröße USE[1], USE [2]... auf "0" initialisiert (Fig. 7, Schritt 501). Das USE[k] repräsentiert die Benutzungsfrequenz des Codemusters mit Priorität auf Codegröße hinsichtlich des an dem k-ten des Codemuster-Registrierteils 16 registrierten Codemusters.
Nach dem Abschluss der Initialisierung des Schritts 501 wird ein Vergleich an der durch einen Programmierer festgelegten Codegröße "USER" und der Codegröße mit Priorität auf Codegröße "CODE" durchgeführt (Schritt 502). Wenn die durch einen Programmierer festgelegte Codegröße "USER" unter der Codegröße mit Priorität auf Codegröße "CODE" liegt, wird der Wert der Benutzungsfrequenz "CNT[]" des Codemusters auf die Benutzungsfrequenz "USE"[] des Codemusters mit Priorität auf Codegröße gesetzt (Schritt 503). In bezug zu dem an dem k-ten des Codemuster-Registrierteils 16 registrierten Codemuster wird der Wert der Benutzungsfrequenz CNT[k] auf die Benutzungsfrequenz USE[k] des Codemusters mit Priorität auf Codegröße gesetzt.
Durch Setzen im Schritt 503 wird die Codeerzeugung mit Priorität an allen der Codemuster durchgeführt, indem der Codegröße Priorität gegeben wird. Nach Abschluss des Prozesses im Schritt 503 wird die Steuerung zu dem Codeerzeugungsteil 17 übertragen, und die Codeerzeugungsverarbeitung nach dem Schritt 511 wird durchgeführt.
Wenn im Schritt 502 die durch einen Programmierer festgelegte Codegröße "USER" größer als die Codegröße mit Priorität auf Codegröße "CODE" ist, wird der Bereich des Speichers "i" zum Repräsentieren der registrierten Zahl des Codemusters des Codemuster-Registrierteils 16 zu "1" initialisiert (Schritt 504), und die durch einen Programmierer festgelegte Codegröße "USER" wird mit der Codegröße einer auszugebenden Objektmoduldatei "SIZE" (Schritt 505) verglichen. Wenn die durch einen Programmierer festgelegte Codegröße "USER" über der Codegröße einer auszugebenden Objektmoduldatei "SIZE" liegt, wird die Steuerung zu dem Codeerzeugungsteil 17 übertragen, und die Codeerzeugungsprozesse in und nach dem Schritt 511 werden ausgeführt.
Im Schritt 505 ist die durch einen Programmierer festgelegte Codegröße "USER" kleiner als die Codegröße einer auszugebenden Objektmoduldatei "SIZE", und ein Vergleich wird zwischen dem Wert, der durch Subtrahieren des Produkts der Codegrößendifferenz D[i], die am i-ten des Codemuster-Registrierteils 16 registriert ist, und der Benutzungsfrequenz CNT[i] von der Codegröße einer auszugebenden Objektmoduldatei "SIZE" erhalten wird, und der Codegröße einer durch einen Programmierer festgelegten Objektmoduldatei "USER" durchgeführt (Schritt 506). Der im Schritt 506 zu verwendende Wert
"SIZE - D[i] x CNT [i]" ist die Codegröße einer auszugebenden Objektmoduldatei in dem Fall, wenn die Codeerzeugung mit Priorität auf Ausführungszeit durch die Codeerzeugung mit Priorität auf Codegröße an allen den Teilen ersetzt wird, wo das i-te Codemuster des Codemuster-Registrierteils 16 verwendet wird.
Im Schritt 506 liegt die durch einen Programmierer festgelegte Codegröße "USER" unter "SIZE - D[i] x CNT [i]", daher wird für das an dem i-ten des Codemuster-Registrierteils 16 registrierte Codemuster der Wert der Benutzungsfrequenz CNT[i] des Codemusters auf die Benutzungsfrequenz CNT[i] des Codemusters mit Priorität auf Codegröße gesetzt (Schritt 507), und "SIZE - D[i] x CNT [i]" wird zu der Codegröße einer auszugebenden Objektmoduldatei "SIZE" zurückgesetzt (Schritt 508). Nach Abschluss der Rücksetzung der Codegröße "SIZE" einer auszugebenden Objektmoduldatei im Schritt 508 wird "1" zu dem Inhalt der registrierten Zahl "i" des Codemusters des Codemuster-Registrierteils 16 addiert (Schritt 509), und die Abfolge kehrt zurück zum Schritt 505, und es wird ein Vergleich zwischen der durch einen Programmierer festgelegten Codegröße "USER" und der Codegröße einer auszugebenden, zurückgesetzten Objektmoduldatei "SIZE" durchgeführt.
Wenn im Schritt 506 die durch einen Programmierer festgelegte Codegröße "USER" größer als "SIZE - D[i] x CNT [i]" für das an dem i-ten des Codemuster-Registrierteils 16 registrierte Codemuster ist, wird eine solche Benutzungsfrequenz des Codemusters mit Priorität auf Codegröße so berechnet, dass sie unter der Codegröße einer auszugebenden Objektmoduldatei "USER" liegt, und sie wird auf USE[i] gesetzt (Schritt 510). Der im Schritt 510 einzusetzende Wert ist der minimale ganzzahlige Wert über (USER- SIZE)/D[i]. Nach Einsetzen von USE [i] wird die Steuerung zu dem Codeerzeugungsteil 17 übertragen, und die Codeerzeugungsprozesse in und nach dem Schritt 511 werden durchgeführt.
In dem Codeerzeugungsteil 17 wird beurteilt, ob die Codeerzeugung abgeschlossen ist oder nicht (Fig. 7, Schritt 511). Wenn die Codeerzeugung abgeschlossen ist, ob mehrere Codeerzeugungen ... oder nicht vorliegen (Schritt 512). Dies ist die gleiche wie die konventionelle Verarbeitung. Wenn nur eine Codeerzeugung vorliegt, wird die Codeerzeugung in der gleichen Weise wie das konventionelle Verfahren durchgeführt (Schritt 513). Wenn mehrere Codeerzeugungen vorliegen, wird die Registrierungszahl von Codemustern in dem Codemuster-Registrierteil 16 beurteilt (Schritt 514). Die Registrierungszahl des im Schritt 514 erhaltenen Codemusters wird als k eingesetzt.
Für das an dem k-ten des Codemuster-Registrierteils 16 registrierte Codemuster wird beurteilt, ob die Benutzungsfrequenz USE[k] des Codemusters mit Priorität auf Codegröße "0" ist oder nicht (Schritt 515), und wenn USE[k] "0" ist, wird die Steuerung zu dem Ausführungszeit-Prioritätscode-Erzeugungsteil 172 übertragen, und Codeerzeugung wird durch das Codemuster mit Priorität auf Ausführungszeit durchgeführt (Schritt 516). Wenn USE[k] nicht "0" ist, wird die Steuerung zu dem Codegrößen-Prioritätscode-Erzeugungsteil 171 übertragen, und Codeerzeugung wird durch das Codemuster mit Priorität auf Codegröße durchgeführt (Schritt 517), und "1" wird von dem Wert von USE[k] subtrahiert (Schritt 518). Nach Codeerzeugung am Schritt 513, Schritt 516 oder Schritt 517, 518 kehrt die Abfolge zurück zum Schritt 511, und es wird beurteilt, ob die Codeerzeugung abgeschlossen ist oder nicht, und wenn sie nicht abgeschlossen ist, wird die nächste Codeerzeugung durchgeführt. Und nach Abschluss aller der Codeerzeugungen wird die Steuerung zu dem Objektmoduldatei-Ausgabeteil 18 übertragen, und eine Objektmoduldatei 19 wird ausgegeben.
Die obige Verarbeitung soll nun anhand eines konkreten Beispiels erklärt werden. Fig. 9 ist ein Beispiel des registrierten Inhalts des Codemuster-Registrierteils 16. Wie in der Figur gezeigt, ist die Einheit der Codegröße in diesem Beispiel als Byte festgelegt, und die Einheit der Ausführungszeit ist als Takt festgelegt. Das in dem registrierten Inhalt in Fig. 9 gezeigte Codemuster ist das gleiche wie das des in Fig. 5 gezeigten registrierten Inhalts, aber die Codemuster weisen geringe Verschlechterung in der Ausführungszeit auf und sind effektiv für die Verringerung der Codegröße, wenn sie von der Codeerzeugung mit Priorität auf Ausführungszeit durch Codeerzeugung mit Priorität auf Codegröße ersetzt werden, und sie sind in Prioritätsreihenfolge registriert. In bezug auf Prioritätsnorm hat das Codemuster Priorität, bei dem der Wert, der durch Subtrahieren der Ausführungszeitdifferenz C[] von der Codegrößendifferenz D [] erhalten wurde, groß ist, und im dem Fall des gleichen Werts hat das Codemuster Priorität, bei dem die Ausführungszeitdifferenz C[] klein ist. Die Benutzungsfrequenzen des Codemusters CNT[1], CNT[2], ... werden im Schritt 204 eingestellt.
In bezug zu einer speziellen Quellprogrammdatei von der Messung der Codegröße in dem Codegrößen-Messteil 14 wird angenommen, dass die Codegröße einer durch einen Programmierer festgelegten Objektmoduldatei "USER" 1500 Bytes aufweist und die Codegröße einer Objektmoduldatei im Fall von Priorität auf Codegröße "CODE" 1200 Bytes aufweist und die Codegröße einer Objektmoduldatei im Fall von Priorität auf Ausführungszeit "SPEED" 1600 Bytes aufweist. Es sei ferner angenommen, dass die Benutzungsfrequenz des in dem Codemuster-Registrierteil 16 registrierten Codemusters CNT [] 52 Mal, 68 Mal, 40 Mal, 22 Mal, 26 Mal und 34 Mal in der Reihenfolge registrierter Zahlen ist.
Im Schritt 208 wird die Codegröße einer auszugebenden Objektmoduldatei "SIZE" auf 1600 Bytes in der gleichen Weise wie die Codegröße der Objektmoduldatei im Fall von Priorität auf Ausführungszeit "SPEED" eingestellt.
Im Schritt 501 werden alle die Benutzungsfrequenzen USE[] des Codemusters mit Priorität auf Codegröße auf "0" initialisiert.
Im Vergleich der Codegröße "USER" (1500 Bytes) und der Codegröße "CODE" (1200 Bytes) im Schritt 502 ist die Codegröße "USER" größer als die Codegröße "CODE", daher gelangt die Abfolge zum Schritt 504, und der Bereich im Speicher "i" zum Repräsentieren der registrierten Zahl des Codemusters des Codemuster-Registrierteils 16 wird zu "1" initialisiert.
Im Vergleich der Codegröße "USER" (1500 Bytes) und der Codegröße "SIZE" (1600 Bytes) im Schritt 505 ist die Codegröße "USER" kleiner als die Codegröße "SIZE", daher wird die Verarbeitung zum Schritt 506 übertragen. Nach Fig. 9 ist die Codegrößendifferenz D[1] 2 Bytes und die Codemuster-Benutzungsfrequenz CNT[1] ist 52 Mal, daher wird im Schritt 506 ein Vergleich zwischen der Codegröße "USER" (1500 Bytes) und der Codegröße "SIZE - D[1] · CNT [1]" (1600 - 2 · 52 Bytes) durchgeführt.
Die Codegröße "USER" ist größer als die Codegröße "SIZE - D [1] · CNT [1]", daher wird die Verarbeitung zum Schritt 510 übertragen, in dem der minimale ganzzahlige Wert über (USER-SIZE)/ D[1] auf USE [1] gesetzt wird. Da (1600 - 1500)/2 = 50, wird 50 auf USE[1] eingesetzt. Unter den 52 Malen der Benutzungsfrequenz des zuerst registrierten Codemusters wird 50 Mal die Codeerzeugung mit Priorität auf Codegröße durchgeführt, und für die verbleibenden 2 Male wird die Codeerzeugung mit Priorität auf Ausführungszeit durchgeführt.
Wenn die Codeerzeugung hinsichtlich des ersten Codemusters erfolgt, wird die Verarbeitung zum Schritt 517 übertragen, bis der Wert von USE[1] "0" wird, und die Codeerzeugung mit Priorität auf Codegröße wird durchgeführt, und im Schritt 518 wird "1" von dem Wert von USE[1] subtrahiert. Wenn der Wert von USE[1] "0" wird, wird die Verarbeitung zum Schritt 516 übertragen, und die Codeerzeugung mit Priorität auf Ausführungszeit wird durchgeführt. Da der Wert von USE[] "0" ist, wird für das Codemuster in und nach der Sekunde die Verarbeitung zum Schritt 516 übertragen, und die Codeerzeugung mit Priorität auf Ausführungszeit wird durchgeführt. Und nach Abschluss aller der Codeerzeugungen wird eine Objektmoduldatei ausgegeben.
Die Codegröße der ausgegebenen Objektmoduldatei wird 1500 Bytes, was die Bedingung erfüllt, dass die Codegröße einer von einem Programmierer gewünschten Objektmoduldatei unter 1500 Bytes liegen sollte. Und da das Codemuster mit Priorität auf Ausführungszeit eingeschlossen ist, wird die Ausführungszeit kürzer als eine Objektmoduldatei im Fall von Priorität auf Codegröße. Und weiter wird hinsichtlich der Ersetzung zum Begrenzen der Verschlechterung in der Ausführungszeit die Ausführungszeit kürzer als bei der ersten bevorzugten Ausführungsform.
Wie oben beschrieben ist, werden in der vorliegenden Erfindung die Codegröße im Fall von Priorität auf Codegröße und die Benutzungsfrequenz des registrierten Codemusters, und die Codegröße im Fall von Priorität auf Ausführungszeit gemessen, und ein Teil oder die gesamten Codeerzeugungen im Fall von Priorität auf Ausführungszeit wird mit den Codeerzeugungen im Fall von Priorität auf Codegröße ersetzt, bis sie in der durch einen Programmierer festgelegten Codegröße gespeichert werden und eine Objektmoduldatei ausgegeben wird. Dementsprechend ist es möglich, einen Code bei einer wahlweisen Größe zwischen der konventionellen Codeerzeugung mit Priorität auf Codegröße und der Codeerzeugung mit Priorität auf Ausführungszeit zu erzeugen, und als Ergebnis ist es möglich, eine Objektmoduldatei mit einer kurzen Ausführungszeit in der durch einen Programmierer festgelegten Codegröße auszugeben.
Wie vorhergehend hier beschrieben wurde, gibt es gemäß einer Sprachverarbeitungseinheit und einem Sprachverarbeitungsverfahren der vorliegenden Erfindung einen Effekt, dass es möglich ist, die Verschlechterung in der Ausführungszeit zu begrenzen und die Codegröße einer Objektmoduldatei durch Ersetzen eines Teils der Codeerzeugungen mit Priorität auf Ausführungszeit anzupassen und dadurch die Codegröße zu verkürzen.
Dadurch gibt es einen anderen Effekt, dass es möglich ist, die Mühe für einen Programmierer zu beseitigen, eine Objektmoduldatei neu zu schreiben und die Codegröße einer Objektmoduldatei anzupassen, wenn eine Objektmoduldatei, die die Codeerzeugung mit Priorität auf Ausführungszeit ausgeführt hat, nicht in der durch einen Programmierer gewünschten Codegröße gespeichert sein sollte.
Und darüber hinaus gibt es einen weiteren Effekt, dass es möglicht ist, die Ausführungszeit durch Anpassen der Codegröße einer Objektmoduldatei zu verbessern, so dass eine Objektmoduldatei, die die Codeerzeugung mit Priorität auf Codegröße durchgeführt hat, viel kleiner als die durch einen Programmierer gewünschte Größe wird, und ist es möglich, eine Objektmoduldatei mit einer kürzeren Ausführungszeit durch Vergrößern der Codegröße einer Objektmoduldatei bis zu der von einem Programmierer gewünschten Codegröße zu erzeugen.

Claims

1. Sprachverarbeitungseinheit zum Übersetzen eines Quellprogramms in eine Objektmoduldatei mit:

Syntaxanalysemitteln (13) zum Eingeben und Analysieren eines Quellprogramms,

Codemuster-Registermittel (16) zum Registrieren eines Codeerzeugungsverfahrens und von Codegrößendifferenzen an unterschiedlichen Codemustern im Fall der Codeerzeugung, um eine Priorität darauf zu setzen, dass die Größe einer Objekmoduldatei klein gestaltet wird, und im Fall der Codeerzeugung die Priorität auf eine kurze Ausführungszeit zu setzen,

Codegrößen-Messmitteln (14) zum Messen der Größe einer Objektmoduldatei im Fall der Codeerzeugung mit Priorität auf der Herstellung einer kleinen Objektmoduldatei, und der Größe einer Objektmoduldatei im Fall der Codeerzeugung mit Priorität auf kurze Ausführungszeit, gemäß einem Analyseergebnis der Syntaxanalysemittel (13) und zum Zählen der Anzahl von Auftritten jedes Musters der Ausgabecodes, die in dem Codemuster-Registermitteln (16) registriert sind, in generierten Operationscodes,

Codemuster-Auswahlmitteln (15) zum Ersetzen eines Teils oder des Ganzen der Codeerzeugung mit Priorität auf der Ausführungszeit einer Objektmoduldatei durch Erzeugen von Codes mit Priorität auf der Größe einer Objektmoduldatei, so dass sie innerhalb der Codegröße einer Objektmoduldatei gespeichert werden können, die durch einen Programmierer mit Bezug auf die Messergebnisse der Codegrößen-Messmittel (14) und des registrierten Inhalts der Codemuster-Registriermittel (16) ausgelegt wurde,

Codeerzeugungsmitteln (17) zur Erzeugung eines Operationscodes entsprechend eines Analyseergebnisses durch die Syntaxanalysemittel (13) in Übereinstimmung mit den Auswahlergebnissen der Codemuster-Auswahlmittel (15), Objektmoduldatei-Ausgabemitteln (18) zum Ausgeben des Operationscodes, der durch die Codeerzeugungsmittel (17) erzeugt wurde, als eine Objektmoduldatei.

2. Sprachverarbeitungseinheit nach Anspruch 1, wobei

die Codemuster-Registermittel (16) Codemuster in einer solchen Reihenfolge registrieren, dass die Verschlechterung in der Ausführungszeit einer Objektmoduldatei beschränkt ist und die Größe der Objektmoduldatei kleiner wird.

3. Sprachverarbeitungseinheit nach Anspruch 1, wobei

die Codemuster-Auswahlmittel (15) die Anzahlen von Codeerzeugung mit Priorität auf der Größe einer Objektmoduldatei unter den Benutzungsfrequenzen jedes Codemusters entscheiden.

4. Sprachverarbeitungseinheit nach Anspruch 1, wobei

die Codemuster-Registermittel (16) Codemuster in einer solchen Reihenfolge registrieren, dass die Verschlechterung der Ausführungszeit einer Objektmoduldatei beschränkt ist und die Größe einer Objektmoduldatei verkleinert ist und

wobei die Codemuster-Auswahlmittel (15) die Anzahlen von Codeerzeugung mit Priorität auf der Größe einer Objektmoduldatei unter den Benutzungsfrequenzen jedes Codemusters entscheiden.

5. Sprachverarbeitungsverfahren zum Übersetzen eines Quellprogramms in eine Objektmoduldatei mit den Schritten:

Eingeben und Analysieren eines Quellprogramms,

Messen der Größe einer Objektmoduldatei im Fall von Codeerzeugung mit Priorität auf Verringern der Größe einer Objektmoduldatei und der Größe einer Objektmoduldatei für den Fall der Codeerzeugung mit Priorität auf Verkürzen der Ausführungszeit entsprechend eines Analyseergebnisses durch den Quellprogrammanalyseschritt und Zählen der Anzahlen von Auftreten jedes Musters der Ausgangscodes, die von den erzeugten Operationscodes registriert wurden,

selektives Ersetzen eines Teils oder des Ganzen der Codeerzeugung mit Priorität auf der Ausführungszeit einer Objektmoduldatei durch Codeerzeugung mit Priorität auf der Größe einer Objektmoduldatei, so dass sie innerhalb der Codegröße einer Objektmoduldatei gespeichert werden können, die durch einen Programmierer mit Bezug auf die Messergebnisse des Codegrößen-Messschrittes und der jeweiligen Codeerzeugungsverfahren und der Daten hinsichtlich der Codeerzeugung festgelegt wurden, die hinsichtlich unterschiedlicher Codemuster im Fall mit Priorität auf kleiner Größe der Objektmoduldatei und im Fall der Priorität mit verkürzter Ausführungszeit der Objektmoduldatei gesammelt wurden,

Erzeugen eines Operationscodes für das Programm, das durch den Quellprogramm-Analyseschritt analysiert wurde, entsprechend den Auswahlergebnissen durch den Codeerzeugung-Auswahlschritt, und

Ausgeben des Operationscodes, der durch den Operationscode-Erzeugungsschritt erzeugt wurde, als Objektmoduldatei.

6. Sprachverarbeitungsverfahren nach Anspruch 5, wobei

sich der Codeerzeugungs-Auswahlschritt auf Daten bezieht, die anhand von Codemustern gesammelt wurden, um die Verschlechterung in der Ausführungszeit einer Objektmoduldatei zu beschränken und die Größe einer Objektmoduldatei zu verkleinern.

7. Sprachverarbeitungsverfahren nach Anspruch 5, wobei

der Codeerzeugungs-Auswahlschritt die Anzahlen von Codeerzeugung mit Priorität auf der Größe einer Objektmoduldatei aufgrund der Benutzungsfrequenzen jedes Codemusters entscheidet.

8. Sprachverarbeitungsverfahren nach Anspruch 5, wobei

der Codeerzeugungs-Auswahlschritt sich auf Daten bezieht, die anhand der Codemuster gesammelt wurden, in der Reihenfolge, um die Verschlechterung der Ausführungszeit einer Objektmoduldatei zu beschränken und die Größe einer Objektmoduldatei zu verkleinern, und

wobei der Codeerzeugungs-Auswahlschritt die Anzahlen von Codeerzeugung mit Priorität auf die Größe einer Objektmoduldatei aufgrund der Benutzungsfrequenzen jedes Codemusters entscheidet.