Loading…

Improved RISC Support for the Smalltalk-80 Language

The Smalltalk-80 language is polymorphic and dynamically typed. That is, subprograms (methods in Smalltalk jargon) legally may operate on arguments of different types; the method invoked as a result of a given textual call (send) depends on the type (class) of the first operand; and the classes of l...

Full description

Saved in:
Bibliographic Details
Main Author: Hilfinger, Paul N
Format: Report
Language:English
Subjects:
Online Access:Request full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by
cites
container_end_page
container_issue
container_start_page
container_title
container_volume
creator Hilfinger, Paul N
description The Smalltalk-80 language is polymorphic and dynamically typed. That is, subprograms (methods in Smalltalk jargon) legally may operate on arguments of different types; the method invoked as a result of a given textual call (send) depends on the type (class) of the first operand; and the classes of local variables, parameters, and fields (instance variables) in general cannot be deduced at compilation time. Because all sends can involve polymorphism, a straightforward implementation requires run-time dispatching on the class of the first operand for every send. Typical Samlltalk-80 coding style results in many small methods, implying that sends figure prominently in dynamic instruction counts, and that their fast execution is important. There are two basic ways that have been used to reduce the time required for a polymorphic send. First, one can use some form of method caching. Second, one can use type inference and in-line substitution. Polymorphism is relatively rare; about 5% of sends reach the same target on consecutive executions. As a result, it makes sense to save the result of each method look up operation so that it can be quickly retrieved upon subsequent re-execution of the same text. Ungar describes the in-line caching scheme used in the SOAR project at Berkeley, in which the result of each look up is saved by replacing the look up code with a direct call on the method found.
format report
fullrecord <record><control><sourceid>dtic_1RU</sourceid><recordid>TN_cdi_dtic_stinet_ADA179325</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>ADA179325</sourcerecordid><originalsourceid>FETCH-dtic_stinet_ADA1793253</originalsourceid><addsrcrecordid>eNrjZDD2zC0oyi9LTVEI8gx2VgguLSjILypRSMsvUijJSFUIzk3MySlJzMnWtTBQ8EnMSy9NTE_lYWBNS8wpTuWF0twMMm6uIc4euiklmcnxxSWZeakl8Y4ujobmlsZGpsYEpAHNRyhm</addsrcrecordid><sourcetype>Open Access Repository</sourcetype><iscdi>true</iscdi><recordtype>report</recordtype></control><display><type>report</type><title>Improved RISC Support for the Smalltalk-80 Language</title><source>DTIC Technical Reports</source><creator>Hilfinger, Paul N</creator><creatorcontrib>Hilfinger, Paul N ; CALIFORNIA UNIV BERKELEY DEPT OF COMPUTER SCIENCES</creatorcontrib><description>The Smalltalk-80 language is polymorphic and dynamically typed. That is, subprograms (methods in Smalltalk jargon) legally may operate on arguments of different types; the method invoked as a result of a given textual call (send) depends on the type (class) of the first operand; and the classes of local variables, parameters, and fields (instance variables) in general cannot be deduced at compilation time. Because all sends can involve polymorphism, a straightforward implementation requires run-time dispatching on the class of the first operand for every send. Typical Samlltalk-80 coding style results in many small methods, implying that sends figure prominently in dynamic instruction counts, and that their fast execution is important. There are two basic ways that have been used to reduce the time required for a polymorphic send. First, one can use some form of method caching. Second, one can use type inference and in-line substitution. Polymorphism is relatively rare; about 5% of sends reach the same target on consecutive executions. As a result, it makes sense to save the result of each method look up operation so that it can be quickly retrieved upon subsequent re-execution of the same text. Ungar describes the in-line caching scheme used in the SOAR project at Berkeley, in which the result of each look up is saved by replacing the look up code with a direct call on the method found.</description><language>eng</language><subject>COMPILERS ; COMPUTER ARCHITECTURE ; Computer Hardware ; Computer Programming and Software ; COUNTING METHODS ; DYNAMICS ; HIGH LEVEL LANGUAGES ; INSTRUCTIONS ; POLYMORPHISM ; Smalltalk 80 programming lanugage ; SOAR computer architecture ; VARIABLES</subject><creationdate>1987</creationdate><rights>Approved for public release; distribution is unlimited.</rights><oa>free_for_read</oa><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>230,776,881,27543,27544</link.rule.ids><linktorsrc>$$Uhttps://apps.dtic.mil/sti/citations/ADA179325$$EView_record_in_DTIC$$FView_record_in_$$GDTIC$$Hfree_for_read</linktorsrc></links><search><creatorcontrib>Hilfinger, Paul N</creatorcontrib><creatorcontrib>CALIFORNIA UNIV BERKELEY DEPT OF COMPUTER SCIENCES</creatorcontrib><title>Improved RISC Support for the Smalltalk-80 Language</title><description>The Smalltalk-80 language is polymorphic and dynamically typed. That is, subprograms (methods in Smalltalk jargon) legally may operate on arguments of different types; the method invoked as a result of a given textual call (send) depends on the type (class) of the first operand; and the classes of local variables, parameters, and fields (instance variables) in general cannot be deduced at compilation time. Because all sends can involve polymorphism, a straightforward implementation requires run-time dispatching on the class of the first operand for every send. Typical Samlltalk-80 coding style results in many small methods, implying that sends figure prominently in dynamic instruction counts, and that their fast execution is important. There are two basic ways that have been used to reduce the time required for a polymorphic send. First, one can use some form of method caching. Second, one can use type inference and in-line substitution. Polymorphism is relatively rare; about 5% of sends reach the same target on consecutive executions. As a result, it makes sense to save the result of each method look up operation so that it can be quickly retrieved upon subsequent re-execution of the same text. Ungar describes the in-line caching scheme used in the SOAR project at Berkeley, in which the result of each look up is saved by replacing the look up code with a direct call on the method found.</description><subject>COMPILERS</subject><subject>COMPUTER ARCHITECTURE</subject><subject>Computer Hardware</subject><subject>Computer Programming and Software</subject><subject>COUNTING METHODS</subject><subject>DYNAMICS</subject><subject>HIGH LEVEL LANGUAGES</subject><subject>INSTRUCTIONS</subject><subject>POLYMORPHISM</subject><subject>Smalltalk 80 programming lanugage</subject><subject>SOAR computer architecture</subject><subject>VARIABLES</subject><fulltext>true</fulltext><rsrctype>report</rsrctype><creationdate>1987</creationdate><recordtype>report</recordtype><sourceid>1RU</sourceid><recordid>eNrjZDD2zC0oyi9LTVEI8gx2VgguLSjILypRSMsvUijJSFUIzk3MySlJzMnWtTBQ8EnMSy9NTE_lYWBNS8wpTuWF0twMMm6uIc4euiklmcnxxSWZeakl8Y4ujobmlsZGpsYEpAHNRyhm</recordid><startdate>19870316</startdate><enddate>19870316</enddate><creator>Hilfinger, Paul N</creator><scope>1RU</scope><scope>BHM</scope></search><sort><creationdate>19870316</creationdate><title>Improved RISC Support for the Smalltalk-80 Language</title><author>Hilfinger, Paul N</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-dtic_stinet_ADA1793253</frbrgroupid><rsrctype>reports</rsrctype><prefilter>reports</prefilter><language>eng</language><creationdate>1987</creationdate><topic>COMPILERS</topic><topic>COMPUTER ARCHITECTURE</topic><topic>Computer Hardware</topic><topic>Computer Programming and Software</topic><topic>COUNTING METHODS</topic><topic>DYNAMICS</topic><topic>HIGH LEVEL LANGUAGES</topic><topic>INSTRUCTIONS</topic><topic>POLYMORPHISM</topic><topic>Smalltalk 80 programming lanugage</topic><topic>SOAR computer architecture</topic><topic>VARIABLES</topic><toplevel>online_resources</toplevel><creatorcontrib>Hilfinger, Paul N</creatorcontrib><creatorcontrib>CALIFORNIA UNIV BERKELEY DEPT OF COMPUTER SCIENCES</creatorcontrib><collection>DTIC Technical Reports</collection><collection>DTIC STINET</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext_linktorsrc</fulltext></delivery><addata><au>Hilfinger, Paul N</au><aucorp>CALIFORNIA UNIV BERKELEY DEPT OF COMPUTER SCIENCES</aucorp><format>book</format><genre>unknown</genre><ristype>RPRT</ristype><btitle>Improved RISC Support for the Smalltalk-80 Language</btitle><date>1987-03-16</date><risdate>1987</risdate><abstract>The Smalltalk-80 language is polymorphic and dynamically typed. That is, subprograms (methods in Smalltalk jargon) legally may operate on arguments of different types; the method invoked as a result of a given textual call (send) depends on the type (class) of the first operand; and the classes of local variables, parameters, and fields (instance variables) in general cannot be deduced at compilation time. Because all sends can involve polymorphism, a straightforward implementation requires run-time dispatching on the class of the first operand for every send. Typical Samlltalk-80 coding style results in many small methods, implying that sends figure prominently in dynamic instruction counts, and that their fast execution is important. There are two basic ways that have been used to reduce the time required for a polymorphic send. First, one can use some form of method caching. Second, one can use type inference and in-line substitution. Polymorphism is relatively rare; about 5% of sends reach the same target on consecutive executions. As a result, it makes sense to save the result of each method look up operation so that it can be quickly retrieved upon subsequent re-execution of the same text. Ungar describes the in-line caching scheme used in the SOAR project at Berkeley, in which the result of each look up is saved by replacing the look up code with a direct call on the method found.</abstract><oa>free_for_read</oa></addata></record>
fulltext fulltext_linktorsrc
identifier
ispartof
issn
language eng
recordid cdi_dtic_stinet_ADA179325
source DTIC Technical Reports
subjects COMPILERS
COMPUTER ARCHITECTURE
Computer Hardware
Computer Programming and Software
COUNTING METHODS
DYNAMICS
HIGH LEVEL LANGUAGES
INSTRUCTIONS
POLYMORPHISM
Smalltalk 80 programming lanugage
SOAR computer architecture
VARIABLES
title Improved RISC Support for the Smalltalk-80 Language
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-02-24T12%3A23%3A39IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-dtic_1RU&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=unknown&rft.btitle=Improved%20RISC%20Support%20for%20the%20Smalltalk-80%20Language&rft.au=Hilfinger,%20Paul%20N&rft.aucorp=CALIFORNIA%20UNIV%20BERKELEY%20DEPT%20OF%20COMPUTER%20SCIENCES&rft.date=1987-03-16&rft_id=info:doi/&rft_dat=%3Cdtic_1RU%3EADA179325%3C/dtic_1RU%3E%3Cgrp_id%3Ecdi_FETCH-dtic_stinet_ADA1793253%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_id=info:pmid/&rfr_iscdi=true