A comparison of the use of virtual versus physical snapshots for supporting update-intensive workloads

Darius Sidlauskas, Christian Søndergaard Jensen, Simonas Saltenis

Research output: Contribution to book/anthology/report/conference proceedingArticle in proceedingResearchpeer-review

4 Citations (Scopus)

Abstract

Deployments of networked sensors fuel online applications that feed on real-time sensor data. This scenario calls for techniques that support the management of workloads that contain queries as well as very frequent updates. This paper compares two well-chosen approaches to exploiting the parallelism offered by modern processors for supporting such workloads. A general approach to avoiding contention among parallel hardware threads and thus exploiting the parallelism available in processors is to maintain two copies, or snapshots, of the data: one for the relatively long-duration queries and one for the frequent and very localized updates. The snapshot that receives the updates is frequently made available to queries, so that queries see up-to-date data. The snapshots may be physical or virtual. Physical snapshots are created using the C library \texttt{memcpy} function. Virtual snapshots are created by the \texttt{fork} system function that creates a new process that initially has the same data snapshot as the process it was forked from. When the new process carries out updates, this triggers the actual memory copying in a copy-on-write manner at memory page granularity. This paper characterizes the circumstances under which each technique is preferable. The use of physical snapshots is surprisingly efficient.
Original languageEnglish
Title of host publicationProceedings of the Eighth International Workshop on Data Management on New Hardware, DaMoN 2012
Number of pages8
PublisherAssociation for Computing Machinery
Publication date2012
Pages1-8
ISBN (Print)978-1-4503-1445-9
DOIs
Publication statusPublished - 2012
EventEighth International Workshop on Data Management on New Hardware - Scottsdale, Arizona, United States
Duration: 21 May 201221 May 2012
Conference number: 8th

Conference

ConferenceEighth International Workshop on Data Management on New Hardware
Number8th
CountryUnited States
CityScottsdale, Arizona
Period21/05/201221/05/2012

Fingerprint

Data storage equipment
Copying
Sensors
Hardware

Cite this

Sidlauskas, D., Jensen, C. S., & Saltenis, S. (2012). A comparison of the use of virtual versus physical snapshots for supporting update-intensive workloads. In Proceedings of the Eighth International Workshop on Data Management on New Hardware, DaMoN 2012 (pp. 1-8). Association for Computing Machinery. https://doi.org/10.1145/2236584.2236585
Sidlauskas, Darius ; Jensen, Christian Søndergaard ; Saltenis, Simonas. / A comparison of the use of virtual versus physical snapshots for supporting update-intensive workloads. Proceedings of the Eighth International Workshop on Data Management on New Hardware, DaMoN 2012. Association for Computing Machinery, 2012. pp. 1-8
@inproceedings{61e62eb132a1447ab7863dcfc3b4a563,
title = "A comparison of the use of virtual versus physical snapshots for supporting update-intensive workloads",
abstract = "Deployments of networked sensors fuel online applications that feed on real-time sensor data. This scenario calls for techniques that support the management of workloads that contain queries as well as very frequent updates. This paper compares two well-chosen approaches to exploiting the parallelism offered by modern processors for supporting such workloads. A general approach to avoiding contention among parallel hardware threads and thus exploiting the parallelism available in processors is to maintain two copies, or snapshots, of the data: one for the relatively long-duration queries and one for the frequent and very localized updates. The snapshot that receives the updates is frequently made available to queries, so that queries see up-to-date data. The snapshots may be physical or virtual. Physical snapshots are created using the C library \texttt{memcpy} function. Virtual snapshots are created by the \texttt{fork} system function that creates a new process that initially has the same data snapshot as the process it was forked from. When the new process carries out updates, this triggers the actual memory copying in a copy-on-write manner at memory page granularity. This paper characterizes the circumstances under which each technique is preferable. The use of physical snapshots is surprisingly efficient.",
author = "Darius Sidlauskas and Jensen, {Christian S{\o}ndergaard} and Simonas Saltenis",
year = "2012",
doi = "10.1145/2236584.2236585",
language = "English",
isbn = "978-1-4503-1445-9",
pages = "1--8",
booktitle = "Proceedings of the Eighth International Workshop on Data Management on New Hardware, DaMoN 2012",
publisher = "Association for Computing Machinery",
address = "United States",

}

