Simple rational guidance for chopping up transactions

Dennis Shasha, Eric Simon, Patrick Valcluriez

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Abstract

Chopping transactions into pieces is good for performance but may lead to non-serializable executions. Many research ers have reacted to this fact by either inventing new concurrency control mechanisms, weakening serializability, or both. We adopt a different approach. We assume a user who l has only the degree 2 and degree 3 consistency options offered by the vast majority of conventions] database systems; and knows the set of transactions that may run during a certain interval (users are likely to Jrave such knowledge for online or real-time transactional applications). Given this information, our algorifhm finds the finest parfifioning of a set of transactions TranSet with the following property: if the partitioned transactions execute serializable, then TranSet executes serializable. This permits users to obtain more concurrency while preserving correctness. Besides obtaining more inter-transaction concurrency, chopping transactions in this way can enhance intra-transaction parallelism. The algorithm is inexpensive, running in O(n x (e + m)) time using a naive implementation where n is the number of concurrent transactions in fhe interval, e is the number of edges in the conflict graph among the transactions, and m is the maximum number of accesses of any transaction. This makes it feasible to add as a tuning knob to pracfical Systems.

Original languageEnglish (US)
Title of host publicationProceedings of the 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992
PublisherAssociation for Computing Machinery
Pages298-307
Number of pages10
VolumePart F129624
ISBN (Electronic)0897915216
DOIs
StatePublished - Jun 2 1992
Event1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992 - San Diego, United States
Duration: Jun 2 1992Jun 5 1992

Other

Other1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992
CountryUnited States
CitySan Diego
Period6/2/926/5/92

Fingerprint

Knobs
Concurrency control
Tuning

ASJC Scopus subject areas

  • Software
  • Information Systems

Cite this

Shasha, D., Simon, E., & Valcluriez, P. (1992). Simple rational guidance for chopping up transactions. In Proceedings of the 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992 (Vol. Part F129624, pp. 298-307). Association for Computing Machinery. https://doi.org/10.1145/130283.130317

Simple rational guidance for chopping up transactions. / Shasha, Dennis; Simon, Eric; Valcluriez, Patrick.

Proceedings of the 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992. Vol. Part F129624 Association for Computing Machinery, 1992. p. 298-307.

Research output: Chapter in Book/Report/Conference proceedingConference contribution

Shasha, D, Simon, E & Valcluriez, P 1992, Simple rational guidance for chopping up transactions. in Proceedings of the 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992. vol. Part F129624, Association for Computing Machinery, pp. 298-307, 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992, San Diego, United States, 6/2/92. https://doi.org/10.1145/130283.130317
Shasha D, Simon E, Valcluriez P. Simple rational guidance for chopping up transactions. In Proceedings of the 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992. Vol. Part F129624. Association for Computing Machinery. 1992. p. 298-307 https://doi.org/10.1145/130283.130317
Shasha, Dennis ; Simon, Eric ; Valcluriez, Patrick. / Simple rational guidance for chopping up transactions. Proceedings of the 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992. Vol. Part F129624 Association for Computing Machinery, 1992. pp. 298-307
@inproceedings{9fe51f66d58943f499af52c8f7d0bd09,
title = "Simple rational guidance for chopping up transactions",
abstract = "Chopping transactions into pieces is good for performance but may lead to non-serializable executions. Many research ers have reacted to this fact by either inventing new concurrency control mechanisms, weakening serializability, or both. We adopt a different approach. We assume a user who l has only the degree 2 and degree 3 consistency options offered by the vast majority of conventions] database systems; and knows the set of transactions that may run during a certain interval (users are likely to Jrave such knowledge for online or real-time transactional applications). Given this information, our algorifhm finds the finest parfifioning of a set of transactions TranSet with the following property: if the partitioned transactions execute serializable, then TranSet executes serializable. This permits users to obtain more concurrency while preserving correctness. Besides obtaining more inter-transaction concurrency, chopping transactions in this way can enhance intra-transaction parallelism. The algorithm is inexpensive, running in O(n x (e + m)) time using a naive implementation where n is the number of concurrent transactions in fhe interval, e is the number of edges in the conflict graph among the transactions, and m is the maximum number of accesses of any transaction. This makes it feasible to add as a tuning knob to pracfical Systems.",
author = "Dennis Shasha and Eric Simon and Patrick Valcluriez",
year = "1992",
month = "6",
day = "2",
doi = "10.1145/130283.130317",
language = "English (US)",
volume = "Part F129624",
pages = "298--307",
booktitle = "Proceedings of the 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992",
publisher = "Association for Computing Machinery",

}

TY - GEN

T1 - Simple rational guidance for chopping up transactions

AU - Shasha, Dennis

AU - Simon, Eric

AU - Valcluriez, Patrick

PY - 1992/6/2

Y1 - 1992/6/2

N2 - Chopping transactions into pieces is good for performance but may lead to non-serializable executions. Many research ers have reacted to this fact by either inventing new concurrency control mechanisms, weakening serializability, or both. We adopt a different approach. We assume a user who l has only the degree 2 and degree 3 consistency options offered by the vast majority of conventions] database systems; and knows the set of transactions that may run during a certain interval (users are likely to Jrave such knowledge for online or real-time transactional applications). Given this information, our algorifhm finds the finest parfifioning of a set of transactions TranSet with the following property: if the partitioned transactions execute serializable, then TranSet executes serializable. This permits users to obtain more concurrency while preserving correctness. Besides obtaining more inter-transaction concurrency, chopping transactions in this way can enhance intra-transaction parallelism. The algorithm is inexpensive, running in O(n x (e + m)) time using a naive implementation where n is the number of concurrent transactions in fhe interval, e is the number of edges in the conflict graph among the transactions, and m is the maximum number of accesses of any transaction. This makes it feasible to add as a tuning knob to pracfical Systems.

AB - Chopping transactions into pieces is good for performance but may lead to non-serializable executions. Many research ers have reacted to this fact by either inventing new concurrency control mechanisms, weakening serializability, or both. We adopt a different approach. We assume a user who l has only the degree 2 and degree 3 consistency options offered by the vast majority of conventions] database systems; and knows the set of transactions that may run during a certain interval (users are likely to Jrave such knowledge for online or real-time transactional applications). Given this information, our algorifhm finds the finest parfifioning of a set of transactions TranSet with the following property: if the partitioned transactions execute serializable, then TranSet executes serializable. This permits users to obtain more concurrency while preserving correctness. Besides obtaining more inter-transaction concurrency, chopping transactions in this way can enhance intra-transaction parallelism. The algorithm is inexpensive, running in O(n x (e + m)) time using a naive implementation where n is the number of concurrent transactions in fhe interval, e is the number of edges in the conflict graph among the transactions, and m is the maximum number of accesses of any transaction. This makes it feasible to add as a tuning knob to pracfical Systems.

UR - http://www.scopus.com/inward/record.url?scp=85031732932&partnerID=8YFLogxK

UR - http://www.scopus.com/inward/citedby.url?scp=85031732932&partnerID=8YFLogxK

U2 - 10.1145/130283.130317

DO - 10.1145/130283.130317

M3 - Conference contribution

AN - SCOPUS:85031732932

VL - Part F129624

SP - 298

EP - 307

BT - Proceedings of the 1992 ACM SIGMOD International Conference on Management of Data, SIGMOD 1992

PB - Association for Computing Machinery

ER -