Skip to main content
×
×
Home

A concurrent constraint programming interpretation of access permissions

  • CARLOS OLARTE (a1), ELAINE PIMENTEL (a2) and CAMILO RUEDA (a3)
Abstract

A recent trend in object-oriented programming languages is the use of access permissions (APs) as an abstraction for controlling concurrent executions of programs. The use of AP source code annotations defines a protocol specifying how object references can access the mutable state of objects. Although the use of APs simplifies the task of writing concurrent code, an unsystematic use of them can lead to subtle problems. This paper presents a declarative interpretation of APs as linear concurrent constraint programs (lcc). We represent APs as constraints (i.e., formulas in logic) in an underlying constraint system whose entailment relation models the transformation rules of APs. Moreover, we use processes in lcc to model the dependencies imposed by APs, thus allowing the faithful representation of their flow in the program. We verify relevant properties about AP programs by taking advantage of the interpretation of lcc processes as formulas in Girard's intuitionistic linear logic (ILL). Properties include deadlock detection, program correctness (whether programs adhere to their AP specifications or not), and the ability of methods to run concurrently. By relying on a focusing discipline for ILL, we provide a complexity measure for proofs of the above-mentioned properties. The effectiveness of our verification techniques is demonstrated by implementing the Alcove tool that includes an animator and a verifier. The former executes the lcc model, observing the flow of APs, and quickly finding inconsistencies of the APs vis-à-vis the implementation. The latter is an automatic theorem prover based on ILL.

