From 0dc1a8ea20820168149cedaa14e223d4d31dc4b6 Mon Sep 17 00:00:00 2001
From: "Douglas B. Rumbaugh" <doug@douglasrumbaugh.com>
Date: Sun, 6 Jul 2025 18:21:32 -0400
Subject: updates

---
 chapters/abstract.tex | 52 ++++++++++++++++++++++++---------------------------
 1 file changed, 24 insertions(+), 28 deletions(-)

(limited to 'chapters/abstract.tex')

diff --git a/chapters/abstract.tex b/chapters/abstract.tex
index 5ddfd37..602edd4 100644
--- a/chapters/abstract.tex
+++ b/chapters/abstract.tex
@@ -10,33 +10,29 @@ result, a large number of potentially useful data structures are excluded
 from use in such systems, or at the very least require a large amount of
 development time to be made useful.
 
-This work seeks to address this difficulty by introducing a framework for
-automatic data structure dynamization. Given a static data structure and
-an associated query, satisfying certain requirements, this proposed work
-will enable automatically adding support for concurrent updates, with
-minimal modification to the data structure itself. It is based on a
-body of theoretical work on dynamization, often called the "Bentley-Saxe
-Method", which partitions data into a number of small data structures,
-and periodically rebuilds these as records are inserted or deleted, in
-a manner that maintains asymptotic bounds on worst case query time,
-as well as amortized insertion time. These techniques, as they currently
-exist, are limited in usefulness as they exhibit poor performance in
-practice, and lack support for concurrency. But, they serve as a solid
-theoretical base upon which a novel system can be built to address
-these concerns.
+This work seeks to address this difficulty by introducing a framework
+for automatic data structure dynamization. Given a static data structure
+and an associated query, satisfying certain requirements, this proposed
+work will enable automatically adding support for concurrent updates,
+with minimal modification to the data structure itself. It is based on a
+body of theoretical work on dynamization, often called the ``Bentley-Saxe
+Method'', which partitions data into a number of small data structures,
+and periodically rebuilds these as records are inserted or deleted, in a
+manner that maintains asymptotic bounds on worst case query time, as well
+as amortized insertion time. These techniques, as they currently exist,
+are limited in usefulness as they are restricted in the situations they
+can be applied, lack support for configuration and concurrency, and have
+poor insertion tail latency performance. Despite these shortcomings,
+these techniques can serve as a solid theoretical base upon which a
+novel system can be built to address these concerns.
 
-To develop this framework, sampling queries (which are not well served
-by existing dynamic data structures) are first considered. The results
-of this analysis are then generalized to produce a framework for
-single-threaded dynamization that is applicable to a large number
-of possible data structures and query types, and the general framework
-evaluated across a number of data structures and query types. These
-dynamized static structures are shown to equal or exceed the performance
-of existing specialized dynamic structures in both update and query
-performance.
-
-Finally, this general framework is expanded with support for concurrent
-operations (inserts and queries), and the use of scheduling and
-parallelism is studied to provide worst-case insertion guarantees,
-as well as a rich trade-off space between query and insertion performance.
+To develop this framework, we first consider dynamizing data structures
+for sampling queries (which are not well served by existing dynamic data
+structures). We then generalize these results to produce a framework
+that is able to provide concurrent insertion and deletion support for
+a wide range of data structures and query types. Next, we examine the
+design space of our framework and show that it supports useful trade-offs
+between insertion and query performance. Finally, we examine the use
+of concurrency and parallelism to provide better worst-case insertion
+performance for our system.
 
-- 
cgit v1.2.3

