Compiler to interpreter: experiences with a distributed programming language

One interpretive approach for handling concurrency is to provide an interpreter instance for each executing language‐level process. Such an approach has mainly been applied to concurrent implementations of logic and functional languages. This paper describes the use of this approach in constructing...

Celý popis

Uložené v:
Podrobná bibliografia
Vydané v:Software, practice & experience Ročník 31; číslo 9; s. 893 - 909
Hlavní autori: Gebala, Robert M., McNamee, Carole M., Olsson, Ronald A.
Médium: Journal Article
Jazyk:English
Vydavateľské údaje: Chichester, UK John Wiley & Sons, Ltd 25.07.2001
Predmet:
Compilers
Computer programs
Concurrency
concurrent programming language implementation
concurrent programming languages
Interpreters
Java (programming language)
Logic
process communication and synchronization
Programming languages
Run time (computers)
ISSN:0038-0644, 1097-024X
On-line prístup:Získať plný text
Tagy: Pridať tag
Žiadne tagy, Buďte prvý, kto otaguje tento záznam!
Popis
Shrnutí:One interpretive approach for handling concurrency is to provide an interpreter instance for each executing language‐level process. Such an approach has mainly been applied to concurrent implementations of logic and functional languages. This paper describes the use of this approach in constructing an interpreter for an imperative, distributed programming language from an existing compiler and run‐time support system (RTS). Primary design goals were to exploit the existing compiler to the extent possible as well as to have minimal impact on the RTS used to support concurrency. We have been successful in meeting these goals. Additionally, performance results show our interpreter's execution times compare favorably to the times required for compilation, linkage, and execution of small programs or programs with a significant number of calls to the RTS; on such programs, our interpreter's performance also compares favorably to that of the standard Java implementation. However, for larger programs and programs with fewer calls to the underlying RTS, the conventional compiler‐based implementation outperforms the interpreter implementation. For many distributed programs in which network costs dominate, the performances of the two implementations differ little. Copyright © 2001 John Wiley & Sons, Ltd.
Bibliografia:istex:00622476266123276F3BDC8F2C0869CEE142E925
ArticleID:SPE393
ark:/67375/WNG-N9M92M1D-Q
ObjectType-Article-1
SourceType-Scholarly Journals-1
ObjectType-Feature-2
content type line 23
ObjectType-Article-2
ObjectType-Feature-1
ISSN:0038-0644
1097-024X
DOI:10.1002/spe.393