Abortable and query-abortable objects and their efficient implementation

  • Authors:

  • Marcos K. Aguilera;Svend Frolund;Vassos Hadzilacos;Stephanie L. Horn;Sam Toueg

  • Affiliations:

  • HP Laboratories, Palo Alto;Gatehouse A/S;University of Toronto;University of Toronto;University of Toronto

  • Venue:
  • Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
  • Year:
  • 2007

Quantified Score

Hi-index 0.00

Visualization

Abstract

We introduce abortable and query-abortable objects, intended for asynchronous shared-memory systems with low contention. These objects behave like ordinary objects when accessed sequentially, but may abort operations when accessed concurrently. An aborted operation may or may not take effect, i.e., cause a state transition, and it returns no indication of which possibility occurred. Since this uncertainty is problematic, a query-abortable object supports a QUERY operation that each process can use to determine its last non-QUERY operation on the object that caused a state transition, and the response associated with this state transition. Query-abortable objects can easily implement obstruction-free objects (introduced by Herlihy, Luchangco and Moir) and pausable objects (introduced by Attiya, Guerraoui and Kouznetsov). We present universal constructions for abortable and query-abortable objects that use only abortable registers -- registers that are strictly weaker than safe registers. Our universal constructions are novel and efficient in the number of registers used. Specifically, they are based on a simple time stamping mechanism for detecting concurrent executions, and in systems with n processes, they use only 2n abortable registers. It is worth noting that our results imply that any obstruction-free object and any pausable object can be implemented using only 2n abortable registers. Finally, we identify a potential problem with correctness properties based on step contention: with such properties, the composition of correct object implementations may result in an implementation that is not correct. In other words, implementations defined in terms of step contention are not always composable. To avoid this problem, we use interval contention to define the correct behaviour of abortable and query-abortable objects.