Bhaskaram Prabhala

dblp:20/2856 · DBLP profile ↗
← Back
3ranked-venue papers
3as first author
0since 2021 · last 1980
—ORCID · none

Domains — the database's venue-derived domains; a paper can count in several

Software engineering, systems software and programming languages · 1 · 1 first-authorTheory of computation · 1 · 1 first-authorApplied, interdisciplinary, general and emerging computing · 1 · 1 first-author

Expertise — from the expertise taxonomy: the topics of the expert's papers under the CCF categories. A weight counts papers with recency: 1 for a paper about the topic, 0.3 when the topic is its context, halved every five years.

Software engineering, system software, and programming languages
3 papers
Compilers and program optimization · 100%
Theoretical computer science
2 papers
Graph algorithms and graph theory · 82% Algorithms and data structures · 18%
Computer architecture, parallel and distributed computing, and storage systems
1 paper
Processor architecture and microarchitecture · 100%

Topics — the 5 heaviest of 6, each with the papers that count most for it

TopicWeightPapersLastEvidence papers
Compilers and program optimization
code generation
0.021980
Efficient Computation of Expressions with Common Subexpressions · J. ACM 1980
A Comparison of Instruction Sets for Stack Machines · STOC 1977
Compilers and program optimization › code generation
optimal code generation
0.011980
Efficient Computation of Expressions with Common Subexpressions · J. ACM 1980
Graph algorithms and graph theory › graph classes › sparse graphs
series-parallel graphs
0.011980
Efficient Computation of Expressions with Common Subexpressions · J. ACM 1980
Compilers and program optimization › compiler optimization › redundancy elimination
common subexpression elimination
0.011978
Efficient Computation of Expressions with Common Subexpressions · POPL 1978
Processor architecture and microarchitecture
instruction set architecture
0.011977
A Comparison of Instruction Sets for Stack Machines · STOC 1977
YearPublicationVenuePosition
1980 Efficient Computation of Expressions with Common Subexpressions
abstract
Previous results have shown that it ~s easy to generate optimal code from express,on trees, and that optimal code generauon becomes very difficult ff arbitrary common subexpress,ons are handled In this paper a class of expressions containing restricted common subexpressions from which optimal code can be generated effictentty is studied.These expressions are represented by a class of series-parallel graphs, which the authors call collapsible graphs, that mchide trees and are general enough to permit large common subexpresslons, but from which optmml code can be generated m polynomml time for a class of stack machines KEY WORDS AND PHRASES" reg,ster allocaUon, code generation, polynomml algorithm, series-parallel graphs, common subexpresslons, stack machines CR CATEGORIES. 4 12, 5.25 15, lq.Elaborating on (b) above, Bruno and Sethi [11] show that the problem of generating optimal code for a one-register machine is NP-complete.Aho et al. [5] add that even when all common subexpressions have exactly one operaUon, optimal code generation is NPcomplete for a one-register machine and also for an infinite-register machine. 1 Since the stack machines we consider are a generalization of one-register machines, the NP-completeness results from [5, 11] carry-over to stack machines.
Bhaskaram Prabhala, Ravi Sethi
J. ACM1
1978 Efficient Computation of Expressions with Common Subexpressions
Bhaskaram Prabhala, Ravi Sethi
POPL1
1977 A Comparison of Instruction Sets for Stack Machines
abstract
Suppose you are approached by a computer designer who wants to select a machine architecture and instruction set that is desirable from a compiler writers standpoint. What would you recommend, and why? We give a limited answer to the above question. We focus on the computation of arithmetic expressions like a−b+c. When computing a−b we need different instructions depending on where a and b are to be found. On a programmable calculator for example, a or b may be on the stack, or stored in some memory register. We also need instructions that copy values from one place to another. Algorithms that generate code for arithmetic expressions tend to treat general purpose registers as a stack. Moreover, results about machines that perform all arithmetic in a hardware stack are directly applicable to machines with general purpose registers. We therefore start our study of instruction sets by looking at stack machines. We compare machines based on the number of instructions needed to compute a given expression. We then turn to algorithms that generate optimal programs for computing expressions on the various machines.
Bhaskaram Prabhala, Ravi Sethi
STOC1