ACM Home Page
Please provide us with feedback. Feedback
Copying operands versus copying results: A solution to the problem of large operands in FFP'S
Full text PdfPdf (418 KB)
Source Functional Programming Languages and Computer Architecture archive
Proceedings of the 1981 conference on Functional programming languages and computer architecture table of contents
Portsmouth, New Hampshire, United States
Pages: 93 - 98  
Year of Publication: 1981
ISBN:0-89791-060-5
Author
Gyula Magó  Department of Computer Science, University of North Carolina at Chapel Hill
Sponsors
SIGPLAN: ACM Special Interest Group on Programming Languages
SIGOPS: ACM Special Interest Group on Operating Systems
MIT : Massachusetts Institute of Technology
SIGARCH: ACM Special Interest Group on Computer Architecture
Publisher
ACM  New York, NY, USA
Bibliometrics
Downloads (6 Weeks): 2,   Downloads (12 Months): 11,   Citation Count: 4
Additional Information:

abstract   references   cited by   index terms   collaborative colleagues  

Tools and Actions: Request Permissions Request Permissions    Review this Article  
DOI Bookmark: Use this link to bookmark this Article: http://doi.acm.org/10.1145/800223.806767
What is a DOI?

ABSTRACT

In functional programming languages with reduction semantics, operators “use up” their operands to produce their results. This makes it difficult to execute efficiently certain computations, such as one in which several operators are applied—in succession or in parallel—to a large operand. The problem is that providing each operator with a separate copy of the large operand is a costly operation in most computer models. This paper proposes a solution to this problem in the context of a cellular computer that directly executes FFPs. The operators involved are applied in succession to the large operand, and only their results (with the exception of that of the last operator applied) need be moved. Providing each operator with a fresh copy of the large operand incurs no overhead in time. The proposed solution often allows one to avoid unproductive copying, and to suppress parallelism when it does not pay. The functional forms conditional, WHILE loop and construction are among the examples discussed. For example, when executing the conditional usually both the predicate and one of the “arms” of the conditional are applied to the operand. Since the result of the predicate computation is small, the overhead in the execution time of the conditional is negligible. A recursive matrix multiplication program described by Backus uses conditional and construction extensively. The proposed implementation technique reduces the execution time of this program on the cellular computer in question from O(n3) to O(n2).


REFERENCES

Note: OCR errors may be found in this Reference List extracted from the full text article. ACM has opted to expose the complete List rather than only correct and linked references.

 
1
 
2
ARVIND, 'Decomposing a program for multiple processor systems.' Proceedings of the 1980 International Conference on Parallel Processing, (August 1980), 7-14.
3
 
4
MAGO, G. A. 'A network of microprocessors to execute reduction languages.' Two parts. International Journal of Computer and Information Sciences 8, 5 (1979) 349-385, 8, 6 (1979) 435-471.
 
5
MAGO, G. A., STANAT, D. F. and KOSTER, A. 'Program execution in a cellular computer: some matrix algorithms' (in preparation).
 
6
MAGO, G. A. 'A cellular computer architecture for functional programming', Digest of Papers, IEEE Computer Society COMPCON, (Spring 1980), 179-187
7