Abstract
Strictness analysis is crucial for the efficient implementation of the lazy functional languages. A related technique for the concurrent logic languages (CLLs) called schedule analysis is presented which divides at compile-time a CLL program into threads of totally ordered atoms, whose relative ordering is determined at run-time. The technique enables the enqueuing and dequeuing of processes to be reduced, synchronisation tests to be partially removed, introduces the possibility of using unboxed arguments, and permits variables to be migrated from a heap to a stack to affect a form of compile-time garbage collection. The implementation is outlined and some preliminary results are given.
This is a preview of subscription content, log in via an institution to check access.
Preview
Unable to display preview. Download preview PDF.
References
Traub, K.R. (1989). “Compiling as Partitioning: A New Approach to Compiling Nonstrict Functional Languages”, in Proceedings of the Fourth International Conference on Functional Programming, pp. 75–88. ACM Press.
Shapiro, E.Y. (1989). “The Family of Concurrent Logic Programming Languages”, Journal of ACM Computing Surveys, 21 (3): 413–510.
Gregory, S. (1987). Parallel Logic Programming in Parlog, The Language and its Implementation. Addison-Wesley.
Crammond, J.A. (1988). Implementation of Committed-Choice Logic Languages on Shared Memory Multiprocessors. PhD thesis, Heriot-Watt University, Edinburgh.
King, A. and P. Soper (1990). “Granularity Analysis of Concurrent Logic Programs”, in The Fifth International Symposium on Computer and Information Sciences, Nevsehir, Cappadocia, Turkey.
King, A. and P. Soper (1990). “Schedule Analysis of Concurrent Logic Programs”, Technical Report 90-22, Department of Electronics and Computer Science, Southampton University, Southampton, S09 5NH.
King, A. and P. Soper (1991). “A Semantic Approach to Producer and Consumer Analysis”, International Conference on Logic Programming Workshop on Concurrent Logic Programming, Paris, France.
Codish, M., D. Dams, and E. Yardeni (1990). “Derivation and Safety of an Abstract Unification Algorithm for Groundness and Aliasing Analysis”, Technical Report CS90-28, Department of Computer Science, Weizmann Institute of Science, Rehovot 76100, Isreal.
Carré, B. (1979). Graphs and Networks. Clarendon Press, Oxford.
Karp, R.M. (1972). Complexity of Computer Computations, chapter Reducibility among Combinatorial Problems, pp. 85–103. Plenum Press.
D.W. Matula, G. Marble and J.D. Isaacson (1972). Graph theory and computing, chapter Graph colouring algorithms, pp. 109–122. Academic Press, London. Edited by R.C. Read.
Tiernan, J.C. (1970). “An efficient search algorithm to find the elementary ciccuits of a graph”, Communications of the ACM, 13: 722–726.
Francez, N., O. Grumberg, S. Katz, and A. Pnueli (1985). “Proving Termination of Logic Programs”, in Proceedings of Logics of Programs Conference, pp. 89–105, Brooklyn, NY. Springer-Verlag.
Ullman, J.D. and A. Van Gelder (1988). “Top-down Termination of Logical Rules”, Journal of the ACM, 35 (2): 345–373.
Walther, C. (1988). Automated Termination Proofs. PhD thesis, University of Karlsruhe.
Apt, K.R., R.N. Bol, and J.W. Klop (1989). “On the safe termination of Prolog programs”' in Proceedings of the Sixth International Conference on Logic Programming, pp. 353–368, Lisboa, Portugal. MIT Press.
Bezem, M. (1989). “Characterizing Termination of Logic Programs with Level Mappings”, in Proceedings of the North American Conference on Logic Programming, pp. 69–80, Case Western Reserve University, Cleveland, Ohio.
Gelder, A. Van (1990). “Deriving Constraints Among Argument Sizes in Logic Programs”, in Proceedings of the Ninth ACM Symposium on Principles of Database Systems, Nashville, Tennessee.
Plumer, L. (1990). “Termination Proofs for Logic Programs based on Predicate Inequalities”, in Proceedings of the Seventh International Conference on Logic Programming, Jerusalem, Isreal.
Wang, B. and R. K. Shyamasundar (1990). “Towards a Characterisation of the Termination of Logic Programs”, in The Second International Workshop on Programming Language Implementation and Logic Programming, pp. 204–221, Linkoping, Sweden. Springer-Verlag.
Sato, M., H. Shimizu, A. Matsumoto, K. Rokusawa, and A. Goto (1987). “KL1 Execution Model for PIM Cluster with Shared Memory”, in Proceedings of the Fourth International Conference, pp. 338–355.
Author information
Authors and Affiliations
Editor information
Rights and permissions
Copyright information
© 1991 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
King, A., Soper, P. (1991). Reducing scheduling overheads for concurrent logic programs. In: Boley, H., Richter, M.M. (eds) Processing Declarative Knowledge. PDK 1991. Lecture Notes in Computer Science, vol 567. Springer, Berlin, Heidelberg. https://doi.org/10.1007/BFb0013537
Download citation
DOI: https://doi.org/10.1007/BFb0013537
Published:
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-540-55033-4
Online ISBN: 978-3-540-46667-3
eBook Packages: Springer Book Archive