Sidlauskas, D, Jensen, CS & Saltenis, S 2012, A comparison of the use of virtual versus physical snapshots for supporting update-intensive workloads. in Proceedings of the Eighth International Workshop on Data Management on New Hardware, DaMoN 2012. Association for Computing Machinery, pp. 1-8, Eighth International Workshop on Data Management on New Hardware, Scottsdale, Arizona, United States, 21/05/2012. https://doi.org/10.1145/2236584.2236585

A comparison of the use of virtual versus physical snapshots for supporting update-intensive workloads. / Sidlauskas, Darius; Jensen, Christian Søndergaard; Saltenis, Simonas.

Proceedings of the Eighth International Workshop on Data Management on New Hardware, DaMoN 2012. Association for Computing Machinery, 2012. p. 1-8.

Research output: Contribution to book/anthology/report/conference proceedingArticle in proceedingResearchpeer-review

TY - GEN

T1 - A comparison of the use of virtual versus physical snapshots for supporting update-intensive workloads

AU - Sidlauskas, Darius

AU - Jensen, Christian Søndergaard

AU - Saltenis, Simonas

PY - 2012

Y1 - 2012

N2 - Deployments of networked sensors fuel online applications that feed on real-time sensor data. This scenario calls for techniques that support the management of workloads that contain queries as well as very frequent updates. This paper compares two well-chosen approaches to exploiting the parallelism offered by modern processors for supporting such workloads. A general approach to avoiding contention among parallel hardware threads and thus exploiting the parallelism available in processors is to maintain two copies, or snapshots, of the data: one for the relatively long-duration queries and one for the frequent and very localized updates. The snapshot that receives the updates is frequently made available to queries, so that queries see up-to-date data. The snapshots may be physical or virtual. Physical snapshots are created using the C library \texttt{memcpy} function. Virtual snapshots are created by the \texttt{fork} system function that creates a new process that initially has the same data snapshot as the process it was forked from. When the new process carries out updates, this triggers the actual memory copying in a copy-on-write manner at memory page granularity. This paper characterizes the circumstances under which each technique is preferable. The use of physical snapshots is surprisingly efficient.

AB - Deployments of networked sensors fuel online applications that feed on real-time sensor data. This scenario calls for techniques that support the management of workloads that contain queries as well as very frequent updates. This paper compares two well-chosen approaches to exploiting the parallelism offered by modern processors for supporting such workloads. A general approach to avoiding contention among parallel hardware threads and thus exploiting the parallelism available in processors is to maintain two copies, or snapshots, of the data: one for the relatively long-duration queries and one for the frequent and very localized updates. The snapshot that receives the updates is frequently made available to queries, so that queries see up-to-date data. The snapshots may be physical or virtual. Physical snapshots are created using the C library \texttt{memcpy} function. Virtual snapshots are created by the \texttt{fork} system function that creates a new process that initially has the same data snapshot as the process it was forked from. When the new process carries out updates, this triggers the actual memory copying in a copy-on-write manner at memory page granularity. This paper characterizes the circumstances under which each technique is preferable. The use of physical snapshots is surprisingly efficient.

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

U2 - 10.1145/2236584.2236585

DO - 10.1145/2236584.2236585

M3 - Article in proceeding

SN - 978-1-4503-1445-9

SP - 1

EP - 8

BT - Proceedings of the Eighth International Workshop on Data Management on New Hardware, DaMoN 2012

PB - Association for Computing Machinery

ER -

Sidlauskas D, Jensen CS, Saltenis S. A comparison of the use of virtual versus physical snapshots for supporting update-intensive workloads. In Proceedings of the Eighth International Workshop on Data Management on New Hardware, DaMoN 2012. Association for Computing Machinery. 2012. p. 1-8 https://doi.org/10.1145/2236584.2236585