Copyright
References
Hide All
Abrial, J.-R., Butler, M. J., Hallerstede, S., Hoang, T. S., Mehta, F. and Voisin, L. 2010. Rodin: An open toolset for modelling and reasoning in event-b. International Journal on Software Tools for Technology Transfer 12, 6, 447466.
Andreoli, J.-M. 1992. Logic programming with focusing proofs in linear logic. Journal of Logic and Computation 2, 3, 297347.
Beckman, N. E., Bierhoff, K. and Aldrich, J. 2008. Verifying correct usage of atomic blocks and typestate. In OOPSLA, Harris, G. E., Ed. ACM, 227–244.
Bierhoff, K. and Aldrich, J. 2007. Modular typestate checking of aliased objects. In OOPSLA, Gabriel, R. P., Bacon, D. F., Lopes, C. V. and G. L. S. Jr., Eds. ACM, 301–320.
Boyland, J. 2003. Checking interference with fractional permissions. In SAS, Cousot, R., Ed. Lecture Notes in Computer Science, vol. 2694. Springer, 55–72.
Boyland, J., Noble, J. and Retert, W. 2001. Capabilities for sharing: A generalisation of uniqueness and read-only. In ECOOP, Knudsen, J. L., Ed. Lecture Notes in Computer Science, vol. 2072. Springer, 227.
de Boer, F. S., Gabbrielli, M., Marchiori, E. and Palamidessi, C. 1997. Proving concurrent constraint programs correct. ACM Transactions on Programming Languages and Systems 19, 5, 685725.
Fages, F., Ruet, P. and Soliman, S. 2001. Linear concurrent constraint programming: Operational and phase semantics. Information and Computation 165, 1, 1441.
Girard, J.-Y. 1987. Linear logic. Theoretical Computer Science 50, 1102.
Haemmerlé, R. 2011. Observational equivalences for linear logic concurrent constraint languages. Theory and Practice of Logic Programming 11, 45, 469485.
Igarashi, A., Pierce, B. C. and Wadler, P. 2001. Featherweight java: A minimal core calculus for java and GJ. ACM Transactions on Programming Languages and Systems 23, 3, 396450.
Jagadeesan, R., Marrero, W., Pitcher, C. and Saraswat, V. A. 2005. Timed constraint programming: A declarative approach to usage control. In PPDP, Barahona, P. and Felty, A. P., Eds. ACM, 164175.
Leino, K. R. M. 1998. Data groups: Specifying the modification of extended state. In OOPSLA, Freeman-Benson, B. N. and Chambers, C., Eds. ACM, 144153.
Leino, K. R. M. 2010. Verifying concurrent programs with Chalice. In VMCAI, Barthe, G. and Hermenegildo, M. V., Eds. Lecture Notes in Computer Science, Vol. 5944. Springer, 2.
Lincoln, P., Mitchell, J. C., Scedrov, A. and Shankar, N. 1992. Decision problems for propositional linear logic. Annals of Pure and Applied Logic 56, 1–3, 239311.
Martinez, T. 2010. Semantics-preserving translations between linear concurrent constraint programming and constraint handling rules. In PPDP, Kutsia, T., Schreiner, W. and Fernández, M., Eds. ACM, 5766.
Miller, D. and Nadathur, G. 2012. Programming with Higher-Order Logic. Cambridge University Press.
Nadathur, G. and Miller, D. 1988. An overview of lambda-prolog. In Logic Programming, Proc. of the 5th International Conference and Symposium, Kowalski, R. A. and Bowen, K. A., Eds. MIT Press, Seattle, Washington, August 15–19, 1988 (2 Volumes), 810827.
Naden, K., Bocchino, R., Aldrich, J. and Bierhoff, K. 2012. A type system for borrowing permissions. In POPL, Field, J. and Hicks, M., Eds. ACM, 557570.
Nielsen, M., Palamidessi, C. and Valencia, F. D. 2002. Temporal concurrent constraint programming: Denotation, logic and applications. Nordic Journal of Computing 9, 1, 145188.
Nigam, V. 2012. On the complexity of linear authorization logics. In LICS. IEEE, 511–520.
Olarte, C. and Pimentel, E. 2017. On concurrent behaviors and focusing in linear logic. Theoretical Computer Science 685, 4664.
Olarte, C., Pimentel, E., Rueda, C. and Cataño, N. 2012. A linear concurrent constraint approach for the automatic verification of access permissions. In PPDP, Schreye, D. D., Janssens, G. and King, A., Eds. ACM, 207216.
Olarte, C., Rueda, C. and Valencia, F. D. 2013. Models and emerging trends of concurrent constraint programming. Constraints 18, 535578.
Pottier, F. and Protzenko, J. 2013. Programming with permissions in mezzo. Special Interest Group on Programming Languages Notices 48, 9, 173184.
Saraswat, V. A. 1993. Concurrent Constraint Programming. MIT Press.
Saraswat, V. A. and Rinard, M. C. 1990. Concurrent constraint programming. In POPL, Allen, F. E., Ed. ACM Press, 232245.
Saraswat, V. A., Rinard, M. C. and Panangaden, P. 1991. Semantic foundations of concurrent constraint programming. In POPL, Wise, D. S., Ed. ACM Press, 333352.
Stork, S., Marques, P. and Aldrich, J. 2009. Concurrency by default: Using permissions to express dataflow in stateful programs. In OOPSLA Companion, Arora, S. and Leavens, G. T., Eds. ACM, 933940.
Stork, S., Naden, K., Sunshine, J., Mohr, M., Fonseca, A., Marques, P. and Aldrich, J. 2014. Æminium: A permission-based concurrent-by-default programming language approach. ACM Transactions on Programming Languages and Systems 36, 1, 2.
Sunshine, J., Naden, K., Stork, S., Aldrich, J. and Tanter, É. 2011. First-class state change in plaid. In OOPSLA, Lopes, C. V. and Fisher, K., Eds. ACM, 713732.
Ullrich, S. A. 2016. Simple Verification of Rust Programs via Functional Purification. Master's Thesis, Karlsruher Institut für Technologie (KIT).
Recommend this journal

Email your librarian or administrator to recommend adding this journal to your organisation's collection.

Theory and Practice of Logic Programming
  • ISSN: 1471-0684
  • EISSN: 1475-3081
  • URL: /core/journals/theory-and-practice-of-logic-programming
Please enter your name
Please enter a valid email address
Who would you like to send this to? *
×

Keywords

Metrics

Full text views

Total number of HTML views: 0
Total number of PDF views: 0 *
Loading metrics...

Abstract views

Total abstract views: 0 *
Loading metrics...

* Views captured on Cambridge Core between <date>. This data will be updated every 24 hours.

Usage data cannot currently be displayed