Publication detail

Dynamic Validation of Contracts in Concurrent Code

FIEDOR, J. LETKO, Z. VOJNAR, T. LOURENCO, J.

Original Title

Dynamic Validation of Contracts in Concurrent Code

English Title

Dynamic Validation of Contracts in Concurrent Code

Type

conference paper

Language

en

Original Abstract

With multi-core processors present in every newer computer, multi-threaded programs are becoming increasingly common. However, multi-threaded programs require proper synchronisation to restrict the thread interleavings and make the program produce correct results. Atomicity violations are a class of errors which result from an incorrect definition of the scope of an atomic region. Such errors are usually hard to localize and diagnose, which becomes even harder when using a (third-party) software library where it is unknown to the programmer how to form the atomic regions correctly when accessing the library. One way to address the problem of proper atomicity is to associate a contract with each program library. In general, a contract defines a sequence of method calls that must be executed atomically. In this paper, we devise a technique for dynamic validation of contracts at program run time.

English abstract

With multi-core processors present in every newer computer, multi-threaded programs are becoming increasingly common. However, multi-threaded programs require proper synchronisation to restrict the thread interleavings and make the program produce correct results. Atomicity violations are a class of errors which result from an incorrect definition of the scope of an atomic region. Such errors are usually hard to localize and diagnose, which becomes even harder when using a (third-party) software library where it is unknown to the programmer how to form the atomic regions correctly when accessing the library. One way to address the problem of proper atomicity is to associate a contract with each program library. In general, a contract defines a sequence of method calls that must be executed atomically. In this paper, we devise a technique for dynamic validation of contracts at program run time.

Keywords

concurrency, contracts, dynamic analysis, atomicity violation

RIV year

2015

Released

08.02.2015

Publisher

The Universidad de Las Palmas de Gran Canaria

Location

Universidad de Las Palmas de Canaria

ISBN

978-84-606-5438-4

Book

Proceedings of the 15th International Conference on Computer Aided Systems Theory

Edition

NEUVEDEN

Edition number

NEUVEDEN

Pages from

177

Pages to

178

Pages count

2

BibTex


@inproceedings{BUT119823,
  author="Jan {Fiedor} and Zdeněk {Letko} and Tomáš {Vojnar} and Joao {Lourenco}",
  title="Dynamic Validation of Contracts in Concurrent Code",
  annote="With multi-core processors present in every newer computer, multi-threaded
programs are becoming increasingly common. However, multi-threaded programs
require proper synchronisation to restrict the thread interleavings and make the
program produce correct results. Atomicity violations are a class of errors which
result from an incorrect definition of the scope of an atomic region. Such errors
are usually hard to localize and diagnose, which becomes even harder when using
a (third-party) software library where it is unknown to the programmer how to
form the atomic regions correctly when accessing the library. One way to address
the problem of proper atomicity is to associate a contract with each program
library. In general, a contract defines a sequence of method calls that must be
executed atomically. In this paper, we devise a technique for dynamic validation
of contracts at program run time.",
  address="The Universidad de Las Palmas de Gran Canaria",
  booktitle="Proceedings of the 15th International Conference on Computer Aided Systems Theory",
  chapter="119823",
  edition="NEUVEDEN",
  howpublished="print",
  institution="The Universidad de Las Palmas de Gran Canaria",
  year="2015",
  month="february",
  pages="177--178",
  publisher="The Universidad de Las Palmas de Gran Canaria",
  type="conference paper"
}